Patent Publication Number: US-5634116-A

Title: Non-integer multiple clock translator

Description:
BACKGROUND OF THE INVENTION 
     1. Technical Field 
     The present invention relates in general to clock translators and in particular to clock translators for microprocessors. Still more particularly, the present invention relates to non-integer multiple clock translators for microprocessors. 
     2. Description of the Related Art 
     In modern personal computers (PCs), PC computer boards typically have a transmission speed limitation that is less than the PC&#39;s microprocessor speed. Cost considerations have prevented the PC board from being made faster. Instead, the speed of the PC computer system has been increased by speeding up the microprocessor and providing internal cache memory to the processor, decreasing the bandwidth required of the system bus. Thus, data being transferred over the bus on the PC computer board is timed by a bus clock having a speed limitation of, for example, 66 Mhz, while the processor is operating at a speed of, for example, 100 Mhz. Data being transferred from the PC board to the microprocessor would be delivered to a clock translator that synchronizes data from the bus with the faster processor clock and transfers it out to the processor. Therefore, in order to couple the faster processor with the slower PC board, the external clock on the PC board has to be synchronized with the internal system clock on the microprocessor. 
     In the prior art, the processor clock has typically been an integer (n) multiple of the external clock, typically two or three times faster. While the prior art has provided clock translators for operation with internal microprocessors that operate at nx integer multiples of the system bus speed, the prior art has heretofore not provided a clock translator capable of operating with a system microprocessor that operates at both an integer and a non-integer multiple of clock frequencies. Thus, it would be desirable to provide a multiple clock translator that translates data to a non-integer multiple clock frequency. 
     SUMMARY OF THE INVENTION 
     According to the present invention, a multiple clock translator for a microprocessor is provided for synchronizing data from an external clock speed to an internal clock speed that is a non-integer multiple of the external clock speed. The translator comprises a latch circuit and a synchronization signal generator. The latch circuit receives data at the external clock speed and outputs data at the internal clock speed. The latch circuit includes an input latch and a sync latch, and receives an external clock having an enabling phase and an internal clock having an enabling phase. The input latch is clocked by the enabling phase of the external clock, and the sync latch is clocked by the enabling phase of the internal clock and enabled by a sync pulse. The synchronization signal generator generates a series of sync pulses that are output to the latch circuit in a selected pattern, wherein the pattern is a function of the non-integer multiple. 
     The above as well as additional objects, features, and advantages of the present invention will become apparent in the following detailed written description. 
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS 
     The novel features believed characteristic of the invention are set forth in the appended claims. The invention itself however, as well as a preferred mode of use, further objects and advantages thereof, will best be understood by reference to the following detailed description of an illustrative embodiment when read in conjunction wit,h-the accompanying drawings, wherein: 
     FIG. 1 depicts the clock translator, in accordance with a preferred embodiment of the present invention. 
     FIG. 2 is a timing diagram for a preferred embodiment of the clock translator of the present invention shown in FIG. 1. 
     FIG. 3 depicts a more detailed schematic block diagram of latch circuit and the sync generator, in accordance with a preferred embodiment of the present invention. 
     FIG. 4 is a timing diagram of the 2.5× clocking mode of a preferred embodiment of clock translator of the present invention. 
     FIG. 5 depicts a preferred embodiment of a sync generator of the present invention. 
     FIG. 6 depicts a timing diagram of the clocks input to the sync generator of a preferred embodiment of the present invention. 
     FIG. 7 is a schematic block diagram of count logic 70, according to a preferred embodiment of the present invention. 
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENT 
     With reference now to the figures and in particular with reference to FIG. 1, there is depicted the clock translator of a preferred embodiment of the present invention. &#34;busclk&#34; and &#34;sysclk&#34; are internally distributed processor clocks derived from the phase lock loop (PLL) circuit 10, which is triggered with an external oscillator. busclk clocks data at the bus I/O of the microprocessor at the system bus speed. syselk is the processor core clock and sets the internal logic cycle time. busclk is a two phase clock with busclk phase 1 (busclk P1) being the up level and busclk phase 2 (busclk P2) being the down level. (See FIGS. 2 and 3) syselk is divided in the same way into sysclk phase 1 and sysclk phase 2. 
     Latch circuit 20 receives external data from the PC board over a system bus operating at the external clock frequency of the computer system (i.e. the frequency of busclk). busclk and sysclk are input into latch circuit 20, along with the bussync signal from sync generator 30. Latch circuit 20 synchronizes the input external data with sysclk in response to the bussync signal, and outputs the data to the central processing unit at the faster internal clock frequency. 
     According to the present invention, the clock translator allows the synchronization of the external data, which has been latched in latch circuit 20 at the external clock frequency, to the internal processor speed, even if the internal clock frequency is a non-integer multiple of the external clock frequency. A non-integer multiple is one which has a non-zero fraction. (Conversely, an integer multiple is an integer number with a zero fraction. For example, integer numbers include 1, 2, 3, 4 . . . etc.) In other words, for sysclk to be a non-integer multiple of busclk, sysclk cannot be an integer number of times faster than busclk. (So, for example, sysclk=3 1/3× busclk.) For illustrative purposes, the present invention will be described in a preferred embodiment of a 2.5× multiple clock translator. Although the present invention will be described for system having a system clock operating at 2.5× that of the external clock, it will be appreciated that the present invention may be practiced using an internal clock frequency that is any non-integer or integer multiple of the external clock frequency. 
     With reference now to FIG. 2, there is depicted a timing diagram for a preferred embodiment of the clock translator of the present invention shown in FIG. 1, where the frequency of sysclk is 2 1/2 times busclk. The &#34;qualifier&#34; signal from the PLL 10 indicates the phase relationship of busclk and sysclk. A logic &#34;1&#34; indicates sysclk is in phase with busclk. For  1/2× multiples, the qualifier signal will toggle every other cycle of busclk. For other multiples, the PLL 10 can be designed to produce the qualifier at each cycle of the busclk that is synchronized with the sysclk, which can be determined mathematically as a function of the multiple, as will be appreciated by those skilled in the art. 
     External data transferred on the system bus at the external frequency is captured and latched into latch circuit 20 by the clocking of busclk. Latch circuit 20 transfers the latched data to the CPU core when the data is synchronized with sysclk. Sync generator 30 provides the &#34;bussync&#34; signal that allows the synchronization of the latched data with the internal processor speed, even if the internal clock frequency is a non-integer multiple of the external clock frequency. Sync generator 30 creates the bussync signal to properly control when external data latched in latch circuit 20 can be transferred to the CPU. 
     The &#34;clkmf&#34; input to PLL 10 and sync generator 30 is a 4-bit input which is encoded for the multiplication frequency (i.e. the non-integer multiple) of sysclk. Because the clock translator of the present invention can perform data clock translations for either integer or non-integer multiples, the  1/2 n× multiple clock translator of the preferred embodiment provides sixteen possible translations from a 1× multiple to an 8× multiple (i.e. 1×, 1.5×, 2×, 2.5×, 3×, 3.5×, 4×. . . 8×). The encoded four bits indicates to the sync generator 30 how to generate the bussync for the various modes, as will be described herein below. 
     Referring now to FIG. 3, there is depicted a more detailed schematic block diagram of latch circuit 20 and sync generator 30. Latch circuit 20 includes an input latch and a sync latch. Both latches are a master-slave type, wherein the input latch comprises latches L1 and L2, and the sync latch comprises latches L3 and L4. All four latches are level sensitive scan devices (LSSD) with the &#34;master&#34; (L1 and L3) latch clocked with phase 2 and the &#34;slave&#34; (L2 and L4) latch clocked with phase 1. 
     External data transferred on the system bus at the external frequency is captured and latched into latch circuit 20 by the clocking of busclk. &#34;External datain&#34; has a setup and hold specification with respect to the busclk rising edge. The external datain is input to input latch L1. While busclk phase 2 is active, data out of input latch L1 will follow the external datain. During the period that busclk P2 is active, input latch L1 is transparent and the external datain passes through the input latch and is presented to the sync latch L3. bussync is used to enable the sync latch L3 at the closest sysclk rising edge to a busclk rising edge. All other edges of sysclk will be disabled from the latch. On the rising edge of busclk (end of busclk P2), data is latched in input latch L1. This data is latched in input latch L1 until busclk P2 is active again in the next bus cycle. During the phase that busclk P1 is active, input latch L2 is transparent and the latch data of input latch L1 is output as LSSD scan. The input latch L2 is used just for LSSD scan, as will be appreciated by those skilled in the art. 
     Referring now to FIG. 4, there is shown a timing diagram of the 2.5× clocking mode of a preferred embodiment of the clock translator of the present invention. Referring first to the time line B, there is shown &#34;in phase&#34; timing, as it occurs in the clock translator of the present invention. At this time line B, busclk and sysclk are active in the enabling phase P2. Also, bussync, which is a series of pulses having its up (high) level as its enabling phase, is also active. 
     As can be seen in FIG. 3, the datain &#34;B&#34; will pass through input latch L1, which is transparent during the active phase of busclk P2, and into the input of sync latch L3, during this time line. sysclk P2 and bussync, being active, allow the flushed external data to be clocked into sync latch L3. On the rising edges of busclk and sysclk (end of enabling phase P2), the external data is latched into both input latch L1 and sync latch L3. There is no clock edge dependency between busclk rising and sysclk rising edges to latch the external data into the sync latch. It can be seen that the latch data in sync latch L3 is immediately available to sync latch L4 when sysclk P1 becomes active at the top of the rising edge. At this point, L4 becomes transparent and the latch data &#34;B&#34; is output to the CPU. In the next P2 phase of sysclk, the data has been latched by sync latch L4 and is held as a stable output to the CPU, while the data in sync latch L3 is immune from changes on its data input because bussync has entered a disabling phase and has disabled the sync latch. 
     Referring again to FIG. 4, time line A shows the case of data capturing when busclk and sysclk are &#34;out-of-phase&#34; with each other, as will occur during certain busclk cycles when the sysclk is a non-integer multiple of the busclk frequency. On the rising edge of the busclk enabling phase P2 input latch L1 will latch in the external datain and will hold this data until busclk P2 is active again. During this P1 active phase, input latch L1 will provide stable data to sync latch L3. During this latching phase of input latch L1 (some time after time line A), sysclk P2 and bussync both attain an active phase, allowing sync latch L3 to sense the latch data output from input latch L1. This data is latched in sync latch L3 on the rising edge of sysclk (at the end of sysclk enabling phase) and, at the same time, is transferred from sync latch L3 to sync latch L4. The external datain is now synchronized with sysclk and it is output to the CPU. 
     It will be appreciated that when busclk and sysclk are in-phase, there is no latency penalty induced. However, when busclk and sysclk are out of phase, there is one sysclk phase sync-up latency. 
     As can be seen from the above description, the clock translator of the present invention synchronizes external data with the processor internal clock, even in cases where the processor clock is operating at a non-integer multiple of the external datain. Thus, the present invention can synchronize the input data with sysclk, whether or not the phase changes of the busclk are synchronized with the sysclk. 
     While the present invention can perform a clock translation for a pair of non-integer multiple clocks, there is a restriction on the timing. A busclk falling edge must not fall before a sysclk rising edge because the data out of the input latch L1 must maintain stable data to the sync latch L3 until the rising edge of sysclk. There is no clock edge dependency between busclk rising and sysclk falling edges. While FIG. 4 describes the theoretical operation of the clock translator of the present invention, an actual circuit will include wiring or logic delays that will effect the timing. Nonetheless, busclk rising can be before or after sysclk rising edges for the external datain to be latched into the sync latch. The constraints of this mode are the datain set up times, receiver and latch delays, logic and wiring delays, and sync latch set up times. Traditional static timing analysis can be used to verify path delays, as will be appreciated by those skilled in the art. 
     Referring to FIG. 6, there is depicted a timing diagram of the clocks input to sync generator 30. As has been explained, the qualifier signal is produced by PLL 10 as a function of the clock multiplication frequency (clkmf). The qualifier signal is preprogrammed to toggle between an enabling signal, for example, a logic &#34;1&#34;, to a non-enabling phase in synchronization with the busclk. An active qualifier signal indicates a busclk cycle that is synchronized with the sysclk. Thus, for example, with a  1/2× timing (i.e. where the sysclk is a  1/2 multiple of the busclk), the qualifier signal will toggle to the active level every other busclk cycle. This can be seen in FIG. 6, which is an example of a 2.5× clocking mode for sync generator 30. There, the syscik is operating at a frequency 2.5 times the busclk. The sysclk will be synchronized with the busclk every fifth cycle of the sysclk, as can be seen in FIG. 6. Therefore, the qualifier signal is generated to attain an active level at the &#34;cycle1&#34;. 
     The operation of sync generator 30 will now be described with reference to FIG. 5, wherein a preferred embodiment of a sync generator of the present invention is shown. To detect when busclk and sysclk are aligned, the qualifier signal from the PLL 10 is latched with busclk in a master-slave latch 40. Master-slave latch 40 includes latches L1 and L2. Latch L1 is clocked by busclk phase 2 (P2) and latch L2 is clocked by busclk phase 1 (P1). The output of master-slave latch 40 is input to ANDgate 50. The output of that latch is also inverted and latched into master-slave latch 60 with sysclk. Master-slave 60 comprises a latch L1 being clocked by sysclk phase 2 (P2) and a latch L2 being clocked by sysclk phase 1 (P1). The output of master-slave latch 60 is also input into ANDgate 50. The output of ANDgate 50 is the &#34;preload signal&#34;. The preload signal is the logical AND of the master-slave latches 40 and 60 and produces a one sysclk period pulse, which starts the count to &#34;cycle1&#34; or &#34;cntl&#34; of the timing. 
     It can be seen that during the busclk cycles where the qualifier signal is active, an active high signal will be output from the master-slave latch 40 into ANDgate 50. Similarly, the synchronized first cycle (&#34;cycle1&#34;) of sysclk will latch the high input to master-slave latch 60 and output an active high signal to ANDGATE 50. These two signals will be ANDed by ANDgate 50 to produce the preload signal, as seen in FIG. 6. 
     The preload signal indicates the specific cycle that the busclk and sysclk are synchronized, and, in turn, indicates the first cycle of a period within which a selected pattern of bussync signals are generated. Each multiplication frequency has a selected pattern of bussync pulses that properly allow the synchronization of the input data to the non-integer multiple frequency of the internal clock. For the example of the 2.5× clocking mode, the selected pattern of bussync pulses has a period of five sysclk cycles and contains two bussync pulses occurring at cycle three and cycle five. 
     Referring again to FIG. 5, the selected pattern of bussync pulses is generated by count logic 70, as a function of the clock multiplication frequency (clkmf) input of four bits. The preload signal is used to precondition a serial chain of latches (cnt2-cnt5) clocked with sysclk. Count logic 70 generates a selected pattern of logical zeros and ones that corresponds to the bussync pulse pattern required for the given clock multiplication frequency. A separate bit of the selected pattern is sent to each of multiplexers 75, 80, 85, and ANDgate 90. When a preload signal occurs, the selected pattern will be preloaded into the chain of count latches cnt5-cnt2. (The count latches cnt2-cnt5 correspond to cycle2-cycle5 of FIG. 6.) After the preload cycle (cycle1), the selected pattern is shifted through the latch chain every sysclk cycle. The output of the count latch cnt2 produces the bussync sent to latch circuit 20. 
     Thus, for the example of 2.5× clocking as shown in FIG. 6, clkmf would indicate a 2.5 multiple to count logic 70. Count logic 70 would output a pattern of bits equal to &#34;0101&#34;, producing a zero input to multiplexers 75 and 85 and a &#34;1&#34; signal to multiplexer 80 and ANDgate 90. At the occurrence of a preload signal indicating cycle1 of a new period for the pattern, count latches cnt2-cnt5 are loaded with the pattern. Subsequent cycles of sysclk transfer the bits through multiplexers 75-85 to the next count latches in the serial chain until each bit is output as a bussync pulse at the proper sysclk cycle. 
     Referring now to FIG. 7, there is depicted a schematic block diagram of count logic 70, according to a preferred embodiment of the present invention. Here, count logic 70 is designed to provide the selected pattern to four count latches in a clock translator capable of synchronizing  1/2n× multiple clocks. This circuit will now be described using the VHDL Hardware Description Language, which is well known to those skilled in the art. 
     
         __________________________________________________________________________
preload count decoder. &#34;count logic&#34;                                      
bypass                                                                    
      &lt;= `1` when (clkmf=&#34;0000&#34;) or (wdmode =`1`) else `0`;               
x1    &lt;= `1` when (clkmf=&#34;0001&#34;) or (wdmode =&#34;1&#34;) else `0`;               
x1point5                                                                  
      &lt;= `1` when clkmf=&#34;0010&#34; else `0`;                                  
x2    &lt;= `1` when clkmf=&#34;0011&#34; else `0`;                                  
x2point5                                                                  
      &lt;= `1` when clkmf=&#34;0100&#34; else `0`;                                  
x3    &lt;= `1` when clkmf=&#34;0101&#34; else `0`;                                  
x3point5                                                                  
      &lt;= `1` when clkmf=&#34;0110&#34; else `0`;                                  
x4    &lt;= `1` when clkmf=&#34;0111&#34; else `0`;                                  
x4point5                                                                  
      &lt;= `1` when clkmf=&#34;1000&#34; else `0`;                                  
x5    &lt;= `1` when clkmf=&#34;1001&#34; else `0`;                                  
x5point5                                                                  
      &lt;= `1` when clkmf=&#34;1010&#34; else `0`;                                  
x6    &lt;= `1` when clkmf=&#34;1011&#34; else `0`;                                  
x6point5                                                                  
      &lt;= `1` when clkmf=&#34;1100&#34; else `0`;                                  
x7    &lt;= `1` when clkmf=&#34;1101&#34; else `0`;                                  
x7point5                                                                  
      &lt;= `1` when clkmf=&#34;1110&#34; else `0`;                                  
x8    &lt;= `1` when clkmf=&#34;1111&#34; else `0`;                                  
preloadcnt2                                                               
      &lt;= bypass or x1 or x1point5                                         
                       or x2 ;                                            
preloadcnt3                                                               
      &lt;= x1point5                                                         
                or                                                        
                  x2point5                                                
                         or x3 ;                                          
preloadcnt4                                                               
      &lt;= x3point5                                                         
                or                                                        
                  x4 ;                                                    
preloadcnt5                                                               
      &lt;= x2point5                                                         
                or                                                        
                  x4point5                                                
                         or x5 ;                                          
preloadcnt6                                                               
      &lt;= x6 ;                                                             
preloadcnt7                                                               
      &lt;= x7 or x3point5 ;                                                 
preloadcnt8                                                               
      &lt;= x8 ;                                                             
preloadcnt9                                                               
      &lt;= x4point5 ;                                                       
bussync counter.                                                          
cnt9in &lt;= preloadcnt9 and preload;                                        
CNT9LAT                                                                   
       : srll port                                                        
               map(                                                       
               datain                                                     
                     =&gt; cnt9in,                                           
               M.sub.-- Clock                                             
                     =&gt; PH2,                                              
               S.sub.-- Clock                                             
                     =&gt; PH1,                                              
               Reset =&gt; por,                                              
               M.sub.-- Out                                               
                     =&gt; terminate6,                                       
               S.sub.-- Out                                               
                     =&gt; synct9                                            
         );                                                               
cnt8in &lt;=                                                                 
       preloadcnt8                                                        
              when preload=`1` else                                       
       syncnt9                                                            
              when preload=`0` else                                       
       `X`;                                                               
CNT8LAT                                                                   
       : srll port                                                        
               map(                                                       
               datain                                                     
                     =&gt; cnt8in,                                           
               M.sub.-- Clock                                             
                     =&gt; PH2,                                              
               S.sub.-- Clock                                             
                     =&gt; PH1,                                              
               Reset =&gt; por,                                              
               M.sub.-- Out                                               
                     =&gt; terminate7,                                       
               S.sub.-- Out                                               
                     =&gt; syncnt8                                           
         );                                                               
cnt7in &lt;=                                                                 
       preloadcnt7                                                        
              when preload=`1` else                                       
       syncnt8                                                            
              when preload=`0` else                                       
       `X`;                                                               
CNT7LAT                                                                   
       : srll port                                                        
               map(                                                       
               datain                                                     
                     =&gt; cnt7in,                                           
               M.sub.-- Clock                                             
                     =&gt; PH2,                                              
               S.sub.-- Clock                                             
                     =&gt; PH1,                                              
               Reset =&gt; por,                                              
               M.sub.-- Out                                               
                     =&gt; terminates,                                       
               S.sub.-- Out                                               
                     =&gt; syncnt7                                           
         );                                                               
cnt6in &lt;=                                                                 
       preloadcnt6                                                        
              when preload=`1` else                                       
       syncnt7                                                            
              when preload=`0` else                                       
       `X`;                                                               
CNT6LAT                                                                   
       : srll port                                                        
               map(                                                       
               datain                                                     
                     =&gt; cnt6in,                                           
               M.sub.-- Clock                                             
                     =&gt; PH2,                                              
               S.sub.-- Clock                                             
                     =&gt; PH1,                                              
               Reset =&gt; por,                                              
               M.sub.-- Out                                               
                     =&gt; terminate9,                                       
               S.sub.-- Out                                               
                     =&gt; syncnt6                                           
         );                                                               
cnt5in &lt;=                                                                 
       preloadcnt5                                                        
              when preload=`1` else                                       
       syncnt6                                                            
              when preload=`0` else                                       
       `X`;                                                               
CNT5LAT                                                                   
       : srll port                                                        
               map(                                                       
               datain                                                     
                     =&gt; cnt5in,                                           
               M.sub.-- Clock                                             
                     =&gt; PH2,                                              
               S.sub.-- Clock                                             
                     =&gt; PH1,                                              
               Reset =&gt; por,                                              
               M.sub.-- Out                                               
                     =&gt; terminate10,                                      
               S.sub.-- Out                                               
                     =&gt; syncnt5                                           
         );                                                               
cnt4in &lt;=                                                                 
       preloadcnt4                                                        
              when preload=`1` else                                       
       syncnt5                                                            
              when preload=`0` else                                       
       `X`;                                                               
CNT4LAT                                                                   
       : srll port                                                        
               map(                                                       
               datain                                                     
                     =&gt; cnt4in,                                           
               M.sub.-- Clock                                             
                     =&gt; PH2,                                              
               S.sub.-- Clock                                             
                     =&gt; PH1,                                              
               Reset =&gt; por,                                              
               M.sub.-- Out                                               
                     =&gt; terminate11,                                      
               S.sub.-- Out                                               
                     =&gt; syncnt4                                           
         );                                                               
cnt3in &lt;=                                                                 
       preloadcnt3                                                        
              when preload=`1` else                                       
       syncnt4                                                            
              when preload=`0` else                                       
       `X`;                                                               
CNT3LAT                                                                   
       : srll port                                                        
               map(                                                       
               datain                                                     
                     =&gt; cnt3in,                                           
               M.sub.-- Clock                                             
                     =&gt; PH2,                                              
               S.sub.-- Clock                                             
                     =&gt; PH1,                                              
               Reset =&gt; por,                                              
               M.sub.-- Out                                               
                     =&gt; terminate12,                                      
               S.sub.-- Out                                               
                     =&gt; syncnt3                                           
         );                                                               
cnt2in &lt;=                                                                 
       preloadcnt2                                                        
              when preload=`1` else                                       
       syncnt3                                                            
              when preload=`0` else                                       
       `X`;                                                               
CNT2LAT                                                                   
       : srll port                                                        
               map(                                                       
               datain                                                     
                     =&gt; cnt2in,                                           
               M.sub.-- Clock                                             
                     =&gt; PH2,                                              
               S.sub.-- Clock                                             
                     =&gt; PH1,                                              
               Reset =&gt; por,                                              
               M.sub.-- Out                                               
                     =&gt; terminate13,                                      
               S.sub.-- Out                                               
                     =&gt; syncnt2                                           
         );                                                               
CNT1LAT                                                                   
       : srll port                                                        
               map(                                                       
               datain                                                     
                     =&gt; syncnt2,                                          
               M.sub.-- Clock                                             
                     =&gt; PH2,                                              
               S.sub.-- Clock                                             
                     =&gt; PH1,                                              
               Reset =&gt; por,                                              
               M.sub.-- Out                                               
                     =&gt; terminate14,                                      
               S.sub.-- Out                                               
                     =&gt; syncnt1                                           
         );                                                               
bussync &lt;= syncnt2;                                                       
acksync &lt;= syncnt1;                                                       
__________________________________________________________________________
 
    
     Referring again to FIG. 6, the count logic 70 is combinational logic used to generate the selected pattern for the serial chain of count latches. It will be appreciated by those skilled in the art that the clock multiplication factors that are input to count logic 70 may be expanded to include additional multiplication factors or even generalized to accommodate other non-integer multiples of clock frequencies. For example, the clock multiples could be  1/3n× or  1/5n× (for instance, 3 1/3 or 2 1/5). 
     As has been explained, a selected pattern has a preset value of logic &#34;1&#34; for the cycle count in which a bussync pulse is needed. As will be appreciated by those skilled in the art, the selected pattern for a given multiplication frequency can be determined by count logic 70 by calculating (empirically or mathematically) the sysclk cycle that overlaps a busclk rising edge. To calculate which count latches (cnt(x)) must be loaded with a logic 1 to produce the correct pattern of bussync pulses can be given mathematically as follows: 
     
         ______________________________________                                    
preset cnt(x)                                                             
         = integer (MF × J) + 1                                     
                           for J=1 to n-1                                 
         = MF × J    for J=n.                                       
______________________________________                                    
 
    
     where 
     MF is the multiplication factor 
     n is the integer fraction 
     example: 
     MF=2 2/3 (two and two thirds) 
     n=3 (1/3× clocking) 
     preset cnt for J=1=integer(2 2/3×1)+1=3 
     preset cnt for J=2=integer(2 2/3×2)+1=6 
     preset cnt for J=3=2 2/3×=8 
     Therefore, the count logic will assert cnt3, cnt6, and cnt8 for a non-integer multiple of 2 2/3. A truth table describing the pattern for selected multiplication frequencies is given below. 
     
         ______________________________________                                    
Truth table for example of 1/n × clocking                           
MF                                                                        
(clock       Preset values                                                
multiplication                                                            
             cnt   cnt   cnt  cnt cnt cnt cnt cnt cnt                     
frequency)   2     3     4    5   6   7   8   9   10                      
______________________________________                                    
integer   1      1     1   1    1   1   1   1   1   1                     
          2      1     0   0    0   0   0   0   0   0                     
          3      0     1   0    0   0   0   0   0   0                     
          4      0     0   1    0   0   0   0   0   0                     
          5      0     0   0    1   0   0   0   0   0                     
          6      0     0   0    0   1   0   0   0   0                     
          7      0     0   0    0   0   1   0   0   0                     
          8      0     0   0    0   0   0   1   0   0                     
 1/2 ×                                                              
          1.5    1     1   0    0   0   0   0   0   0                     
          2.5    0     1   0    1   0   0   0   0   0                     
          3.5    0     0   1    0   0   1   0   0   0                     
          4.5    0     0   0    1   0   0   0   1   0                     
 1/3 ×                                                              
          1 1/3  1     1   1    0   0   0   0   0   0                     
          1 2/3  1     0   1    1   0   0   0   0   0                     
          2 1/3  0     1   0    1   0   1   0   0   0                     
          2 2/3  0     1   0    0   1   0   1   0   0                     
 1/4 ×                                                              
          1 1/4  1     1   1    1   0   0   0   0   0                     
          1 3/4  1     0   1    0   0   1   0   0   0                     
          2 1/4  0     1   0    1   0   1   0   1   0                     
 1/5 ×                                                              
          1 1/5  1     1   1    1   1   0   0   0   0                     
          1 2/5  1     1   0    1   1   1   0   0   0                     
          1 3/5  1     0   1    1   0   1   1   0   0                     
______________________________________                                    
 
    
     It can be seen from the above table that the selected pattern covers a period of cycles of the internal clock and that the pattern repeats every period. This period has a number of cycles L of the internal clock, wherein: 
     
         L=(n)×(MF) 
    
     where, 
     n is an integer fraction 
     MF is the non-integer multiple (i.e. the multiplication frequency). 
     To generalize the present invention for 1/n× multiple timing, PLL 10 and latch circuit 20, as described in the preferred embodiment, remain unchanged. Sync generator 30, however, must be designed to accommodate 1/n multiple clocking. The same criteria as described in the preferred embodiment still apply. busclk and sysclk must be synchronized clocks (i.e. having an &#34;in-phase&#34; condition when both busclk and sysclk have rising edges), and busclk&#39;s falling edge must always occur later than the next sysclk rising edge. For the generalized case, count logic 70 would be designed to produce the appropriate pattern for the multiple frequency of sysclk, as described above. In addition, the number of latches required in sync generator 30 is also a function of the non-integer multiple frequency of sysclk. The number of latches required is calculated as follows: 
     
         number-latches=(n)×(MF) 
    
     where, 
     MF is the multiplication factor (non-integer multiple) 
     n is the integer fraction. 
     Two examples are given below. 
     EXAMPLE 1 
     MF=1 1/4 (one and one quarter) 
     n=4(1/4× clocking) #latches=4×1 1/4=5. 
     EXAMPLE 2 
     MF=5 2/3 (five and two thirds) 
     n=3 (1/3× clocking) #latches=3×5 2/3=17. 
     As used herein, the multiplication factor (MF) is equal to the ratio of the internal clock frequency to the external clock frequency. The multiplication factor may be an integer multiple or a non-integer multiple, according to the present invention. Also, as used herein, the integer fraction (n) is the fractional remainder of a non-integer multiple internal clock frequency (i.e., the fractional remainder of a non-integer multiplication frequency). For example, for a non-integer multiple of 2 1/2, MF=2.5 and n=2. 
     While the invention has been particularly shown and described with reference to a preferred embodiment, it will be understood by those skilled in the art that various changes in form and detail may be made therein without departing from the spirit and scope of the invention.