Abstract:
A method of optimizing communication over a high-speed serial bus by minimizing the delay between packets transmitted over the bus is disclosed. The method comprises: calculating the round trip delay between PHYs connected on the bus by pinging; a bus manager sending a configuration packet to all PHYs connected on the bus, the configuration packet containing a minimum gap_count parameter value; and all PHYs connected on the bus sending packets over the bus using the minimum gap_count parameter value as a delay between packets.

Description:
PRIORITY 
       [0001]    This application is a continuation of co-owned and co-pending U.S. patent application Ser. No. 10/749,791 of the same title filed Dec. 29, 2003, incorporated herein by reference in its entirety. 
     
    
     FIELD OF THE INVENTION 
       [0002]    The present invention relates broadly to serial bus performance. Specifically, the present invention relates to improving bus performance by calculating the optimal gap_count parameter for a given topology utilizing a high-speed serial bus to connect devices. 
       BACKGROUND OF THE INVENTION 
       [0003]    The Institute of Electrical and Electronic Engineers (IEEE) has promulgated a number of versions of a high-speed serial bus protocol falling under the IEEE 1394 family of standards (referred to herein collectively as “1394”). A typical serial bus having a 1394 architecture interconnects multiple node devices via point-to-point links, such as cables, each connecting a single node on the serial bus to another node on the serial bus. Data packets are propagated throughout the serial bus using a number of point-to-point transactions, such that a node that receives a packet from another node via a first point-to-point link retransmits the received packet via other point-to-point links. A tree network configuration and associated packet handling protocol ensures that each node receives every packet once. The 1394-compliant serial bus may be used as an alternate bus for the parallel backplane of a computer system, as a low cost peripheral bus, or as a bus bridge between architecturally compatible buses. Bus performance is gauged by throughput, or the amount of data that can be transmitted over the bus during a period of time. 
         [0004]    There are several ways to improve bus performance. Devices connected to the bus can be arranged to minimize the longest round-trip delay between any two leaf nodes. This may involve either minimizing the number of cable connections between the farthest devices, reducing cable lengths, or both. Another way to improve bus performance is to group devices with identical speed capabilities next to one another. This avoids the creation of a “speed trap” when a slower device lies along the path between the two faster devices. Finally, bus performance can be improved by setting the PHY gap count parameter to the lowest workable value for a particular topology. However, determining this lowest workable value is problematic in that all of the variables affecting this value are unknown. Gap count parameters have been configured in the past using a subset of all possible variables, and the result is that the gap count is not optimal. 
       SUMMARY OF THE INVENTION 
       [0005]    The present invention provides an optimal gap count that allows a high-speed serial bus to run faster and thus realize superior performance over prior buses. In an embodiment, bus management software sends a special PHY configuration packet that is recognized by all PHYs on the bus. The configuration packet contains a gap count value that all PHYs on the bus can use. As this gap count value decreases the time interval between packets that are transmitted, more real data can be transmitted over the bus per unit of time. 
         [0006]    In an embodiment, the bus manager pings a PHY. The PHY sends a response to the ping, and a flight time value of the response from the PHY to the bus manager is added to calculate a round trip delay value. The ping command runs at the link layer level, from the link layer of one node to the link layer of another node. All flight time between link layer and PHY is ignored, and just the flight time from one PHY to another PHY is calculated. The ping time measured shows the link-to-link delay. The delay between the bus and the link is specified in the bus standard with minimum and maximum values. The PHY and link layer of a node is designed to be within that range specified by the standard. The round trip delay between nodes can be calculated as: 
         [0000]    
       
         
           
             
               Round_Trip 
                
               
                 _Delay 
                 max 
                 
                   [ 
                   
                     
                       P 
                       X 
                     
                      
                     
                       OP 
                       Y 
                     
                   
                   ] 
                 
               
             
             ≤ 
             
               
                 ( 
                 
                   
                     
                       
                         
                           Round_Trip 
                            
                           
                             _Delay 
                             
                               Ping 
                               , 
                               max 
                             
                             
                               [ 
                               
                                 
                                   P 
                                   BM 
                                 
                                  
                                 
                                     
                                 
                                  
                                 O 
                                  
                                 
                                     
                                 
                                  
                                 
                                   P 
                                   X 
                                 
                               
                               ] 
                             
                           
                         
                         + 
                         
                           
                             
                               ∑ 
                               
                                 ( 
                                 
                                   BM 
                                   , 
                                   X 
                                 
                                 ) 
                               
                             
                             n 
                           
                            
                           
                             2 
                             · 
                             
                               Jitter 
                               n 
                             
                           
                         
                         + 
                       
                     
                   
                   
                     
                       
                         
                           Round_Trip 
                            
                           
                             _Delay 
                             
                               Ping 
                               , 
                               max 
                             
                             
                               [ 
                               
                                 
                                   P 
                                   BM 
                                 
                                  
                                 
                                     
                                 
                                  
                                 O 
                                  
                                 
                                     
                                 
                                  
                                 
                                   P 
                                   Y 
                                 
                               
                               ] 
                             
                           
                         
                         + 
                         
                           
                             
                               ∑ 
                               
                                 ( 
                                 
                                   BM 
                                   , 
                                   Y 
                                 
                                 ) 
                               
                             
                             n 
                           
                            
                           
                             2 
                             · 
                             
                               Jitter 
                               n 
                             
                           
                         
                         + 
                       
                     
                   
                   
                     
                       
                         
                           PHY_DELAY 
                           
                             N 
                             , 
                             max 
                           
                           
                             
                               P 
                               N 
                               ′ 
                             
                             -&gt; 
                             
                               P 
                               N 
                             
                           
                         
                         + 
                         
                           ARB_RESPONSE 
                            
                           
                             _DELAY 
                             
                               N 
                               , 
                               max 
                             
                             
                               
                                 P 
                                 N 
                               
                               -&gt; 
                               
                                 P 
                                 N 
                                 ′ 
                               
                             
                           
                         
                       
                     
                   
                 
                 ) 
               
               - 
               
                 ( 
                 
                   
                     
                       
                         
                           
                             2 
                             · 
                             Round_Trip 
                           
                            
                           
                             _Delay 
                             
                               Ping 
                               , 
                               min 
                             
                             
                               [ 
                               
                                 
                                   P 
                                   BM 
                                 
                                  
                                 
                                   OP 
                                   N 
                                 
                               
                               ] 
                             
                           
                         
                         + 
                         
                           4 
                           · 
                           
                             Jitter 
                             N 
                           
                         
                         + 
                       
                     
                   
                   
                     
                       
                         
                           PHY_DELAY 
                           
                             N 
                             , 
                             min 
                           
                           
                             
                               P 
                               N 
                               BM 
                             
                             -&gt; 
                             
                               P 
                               N 
                               ′ 
                             
                           
                         
                         + 
                         
                           ARB_RESPONSE 
                            
                           
                             _DELAY 
                             
                               N 
                               , 
                               min 
                             
                             
                               
                                 P 
                                 N 
                                 ′ 
                               
                               -&gt; 
                               
                                 P 
                                 N 
                                 BM 
                               
                             
                           
                         
                         + 
                       
                     
                   
                   
                     
                       
                         
                           PHY_DELAY 
                           
                             N 
                             , 
                             min 
                           
                           
                             
                               P 
                               N 
                               BM 
                             
                             -&gt; 
                             
                               P 
                               N 
                             
                           
                         
                         + 
                         
                           ARB_RESPONSE 
                            
                           
                             _DELAY 
                             
                               N 
                               , 
                               min 
                             
                             
                               
                                 P 
                                 N 
                               
                               -&gt; 
                               
                                 P 
                                 N 
                                 BM 
                               
                             
                           
                         
                       
                     
                   
                 
                 ) 
               
             
           
         
       
     
         [0007]    This value can be communicated as the gap count parameter contained in the configuration packet, thus setting the gap between packets to an optimal value and increasing bus performance. 
         [0008]    In another aspect of the invention, an apparatus for calculating and enforcing a substantially optimized gap count parameter is disclosed. In one embodiment, the apparatus comprises: a first module adapted to receive first data, the first data indicating the largest idle period allowable during a first interval; a second module adapted to receive second data, the second data indicating the largest period allowable for a second interval; and a third module adapted to calculate a gap parameter based at least in part upon the largest idle period allowable during the first interval, and the largest period allowable for the second interval. 
         [0009]    In one variant, the first interval comprises a subaction. 
         [0010]    In another variant, the first interval comprises an isochronous interval. 
         [0011]    In yet another variant, the second interval comprises a subaction gap. 
         [0012]    In still a further variant, the third module is further adapted to calculate a gap parameter by a process comprising setting a value such that the value exceeds the largest idle period allowable during the first interval. For example, the value may comprise a subaction gap timeout. 
         [0013]    In still another variant, the third module is further adapted to calculate a gap parameter by a process comprising setting a value such that the value exceeds the largest period allowable for the second interval. For example, the value may comprise an arbitration reset gap. 
         [0014]    In yet a further variant, the apparatus further comprises: a fourth module adapted to ensure that a first idle period observed is repeated with a period not less than the largest idle period allowable during the first interval; and a fifth module adapted to ensure that a second idle period observed is repeated with a period not less than the largest period allowable for the second interval. 
         [0015]    In another aspect of the invention, a storage apparatus comprising a computer readable medium is disclosed. In one embodiment, the medium comprises a program having a plurality of instructions which, when executed by a computer, enforces a gap count parameter by: setting a first value to be greater than the largest idle period allowable during a first interval; setting a second value to be greater than the largest period allowable for a second interval; requiring that a first idle period observed is repeated with a period not less than the largest idle period allowable during the first interval; and requiring that a second idle period observed is repeated with a period not less than the largest period allowable for the second interval. 
         [0016]    In one variant, the first interval comprises a subaction. 
         [0017]    In another variant, the first interval comprises an isochronous interval. 
         [0018]    In still another variant, the second interval comprises a subaction gap. 
         [0019]    In yet another variant, the first value comprises a subaction gap timeout. 
         [0020]    In a further variant, the second value comprises an arbitration reset timeout. 
         [0021]    In yet another aspect of the invention, a method for enforcing a gap count parameter for use in a data bus is disclosed. In one embodiment, the method comprises: receiving first data, the first data indicating the largest idle period allowable during a first interval; receiving second data, the second data indicating the largest period allowable for a second interval; determining a gap count parameter based at least in part by setting a value greater than at least one of the first and second data. 
         [0022]    In one variant, the first interval comprises at least one of a subaction and an isochronous interval. 
         [0023]    In another variant, the second interval comprises a subaction gap. 
         [0024]    In still another variant, the method further comprises requiring that a first idle period observed is repeated with a period not less than the largest idle period allowable during the first interval. 
         [0025]    In yet another variant, the method further comprises requiring that a second idle period observed is repeated with a period not less than the largest period allowable for the second interval. 
         [0026]    In a further aspect of the invention, an apparatus for enforcing a substantially optimized gap count parameter associated with a data bus is disclosed. In one embodiment, the apparatus comprises: a first module adapted to store a first variable greater than the largest idle period allowable during a first interval; a second module adapted to store a second variable greater than the largest period allowable for a second interval; a third module adapted to calculate a substantially optimal gap count parameter based at least in part upon the first and second variables; and a fourth module adapted to ensure that an idle period observed is not repeated with a period less than at least one of the first and second variables. 
         [0027]    In one variant, the data bus comprises a serial bus, and the first interval comprises at least one of a subaction and an isochronous interval. 
         [0028]    In another variant, the second interval comprises a subaction gap. 
         [0029]    In yet another variant, the first variable comprises a subaction gap timeout value. 
         [0030]    In still a further variant, the second variable comprises an arbitration reset timeout value. 
         [0031]    In still another variant, the third module is further adapted to calculate a substantially optimal gap count parameter based at least in part upon a maximum round trip delay between a first PHY associated with a first node and a second PHY associated with a second node. 
         [0032]    In still another aspect of the invention, a method for enforcing an optimized gap count parameter associated with a data bus is disclosed. In one embodiment, the method comprises: determining the largest idle period allowable during a first interval; determining the largest period allowable for a second interval; and deriving a gap count parameter based at least in part by setting a first value to be greater than the largest idle period allowable during the first interval, and based at least in part by setting a second value to be greater than the largest period allowable for the second interval. 
         [0033]    In one variant, the method further comprises requiring that an idle period observed is not repeated with a period less than at least one of the largest idle period allowable during the first interval, and the largest period allowable for the second interval. 
         [0034]    In another variant, the derivation of a gap count parameter is also based at least in part by calculating a maximum round trip delay between a first PHY associated with a first node and a second PHY associated with a second node. 
         [0035]    Many other features and advantages of the present application will become apparent from the following detailed description considered in conjunction with the accompanying drawings, in which: 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0036]      FIG. 1  illustrates an intervening path model between two nodes, X &amp; Y, and denotes the reference points required for a full analysis; 
           [0037]      FIG. 2  illustrates ack/iso gap preservation, in the case where PHY X originated the most recent packet and PHY Y is responding (either with an ack or the next isochronous arbitration/packet). 
           [0038]      FIG. 3  illustrates the sequence PHY Y will follow in responding to a received packet. 
           [0039]      FIG. 4  illustrates subaction gap preservation, in the case where PHY X originated the most recent packet and PHY Y is responding after a subaction gap with arbitration for the current fairness interval. 
           [0040]      FIG. 5  illustrates consistent subaction gap detection, in the case where PHY X originates an isochronous packet, observes a subaction_gap, and begins to drive an arbitration indication. 
           [0041]      FIG. 6  illustrates an internal gap detection sequence, by showing the timing reference for relating the external gap detection times to the internal gap detection times. 
           [0042]      FIG. 7  illustrates consistent arbitration reset gap detection, in the case where PHY X originates an asynchronous packet, observes an arbitration reset gap, and begins to drive an arbitration indication. 
           [0043]      FIG. 8  illustrates a ping subaction issued by the link in Node X and directed to Node Y. 
           [0044]      FIG. 9  illustrates a Bus Manager Leaf to Leaf topology. 
           [0045]      FIG. 10  illustrates a topology where the bus manager is not a leaf but is part of the connecting path between the two leaves. 
           [0046]      FIG. 11  illustrates a topology where the bus manager is not a leaf but is not part of the connecting path between the two leaves. 
       
    
    
     DETAILED DESCRIPTION 
       [0047]    Four well known limiting corner cases for gap count are examined in an effort to find the minimum allowable gap count for a given topology. Both the table method and pinging method of determining the optimal gap count are explored. 
         [0048]    It is important to note that this analysis assumes that PHY_DELAY can never exceed the maximum published in the PHY register set. However, corner conditions have been identified in which it is theoretically possible to have PHY_DELAY temporarily exceed the maximum published delay when repeating minimally spaced packets. Although not a rigorous proof, this phenomena is ignored for this analysis on the basis that it is presumed to be statistically insignificant. 
         [0049]    The path between any two given PHYs can be represented as a daisy chain connection of the two devices with zero or more intervening, or repeating, PHYs.  FIG. 1  illustrates such a path between two nodes, X &amp; Y, and denotes the reference points required for a full analysis. 
         [0000]    
       
         
               
             
               
               
             
           
               
                 TABLE 1 
               
               
                   
               
               
                 Variable Definitions 
               
               
                   
               
             
             
               
                   
               
             
          
           
               
                 ARB_RESPONSE_DELAY n   P     n     →P′     n     
                 Delay in propagating arbitration indication received 
               
               
                   
                 from port P n  of PHY n to port P′ n  of PHY n. 
               
               
                 BASERATE n   
                 Fundamental operating frequency of PHY n. 
               
               
                 cable_delay n   
                 One-way flight time of arbitration and data signals 
               
               
                   
                 through cable n . The flight-time is assumed to be 
               
               
                   
                 constant from one transmission to the next and 
               
               
                   
                 symmetric. 
               
               
                 DATA_END_TIME n   P     n     
                 Length of DATA_END transmitted on port P n  of 
               
               
                   
                 PHY n. 
               
               
                 PHY_DELAY n   P′     n     →P     n     
                 Time from receipt of first data bit at port P′ n  of 
               
               
                   
                 PHY n to re-transmission of same bit at port P n  of 
               
               
                   
                 PHY n. 
               
               
                 RESPONSE_TIME n   P′     n     
                 Idle time at port P′ n  of PHY n between the 
               
               
                   
                 reception of a inbound packet and the associated 
               
               
                   
                 outbound arbitration indication for the subsequent 
               
               
                   
                 packet intended to occur within the same 
               
               
                   
                 isochronous interval or asynchronous subaction. 
               
               
                   
               
             
          
         
       
     
         [0050]    For any given topology, the gap count must be set such that an iso or ack gap observed/generated at one PHY isn&#39;t falsely interpreted as a subaction gap by another PHY in the network. Ack/Iso gaps are known to be at their largest nearest the PHY that originated the last packet. To ensure that the most recent originating PHY doesn&#39;t interrupt a subaction or isochronous interval with asynchronous arbitration, its subaction_gap timeout must be greater than the largest IDLE which can legally occur within a subaction or isochronous interval.  FIG. 2  illustrates the case in which PHY X originated the most recent packet and PHY Y is responding (either with an ack or the next isochronous arbitration/packet). 
         [0051]    For all topologies, the idle time observed at point Px must not exceed the subaction gap detection time: 
         [0000]      Idle max   P     X   &lt;subaction_gap min   P     X     (1) 
         [0052]    The idle time at point Px can be determined by examining the sequence of time events in the network. All timing events are referenced to the external bus (as opposed to some internal point in the PHY).
       t 0  First bit of packet sent at point P x      t 1  Last bit of packet sent at point P x , DATA_END begins. t 1  follows t 0  by the length of the packet timed in PHY X&#39;s clock domain.   t 2  DATA_END concludes at point P x , IDLE begins. t 2  follows t 1  by DATA_END_TIME X   P     X        t 3  First bit of packet received at point P′ Y . t 3  follows to by all intervening cable_delay and PHY_DELAY instances.   t 4  Last bit of packet received at point P′ Y . t 4  follows t 3  by the length of the packet timed in PHY Y−1&#39;s clock domain.   t 5  DATA_END concludes at point P′ Y , gap begins. t 5  follows t 4  by DATA_END_TIME Y−1   P     Y−1        t 6  PHY Y responds with ack packet, isoch packet, or isoch arbitration within RESPONSE_TIME Y   P′     Y    following t 5      t 7  Arbitration indication arrives at point P X . t 7  follows t 6  by the all intervening cable_delay and ARB_RESPONSE_DELAY instances.       
 
         [0000]    
       
         
           
             
               
                 
                   
                       
                   
                    
                   
                     
                       t 
                       1 
                     
                     = 
                     
                       
                         t 
                         0 
                       
                       + 
                       
                         packet_length 
                         
                           packet_speed 
                           · 
                           
                             BASERATE 
                             X 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         
                           
                               
                           
                            
                           
                             
                               t 
                               2 
                             
                             = 
                               
                              
                             
                               
                                 t 
                                 1 
                               
                               + 
                               
                                 DATA_END 
                                  
                                 
                                   _TIME 
                                   X 
                                   
                                     P 
                                     X 
                                   
                                 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           = 
                             
                            
                           
                             
                               t 
                               0 
                             
                             + 
                             
                               packet_length 
                               
                                 packet_speed 
                                 · 
                                 
                                   BASERATE 
                                   X 
                                 
                               
                             
                             + 
                           
                         
                       
                     
                     
                       
                         
                             
                            
                           
                             DATA_END 
                              
                             
                               _TIME 
                               X 
                               
                                 P 
                                 X 
                               
                             
                           
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                     
                       
                         
                           
                             t 
                             3 
                           
                           = 
                           
                             
                               t 
                               0 
                             
                             + 
                             
                               cable_delay 
                               X 
                             
                             + 
                             
                               
                                 ∑ 
                                 
                                   n 
                                   = 
                                   
                                     X 
                                     + 
                                     1 
                                   
                                 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                                
                               
                                 ( 
                                 
                                   
                                     cable_delay 
                                     n 
                                   
                                   + 
                                   
                                     PHY_DELAY 
                                     n 
                                     
                                       
                                         P 
                                         n 
                                         ′ 
                                       
                                       -&gt; 
                                       
                                         P 
                                         n 
                                       
                                     
                                   
                                 
                                 ) 
                               
                             
                           
                         
                       
                       
                         
                             
                         
                       
                     
                   
                 
               
               
                 
                   
                     
                       
                         ( 
                         3 
                         ) 
                       
                     
                   
                   
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                   
                   
                     
                       
                           
                       
                     
                   
                   
                     
                       
                         ( 
                         4 
                         ) 
                       
                     
                   
                 
               
             
             
               
                 
                   
                     
                       
                         
                             
                         
                          
                         
                           
                             t 
                             4 
                           
                           = 
                             
                            
                           
                             
                               t 
                               3 
                             
                             + 
                             
                               packet_length 
                               
                                 packet_speed 
                                 · 
                                 
                                   BASERATE 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             0 
                           
                           + 
                           
                             cable_delay 
                             X 
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   cable_delay 
                                   n 
                                 
                                 + 
                                 
                                   PHY_DELAY 
                                   n 
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           packet_length 
                           
                             packet_speed 
                             · 
                             
                               BASERATE 
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         
                             
                         
                          
                         
                           
                             t 
                             5 
                           
                           = 
                             
                            
                           
                             
                               t 
                               4 
                             
                             + 
                             
                               DATA_END 
                                
                               
                                 _TIME 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                                 
                                   P 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             0 
                           
                           + 
                           
                             cable_delay 
                             X 
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   cable_delay 
                                   n 
                                 
                                 + 
                                 
                                   PHY_DELAY 
                                   n 
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                             
                           
                           + 
                           
                             DATA_END 
                              
                             
                               _TIME 
                               
                                 Y 
                                 - 
                                 1 
                               
                               
                                 P 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         
                             
                         
                          
                         
                           
                             t 
                             6 
                           
                           = 
                             
                            
                           
                             
                               t 
                               5 
                             
                             + 
                             
                               RESPONSE_TIME 
                               Y 
                               
                                 P 
                                 Y 
                                 ′ 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             0 
                           
                           + 
                           
                             cable_delay 
                             X 
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   cable_delay 
                                   n 
                                 
                                 + 
                                 
                                   PHY_DELAY 
                                   n 
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             DATA_END 
                              
                             
                               _TIME 
                               
                                 Y 
                                 - 
                                 1 
                               
                               
                                 P 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                             
                           
                           + 
                           
                             RESPONSE_TIME 
                             Y 
                             
                               P 
                               Y 
                               ′ 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         
                             
                         
                          
                         
                           
                             t 
                             7 
                           
                           = 
                             
                            
                           
                             
                               t 
                               6 
                             
                             + 
                             
                               
                                 ∑ 
                                 
                                   n 
                                   = 
                                   
                                     X 
                                     + 
                                     1 
                                   
                                 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                                
                               
                                 ( 
                                 
                                   
                                     
                                       
                                         
                                           cable_delay 
                                           n 
                                         
                                         + 
                                       
                                     
                                   
                                   
                                     
                                       
                                         ARB_RESPONSE 
                                          
                                         
                                           _DELAY 
                                           n 
                                           
                                             
                                               P 
                                               n 
                                             
                                             -&gt; 
                                             
                                               P 
                                               n 
                                               ′ 
                                             
                                           
                                         
                                       
                                     
                                   
                                 
                                 ) 
                               
                             
                             + 
                           
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           cable_delay 
                           X 
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             0 
                           
                           + 
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   
                                     
                                       
                                         2 
                                         · 
                                         
                                           cable_delay 
                                           n 
                                         
                                       
                                       + 
                                       
                                         PHY_DELAY 
                                         n 
                                         
                                           
                                             P 
                                             n 
                                             ′ 
                                           
                                           -&gt; 
                                           
                                             P 
                                             n 
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       ARB_RESPONSE 
                                        
                                       
                                         _DELAY 
                                         n 
                                         
                                           
                                             P 
                                             n 
                                           
                                           -&gt; 
                                           
                                             P 
                                             n 
                                             ′ 
                                           
                                         
                                       
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             2 
                             · 
                             
                               cable_delay 
                               X 
                             
                           
                           + 
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             DATA_END 
                              
                             
                               _TIME 
                               
                                 Y 
                                 - 
                                 1 
                               
                               
                                 P 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                             
                           
                           + 
                           
                             RESPONSE_TIME 
                             Y 
                             
                               P 
                               Y 
                               ′ 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Given t 0  through t 7  above, the Idle time seen at point P X  is given as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Idle 
                           
                             P 
                             X 
                           
                         
                         = 
                           
                          
                         
                           
                             t 
                             7 
                           
                           - 
                           
                             t 
                             2 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             ∑ 
                             
                               n 
                               = 
                               
                                 X 
                                 + 
                                 1 
                               
                             
                             
                               Y 
                               - 
                               1 
                             
                           
                            
                           
                             ( 
                             
                               
                                 2 
                                 · 
                                 
                                   cable_delay 
                                   n 
                                 
                               
                               + 
                               
                                 PHY_DELAY 
                                 n 
                                 
                                   
                                     P 
                                     n 
                                     ′ 
                                   
                                   -&gt; 
                                   
                                     P 
                                     n 
                                   
                                 
                               
                               + 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         
                             
                            
                           
                             ARB_RESPONSE 
                              
                             
                               _DELAY 
                               n 
                               
                                 
                                   P 
                                   n 
                                 
                                 -&gt; 
                                 
                                   P 
                                   n 
                                   ′ 
                                 
                               
                             
                           
                           ) 
                         
                         + 
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             2 
                             · 
                             
                               cable_delay 
                               X 
                             
                           
                           + 
                           
                             RESPONSE_TIME 
                             Y 
                             
                               P 
                               Y 
                               ′ 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             DATA_END 
                              
                             
                               _TIME 
                               
                                 Y 
                                 - 
                                 1 
                               
                               
                                 P 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                             
                           
                           - 
                           
                             DATA_END 
                              
                             
                               _TIME 
                               X 
                               
                                 P 
                                 X 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             packet_length 
                             packet_speed 
                           
                           · 
                           
                             ( 
                             
                               
                                 1 
                                 
                                   BASERATE 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                 
                               
                               - 
                               
                                 1 
                                 
                                   BASERATE 
                                   X 
                                 
                               
                             
                             ) 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
             
               
                 
                   
                       
                   
                    
                   
                     Let 
                      
                     
                       : 
                     
                   
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     DE_delta 
                     
                       [ 
                       
                         
                           P 
                           
                             Y 
                             - 
                             1 
                           
                         
                         , 
                         
                           P 
                           X 
                         
                       
                       ] 
                     
                   
                   = 
                   
                     
                       DATA_END 
                        
                       
                         _TIME 
                         
                           Y 
                           - 
                           1 
                         
                         
                           P 
                           
                             Y 
                             - 
                             1 
                           
                         
                       
                     
                     - 
                     
                       DATA_END 
                        
                       
                         _TIME 
                         X 
                         
                           P 
                           X 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
             
               
                 
                   
                     PPM_delta 
                     
                       [ 
                       
                         
                           Y 
                           - 
                           1 
                         
                         , 
                         X 
                       
                       ] 
                     
                   
                   = 
                   
                     
                       packet_length 
                       packet_speed 
                     
                     · 
                     
                       ( 
                       
                         
                           1 
                           
                             BASERATE 
                             
                               Y 
                               - 
                               1 
                             
                           
                         
                         - 
                         
                           1 
                           
                             BASERATE 
                             X 
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         
                           [ 
                           
                             
                               P 
                               X 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               Y 
                             
                           
                           ] 
                         
                       
                     
                     = 
                     
                       
                         
                           ∑ 
                           
                             n 
                             = 
                             
                               X 
                               + 
                               1 
                             
                           
                           
                             Y 
                             - 
                             1 
                           
                         
                          
                         
                           ( 
                           
                             
                               2 
                               · 
                               
                                 cable_delay 
                                 n 
                               
                             
                             + 
                             
                               PHY_DELAY 
                               n 
                               
                                 
                                   P 
                                   n 
                                   ′ 
                                 
                                 -&gt; 
                                 
                                   P 
                                   n 
                                 
                               
                             
                             + 
                             
                               ARB_RESPONSE 
                                
                               
                                 _DELAY 
                                 n 
                                 
                                   
                                     P 
                                     n 
                                   
                                   -&gt; 
                                   
                                     P 
                                     n 
                                     ′ 
                                   
                                 
                               
                             
                           
                           ) 
                         
                       
                       + 
                       
                         2 
                         · 
                         
                           cable_delay 
                           X 
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                       
                   
                    
                   
                     Then 
                     , 
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
             
               
                 
                   
                     Idle 
                     
                       P 
                       X 
                     
                   
                   = 
                   
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         
                           [ 
                           
                             
                               P 
                               X 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               Y 
                             
                           
                           ] 
                         
                       
                     
                     + 
                     
                       RESPONSE_TIME 
                       Y 
                       
                         P 
                         Y 
                         ′ 
                       
                     
                     + 
                     
                       DE_delta 
                       
                         [ 
                         
                           
                             P 
                             
                               Y 
                               - 
                               1 
                             
                           
                           , 
                           
                             P 
                             X 
                           
                         
                         ] 
                       
                     
                     + 
                     
                       PPM_delta 
                       
                         [ 
                         
                           
                             Y 
                             - 
                             1 
                           
                           , 
                           X 
                         
                         ] 
                       
                     
                   
                 
               
               
                 
                   ( 
                   13 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Substituting into Equation (1), Ack and Iso gaps are preserved network-wide if and only if: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 Round_Trip 
                                  
                                 
                                   _Delay 
                                   
                                     [ 
                                     
                                       
                                         P 
                                         X 
                                       
                                        
                                       
                                         OP 
                                         Y 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 RESPONSE_TIME 
                                 Y 
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       
                                         Y 
                                         - 
                                         1 
                                       
                                     
                                     , 
                                     
                                       P 
                                       X 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               PPM_delta 
                               
                                 [ 
                                 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                   , 
                                   X 
                                 
                                 ] 
                               
                             
                           
                         
                       
                       ] 
                     
                     max 
                   
                   &lt; 
                   
                     subaction_gap 
                     min 
                     
                       P 
                       X 
                     
                   
                 
               
               
                 
                   ( 
                   14 
                   ) 
                 
               
             
           
         
       
     
         [0061]    The minimum subaction_gap at point Px isn&#39;t well known. IEEE1394-1995, in Table 4-33, defines the minimum subaction_gap timeout used at a PHY&#39;s internal state machines, not at the external interface. It has been argued that the internal and external representations of time may differ by as much as ARB_RESPONSE_DELAY when a PHY is counting elapsed time between an internally generated event and an externally received event. However, the ARB_RESPONSE_DELAY value for a particular PHY isn&#39;t generally known externally. Fortunately, the ARB_RESPONSE_DELAY value for a PHY whose FIFO is known to be empty is bounded by the worst case PHY_DELAY reported within the PHY register map. This suggests a realistic bound for the minimum subaction gap referenced at point Px: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       subaction_gap 
                       min 
                       
                         P 
                         X 
                       
                     
                     ≥ 
                     
                       
                         subaction_gap 
                         min 
                         
                           i 
                           X 
                         
                       
                       - 
                       
                         PHY_DELAY 
                         
                           X 
                           , 
                           max 
                         
                         
                           P 
                           X 
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   where 
                 
               
               
                 
                   ( 
                   15 
                   ) 
                 
               
             
             
               
                 
                   
                     subaction_gap 
                     min 
                     
                       i 
                       X 
                     
                   
                   = 
                   
                     
                       27 
                       + 
                       
                         gap_count 
                         · 
                         16 
                       
                     
                     
                       BASERATE 
                       
                         X 
                         , 
                         max 
                       
                     
                   
                 
               
               
                 
                   ( 
                   16 
                   ) 
                 
               
             
           
         
       
     
       Combing Equations (14), (15), and (16): 
       [0062]    
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 Round_Trip 
                                  
                                 
                                   _Delay 
                                   
                                     [ 
                                     
                                       
                                         P 
                                         X 
                                       
                                        
                                       
                                         OP 
                                         Y 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 RESPONSE_TIME 
                                 Y 
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       
                                         Y 
                                         - 
                                         1 
                                       
                                     
                                     , 
                                     
                                       P 
                                       X 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               PPM_delta 
                               
                                 [ 
                                 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                   , 
                                   X 
                                 
                                 ] 
                               
                             
                           
                         
                       
                       ] 
                     
                     max 
                   
                   &lt; 
                   
                     [ 
                     
                         
                     
                      
                     
                       
                         
                           
                             
                               
                                 27 
                                 + 
                                 
                                   gap_count 
                                   · 
                                   16 
                                 
                               
                               
                                 BASERATE 
                                 
                                   X 
                                   , 
                                   max 
                                 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             PHY_DELAY 
                             
                               X 
                               , 
                               max 
                             
                             
                               P 
                               X 
                             
                           
                         
                       
                     
                      
                     
                         
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Solving for gap count: 
         [0000]    
       
         
           
             
               
                 
                   gap_count 
                   &gt; 
                   
                     
                       
                         
                           BASERATE 
                           
                             X 
                             , 
                             max 
                           
                         
                         · 
                         
                           [ 
                           
                               
                           
                            
                           
                             
                               
                                 
                                   
                                     Round_Trip 
                                      
                                     
                                       _Delay 
                                       max 
                                       
                                         [ 
                                         
                                           
                                             P 
                                             X 
                                           
                                            
                                           
                                             OP 
                                             Y 
                                           
                                         
                                         ] 
                                       
                                     
                                   
                                   + 
                                 
                               
                             
                             
                               
                                 
                                   
                                     
                                       [ 
                                       
                                         
                                           
                                             
                                               
                                                 RESPONSE_TIME 
                                                 Y 
                                                 
                                                   P 
                                                   Y 
                                                   ′ 
                                                 
                                               
                                               + 
                                             
                                           
                                         
                                         
                                           
                                             
                                               
                                                 DE_delta 
                                                 
                                                   [ 
                                                   
                                                     
                                                       P 
                                                       
                                                         Y 
                                                         - 
                                                         1 
                                                       
                                                     
                                                     , 
                                                     
                                                       P 
                                                       X 
                                                     
                                                   
                                                   ] 
                                                 
                                               
                                               + 
                                             
                                           
                                         
                                         
                                           
                                             
                                               PPM_delta 
                                               
                                                 [ 
                                                 
                                                   
                                                     Y 
                                                     - 
                                                     1 
                                                   
                                                   , 
                                                   X 
                                                 
                                                 ] 
                                               
                                             
                                           
                                         
                                       
                                       ] 
                                     
                                     max 
                                   
                                   + 
                                 
                               
                             
                             
                               
                                 
                                   PHY_DELAY 
                                   
                                     X 
                                     , 
                                     max 
                                   
                                   
                                     P 
                                     X 
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                        
                       
                           
                       
                       - 
                       27 
                     
                     
                       ( 
                       16 
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   18 
                   ) 
                 
               
             
           
         
       
     
         [0063]    Since RESPONSE_TIME, DE_delta, and PPM_delta are not independent parameters, the maximum of their sum is not accurately represented by the sum of their maximas. Finding a more accurate maximum for the combined quantity requires the identification of components of RESPONSE_TIME. 
         [0064]    As specified in p1394a, RESPONSE_TIME includes the time a responding node takes to repeat the received packet and then drive a subsequent arbitration indication. (Note that by examination of the C code, RESPONSE_TIME is defined to include the time it takes to repeat a packet even if the PHY in question is a leaf node.)  FIG. 3  illustrates the sequence PHY Y will follow in responding to a received packet. iy denotes the timings as seen/interpreted by the PHY state machine. Note that PY can be any repeating port on PHY Y. Consequently, the timing constraints referenced to PY in the following analysis must hold worst case for any and all repeating ports. 
         [0065]    Beginning with the first arrival of data at P′Y (t 3 ), the elaborated timing sequence for RESPONSE_TIME is:
       t 3  First bit of packet received at point P′ Y      t 3 ′ First bit of packet repeated at point P Y . t 3 ′ lags t 3  by PHY_DELAY   t 4  Last bit of packet received at point P′ Y . t 4  follows t 3  by the length of the packet timed in PHY N&#39;s clock domain. DATA_END begins   t 4 ′ Last bit of packet repeated at point P Y . t 4 ′ lags t 3 ′ by the length of the packet timed in PHY Y&#39;s clock domain. The PHY begins “repeating” DATA_END   t 5  DATA_END concludes at point P′ Y . t 5  follows t 4  by DATA_END_TIME Y−1   P     Y−1        t 5a  stop_tx_packet( ) concludes at point i Y  and the state machines command the PHY ports to stop repeating DATA_END. t 5 a leads t 5 ′ by any transceiver delay.   t 5 ′ DATA_END concludes at point P Y . t 5 ′ follows t 4 ′ by DATA_END_TIME Y   P     Y        t 5b  start_tx_packet( ) commences at point i Y  and the state machines command the PHY ports to begin driving the first arbitration indication of any response. t 5b  lags t 5a  by an IDLE_GAP and an unspecified state machine delay herein called SM_DELAY.   t 6  PHY Y drives arbitration at points P′ Y . t 6  follows t 5b  by any transceiver delay.       
 
         [0000]    
       
         
           
             
               
                 
                   
                     t 
                     
                       3 
                       ′ 
                     
                   
                   = 
                   
                     
                       t 
                       3 
                     
                     + 
                     
                       PHY_DELAY 
                       Y 
                       
                         
                           P 
                           Y 
                           ′ 
                         
                         -&gt; 
                         
                           P 
                           Y 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   19 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         
                           t 
                           
                             4 
                             ′ 
                           
                         
                         = 
                           
                          
                         
                           
                             t 
                             
                               3 
                               ′ 
                             
                           
                           + 
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 Y 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             3 
                           
                           + 
                           
                             PHY_DELAY 
                             Y 
                             
                               
                                 P 
                                 Y 
                                 ′ 
                               
                               -&gt; 
                               
                                 P 
                                 Y 
                               
                             
                           
                           + 
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 Y 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   20 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         
                           t 
                           
                             5 
                             ′ 
                           
                         
                         = 
                           
                          
                         
                           
                             t 
                             
                               4 
                               ′ 
                             
                           
                           + 
                           
                             DATA_END 
                              
                             
                               _TIME 
                               Y 
                               
                                 P 
                                 Y 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             3 
                           
                           + 
                           
                             PHY_DELAY 
                             Y 
                             
                               
                                 P 
                                 Y 
                                 ′ 
                               
                               -&gt; 
                               
                                 P 
                                 Y 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 Y 
                               
                             
                           
                           + 
                           
                             DATA_END 
                              
                             
                               _TIME 
                               Y 
                               
                                 P 
                                 Y 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   21 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         
                           T 
                           
                             5 
                              
                             
                                 
                             
                              
                             a 
                           
                         
                         = 
                           
                          
                         
                           
                             t 
                             
                               5 
                               ′ 
                             
                           
                           - 
                           
                             transceiver_delay 
                             Y 
                             
                               P 
                               Y 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             3 
                           
                           + 
                           
                             PHY_DELAY 
                             Y 
                             
                               
                                 P 
                                 Y 
                                 ′ 
                               
                               -&gt; 
                               
                                 P 
                                 Y 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 Y 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             DATA_END 
                              
                             
                               _TIME 
                               Y 
                               
                                 P 
                                 Y 
                               
                             
                           
                           - 
                           
                             transceiver_delay 
                             Y 
                             
                               P 
                               Y 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         
                           t 
                           
                             5 
                              
                             
                                 
                             
                              
                             b 
                           
                         
                         = 
                           
                          
                         
                           
                             t 
                             
                               5 
                                
                               
                                   
                               
                                
                               a 
                             
                           
                           + 
                           
                             IDLE_GAP 
                             Y 
                           
                           + 
                           
                             SM_DELAY 
                             Y 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             3 
                           
                           + 
                           
                             PHY_DELAY 
                             Y 
                             
                               
                                 P 
                                 Y 
                                 ′ 
                               
                               -&gt; 
                               
                                 P 
                                 Y 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 Y 
                               
                             
                           
                           + 
                           
                             DATA_END 
                              
                             
                               _TIME 
                               Y 
                               
                                 P 
                                 Y 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             IDLE_GAP 
                             Y 
                           
                           + 
                           
                             SM_DELAY 
                             Y 
                           
                           - 
                           
                             transceiver_delay 
                             Y 
                             
                               P 
                               Y 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   23 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       
                         
                           t 
                           6 
                         
                         = 
                           
                          
                         
                           
                             t 
                             
                               5 
                                
                               
                                   
                               
                                
                               b 
                             
                           
                           + 
                           
                             transceiver_delay 
                             Y 
                             
                               P 
                               Y 
                               ′ 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             3 
                           
                           + 
                           
                             PHY_DELAY 
                             Y 
                             
                               
                                 P 
                                 Y 
                                 ′ 
                               
                               -&gt; 
                               
                                 P 
                                 Y 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 Y 
                               
                             
                           
                           + 
                           
                             DATA_END 
                              
                             
                               _TIME 
                               Y 
                               
                                 P 
                                 Y 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             IDLE_GAP 
                             Y 
                           
                           + 
                           
                             SM_DELAY 
                             Y 
                           
                           + 
                           
                             transceiver_delay 
                             Y 
                             
                               P 
                               Y 
                               ′ 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           transceiver_delay 
                           Y 
                           
                             P 
                             Y 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   24 
                   ) 
                 
               
             
           
         
       
     
         [0000]    By definition, 
         [0000]      RESPONSE_TIME Y   P′     Y     =t   6   −t   5   (25) 
         [0000]    and through substitution: 
         [0000]    
       
         
           
             
               
                 
                   
                     RESPONSE_TIME 
                     Y 
                     
                       P 
                       Y 
                       ′ 
                     
                   
                   = 
                   
                     
                       PHY_DELAY 
                       Y 
                       
                         
                           P 
                           Y 
                           ′ 
                         
                         -&gt; 
                         
                           P 
                           Y 
                         
                       
                     
                     + 
                     
                       DE_delta 
                       
                         [ 
                         
                           
                             P 
                             Y 
                           
                           , 
                           
                             P 
                             
                               Y 
                               - 
                               1 
                             
                           
                         
                         ] 
                       
                     
                     + 
                     
                       PPM_delta 
                       
                         [ 
                         
                           Y 
                           , 
                           
                             Y 
                             - 
                             1 
                           
                         
                         ] 
                       
                     
                     + 
                     
                       IDLE_GAP 
                       Y 
                     
                     + 
                     
                       SM_DELAY 
                       Y 
                     
                     + 
                     
                       transceiver_delay 
                       Y 
                       
                         P 
                         Y 
                         ′ 
                       
                     
                     - 
                     
                       transceiver_delay 
                       Y 
                       
                         P 
                         Y 
                       
                     
                   
                 
               
               
                 
                   ( 
                   26 
                   ) 
                 
               
             
           
         
       
     
         [0000]    As such, the combination of RESPONSE_TIME, DE_delta, and PPM_delta from equation (18) can be represented as: 
         [0000]    
       
         
           
             
               
                 
                   
                     [ 
                     
                       
                         
                           
                             
                               RESPONSE_TIME 
                               Y 
                               
                                 P 
                                 Y 
                                 ′ 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               DE_delta 
                               
                                 [ 
                                 
                                   
                                     P 
                                     
                                       Y 
                                       - 
                                       1 
                                     
                                   
                                   , 
                                   
                                     P 
                                     X 
                                   
                                 
                                 ] 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             PPM_delta 
                             
                               [ 
                               
                                 
                                   Y 
                                   - 
                                   1 
                                 
                                 , 
                                 X 
                               
                               ] 
                             
                           
                         
                       
                     
                     ] 
                   
                   = 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 PHY_DELAY 
                                 Y 
                                 
                                   
                                     P 
                                     Y 
                                     ′ 
                                   
                                   -&gt; 
                                   
                                     P 
                                     Y 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       Y 
                                     
                                     , 
                                     
                                       P 
                                       
                                         Y 
                                         - 
                                         1 
                                       
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 PPM_delta 
                                 
                                   [ 
                                   
                                     Y 
                                     , 
                                     
                                       Y 
                                       - 
                                       1 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 IDLE_GAP 
                                 Y 
                               
                               + 
                               
                                 SM_DELAY 
                                 Y 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 transceiver_delay 
                                 Y 
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 transceiver_delay 
                                 Y 
                                 
                                   P 
                                   Y 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       
                                         Y 
                                         - 
                                         1 
                                       
                                     
                                     , 
                                     
                                       P 
                                       X 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               PPM_delta 
                               
                                 [ 
                                 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                   , 
                                   X 
                                 
                                 ] 
                               
                             
                           
                         
                       
                       ] 
                     
                     = 
                     
                       
 
                     
                      
                     
                         
                     
                      
                     
                       [ 
                       
                           
                       
                        
                       
                         
                           
                             
                               
                                 PHY_DELAY 
                                 Y 
                                 
                                   
                                     P 
                                     Y 
                                     ′ 
                                   
                                   -&gt; 
                                   
                                     P 
                                     Y 
                                   
                                 
                               
                               + 
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       Y 
                                     
                                     , 
                                     
                                       P 
                                       X 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 PPM_delta 
                                 
                                   [ 
                                   
                                     Y 
                                     , 
                                     X 
                                   
                                   ] 
                                 
                               
                               + 
                               
                                 IDLE_GAP 
                                 Y 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 SM_DELAY 
                                 Y 
                               
                               + 
                               
                                 transceiver_delay 
                                 Y 
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               transceiver_delay 
                               Y 
                               
                                 P 
                                 Y 
                               
                             
                           
                         
                       
                       ] 
                     
                   
                 
               
               
                 
                   ( 
                   27 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Noting that if PHYs X and Y−1 both adhere to the same minimum timing requirement for DATA_END_TIME and maximum timing requirement for BASE_RATE, then 
         [0000]        DE _delta max   [P     Y     ,P     X     ]   =DE _delta max   [P     Y     ,P     Y−1     ]   
         [0000]        PPM _delta max   [Y,X]   =PPM _delta max   [Y,Y−1]   (28) 
         [0000]    The combined maximum can be rewritten as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 RESPONSE_TIME 
                                 Y 
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       
                                         Y 
                                         - 
                                         1 
                                       
                                     
                                     , 
                                     
                                       P 
                                       X 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               PPM_delta 
                               
                                 [ 
                                 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                   , 
                                   X 
                                 
                                 ] 
                               
                             
                           
                         
                       
                       ] 
                     
                     max 
                   
                   = 
                   
                     [ 
                     
                       
                         
                           
                             
                               PHY_DELAY 
                               
                                 Y 
                                 , 
                                 max 
                               
                               
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                                 -&gt; 
                                 
                                   P 
                                   Y 
                                 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               DE_delta 
                               max 
                               
                                 [ 
                                 
                                   
                                     P 
                                     Y 
                                   
                                   , 
                                   
                                     P 
                                     
                                       Y 
                                       - 
                                       1 
                                     
                                   
                                 
                                 ] 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               PPM_delta 
                               max 
                               
                                 [ 
                                 
                                   Y 
                                   , 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                 
                                 ] 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               IDLE_GAP 
                               
                                 Y 
                                 , 
                                 max 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               SM_DELAY 
                               
                                 Y 
                                 , 
                                 max 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               transceiver_delay 
                               
                                 Y 
                                 , 
                                 max 
                               
                               
                                 P 
                                 Y 
                                 ′ 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             transceiver_delay 
                             
                               Y 
                               , 
                               min 
                             
                             
                               P 
                               Y 
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   29 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Comparing to equation (26) allows 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 RESPONSE_TIME 
                                 Y 
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       
                                         Y 
                                         - 
                                         1 
                                       
                                     
                                     , 
                                     
                                       P 
                                       X 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               PPM_delta 
                               
                                 [ 
                                 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                   , 
                                   X 
                                 
                                 ] 
                               
                             
                           
                         
                       
                       ] 
                     
                     max 
                   
                   = 
                   
                     RESPONSE_TIME 
                     
                       Y 
                       , 
                       max 
                     
                     
                       P 
                       Y 
                       ′ 
                     
                   
                 
               
               
                 
                   ( 
                   30 
                   ) 
                 
               
             
           
         
       
     
       Finally: 
       [0075]    
       
         
           
             
               
                 
                   gap_count 
                   &gt; 
                   
                     
                       
                         
                           BASERATE 
                           
                             X 
                             , 
                             max 
                           
                         
                         · 
                         
                           [ 
                           
                             
                               
                                 
                                   
                                     Round_Trip 
                                      
                                     
                                       _Delay 
                                       max 
                                       
                                         [ 
                                         
                                           
                                             P 
                                             X 
                                           
                                            
                                           O 
                                            
                                           
                                               
                                           
                                            
                                           
                                             P 
                                             Y 
                                           
                                         
                                         ] 
                                       
                                     
                                   
                                   + 
                                 
                               
                             
                             
                               
                                 
                                   
                                     RESPONSE_TIME 
                                     
                                       Y 
                                       , 
                                       max 
                                     
                                     
                                       P 
                                       Y 
                                       ′ 
                                     
                                   
                                   + 
                                 
                               
                             
                             
                               
                                 
                                   PHY_DELAY 
                                   
                                     X 
                                     , 
                                     max 
                                   
                                   
                                     P 
                                     X 
                                   
                                 
                               
                             
                           
                           ] 
                         
                       
                       - 
                       27 
                     
                     16 
                   
                 
               
               
                 
                   ( 
                   31 
                   ) 
                 
               
             
           
         
       
     
         [0076]    For any given topology, the gap count must be set such that subaction gaps observed/generated at one PHY aren&#39;t falsely interpreted as arb_reset gaps by another PHY in the network. Subaction gaps are known to be at their largest nearest the PHY that originated the last packet. To ensure that the most recent originating PHY doesn&#39;t begin a new fairness interval before all PHYs exit the current one, its arb_reset_gap timeout must be greater than the largest subaction_gap which can legally occur.  FIG. 4  illustrates the case in which PHY X originated the most recent packet and PHY Y is responding after a subaction gap with arbitration for the current fairness interval. 
         [0077]    For all topologies, the idle time observed at point Px must not exceed the arbitration reset gap detection time: 
         [0000]      Idle max   P     X   &lt;arb_reset_gap min   P     X     (32) 
         [0078]    The analysis is identical to the case in which Ack and Iso gaps are preserved with the exception that PHY Y takes longer to respond to the trailing edge of DATA_END. Let PHY Y have a response time of subaction_response_time. Then, 
         [0000]      Idle P     X   =Round_Trip_Delay [P     X     OP     Y     ] +subaction_response_time Y   P′     Y     +DE _delta [P     Y−1     ,P     X     ]   +PPM _delta [Y−1,X]   (33) 
         [0079]    Substituting into Equation (32), subaction gaps are preserved network-wide if and only if: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 Round_Trip 
                                  
                                 
                                   _Delay 
                                   
                                     [ 
                                     
                                       
                                         P 
                                         X 
                                       
                                        
                                       
                                         OP 
                                         Y 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 subaction_response 
                                  
                                 
                                   _time 
                                   Y 
                                   
                                     P 
                                     Y 
                                     ′ 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       
                                         Y 
                                         - 
                                         1 
                                       
                                     
                                     , 
                                     
                                       P 
                                       X 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               PPM_delta 
                               
                                 [ 
                                 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                   , 
                                   X 
                                 
                                 ] 
                               
                             
                           
                         
                       
                       ] 
                     
                     max 
                   
                   &lt; 
                   
                     arb_reset 
                      
                     
                       _gap 
                       min 
                       
                         P 
                         X 
                       
                     
                   
                 
               
               
                 
                   ( 
                   34 
                   ) 
                 
               
             
           
         
       
     
         [0080]    The minimum arb_reset_gap at point Px isn&#39;t well known. IEEE1394-1995, in Table 4-33, defines the minimum arb_reset_gap timeout used at a PHY&#39;s internal state machines, not at the external interface. It has been argued that the internal and external representations of time may differ by as much as ARB_RESPONSE_DELAY when a PHY is counting elapsed time between an internally generated event and an externally received event. However, the ARB_RESPONSE_DELAY value for a particular PHY isn&#39;t generally known externally. Fortunately, the ARB_RESPONSE_DELAY value for a PHY whose FIFO is known to be empty is bounded by the worst case PHY_DELAY reported within the PHY register map. This suggests a realistic bound for the minimum subaction gap referenced at point Px: 
         [0000]    
       
         
           
             
               
                 
                   
                     arb_reset 
                      
                     
                       _gap 
                       min 
                       
                         P 
                         X 
                       
                     
                   
                   ≥ 
                   
                     
                       arb_reset 
                        
                       
                         _gap 
                         min 
                         
                           i 
                           X 
                         
                       
                     
                     - 
                     
                       PHY_DELAY 
                       
                         X 
                         , 
                         max 
                       
                       
                         P 
                         X 
                       
                     
                   
                 
               
               
                 
                   ( 
                   35 
                   ) 
                 
               
             
             
               
                 
                   where 
                    
                   
                     
 
                   
                    
                   
                     
                       arb_reset 
                        
                       
                         _gap 
                         min 
                         
                           i 
                           X 
                         
                       
                     
                     = 
                     
                       
                         51 
                         + 
                         
                           gap_count 
                           · 
                           32 
                         
                       
                       
                         BASERATE 
                         
                           X 
                           , 
                           max 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   36 
                   ) 
                 
               
             
           
         
       
     
         [0081]    The maximum subaction_response_time for PHY Y parallels the earlier dissection of RESPONSE_TIME. The timing sequence for subaction_response_time is identical to that of RESPONSE_TIME except that PHY Y, after concluding stop_tx_Packet( ), must wait to detect a subaction gap and then wait an additional arb_delay before calling start_tx_packet( ). Said differently, the idle period timed internally is a subaction gap plus arb_delay rather than an IDLE_GAP. Consequently, t 5 b becomes: 
         [0000]        t   5b   =t   5a +subaction_gap i     Y   +arb_delay i     Y     +SM _DELAY Y   (37) 
         [0000]      and 
         [0000]      subaction_response_time Y   P′     Y   =RESPONSE_TIME Y   P′     Y   −IDLE_GAP Y +subaction_gap i     Y   +arb_delay i     Y     (38) 
         [0000]    Substituting into Equation (34), 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 Round_Trip 
                                  
                                 
                                   _Delay 
                                   
                                     [ 
                                     
                                       
                                         P 
                                         X 
                                       
                                        
                                       
                                         OP 
                                         Y 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 RESPONSE_TIME 
                                 Y 
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       
                                         Y 
                                         - 
                                         1 
                                       
                                     
                                     , 
                                     
                                       P 
                                       X 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 PPM_delta 
                                 
                                   [ 
                                   
                                     
                                       Y 
                                       - 
                                       1 
                                     
                                     , 
                                     X 
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 subaction_gap 
                                 
                                   i 
                                   Y 
                                 
                               
                               + 
                               
                                 arb_delay 
                                 
                                   i 
                                   Y 
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               IDLE_GAP 
                               Y 
                             
                           
                         
                       
                       ] 
                     
                     max 
                   
                   &lt; 
                   
                     arb_reset 
                      
                     
                       _gap 
                       min 
                       
                         P 
                         X 
                       
                     
                   
                 
               
               
                 
                   ( 
                   39 
                   ) 
                 
               
             
           
         
       
     
         [0082]    Again, RESPONSE_TIME, DE_delta, and PPM_delta are not independent parameters. As shown previously, if PHYs X and Y−1 adhere to the same timing constant limits, the explicit DE_Delta and PPM_delta terms can be subsumed within RESPONSE_TIME giving: 
         [0000]    
       
         
           
             
               
                 
                   
                     [ 
                     
                       
                         
                           
                             
                               Round_Trip 
                                
                               
                                 _Delay 
                                 max 
                                 
                                   p 
                                    
                                   
                                     [ 
                                     
                                       
                                         P 
                                         X 
                                       
                                        
                                       
                                         OP 
                                         Y 
                                       
                                     
                                     ] 
                                   
                                 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               RESPONSE_TIME 
                               
                                 Y 
                                 , 
                                 max 
                               
                               
                                 P 
                                 Y 
                                 ′ 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               subaction_gap 
                               max 
                               
                                 i 
                                 Y 
                               
                             
                             + 
                             
                               arb_delay 
                               max 
                               
                                 i 
                                 Y 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             MIN_IDLE 
                              
                             
                               _TIME 
                               Y 
                             
                           
                         
                       
                     
                     ] 
                   
                   &lt; 
                   
                     arb_reset 
                      
                     
                       _gap 
                       min 
                       
                         P 
                         X 
                       
                     
                   
                 
               
               
                 
                   ( 
                   40 
                   ) 
                 
               
             
             
               
                 
                   where 
                    
                   
                     
 
                   
                    
                   
                     
                       subaction_gap 
                       max 
                       
                         i 
                         Y 
                       
                     
                     = 
                     
                       
                         29 
                         + 
                         
                           gap_count 
                           · 
                           16 
                         
                       
                       
                         BASERATE 
                         
                           Y 
                           , 
                           min 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   41 
                   ) 
                 
               
             
             
               
                 
                   
                     arb_delay 
                     max 
                     
                       i 
                       Y 
                     
                   
                   = 
                   
                     
                       gap_count 
                       · 
                       4 
                     
                     
                       BASERATE 
                       
                         Y 
                         , 
                         min 
                       
                     
                   
                 
               
               
                 
                   ( 
                   42 
                   ) 
                 
               
             
             
               
                 
                   and 
                    
                   
                     
 
                   
                    
                   
                     
                       IDLE_GAP 
                       
                         Y 
                         , 
                         min 
                       
                     
                     = 
                     
                       MIN_IDLE 
                        
                       
                         _TIME 
                         Y 
                       
                     
                   
                 
               
               
                 
                   ( 
                   43 
                   ) 
                 
               
             
           
         
       
     
       Combining Equations (35), (36), (40), (41), and (42): 
       [0083]    
       
         
           
             
               
                 
                   
                     [ 
                     
                       
                         
                           
                             
                               Round_Trip 
                                
                               
                                 _Delay 
                                 max 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       X 
                                     
                                      
                                     
                                       OP 
                                       Y 
                                     
                                   
                                   ] 
                                 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               RESPONSE_TIME 
                               
                                 Y 
                                 , 
                                 max 
                               
                               
                                 P 
                                 Y 
                                 ′ 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             
                               MIN_IDLE 
                                
                               
                                 _TIME 
                                 Y 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               29 
                               + 
                               
                                 gap_count 
                                 · 
                                 20 
                               
                             
                             
                               BASERATE 
                               
                                 Y 
                                 , 
                                 min 
                               
                             
                           
                         
                       
                     
                     ] 
                   
                   &lt; 
                   
                     [ 
                     
                         
                     
                      
                     
                       
                         
                           
                             
                               
                                 51 
                                 + 
                                 
                                   gap_count 
                                   · 
                                   32 
                                 
                               
                               
                                 BASERATE 
                                 
                                   X 
                                   , 
                                   max 
                                 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             PHY_DELAY 
                             
                               X 
                               , 
                               max 
                             
                             
                               P 
                               X 
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   44 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Solving for gap_count: 
         [0000]    
       
         
           
             
               
                 
                   gap_count 
                   &gt; 
                   
                     
                       
                         
                           
                             
                               
                                 BASERATE 
                                 
                                   X 
                                   , 
                                   max 
                                 
                               
                               · 
                               
                                 [ 
                                 
                                   
                                     
                                       
                                         
                                           Round_Trip 
                                            
                                           
                                             _Delay 
                                             max 
                                             
                                               [ 
                                               
                                                 
                                                   P 
                                                   X 
                                                 
                                                  
                                                 
                                                   OP 
                                                   Y 
                                                 
                                               
                                               ] 
                                             
                                           
                                         
                                         + 
                                       
                                     
                                   
                                   
                                     
                                       
                                         
                                           RESPONSE_TIME 
                                           
                                             Y 
                                             , 
                                             max 
                                           
                                           
                                             P 
                                             Y 
                                             ′ 
                                           
                                         
                                         - 
                                       
                                     
                                   
                                   
                                     
                                       
                                         
                                           MIN_IDLE 
                                            
                                           
                                             _TIME 
                                             Y 
                                           
                                         
                                         + 
                                       
                                     
                                   
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           X 
                                           , 
                                           max 
                                         
                                         
                                           P 
                                           X 
                                         
                                       
                                     
                                   
                                 
                                 ] 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               29 
                               · 
                               
                                 
                                   BASERATE 
                                   
                                     X 
                                     , 
                                     max 
                                   
                                 
                                 
                                   BASERATE 
                                   
                                     Y 
                                     , 
                                     min 
                                   
                                 
                               
                             
                             - 
                             51 
                           
                         
                       
                     
                     
                       32 
                       - 
                       
                         20 
                         · 
                         
                           
                             BASERATE 
                             
                               X 
                               , 
                               max 
                             
                           
                           
                             BASERATE 
                             
                               Y 
                               , 
                               min 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   45 
                   ) 
                 
               
             
           
         
       
     
         [0084]    For any given topology, the gap count must be set such that if a subaction gap is observed following an isochronous packet at one PHY, it is observed at all PHYs. The danger occurs when a subsequent arbitration indication is transmitted in the same direction as the previous data packet. Given that arbitration indications may propagate through intervening PHYs faster than data bits, gaps may be shortened as they are repeated.  FIG. 5  illustrates the case in which PHY X originates an isochronous packet, observes a subaction_gap, and begins to drive an arbitration indication. 
         [0085]    For all topologies, the minimum idle time observed at point P′Y must always exceed the maximum subaction gap detection time: 
         [0000]      Idle min   P′     Y   &gt;subaction_gap max   P′     Y     (46) 
         [0086]    The time events t 0  through t 5  are identical to the previous analyses. In this scenario, t 6  follows t 2  by the time it takes PHY X to time subaction gap and arb_delay: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           t 
                           6 
                         
                         = 
                           
                          
                         
                           
                             t 
                             2 
                           
                           + 
                           
                             subaction_gap 
                             
                               P 
                               X 
                             
                           
                           + 
                           arb_delay 
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             0 
                           
                           + 
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 X 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             DATA_END 
                              
                             
                               _TIME 
                               X 
                               
                                 P 
                                 X 
                               
                             
                           
                           + 
                           
                             subaction_gap 
                             
                               P 
                               X 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           arb_delay 
                           
                             P 
                             X 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   47 
                   ) 
                 
               
             
           
         
       
     
         [0087]    The 1995 specification provides the timeouts used internally by the state machine. The externally observed timing requirements could differ (given possible mismatches in transceiver delay and state machines between the leading edge of IDLE and the leading edge of the subsequent arbitration indication). However, previous works have suggested any such delays could and should be well matched and that the external timing would follow the internal timing exactly. 
       Consequently, 
       [0088]      subaction_gap P     X   +arb_delay P     X   =subaction_gap i     X   +arb_delay i     x     (48) 
         [0000]    T 7  follows T 6  by the time it takes the arbitration signal to propagate through the intervening PHYs and cables: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           t 
                           7 
                         
                         = 
                           
                          
                         
                           
                             t 
                             6 
                           
                           + 
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   cable_delay 
                                   n 
                                 
                                 + 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         
                             
                            
                           
                             ARB_RESPONSE 
                              
                             
                               _DELAY 
                               n 
                               
                                 
                                   P 
                                   n 
                                   ′ 
                                 
                                 → 
                                 
                                   P 
                                   n 
                                 
                               
                             
                           
                           ) 
                         
                         + 
                         
                           cable_delay 
                           X 
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             0 
                           
                           + 
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 X 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             DATA_END 
                              
                             
                               _TIME 
                               X 
                               
                                 P 
                                 X 
                               
                             
                           
                           + 
                           
                             subaction_gap 
                             
                               i 
                               X 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             arb_delay 
                             
                               i 
                               X 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             ∑ 
                             
                               n 
                               = 
                               
                                 X 
                                 + 
                                 1 
                               
                             
                             
                               Y 
                               - 
                               1 
                             
                           
                            
                           
                             ( 
                             
                               
                                 cable_delay 
                                 n 
                               
                               + 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         
                             
                            
                           
                             ARB_RESPONSE 
                              
                             
                               _DELAY 
                               n 
                               
                                 
                                   P 
                                   n 
                                   ′ 
                                 
                                 → 
                                 
                                   P 
                                   n 
                                 
                               
                             
                           
                           ) 
                         
                         + 
                         
                           cable_delay 
                           X 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   49 
                   ) 
                 
               
             
           
         
       
     
         [0089]    Given t 0  through t 7  above, the Idle time seen at point P′ Y  is given as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Idle 
                           
                             P 
                             Y 
                             ′ 
                           
                         
                         = 
                           
                          
                         
                           
                             t 
                             7 
                           
                           - 
                           
                             t 
                             5 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             subaction_gap 
                             
                               i 
                               X 
                             
                           
                           + 
                           
                             arb_delay 
                             
                               i 
                               X 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             ∑ 
                             
                               n 
                               = 
                               
                                 X 
                                 + 
                                 1 
                               
                             
                             
                               Y 
                               - 
                               1 
                             
                           
                            
                           
                             ( 
                             
                               
                                 PHY_DELAY 
                                 n 
                                 
                                   
                                     P 
                                     n 
                                     ′ 
                                   
                                   → 
                                   
                                     P 
                                     n 
                                   
                                 
                               
                               - 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         
                             
                            
                           
                             ARB_RESPONSE 
                              
                             
                               _DELAY 
                               n 
                               
                                 
                                   P 
                                   n 
                                   ′ 
                                 
                                 → 
                                 
                                   P 
                                   n 
                                 
                               
                             
                           
                           ) 
                         
                         - 
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             DE_delta 
                             
                               [ 
                               
                                 
                                   P 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                 
                                 , 
                                 
                                   P 
                                   X 
                                 
                               
                               ] 
                             
                           
                           - 
                           
                             PPM_delta 
                             
                               [ 
                               
                                 
                                   Y 
                                   - 
                                   1 
                                 
                                 , 
                                 X 
                               
                               ] 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   50 
                   ) 
                 
               
             
           
         
       
     
       Let 
       [0090]    
       
         
           
             
               
                 
                   
                     Data_Arb 
                      
                     
                       _Mismatch 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                           → 
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   = 
                   
                     
                       ∑ 
                       
                         n 
                         = 
                         
                           X 
                           + 
                           1 
                         
                       
                       
                         Y 
                         - 
                         1 
                       
                     
                      
                     
                       ( 
                       
                         
                           PHY_DELAY 
                           n 
                           
                             
                               P 
                               n 
                               ′ 
                             
                             → 
                             
                               P 
                               n 
                             
                           
                         
                         - 
                         
                           ARB_RESPONSE 
                            
                           
                             _DELAY 
                             n 
                             
                               
                                 P 
                                 n 
                                 ′ 
                               
                               → 
                               
                                 P 
                                 n 
                               
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   51 
                   ) 
                 
               
             
           
         
       
     
       Then, 
       [0091]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Idle 
                           
                             P 
                             Y 
                             ′ 
                           
                         
                         = 
                           
                          
                         
                           
                             t 
                             7 
                           
                           - 
                           
                             t 
                             5 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             subaction_gap 
                             
                               i 
                               X 
                             
                           
                           + 
                           
                             arb_delay 
                             
                               i 
                               X 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             Data_Arb 
                              
                             
                               _Mismatch 
                               
                                 [ 
                                 
                                   
                                     P 
                                     X 
                                   
                                   → 
                                   
                                     P 
                                     Y 
                                   
                                 
                                 ] 
                               
                             
                           
                           - 
                           
                             DE_delta 
                             
                               [ 
                               
                                 
                                   P 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                 
                                 , 
                                 
                                   P 
                                   X 
                                 
                               
                               ] 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           PPM_delta 
                           
                             [ 
                             
                               
                                 Y 
                                 - 
                                 1 
                               
                               , 
                               X 
                             
                             ] 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   52 
                   ) 
                 
               
             
           
         
       
     
         [0092]    For the maximum subaction_gap detection time at point P′Y, the 1995 standard again only specifies the internal state machine timeout values.  FIG. 6  provides the timing reference for relating the external gap detection times to the internal ones. The elaborated timing sequence is identical to the case for RESPONSE_TIME through point t 5 ′. The remaining sequence is:
       T 7  The arbitration indication launched by PHY X arrives at point P′ Y      T 7a  The arbitration indication launched by PHY X arrives at point iY. t 7a  lags t 7  by an unspecified arbitration detection time, herein termed ARB_DETECTION_TIME
 
The externally seen gap at point P′ Y  is given as
       
 
         [0000]      gap P′     Y     =t   7   −t   5   (53) 
         [0000]    The corresponding internal gap at point iY is 
         [0000]      gap i     Y     =t   7a   −t   5a   (54) 
         [0000]    Given that 
         [0000]        t   7a   =t   7   +ARB _DETECTION_TIME Y   P′     Y     (55) 
         [0000]    the external gap can be expressed as 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           gap 
                           
                             P 
                             Y 
                             ′ 
                           
                         
                         = 
                           
                          
                         
                           
                             t 
                             7 
                           
                           - 
                           
                             t 
                             5 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             
                               7 
                                
                               a 
                             
                           
                           - 
                           
                             t 
                             5 
                           
                           - 
                           
                             ARB_DETECTION 
                              
                             
                               _TIME 
                               Y 
                               
                                 P 
                                 Y 
                                 ′ 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             
                               7 
                                
                               a 
                             
                           
                           - 
                           
                             t 
                             
                               5 
                                
                               a 
                             
                           
                           + 
                           
                             t 
                             
                               5 
                                
                               a 
                             
                           
                           - 
                           
                             t 
                             5 
                           
                           - 
                           
                             ARB_DETECTION 
                              
                             
                               _TIME 
                               Y 
                               
                                 P 
                                 Y 
                                 ′ 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             gap 
                             
                               i 
                               Y 
                             
                           
                           + 
                           
                             t 
                             
                               5 
                                
                               a 
                             
                           
                           - 
                           
                             t 
                             5 
                           
                           - 
                           
                             ARB_DECTECTION 
                              
                             
                               _TIME 
                               Y 
                               
                                 P 
                                 Y 
                                 ′ 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             gap 
                             
                               i 
                               Y 
                             
                           
                           + 
                           
                             PHY_DELAY 
                             Y 
                             
                               
                                 P 
                                 Y 
                                 ′ 
                               
                               → 
                               
                                 P 
                                 Y 
                               
                             
                           
                           + 
                           
                             DE_delta 
                             
                               [ 
                               
                                 
                                   P 
                                   Y 
                                 
                                 , 
                                 
                                   P 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                 
                               
                               ] 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             PPM_delta 
                             
                               [ 
                               
                                 Y 
                                 , 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                               ] 
                             
                           
                           - 
                           
                             transceiver_delay 
                             Y 
                             
                               P 
                               Y 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           ARB_DECTECTION 
                            
                           
                             _TIME 
                             Y 
                             
                               P 
                               Y 
                               ′ 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   56 
                   ) 
                 
               
             
           
         
       
     
       Consequently, 
       [0095]    
       
         
           
             
               
                 
                   
                     subaction_gap 
                     
                       P 
                       Y 
                       ′ 
                     
                   
                   = 
                   
                     
                       subaction_gap 
                       
                         i 
                         Y 
                       
                     
                     + 
                     
                       PHY_DELAY 
                       Y 
                       
                         
                           P 
                           Y 
                           ′ 
                         
                         → 
                         
                           P 
                           Y 
                         
                       
                     
                     + 
                     
                       DE_delta 
                       
                         [ 
                         
                           
                             P 
                             Y 
                           
                           , 
                           
                             P 
                             
                               Y 
                               - 
                               1 
                             
                           
                         
                         ] 
                       
                     
                     + 
                     
                       PPM_delta 
                       
                         [ 
                         
                           Y 
                           , 
                           
                             Y 
                             - 
                             1 
                           
                         
                         ] 
                       
                     
                     - 
                     
                       tranceiver_delay 
                       Y 
                       
                         P 
                         Y 
                       
                     
                     - 
                     
                       ARB_DECTECTION 
                        
                       
                         _TIME 
                         Y 
                         
                           P 
                           Y 
                           ′ 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   57 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Substituting (52) and (57) into (46) yields 
         [0000]    
       
         
           
             
               
                 
                   
                     [ 
                     
                       
                         
                           
                             
                               subaction_gap 
                               
                                 i 
                                 X 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               arb_delay 
                               
                                 i 
                                 X 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             
                               Data_Arb 
                                
                               
                                 _Mismatch 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       X 
                                     
                                     → 
                                     
                                       P 
                                       Y 
                                     
                                   
                                   ] 
                                 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             
                               DE_delta 
                               
                                 [ 
                                 
                                   
                                     P 
                                     
                                       Y 
                                       - 
                                       1 
                                     
                                   
                                   , 
                                   
                                     P 
                                     X 
                                   
                                 
                                 ] 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             PPM_delta 
                             
                               [ 
                               
                                 
                                   Y 
                                   - 
                                   1 
                                 
                                 , 
                                 X 
                               
                               ] 
                             
                           
                         
                       
                     
                     ] 
                   
                   &gt; 
                   
                     [ 
                     
                       
                         
                           
                             
                               subaction_gap 
                               
                                 i 
                                 Y 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               PHY_DELAY 
                               Y 
                               
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                                 → 
                                 P 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               DE_delta 
                               
                                 [ 
                                 
                                   
                                     P 
                                     Y 
                                   
                                   , 
                                   
                                     P 
                                     
                                       Y 
                                       - 
                                       1 
                                     
                                   
                                 
                                 ] 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               PPM_delta 
                               
                                 [ 
                                 
                                   Y 
                                   , 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                 
                                 ] 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             
                               transceiver_delay 
                               Y 
                               
                                 P 
                                 Y 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             ARB_DETECTION 
                              
                             
                               _TIME 
                               Y 
                               
                                 P 
                                 Y 
                                 ′ 
                               
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   58 
                   ) 
                 
               
             
           
         
       
     
         [0000]    The inequality holds generally if 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 subaction_gap 
                                 
                                   i 
                                   X 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               arb_delay 
                               
                                 i 
                                 X 
                               
                             
                           
                         
                       
                       ] 
                     
                     min 
                   
                   &gt; 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 subaction_gap 
                                 
                                   i 
                                   Y 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 PHY_DELAY 
                                 Y 
                                 
                                   
                                     P 
                                     Y 
                                     ′ 
                                   
                                   → 
                                   
                                     P 
                                     Y 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       Y 
                                     
                                     , 
                                     
                                       P 
                                       
                                         Y 
                                         - 
                                         1 
                                       
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 PPM_delta 
                                 
                                   [ 
                                   
                                     Y 
                                     , 
                                     
                                       Y 
                                       - 
                                       1 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       
                                         Y 
                                         - 
                                         1 
                                       
                                     
                                     , 
                                     
                                       P 
                                       X 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 PPM_delta 
                                 
                                   [ 
                                   
                                     
                                       Y 
                                       - 
                                       1 
                                     
                                     , 
                                     X 
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 Data_Arb 
                                  
                                 
                                   _Mismatch 
                                   
                                     [ 
                                     
                                       
                                         P 
                                         X 
                                       
                                       → 
                                       
                                         P 
                                         Y 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 transceiver_delay 
                                 Y 
                                 
                                   P 
                                   Y 
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               ARB_DETECTION 
                                
                               
                                 _TIME 
                                 Y 
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                     max 
                   
                 
               
               
                 
                   ( 
                   59 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Combining the DE_Delta and PPM_delta terms gives: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 subaction_gap 
                                 
                                   i 
                                   X 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               arb_delay 
                               
                                 i 
                                 X 
                               
                             
                           
                         
                       
                       ] 
                     
                     min 
                   
                   &gt; 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 subaction_gap 
                                 
                                   i 
                                   Y 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 PHY_DELAY 
                                 Y 
                                 
                                   
                                     P 
                                     Y 
                                     ′ 
                                   
                                   → 
                                   
                                     P 
                                     Y 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       Y 
                                     
                                     , 
                                     
                                       P 
                                       X 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 PPM_delta 
                                 
                                   [ 
                                   
                                     Y 
                                     , 
                                     X 
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 Data_Arb 
                                  
                                 
                                   _Mismatch 
                                   
                                     [ 
                                     
                                       
                                         P 
                                         X 
                                       
                                       → 
                                       
                                         P 
                                         Y 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 transceiver_delay 
                                 Y 
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               ARB_DETECTION 
                                
                               
                                 _TIME 
                                 Y 
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                     max 
                   
                 
               
               
                 
                   ( 
                   60 
                   ) 
                 
               
             
           
         
       
     
         [0000]    By assuming 
         [0000]        DE _delta [P     Y     ,P     X     ]   +PPM _delta [Y,X] ≦transceiver_delay Y   P     Y     +ARB _DETECTION_TIME Y   P′     Y     (61) 
         [0000]    the constraining inequality can be further simplified to give 
         [0000]    
       
         
           
             
               
                 
                   
                     [ 
                     
                       
                         
                           
                             
                               subaction_gap 
                               min 
                               
                                 i 
                                 X 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             arb_delay 
                             min 
                             
                               i 
                               X 
                             
                           
                         
                       
                     
                     ] 
                   
                   &gt; 
                   
                     [ 
                     
                       
                         
                           
                             
                               subaction_gap 
                               max 
                               
                                 i 
                                 Y 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               PHY_DELAY 
                               
                                 Y 
                                 , 
                                 max 
                               
                               
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                                 → 
                                 
                                   P 
                                   Y 
                                 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             Data_Arb 
                              
                             
                               _Mismatch 
                               max 
                               
                                 [ 
                                 
                                   
                                     P 
                                     X 
                                   
                                   → 
                                   
                                     P 
                                     Y 
                                   
                                 
                                 ] 
                               
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   62 
                   ) 
                 
               
             
             
               
                 
                   where 
                    
                   
                     
 
                   
                    
                   
                     
                       subaction_gap 
                       min 
                       
                         i 
                         X 
                       
                     
                     = 
                     
                       
                         27 
                         + 
                         
                           gap_count 
                           · 
                           16 
                         
                       
                       
                         BASERATE 
                         
                           X 
                           , 
                           max 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   63 
                   ) 
                 
               
             
             
               
                 
                   
                     arb_delay 
                     min 
                     
                       i 
                       X 
                     
                   
                   = 
                   
                     
                       gap_count 
                       · 
                       4 
                     
                     
                       BASERATE 
                       
                         X 
                         , 
                         max 
                       
                     
                   
                 
               
               
                 
                   ( 
                   64 
                   ) 
                 
               
             
             
               
                 
                   and 
                    
                   
                     
 
                   
                    
                   
                     
                       subaction_gap 
                       max 
                       
                         i 
                         Y 
                       
                     
                     = 
                     
                       
                         29 
                         + 
                         
                           gap_count 
                           · 
                           16 
                         
                       
                       
                         BASERATE 
                         
                           Y 
                           , 
                           min 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   65 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Solving for gap count, 
         [0000]    
       
         
           
             
               
                 
                   gap_count 
                   &gt; 
                   
                     
                       
                         
                           
                             
                               
                                 BASERATE 
                                 
                                   X 
                                   , 
                                   max 
                                 
                               
                               · 
                               
                                 [ 
                                 
                                   
                                     
                                       
                                         
                                           PHY_DELAY 
                                           
                                             Y 
                                             , 
                                             max 
                                           
                                           
                                             
                                               P 
                                               Y 
                                               ′ 
                                             
                                             → 
                                             
                                               P 
                                               Y 
                                             
                                           
                                         
                                         + 
                                       
                                     
                                   
                                   
                                     
                                       
                                         Data_Arb 
                                          
                                         
                                           _Mismatch 
                                           max 
                                           
                                             [ 
                                             
                                               
                                                 P 
                                                 X 
                                               
                                               → 
                                               
                                                 P 
                                                 Y 
                                               
                                             
                                             ] 
                                           
                                         
                                       
                                     
                                   
                                 
                                 ] 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               29 
                               · 
                               
                                 
                                   BASERATE 
                                   
                                     X 
                                     , 
                                     max 
                                   
                                 
                                 
                                   BASERATE 
                                   
                                     Y 
                                     , 
                                     min 
                                   
                                 
                               
                             
                             - 
                             27 
                           
                         
                       
                     
                     
                       20 
                       - 
                       
                         16 
                         · 
                         
                           
                             BASERATE 
                             
                               X 
                               , 
                               max 
                             
                           
                           
                             BASERATE 
                             
                               Y 
                               , 
                               min 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   66 
                   ) 
                 
               
             
           
         
       
     
         [0096]    For any given topology, the gap count must be set such that if an arbitration reset gap is observed following an asynchronous packet at one PHY, it is observed at all PHYs. The danger occurs when a subsequent arbitration indication is transmitted in the same direction as the previous data packet. Given that arbitration indications may propagate through intervening PHYs faster than data bits, gaps may be shortened as they are repeated.  FIG. 7  illustrates the case in which PHY X originates an asynchronous packet, observes an arbitration reset gap, and begins to drive an arbitration indication. 
         [0097]    For all topologies, the minimum idle time observed at point P′Y must always exceed the maximum arbitration reset gap detection time: 
         [0000]      Idle min   P′     Y     &gt;arb _reset_gap max   P′     Y     (67) 
         [0098]    The time events t 0  through t 5  are identical to the previous analyses. In this scenario, t 6  follows t 2  by the time it takes PHY X to time arb_reset_gap and arb_delay: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           t 
                           6 
                         
                         = 
                           
                          
                         
                           
                             t 
                             2 
                           
                           + 
                           
                             arb_reset 
                              
                             
                               _gap 
                               
                                 P 
                                 X 
                               
                             
                           
                           + 
                           
                             arb_delay 
                             
                               P 
                               X 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             0 
                           
                           + 
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 X 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             DATA_END 
                              
                             
                               _TIME 
                               X 
                               
                                 P 
                                 X 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             arb_reset 
                              
                             
                               _gap 
                               
                                 P 
                                 X 
                               
                             
                           
                           + 
                           
                             arb_delay 
                             
                               P 
                               X 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   68 
                   ) 
                 
               
             
           
         
       
     
         [0099]    The 1995 IEEE 1394 standard provides the timeouts used internally by the state machine. The externally observed timing requirements could differ (given possible mismatches in transceiver delay and state machines between the leading edge of IDLE and the leading edge of the subsequent arbitration indication). However, previous works have suggested any such delays could and should be well matched and that the external timing would follow the internal timing exactly. Consequently, 
         [0000]      arb_reset_gap+arb_delay P     X   =arb_reset_gap i     X   +arb_delay i     X     (69) 
         [0100]    T 7  follows T 6  by the time it takes the arbitration signal to propagate through the intervening PHYs and cables: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           t 
                           7 
                         
                         = 
                           
                          
                         
                           
                             t 
                             6 
                           
                           + 
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   cable_delay 
                                   n 
                                 
                                 + 
                                 
                                   ARB_RESPONSE 
                                    
                                   
                                     _DELAY 
                                     n 
                                     
                                       
                                         P 
                                         n 
                                         ′ 
                                       
                                       → 
                                       
                                         P 
                                         n 
                                       
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           cable_delay 
                           X 
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             t 
                             0 
                           
                           + 
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 X 
                               
                             
                           
                           + 
                           
                             DATA_END 
                              
                             
                               _TIME 
                               X 
                               
                                 P 
                                 X 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             arb_reset 
                              
                             
                               _gap 
                               
                                 i 
                                 X 
                               
                             
                           
                           + 
                           
                             arb_delay 
                             
                               i 
                               X 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   cable_delay 
                                   n 
                                 
                                 + 
                                 
                                   ARB_RESPONSE 
                                    
                                   
                                     _DELAY 
                                     n 
                                     
                                       
                                         P 
                                         n 
                                         ′ 
                                       
                                       → 
                                       
                                         P 
                                         n 
                                       
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           cable_delay 
                           X 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   70 
                   ) 
                 
               
             
           
         
       
     
         [0101]    Given t 0  through t 7  above, the Idle time seen at point P′Y is given as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Idle 
                           
                             P 
                             Y 
                             ′ 
                           
                         
                         = 
                           
                          
                         
                           
                             t 
                             7 
                           
                           - 
                           
                             t 
                             5 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             arb_reset 
                              
                             
                               _gap 
                               
                                 i 
                                 X 
                               
                             
                           
                           + 
                           
                             arb_delay 
                             
                               i 
                               X 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             Data_Arb 
                              
                             
                               _Mismatch 
                               
                                 [ 
                                 
                                   
                                     P 
                                     X 
                                   
                                   → 
                                   
                                     P 
                                     Y 
                                   
                                 
                                 ] 
                               
                             
                           
                           - 
                           
                             DE_delta 
                             
                               [ 
                               
                                 
                                   P 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                 
                                 , 
                                 
                                   P 
                                   X 
                                 
                               
                               ] 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           PPM_delta 
                           
                             [ 
                             
                               
                                 Y 
                                 - 
                                 1 
                               
                               , 
                               X 
                             
                             ] 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   71 
                   ) 
                 
               
             
           
         
       
     
         [0102]    For the maximum arbitration_reset_gap detection time at point P′Y, equation (56) gives: 
         [0000]      arb_reset_gap P′     Y   =arb_reset_gap i     Y     +PHY _DELAY Y   P′     Y     →P     Y     +DE _delta [P     Y     ,P     Y−1     ]   +PPM _delta [Y,Y−1] _transceiver_delay Y   P     Y     −ARB _DETECTION_TIME Y   P′     Y     (72) 
         [0103]    Substituting (71) and (72) into (67) yields 
         [0000]    
       
         
           
             
               
                 
                   
                     [ 
                     
                       
                         
                           
                             
                               arb_reset 
                                
                               
                                 _gap 
                                 
                                   i 
                                   X 
                                 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               arb_delay 
                               
                                 i 
                                 X 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             
                               Data_Arb 
                                
                               
                                 _Mismatch 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       X 
                                     
                                     → 
                                     
                                       P 
                                       Y 
                                     
                                   
                                   ] 
                                 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             
                               DE_delta 
                               
                                 [ 
                                 
                                   
                                     P 
                                     
                                       Y 
                                       - 
                                       1 
                                     
                                   
                                   , 
                                   
                                     P 
                                     X 
                                   
                                 
                                 ] 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             PPM_delta 
                             
                               [ 
                               
                                 
                                   Y 
                                   - 
                                   1 
                                 
                                 , 
                                 X 
                               
                               ] 
                             
                           
                         
                       
                     
                     ] 
                   
                   &gt; 
                   
                     
 
                   
                    
                   
                       
                   
                    
                   
                     [ 
                     
                         
                     
                      
                     
                       
                         
                           
                             
                               arb_reset 
                                
                               
                                 _gap 
                                 
                                   i 
                                   Y 
                                 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               PHY_DELAY 
                               Y 
                               
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                                 → 
                                 
                                   P 
                                   Y 
                                 
                               
                             
                             + 
                             
                               DE_delta 
                               
                                 [ 
                                 
                                   
                                     P 
                                     Y 
                                   
                                   , 
                                   
                                     P 
                                     
                                       Y 
                                       - 
                                       1 
                                     
                                   
                                 
                                 ] 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               PPM_delta 
                               
                                 [ 
                                 
                                   Y 
                                   , 
                                   
                                     Y 
                                     - 
                                     1 
                                   
                                 
                                 ] 
                               
                             
                             - 
                             
                               transceiver_delay 
                               Y 
                               
                                 P 
                                 Y 
                               
                             
                             - 
                           
                         
                       
                       
                         
                           
                             ARB_DETECTION 
                              
                             
                               _TIME 
                               Y 
                               
                                 P 
                                 Y 
                                 ′ 
                               
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   73 
                   ) 
                 
               
             
           
         
       
     
         [0104]    The inequality holds generally if 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           arb_reset 
                            
                           
                             _gap 
                             
                               i 
                               X 
                             
                           
                         
                         + 
                         
                           arb_delay 
                           
                             i 
                             X 
                           
                         
                       
                       ] 
                     
                     min 
                   
                   &gt; 
                   
                     
 
                   
                    
                   
                       
                   
                    
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 arb_reset 
                                  
                                 
                                   _gap 
                                   
                                     i 
                                     Y 
                                   
                                 
                               
                               + 
                               
                                 PHY_DELAY 
                                 Y 
                                 
                                   
                                     P 
                                     Y 
                                     ′ 
                                   
                                   → 
                                   
                                     P 
                                     Y 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       Y 
                                     
                                     , 
                                     
                                       P 
                                       
                                         Y 
                                         - 
                                         1 
                                       
                                     
                                   
                                   ] 
                                 
                               
                               + 
                               
                                 PPM_delta 
                                 
                                   [ 
                                   
                                     Y 
                                     , 
                                     
                                       Y 
                                       - 
                                       1 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       
                                         Y 
                                         - 
                                         1 
                                       
                                     
                                     , 
                                     
                                       P 
                                       X 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                               
                                 PPM_delta 
                                 
                                   [ 
                                   
                                     
                                       Y 
                                       - 
                                       1 
                                     
                                     , 
                                     X 
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 Data_Arb 
                                  
                                 
                                   _Mismatch 
                                   
                                     [ 
                                     
                                       
                                         P 
                                         X 
                                       
                                       → 
                                       
                                         P 
                                         Y 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 transceiver_delay 
                                 Y 
                                 
                                   P 
                                   Y 
                                 
                               
                               - 
                               
                                 ARB_DETECTION 
                                  
                                 
                                   _TIME 
                                   Y 
                                   
                                     P 
                                     Y 
                                     ′ 
                                   
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                     max 
                   
                 
               
               
                 
                   ( 
                   74 
                   ) 
                 
               
             
           
         
       
     
         [0105]    Combining the DE_Delta and PPM_delta terms gives: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           arb_reset 
                            
                           
                             _gap 
                             
                               i 
                               X 
                             
                           
                         
                         + 
                         
                           arb_delay 
                           
                             i 
                             X 
                           
                         
                       
                       ] 
                     
                     min 
                   
                   &gt; 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 arb_reset 
                                  
                                 
                                   _gap 
                                   
                                     i 
                                     Y 
                                   
                                 
                               
                               + 
                               
                                 PHY_DELAY 
                                 Y 
                                 
                                   
                                     P 
                                     Y 
                                     ′ 
                                   
                                   → 
                                   
                                     P 
                                     Y 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 DE_delta 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       Y 
                                     
                                     , 
                                     
                                       P 
                                       X 
                                     
                                   
                                   ] 
                                 
                               
                               + 
                               
                                 PPM_delta 
                                 
                                   [ 
                                   
                                     Y 
                                     , 
                                     X 
                                   
                                   ] 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 Data_Arb 
                                  
                                 
                                   _Mismatch 
                                   
                                     [ 
                                     
                                       
                                         P 
                                         X 
                                       
                                       → 
                                       
                                         P 
                                         Y 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 transceiver_delay 
                                 Y 
                                 
                                   P 
                                   Y 
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               ARB_DETECTION 
                                
                               
                                 _TIME 
                                 Y 
                                 
                                   P 
                                   Y 
                                   ′ 
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                     max 
                   
                 
               
               
                 
                   ( 
                   75 
                   ) 
                 
               
             
           
         
       
     
         [0106]    By requiring 
         [0000]        DE _delta [P     Y     ,P     X     ]   +PPM _delta [Y,X] ≦transceiver_delay Y   P     Y     +ARB _DETECTION_TIME Y   P′     Y     Y   (76) 
         [0107]    the constraining inequality can be further simplified to give 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       [ 
                       
                         
                           
                             
                               
                                 arb_reset 
                                  
                                 
                                   _gap 
                                   min 
                                   
                                     i 
                                     X 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               arb_delay 
                               min 
                               
                                 i 
                                 X 
                               
                             
                           
                         
                       
                       ] 
                     
                     &gt; 
                     
                       [ 
                       
                         
                           
                             
                               
                                 arb_reset 
                                  
                                 
                                   _gap 
                                   max 
                                   
                                     i 
                                     Y 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 PHY_DELAY 
                                 
                                   Y 
                                   , 
                                   max 
                                 
                                 
                                   
                                     P 
                                     Y 
                                     ′ 
                                   
                                   → 
                                   
                                     P 
                                     Y 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               Data_Arb 
                                
                               
                                 _Mismatch 
                                 max 
                                 
                                   [ 
                                   
                                     
                                       P 
                                       X 
                                     
                                     → 
                                     
                                       P 
                                       Y 
                                     
                                   
                                   ] 
                                 
                               
                             
                           
                         
                       
                       ] 
                     
                   
                    
                   
                     
 
                   
                    
                   where 
                 
               
               
                 
                   ( 
                   77 
                   ) 
                 
               
             
             
               
                 
                   
                     arb_reset 
                      
                     
                       _gap 
                       min 
                       
                         i 
                         X 
                       
                     
                   
                   = 
                   
                     
                       51 
                       + 
                       
                         gap_count 
                         · 
                         32 
                       
                     
                     
                       BASERATE 
                       
                         X 
                         , 
                         max 
                       
                     
                   
                 
               
               
                 
                   ( 
                   78 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       arb_delay 
                       min 
                       
                         i 
                         X 
                       
                     
                     = 
                     
                       
                         gap_count 
                         · 
                         4 
                       
                       
                         BASERATE 
                         
                           X 
                           , 
                           max 
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   and 
                 
               
               
                 
                   ( 
                   79 
                   ) 
                 
               
             
             
               
                 
                   
                     arb_reset 
                      
                     
                       _gap 
                       max 
                       
                         i 
                         Y 
                       
                     
                   
                   = 
                   
                     
                       53 
                       + 
                       
                         gap_count 
                         · 
                         32 
                       
                     
                     
                       BASERATE 
                       
                         Y 
                         , 
                         min 
                       
                     
                   
                 
               
               
                 
                   ( 
                   80 
                   ) 
                 
               
             
           
         
       
     
         [0108]    Solving for gap count, 
         [0000]    
       
         
           
             
               
                 
                   gap_count 
                   &gt; 
                   
                     
                       
                         
                           
                             
                               
                                 BASERATE 
                                 
                                   X 
                                   , 
                                   max 
                                 
                               
                               · 
                               
                                 [ 
                                 
                                   
                                     
                                       
                                         
                                           PHY_DELAY 
                                           
                                             Y 
                                             , 
                                             max 
                                           
                                           
                                             
                                               P 
                                               Y 
                                               ′ 
                                             
                                             → 
                                             
                                               P 
                                               Y 
                                             
                                           
                                         
                                         + 
                                       
                                     
                                   
                                   
                                     
                                       
                                         Data_Arb 
                                          
                                         
                                           _Mismatch 
                                           max 
                                           
                                             [ 
                                             
                                               
                                                 P 
                                                 X 
                                               
                                               → 
                                               
                                                 P 
                                                 Y 
                                               
                                             
                                             ] 
                                           
                                         
                                       
                                     
                                   
                                 
                                 ] 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               53 
                               · 
                               
                                 
                                   BASERATE 
                                   
                                     X 
                                     , 
                                     max 
                                   
                                 
                                 
                                   BASERATE 
                                   
                                     Y 
                                     , 
                                     min 
                                   
                                 
                               
                             
                             - 
                             51 
                           
                         
                       
                     
                     
                       36 
                       - 
                       
                         32 
                         · 
                         
                           
                             BASERATE 
                             
                               X 
                               , 
                               max 
                             
                           
                           
                             BASERATE 
                             
                               Y 
                               , 
                               min 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   81 
                   ) 
                 
               
             
           
         
       
     
         [0109]    Equations (31), (45), (66) and (81) place a lower bound on gap count. Let: 
         [0000]    
       
         
           
             
               
                 
                   
                     gap_count 
                     A 
                   
                   = 
                   
                     
                       
                         
                           
                             
                               BASERATE 
                               
                                 X 
                                 , 
                                 max 
                               
                             
                             · 
                           
                         
                       
                       
                         
                           
                             
                               [ 
                               
                                 
                                   
                                     
                                       
                                         Round_Trip 
                                          
                                         
                                           _Delay 
                                           max 
                                           
                                             [ 
                                             
                                               
                                                 P 
                                                 X 
                                               
                                                
                                               O 
                                                
                                               
                                                   
                                               
                                                
                                               
                                                 P 
                                                 Y 
                                               
                                             
                                             ] 
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         RESPONSE_TIME 
                                         
                                           Y 
                                           , 
                                           max 
                                         
                                         
                                           P 
                                           Y 
                                           ′ 
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       PHY_DELAY 
                                       
                                         X 
                                         , 
                                         max 
                                       
                                       
                                         P 
                                         X 
                                       
                                     
                                   
                                 
                               
                               ] 
                             
                             - 
                             27 
                           
                         
                       
                     
                     16 
                   
                 
               
               
                 
                   ( 
                   82 
                   ) 
                 
               
             
             
               
                 
                   
                     gap_count 
                     B 
                   
                   = 
                   
                     
                       
                         
                           
                             
                               
                                 BASERATE 
                                 
                                   X 
                                   , 
                                   max 
                                 
                               
                               · 
                               
                                 [ 
                                 
                                   
                                     
                                       
                                         
                                           Round_Trip 
                                            
                                           
                                             _Delay 
                                             max 
                                             
                                               [ 
                                               
                                                 
                                                   P 
                                                   X 
                                                 
                                                  
                                                 O 
                                                  
                                                 
                                                     
                                                 
                                                  
                                                 
                                                   P 
                                                   Y 
                                                 
                                               
                                               ] 
                                             
                                           
                                         
                                         + 
                                       
                                     
                                   
                                   
                                     
                                       
                                         
                                           RESPONSE_TIME 
                                           
                                             Y 
                                             , 
                                             max 
                                           
                                           
                                             P 
                                             Y 
                                             ′ 
                                           
                                         
                                         - 
                                       
                                     
                                   
                                   
                                     
                                       
                                         
                                           MIN_IDLE 
                                            
                                           
                                             _TIME 
                                             Y 
                                           
                                         
                                         + 
                                       
                                     
                                   
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           X 
                                           , 
                                           max 
                                         
                                         
                                           P 
                                           X 
                                         
                                       
                                     
                                   
                                 
                                 ] 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               29 
                               · 
                               
                                 
                                   BASERATE 
                                   
                                     X 
                                     , 
                                     max 
                                   
                                 
                                 
                                   BASERATE 
                                   
                                     Y 
                                     , 
                                     min 
                                   
                                 
                               
                             
                             - 
                             51 
                           
                         
                       
                     
                     
                       32 
                       - 
                       
                         20 
                         · 
                         
                           
                             BASERATE 
                             
                               X 
                               , 
                               max 
                             
                           
                           
                             BASERATE 
                             
                               Y 
                               , 
                               min 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   83 
                   ) 
                 
               
             
             
               
                 
                   
                     gap_count 
                     C 
                   
                   = 
                   
                     
                       
                         
                           
                             
                               
                                 BASERATE 
                                 
                                   X 
                                   , 
                                   max 
                                 
                               
                               · 
                               
                                 [ 
                                 
                                   
                                     
                                       
                                         
                                           Data_Arb 
                                            
                                           
                                             _Mismatch 
                                             max 
                                             
                                               [ 
                                               
                                                 
                                                   P 
                                                   X 
                                                 
                                                 → 
                                                 
                                                   P 
                                                   Y 
                                                 
                                               
                                               ] 
                                             
                                           
                                         
                                         + 
                                       
                                     
                                   
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           Y 
                                           , 
                                           max 
                                         
                                         
                                           
                                             P 
                                             Y 
                                             ′ 
                                           
                                           → 
                                           
                                             P 
                                             Y 
                                           
                                         
                                       
                                     
                                   
                                 
                                 ] 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               29 
                               · 
                               
                                 
                                   BASERATE 
                                   
                                     X 
                                     , 
                                     max 
                                   
                                 
                                 
                                   BASERATE 
                                   
                                     Y 
                                     , 
                                     min 
                                   
                                 
                               
                             
                             - 
                             27 
                           
                         
                       
                     
                     
                       20 
                       - 
                       
                         16 
                         · 
                         
                           
                             BASERATE 
                             
                               X 
                               , 
                               max 
                             
                           
                           
                             BASERATE 
                             
                               Y 
                               , 
                               min 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   84 
                   ) 
                 
               
             
             
               
                 
                   
                     gap_count 
                     D 
                   
                   = 
                   
                     
                       
                         
                           
                             
                               
                                 BASERATE 
                                 
                                   X 
                                   , 
                                   max 
                                 
                               
                               · 
                               
                                 [ 
                                 
                                   
                                     
                                       
                                         
                                           Data_Arb 
                                            
                                           
                                             _Mismatch 
                                             max 
                                             
                                               [ 
                                               
                                                 
                                                   P 
                                                   X 
                                                 
                                                 → 
                                                 
                                                   P 
                                                   Y 
                                                 
                                               
                                               ] 
                                             
                                           
                                         
                                         + 
                                       
                                     
                                   
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           Y 
                                           , 
                                           max 
                                         
                                         
                                           
                                             P 
                                             Y 
                                             ′ 
                                           
                                           → 
                                           
                                             P 
                                             Y 
                                           
                                         
                                       
                                     
                                   
                                 
                                 ] 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             
                               53 
                               · 
                               
                                 
                                   BASERATE 
                                   
                                     X 
                                     , 
                                     max 
                                   
                                 
                                 
                                   BASERATE 
                                   
                                     Y 
                                     , 
                                     min 
                                   
                                 
                               
                             
                             - 
                             51 
                           
                         
                       
                     
                     
                       36 
                       - 
                       
                         32 
                         · 
                         
                           
                             BASERATE 
                             
                               X 
                               , 
                               max 
                             
                           
                           
                             BASERATE 
                             
                               Y 
                               , 
                               min 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   85 
                   ) 
                 
               
             
           
         
       
     
         [0110]    Given the ratio of maximum to minimum BASERATE is always &gt;1 and that MIN_IDLE_TIME is ˜40 ns, it is clear that: 
         [0000]      gap_count B &gt;gap_count A   (86) 
         [0000]      and 
         [0000]      gap_count D &gt;gap_count C   (87) 
         [0111]    To select an appropriate gap count for a given topology, both gap countB and gap_countD must be calculated, rounded up to the next integer, and the maximum of the two results selected. 
         [0112]    For IEEE1394-1995 style topologies (assumed to be limited to 4.5 m cables and a worst case PHY_DELAY of 144 ns), a table can be constructed to provide the gap count setting as a function of hops. In constructing such a table, the constant values in Table 2 are assumed. 
         [0000]    
       
         
               
             
               
               
               
             
               
               
               
               
               
             
               
               
               
               
             
           
               
                 TABLE 2 
               
             
             
               
                   
               
               
                 PHY Timing Constants 
               
             
          
           
               
                 Parameter 
                 Minimum 
                 Maximum 
               
               
                   
               
               
                 ARB_RESPONSE_DELAY 1   
                 PHY_DELAY(max) − 60 ns 
                 PHY_DELAY(max) 
               
             
          
           
               
                 BASERATE 
                 98.294 
                 mbps 
                 98.314 
                 mbps 
               
               
                 cable_delay 
                   
                   
                 22.725 
                 ns 
               
               
                 MIN_IDLE_TIME 
                 40 
                 ns 
               
               
                 PHY_DELAY 
                   
                   
                 144 
                 ns 
               
             
          
           
               
                 RESPONSE_TIME 
                   
                   
                 PHY_DELAY + 100 ns 
               
               
                   
               
             
          
         
       
     
         [0113]    The resulting gap count versus Cable Hops can then be calculated: 
         [0000]    
       
         
               
             
               
               
               
             
               
               
               
             
           
               
                 TABLE 3 
               
             
             
               
                   
               
               
                 Gap Count as a function of hops 
               
             
          
           
               
                   
                 Hops 
                 Gap Count 
               
               
                   
                   
               
             
          
           
               
                   
                 1 
                 5 
               
               
                   
                 2 
                 7 
               
               
                   
                 3 
                 8 
               
               
                   
                 4 
                 10 
               
               
                   
                 5 
                 13 
               
               
                   
                 6 
                 16 
               
               
                   
                 7 
                 18 
               
               
                   
                 8 
                 21 
               
               
                   
                 9 
                 24 
               
               
                   
                 10 
                 26 
               
               
                   
                 11 
                 29 
               
               
                   
                 12 
                 32 
               
               
                   
                 13 
                 35 
               
               
                   
                 14 
                 37 
               
               
                   
                 15 
                 40 
               
               
                   
                 16 
                 43 
               
               
                   
                 17 
                 46 
               
               
                   
                 18 
                 48 
               
               
                   
                 19 
                 51 
               
               
                   
                 20 
                 54 
               
               
                   
                 21 
                 57 
               
               
                   
                 22 
                 59 
               
               
                   
                 23 
                 62 
               
               
                   
                   
               
             
          
         
       
     
         [0114]    Pinging provides an effective way to set an optimal gap count for topologies with initially unspecified or unknown PHY or cable delays. Specifically, pinging allows determination of an instantaneous Round_Trip_Delay between two given points. Once the worst case Round_Trip Delay has been determined via pinging, gap_countb and gap_countd can be calculated and the appropriate gap count selected. 
         [0115]    The Jitter value specified in the PHY register map was introduced to help relate instantaneous measurements of ROUND_TRIP_DELAY to the maximum possible ROUND_TRIP_DELAY between two points. Specifically, the outbound PHY_DELAY and return ARB_RESPONSE_DELAY measured between a given ordered pair of ports on a PHY (say Pc out to and back from Pd) can be related to the maximum outbound PHY_DELAY and return ARB_RESPONSE_DELAY between any and all ordered pairs of ports (referenced as Pa &amp; Pb) on the same PHY: 
         [0000]    
       
         
           
             
               
                 
                   0 
                   ≤ 
                   
                     [ 
                     
                       
                         
                           
                             
                               
                                 
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           n 
                                           , 
                                           max 
                                         
                                         
                                           
                                             P 
                                             a 
                                           
                                           → 
                                           
                                             P 
                                             b 
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       ARB_RESPONSE 
                                        
                                       
                                         _DELAY 
                                         
                                           n 
                                           , 
                                           max 
                                         
                                         
                                           
                                             P 
                                             b 
                                           
                                           → 
                                           
                                             P 
                                             a 
                                           
                                         
                                       
                                     
                                   
                                 
                               
                               2 
                             
                             - 
                           
                         
                       
                       
                         
                           
                             
                               
                                 
                                   
                                     
                                       PHY_DELAY 
                                       
                                         n 
                                         , 
                                         meas 
                                       
                                       
                                         
                                           P 
                                           c 
                                         
                                         → 
                                         
                                           P 
                                           d 
                                         
                                       
                                     
                                     + 
                                   
                                 
                               
                               
                                 
                                   
                                     ARB_RESPONSE 
                                      
                                     
                                       _DELAY 
                                       
                                         n 
                                         , 
                                         meas 
                                       
                                       
                                         
                                           P 
                                           d 
                                         
                                         → 
                                         
                                           P 
                                           c 
                                         
                                       
                                     
                                   
                                 
                               
                             
                             2 
                           
                         
                       
                     
                     ] 
                   
                   ≤ 
                   
                     Jitter 
                     n 
                   
                 
               
               
                 
                   ( 
                   88 
                   ) 
                 
               
             
           
         
       
     
         [0116]    Noting that a measured value can never exceed a maximum value between order ports, the following corollary relating two independent measurements can be proven for any and all combination of ordered ports: 
         [0000]    
       
         
           
             
               
                 
                   
                     [ 
                     
                       
                         
                           
                             
                               
                                 
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           n 
                                           , 
                                           
                                             meas 
                                             1 
                                           
                                         
                                         
                                           
                                             P 
                                             a 
                                           
                                           → 
                                           
                                             P 
                                             b 
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       ARB_RESPONSE 
                                        
                                       
                                         _DELAY 
                                         
                                           n 
                                           , 
                                           
                                             meas 
                                             1 
                                           
                                         
                                         
                                           
                                             P 
                                             b 
                                           
                                           → 
                                           
                                             P 
                                             a 
                                           
                                         
                                       
                                     
                                   
                                 
                               
                               2 
                             
                             - 
                           
                         
                       
                       
                         
                           
                             
                               
                                 
                                   
                                     
                                       PHY_DELAY 
                                       
                                         n 
                                         , 
                                         
                                           meas 
                                           2 
                                         
                                       
                                       
                                         
                                           P 
                                           c 
                                         
                                         → 
                                         
                                           P 
                                           d 
                                         
                                       
                                     
                                     + 
                                   
                                 
                               
                               
                                 
                                   
                                     ARB_RESPONSE 
                                      
                                     
                                       _DELAY 
                                       
                                         n 
                                         , 
                                         
                                           meas 
                                           2 
                                         
                                       
                                       
                                         
                                           P 
                                           d 
                                         
                                         → 
                                         
                                           P 
                                           c 
                                         
                                       
                                     
                                   
                                 
                               
                             
                             2 
                           
                         
                       
                     
                     ] 
                   
                   ≤ 
                   
                     Jitter 
                     n 
                   
                 
               
               
                 
                   ( 
                   89 
                   ) 
                 
               
             
           
         
       
     
         [0117]    In order for a bus manager to calculate ordered leaf-to-leaf delays via a series of ping requests launched from the bus manager, a number of ROUND_TRIP_DELAY relationships will be required and are derived below. 
         [0000]      Round_Trip_Delay max   [P     X     OP     Y     ]   
         [0118]    Using the definition of Round_Trip_Delay first provided in equation (12) as guidance, the roundtrip delay between Nodes X and Y from the perspective of Node X can be written as: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           
                               
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           
                             X 
                             + 
                             1 
                           
                         
                         
                           Y 
                           - 
                           1 
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   2 
                                   · 
                                   
                                     cable_delay 
                                     n 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   PHY_DELAY 
                                   
                                     n 
                                     , 
                                     max 
                                   
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     → 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 ARB_RESPONSE 
                                  
                                 
                                   _DELAY 
                                   
                                     n 
                                     , 
                                     max 
                                   
                                   
                                     
                                       P 
                                       n 
                                     
                                     → 
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                   
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                     + 
                     
                       2 
                       · 
                       
                         cable_delay 
                         X 
                       
                     
                   
                 
               
               
                 
                   ( 
                   90 
                   ) 
                 
               
             
           
         
       
     
         [0119]    From equation (88), the maximum PHY_DELAY and ARB_RESPONSE_DELAY between an ordered pair of ports can be bounded by the measured delays plus the overall jitter sum yielding: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           
                               
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   ≤ 
                   
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           
                             X 
                             + 
                             1 
                           
                         
                         
                           Y 
                           - 
                           1 
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   2 
                                   · 
                                   
                                     cable_delay 
                                     n 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   PHY_DELAY 
                                   
                                     n 
                                     , 
                                     
                                       meas 
                                       1 
                                     
                                   
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     → 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   ARB_RESPONSE 
                                    
                                   
                                     _DELAY 
                                     
                                       n 
                                       , 
                                       
                                         meas 
                                         1 
                                       
                                     
                                     
                                       
                                         P 
                                         n 
                                       
                                       → 
                                       
                                         P 
                                         n 
                                         ′ 
                                       
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 2 
                                 · 
                                 
                                   Jitter 
                                   n 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                     + 
                     
                       2 
                       · 
                       
                         cable_delay 
                         X 
                       
                     
                   
                 
               
               
                 
                   ( 
                   91 
                   ) 
                 
               
             
           
         
       
     
         [0120]    Comparison to the definition of Round_Trip_Delay then allows 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         max 
                         
                           [ 
                           
                             
                               P 
                               X 
                             
                              
                             
                                 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               Y 
                             
                           
                           ] 
                         
                       
                     
                     ≤ 
                     
                       
                         Round_Trip 
                          
                         
                           _Delay 
                           
                             meas 
                             1 
                           
                           
                             [ 
                             
                               
                                 P 
                                 X 
                               
                                
                               
                                   
                               
                                
                               O 
                                
                               
                                   
                               
                                
                               
                                 P 
                                 Y 
                               
                             
                             ] 
                           
                         
                       
                       + 
                       
                         
                           ∑ 
                           
                             n 
                             = 
                             
                               X 
                               + 
                               1 
                             
                           
                           
                             Y 
                             - 
                             1 
                           
                         
                          
                         
                           2 
                           · 
                           
                             Jitter 
                             n 
                           
                         
                       
                     
                   
                    
                   
                     
 
                   
                    
                   
                       
                   
                    
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             Y 
                           
                            
                           
                               
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             X 
                           
                         
                         ] 
                       
                     
                   
                 
               
               
                 
                   ( 
                   92 
                   ) 
                 
               
             
           
         
       
     
         [0121]    Using the definitions of Round_Trip_Delay first provided in equation (12) as guidance, the roundtrip delay between Nodes X and Y from the perspective of Node Y can be written as: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             Y 
                           
                            
                           
                               
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             X 
                           
                         
                         ] 
                       
                     
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           
                             X 
                             + 
                             1 
                           
                         
                         
                           Y 
                           - 
                           1 
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   2 
                                   · 
                                   
                                     cable_delay 
                                     n 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   PHY_DELAY 
                                   
                                     n 
                                     , 
                                     max 
                                   
                                   
                                     
                                       P 
                                       n 
                                     
                                     → 
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 ARB_RESPONSE 
                                  
                                 
                                   _DELAY 
                                   
                                     n 
                                     , 
                                     max 
                                   
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     → 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                     + 
                     
                       2 
                       · 
                       
                         cable_delay 
                         X 
                       
                     
                   
                 
               
               
                 
                   ( 
                   93 
                   ) 
                 
               
             
           
         
       
     
         [0122]    From equation (88), the maximum PHY_DELAY and ARB_RESPONSE_DELAY between an ordered pair of ports can be related to the measured delays observed in the reverse direction: 
         [0000]    
       
         
           
             
               
                 
                   
                     ( 
                     
                       
                         
                           
                             
                               PHY_DELAY 
                               
                                 n 
                                 , 
                                 max 
                               
                               
                                 
                                   P 
                                   n 
                                 
                                 → 
                                 
                                   P 
                                   n 
                                   ′ 
                                 
                               
                             
                             + 
                           
                         
                       
                       
                         
                           
                             ARB_RESPONSE 
                              
                             
                               _DELAY 
                               
                                 n 
                                 , 
                                 max 
                               
                               
                                 
                                   P 
                                   n 
                                   ′ 
                                 
                                 → 
                                 
                                   P 
                                   n 
                                 
                               
                             
                           
                         
                       
                     
                     ) 
                   
                   ≤ 
                   
                     
                       2 
                       · 
                       
                         Jitter 
                         n 
                       
                     
                     + 
                     
                       ( 
                       
                         
                           
                             
                               
                                 PHY_DELAY 
                                 
                                   n 
                                   , 
                                   
                                     meas 
                                     1 
                                   
                                 
                                 
                                   
                                     P 
                                     n 
                                     ′ 
                                   
                                   → 
                                   
                                     P 
                                     n 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               ARB_RESPONSE 
                                
                               
                                 _DELAY 
                                 
                                   n 
                                   , 
                                   
                                     meas 
                                     1 
                                   
                                 
                                 
                                   
                                     P 
                                     n 
                                   
                                   → 
                                   
                                     P 
                                     n 
                                     ′ 
                                   
                                 
                               
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   94 
                   ) 
                 
               
             
           
         
       
     
         [0123]    allowing the maximum round trip between Nodes X and Y to be rewritten as: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         max 
                         
                           [ 
                           
                             
                               P 
                               Y 
                             
                              
                             
                               OP 
                               X 
                             
                           
                           ] 
                         
                       
                     
                     ≤ 
                     
                       
                         
                           ∑ 
                           
                             n 
                             = 
                             
                               X 
                               + 
                               1 
                             
                           
                           
                             Y 
                             - 
                             1 
                           
                         
                          
                         
                           ( 
                           
                             
                               
                                 
                                   
                                     2 
                                     · 
                                     
                                       cable_delay 
                                       n 
                                     
                                   
                                   + 
                                 
                               
                             
                             
                               
                                 
                                   
                                     PHY_DELAY 
                                     
                                       n 
                                       , 
                                       meas 
                                     
                                     
                                       
                                         P 
                                         n 
                                         ′ 
                                       
                                       -&gt; 
                                       
                                         P 
                                         n 
                                       
                                     
                                   
                                   + 
                                 
                               
                             
                             
                               
                                 
                                   
                                     ARB_RESPONSE 
                                      
                                     
                                       _DELAY 
                                       
                                         n 
                                         , 
                                         meas 
                                       
                                       
                                         
                                           P 
                                           n 
                                         
                                         -&gt; 
                                         
                                           P 
                                           n 
                                           ′ 
                                         
                                       
                                     
                                   
                                   + 
                                 
                               
                             
                             
                               
                                 
                                   2 
                                   · 
                                   
                                     Jitter 
                                     n 
                                   
                                 
                               
                             
                           
                           ) 
                         
                       
                       + 
                       
                         2 
                         · 
                         
                           cable_delay 
                           X 
                         
                       
                     
                   
                    
                   
                       
                   
                 
               
               
                 
                   ( 
                   95 
                   ) 
                 
               
             
           
         
       
     
         [0124]    Comparison to the definition of Round_Trip_Delay then allows 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Round_Trip 
                            
                           
                             _Delay 
                             max 
                             
                               [ 
                               
                                 
                                   P 
                                   Y 
                                 
                                  
                                 
                                   OP 
                                   X 
                                 
                               
                               ] 
                             
                           
                         
                         ≤ 
                         
                           
                             Round_Trip 
                              
                             
                               _Delay 
                               
                                 meas 
                                 1 
                               
                               
                                 [ 
                                 
                                   
                                     P 
                                     X 
                                   
                                    
                                   
                                     OP 
                                     Y 
                                   
                                 
                                 ] 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                         
                             
                         
                          
                         
                           
                             ∑ 
                             
                               n 
                               = 
                               
                                 X 
                                 + 
                                 1 
                               
                             
                             
                               Y 
                               - 
                               1 
                             
                           
                            
                           
                             2 
                             · 
                             
                               Jitter 
                               n 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         Round_Trip 
                          
                         
                           _Delay 
                           max 
                           
                             [ 
                             
                               
                                 P 
                                 N 
                               
                                
                               
                                 OP 
                                 X 
                               
                             
                             ] 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   96 
                   ) 
                 
               
             
           
         
       
     
         [0125]    Using the definition of Round_Trip_Delay first provided in equation (12) as guidance, the roundtrip delay between Nodes N and Y from the perspective of Node N can be written as: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             N 
                           
                            
                           
                             OP 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           
                             N 
                             + 
                             1 
                           
                         
                         
                           Y 
                           - 
                           1 
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   2 
                                   · 
                                   
                                     cable_delay 
                                     n 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   PHY_DELAY 
                                   
                                     n 
                                     , 
                                     
                                       max 
                                       1 
                                     
                                   
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 ARB_RESPONSE 
                                  
                                 
                                   _DELAY 
                                   
                                     n 
                                     , 
                                     max 
                                   
                                   
                                     
                                       P 
                                       n 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                   
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                     + 
                     
                       2 
                       · 
                       
                         cable_delay 
                         N 
                       
                     
                   
                 
               
               
                 
                   ( 
                   97 
                   ) 
                 
               
             
           
         
       
     
         [0126]    From equation (88), the maximum PHY_DELAY and ARB_RESPONSE_DELAY between an ordered pair of ports can be bounded by the measured delays plus the overall jitter sum yielding: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             N 
                           
                            
                           
                             OP 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   ≤ 
                   
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           
                             N 
                             + 
                             1 
                           
                         
                         
                           Y 
                           - 
                           1 
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   2 
                                   · 
                                   
                                     cable_delay 
                                     n 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   PHY_DELAY 
                                   
                                     n 
                                     , 
                                     
                                       meas 
                                       1 
                                     
                                   
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   ARB_RESPONSE 
                                    
                                   
                                     _DELAY 
                                     
                                       n 
                                       , 
                                       
                                         meas 
                                         1 
                                       
                                     
                                     
                                       
                                         P 
                                         n 
                                       
                                       -&gt; 
                                       
                                         P 
                                         n 
                                         ′ 
                                       
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 2 
                                 · 
                                 
                                   Jitter 
                                   n 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                     + 
                     
                       2 
                       · 
                       
                         cable_delay 
                         N 
                       
                     
                   
                 
               
               
                 
                   ( 
                   98 
                   ) 
                 
               
             
           
         
       
     
         [0127]    Introducing offsetting terms to the right side: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Round_Trip 
                            
                           
                             _Delay 
                             max 
                             
                               [ 
                               
                                 
                                   P 
                                   N 
                                 
                                  
                                 
                                   OP 
                                   Y 
                                 
                               
                               ] 
                             
                           
                         
                         ≤ 
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   
                                     
                                       
                                         2 
                                         · 
                                         
                                           cable_delay 
                                           n 
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           n 
                                           , 
                                           
                                             meas 
                                             1 
                                           
                                         
                                         
                                           
                                             P 
                                             n 
                                             ′ 
                                           
                                           -&gt; 
                                           
                                             P 
                                             n 
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         ARB_RESPONSE 
                                          
                                         
                                           _DELAY 
                                           
                                             n 
                                             , 
                                             
                                               meas 
                                               1 
                                             
                                           
                                           
                                             
                                               P 
                                               n 
                                             
                                             -&gt; 
                                             
                                               P 
                                               n 
                                               ′ 
                                             
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       2 
                                       · 
                                       
                                         Jitter 
                                         n 
                                       
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             2 
                             · 
                             
                               cable_delay 
                               X 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 N 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   
                                     
                                       
                                         2 
                                         · 
                                         
                                           cable_delay 
                                           n 
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           n 
                                           , 
                                           
                                             meas 
                                             1 
                                           
                                         
                                         
                                           
                                             P 
                                             n 
                                             ′ 
                                           
                                           -&gt; 
                                           
                                             P 
                                             n 
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         ARB_RESPONSE 
                                          
                                         
                                           _DELAY 
                                           
                                             n 
                                             , 
                                             
                                               meas 
                                               1 
                                             
                                           
                                           
                                             
                                               P 
                                               n 
                                             
                                             -&gt; 
                                             
                                               P 
                                               n 
                                               ′ 
                                             
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       2 
                                       · 
                                       
                                         Jitter 
                                         n 
                                       
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             2 
                             · 
                             
                               cable_delay 
                               X 
                             
                           
                           - 
                           
                             PHY_Delay 
                             
                               N 
                               , 
                               
                                 meas 
                                 1 
                               
                             
                             
                               
                                 P 
                                 n 
                                 ′ 
                               
                               -&gt; 
                               
                                 P 
                                 n 
                               
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             ARB_RESPONSE 
                              
                             
                               _DELAY 
                               
                                 N 
                                 , 
                                 
                                   meas 
                                   1 
                                 
                               
                               
                                 
                                   P 
                                   n 
                                 
                                 -&gt; 
                                 
                                   P 
                                   n 
                                   ′ 
                                 
                               
                             
                           
                           - 
                           
                             2 
                             · 
                             
                               Jitter 
                               N 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   99 
                   ) 
                 
               
             
           
         
       
     
         [0128]    Equations (89) and the fact that measured delays are at no smaller than minimum delays allow simplification to: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Round_Trip 
                            
                           
                             _Delay 
                             max 
                             
                               [ 
                               
                                 
                                   P 
                                   N 
                                 
                                  
                                 
                                   OP 
                                   Y 
                                 
                               
                               ] 
                             
                           
                         
                         ≤ 
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   
                                     
                                       
                                         2 
                                         · 
                                         
                                           cable_delay 
                                           n 
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           n 
                                           , 
                                           
                                             meas 
                                             1 
                                           
                                         
                                         
                                           
                                             P 
                                             n 
                                             ′ 
                                           
                                           -&gt; 
                                           
                                             P 
                                             n 
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         ARB_RESPONSE 
                                          
                                         
                                           _DELAY 
                                           
                                             n 
                                             , 
                                             
                                               meas 
                                               1 
                                             
                                           
                                           
                                             
                                               P 
                                               n 
                                             
                                             -&gt; 
                                             
                                               P 
                                               n 
                                               ′ 
                                             
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       2 
                                       · 
                                       
                                         Jitter 
                                         n 
                                       
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             2 
                             · 
                             
                               cable_delay 
                               X 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 N 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   
                                     
                                       
                                         2 
                                         · 
                                         
                                           cable_delay 
                                           n 
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           n 
                                           , 
                                           
                                             meas 
                                             2 
                                           
                                         
                                         
                                           
                                             P 
                                             n 
                                             ′ 
                                           
                                           -&gt; 
                                           
                                             P 
                                             n 
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       ARB_RESPONSE 
                                        
                                       
                                         _DELAY 
                                         
                                           n 
                                           , 
                                           
                                             meas 
                                             2 
                                           
                                         
                                         
                                           
                                             P 
                                             n 
                                           
                                           -&gt; 
                                           
                                             P 
                                             n 
                                             ′ 
                                           
                                         
                                       
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             2 
                             · 
                             
                               cable_delay 
                               X 
                             
                           
                           - 
                           
                             PHY_Delay 
                             
                               N 
                               , 
                               min 
                             
                             
                               
                                 P 
                                 n 
                                 ′ 
                               
                               -&gt; 
                               
                                 P 
                                 n 
                               
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             ARB_RESPONSE 
                              
                             
                               _DELAY 
                               
                                 N 
                                 , 
                                 min 
                               
                               
                                 
                                   P 
                                   n 
                                 
                                 -&gt; 
                                 
                                   P 
                                   n 
                                   ′ 
                                 
                               
                             
                           
                           - 
                           
                             2 
                             · 
                             
                               Jitter 
                               N 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   100 
                   ) 
                 
               
             
           
         
       
     
         [0129]    Comparison to the definition of Round_Trip_Delay then allows 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Round_Trip 
                            
                           
                             _Delay 
                             max 
                             
                               [ 
                               
                                 
                                   P 
                                   N 
                                 
                                  
                                 
                                   OP 
                                   Y 
                                 
                               
                               ] 
                             
                           
                         
                         ≤ 
                           
                          
                         
                           
                             Round_Trip 
                              
                             
                               _Delay 
                               
                                 meas 
                                 1 
                               
                               
                                 [ 
                                 
                                   
                                     P 
                                     X 
                                   
                                    
                                   
                                     OP 
                                     Y 
                                   
                                 
                                 ] 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               2 
                               · 
                               
                                 Jitter 
                                 n 
                               
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             Round_Trip 
                              
                             
                               _Delay 
                               
                                 meas 
                                 2 
                               
                               
                                 [ 
                                 
                                   
                                     P 
                                     X 
                                   
                                    
                                   
                                     OP 
                                     N 
                                   
                                 
                                 ] 
                               
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             PHY_DELAY 
                             
                               N 
                               , 
                               min 
                             
                             
                               
                                 P 
                                 N 
                                 ′ 
                               
                               -&gt; 
                               
                                 P 
                                 N 
                               
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             ARB_RESPONSE 
                              
                             
                               _DELAY 
                               
                                 N 
                                 , 
                                 min 
                               
                               
                                 
                                   P 
                                   N 
                                 
                                 -&gt; 
                                 
                                   P 
                                   N 
                                   ′ 
                                 
                               
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           2 
                           · 
                           
                             Jitter 
                             N 
                           
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           Round_Trip 
                            
                           
                             _Delay 
                             max 
                             
                               [ 
                               
                                 
                                   P 
                                   Y 
                                 
                                  
                                 
                                   OP 
                                   N 
                                 
                               
                               ] 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   101 
                   ) 
                 
               
             
           
         
       
     
         [0130]    Using the definition of Round_Trip_Delay first provided in equation (12) as guidance, the roundtrip delay between Nodes N and Y from the perspective of Node Y can be written as: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             Y 
                           
                            
                           
                             OP 
                             N 
                           
                         
                         ] 
                       
                     
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           
                             N 
                             + 
                             1 
                           
                         
                         
                           Y 
                           - 
                           1 
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   2 
                                   · 
                                   
                                     cable_delay 
                                     n 
                                   
                                 
                                 + 
                                 
                                   PHY_DELAY 
                                   
                                     n 
                                     , 
                                     max 
                                   
                                   
                                     
                                       P 
                                       n 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 ARB_RESPONSE 
                                  
                                 
                                   _DELAY 
                                   
                                     n 
                                     , 
                                     max 
                                   
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                     + 
                     
                       2 
                       · 
                       
                         cable_delay 
                         N 
                       
                     
                   
                 
               
               
                 
                   ( 
                   102 
                   ) 
                 
               
             
           
         
       
     
         [0131]    From equation (88), the maximum PHY_DELAY and ARB_RESPONSE_DELAY between an ordered pair of ports can be related to the measured delays observed in the reverse direction: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           ( 
                           
                             
                               
                                 
                                   
                                     PHY_DELAY 
                                     
                                       n 
                                       , 
                                       max 
                                     
                                     
                                       
                                         P 
                                         n 
                                       
                                       -&gt; 
                                       
                                         P 
                                         n 
                                         ′ 
                                       
                                     
                                   
                                   + 
                                 
                               
                             
                             
                               
                                 
                                   ARB_RESPONSE 
                                    
                                   
                                     _DELAY 
                                     
                                       n 
                                       , 
                                       max 
                                     
                                     
                                       
                                         P 
                                         n 
                                         ′ 
                                       
                                       -&gt; 
                                       
                                         P 
                                         n 
                                       
                                     
                                   
                                 
                               
                             
                           
                           ) 
                         
                         ≤ 
                         
                           
                             2 
                             · 
                             
                               Jitter 
                               n 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                         ( 
                         
                           
                             
                               
                                 
                                   PHY_DELAY 
                                   
                                     n 
                                     , 
                                     
                                       meas 
                                       1 
                                     
                                   
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 ARB_RESPONSE 
                                  
                                 
                                   _DELAY 
                                   
                                     n 
                                     , 
                                     
                                       meas 
                                       1 
                                     
                                   
                                   
                                     
                                       P 
                                       n 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                   
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   103 
                   ) 
                 
               
             
           
         
       
     
         [0132]    allowing the maximum round trip between Nodes N and Y to be rewritten as: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             Y 
                           
                            
                           
                             OP 
                             N 
                           
                         
                         ] 
                       
                     
                   
                   ≤ 
                   
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           
                             N 
                             + 
                             1 
                           
                         
                         
                           Y 
                           - 
                           1 
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   2 
                                   · 
                                   
                                     cable_delay 
                                     n 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   PHY_DELAY 
                                   
                                     n 
                                     , 
                                     
                                       meas 
                                       1 
                                     
                                   
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   ARB_RESPONSE 
                                    
                                   
                                     _DELAY 
                                     
                                       n 
                                       , 
                                       
                                         meas 
                                         1 
                                       
                                     
                                     
                                       
                                         P 
                                         n 
                                       
                                       -&gt; 
                                       
                                         P 
                                         n 
                                         ′ 
                                       
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 2 
                                 · 
                                 
                                   Jitter 
                                   n 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                     + 
                     
                       2 
                       · 
                       
                         cable_delay 
                         N 
                       
                     
                   
                 
               
               
                 
                   ( 
                   104 
                   ) 
                 
               
             
           
         
       
     
         [0133]    Introducing offsetting terms to the right side: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             Y 
                           
                            
                           
                             OP 
                             N 
                           
                         
                         ] 
                       
                     
                   
                   ≤ 
                     
                    
                   
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           
                             X 
                             + 
                             1 
                           
                         
                         
                           Y 
                           - 
                           1 
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   2 
                                   · 
                                   
                                     cable_delay 
                                     n 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   PHY_DELAY 
                                   
                                     n 
                                     , 
                                     
                                       meas 
                                       1 
                                     
                                   
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   ARB_RESPONSE 
                                    
                                   
                                     _DELAY 
                                     
                                       n 
                                       , 
                                       
                                         meas 
                                         1 
                                       
                                     
                                     
                                       
                                         P 
                                         n 
                                       
                                       -&gt; 
                                       
                                         P 
                                         n 
                                         ′ 
                                       
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 2 
                                 · 
                                 
                                   Jitter 
                                   n 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                     + 
                   
                 
               
             
             
               
                 
                     
                    
                   
                     
                       2 
                       · 
                       
                         cable_delay 
                         X 
                       
                     
                     - 
                   
                 
               
             
             
               
                 
                     
                    
                   
                     
                       
                         ∑ 
                         
                           n 
                           = 
                           
                             X 
                             + 
                             1 
                           
                         
                         
                           N 
                           - 
                           1 
                         
                       
                        
                       
                         ( 
                         
                           
                             
                               
                                 
                                   2 
                                   · 
                                   
                                     cable_delay 
                                     n 
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   PHY_DELAY 
                                   
                                     n 
                                     , 
                                     
                                       meas 
                                       1 
                                     
                                   
                                   
                                     
                                       P 
                                       n 
                                       ′ 
                                     
                                     -&gt; 
                                     
                                       P 
                                       n 
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 
                                   ARB_RESPONSE 
                                    
                                   
                                     _DELAY 
                                     
                                       n 
                                       , 
                                       
                                         meas 
                                         1 
                                       
                                     
                                     
                                       
                                         P 
                                         n 
                                       
                                       -&gt; 
                                       
                                         P 
                                         n 
                                         ′ 
                                       
                                     
                                   
                                 
                                 + 
                               
                             
                           
                           
                             
                               
                                 2 
                                 · 
                                 
                                   Jitter 
                                   n 
                                 
                               
                             
                           
                         
                         ) 
                       
                     
                     - 
                   
                 
               
             
             
               
                 
                     
                    
                   
                     
                       2 
                       · 
                       
                         cable_delay 
                         X 
                       
                     
                     - 
                     
                       PHY_Delay 
                       
                         N 
                         , 
                         
                           meas 
                           1 
                         
                       
                       
                         
                           P 
                           N 
                           ′ 
                         
                         -&gt; 
                         
                           P 
                           N 
                         
                       
                     
                     - 
                   
                 
               
             
             
               
                 
                     
                    
                   
                     
                       ARB_RESPONSE 
                        
                       
                         _DELAY 
                         
                           N 
                           , 
                           
                             meas 
                             1 
                           
                         
                         
                           
                             P 
                             N 
                           
                           -&gt; 
                           
                             P 
                             N 
                             ′ 
                           
                         
                       
                     
                     - 
                     
                       2 
                       · 
                       
                         Jitter 
                         N 
                       
                     
                   
                 
               
             
           
         
       
     
         [0134]    Equations (89) and the fact that measured delays are at no smaller than minimum delays allow simplification to: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Round_Trip 
                            
                           
                             _Delay 
                             max 
                             
                               [ 
                               
                                 
                                   P 
                                   Y 
                                 
                                  
                                 
                                   OP 
                                   N 
                                 
                               
                               ] 
                             
                           
                         
                         ≤ 
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   
                                     
                                       
                                         2 
                                         · 
                                         
                                           cable_delay 
                                           n 
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           n 
                                           , 
                                           
                                             meas 
                                             1 
                                           
                                         
                                         
                                           
                                             P 
                                             n 
                                             ′ 
                                           
                                           -&gt; 
                                           
                                             P 
                                             n 
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         ARB_RESPONSE 
                                          
                                         
                                           _DELAY 
                                           
                                             n 
                                             , 
                                             
                                               meas 
                                               1 
                                             
                                           
                                           
                                             
                                               P 
                                               n 
                                             
                                             -&gt; 
                                             
                                               P 
                                               n 
                                               ′ 
                                             
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       2 
                                       · 
                                       
                                         Jitter 
                                         n 
                                       
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             2 
                             · 
                             
                               cable_delay 
                               X 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 N 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   
                                     
                                       
                                         2 
                                         · 
                                         
                                           cable_delay 
                                           n 
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           n 
                                           , 
                                           
                                             meas 
                                             2 
                                           
                                         
                                         
                                           
                                             P 
                                             n 
                                             ′ 
                                           
                                           -&gt; 
                                           
                                             P 
                                             n 
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       ARB_RESPONSE 
                                        
                                       
                                         _DELAY 
                                         
                                           n 
                                           , 
                                           
                                             meas 
                                             2 
                                           
                                         
                                         
                                           
                                             P 
                                             n 
                                           
                                           -&gt; 
                                           
                                             P 
                                             n 
                                             ′ 
                                           
                                         
                                       
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             2 
                             · 
                             
                               cable_delay 
                               X 
                             
                           
                           - 
                           
                             PHY_Delay 
                             
                               N 
                               , 
                               min 
                             
                             
                               
                                 P 
                                 N 
                                 ′ 
                               
                               -&gt; 
                               
                                 P 
                                 N 
                               
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             ARB_RESPONSE 
                              
                             
                               _DELAY 
                               
                                 N 
                                 , 
                                 min 
                               
                               
                                 
                                   P 
                                   N 
                                 
                                 -&gt; 
                                 
                                   P 
                                   N 
                                   ′ 
                                 
                               
                             
                           
                           - 
                           
                             2 
                             · 
                             
                               Jitter 
                               N 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   105 
                   ) 
                 
               
             
           
         
       
     
         [0135]    Comparison to the definition of Round_Trip_Delay then allows 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Round_Trip 
                            
                           
                             _Delay 
                             max 
                             
                               [ 
                               
                                 
                                   P 
                                   Y 
                                 
                                  
                                 
                                   OP 
                                   N 
                                 
                               
                               ] 
                             
                           
                         
                         ≤ 
                           
                          
                         
                           
                             Round_Trip 
                              
                             
                               _Delay 
                               
                                 meas 
                                 1 
                               
                               
                                 [ 
                                 
                                   
                                     P 
                                     X 
                                   
                                    
                                   
                                     OP 
                                     Y 
                                   
                                 
                                 ] 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               2 
                               · 
                               
                                 Jitter 
                                 n 
                               
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             Round_Trip 
                              
                             
                               _Delay 
                               
                                 meas 
                                 2 
                               
                               
                                 [ 
                                 
                                   
                                     P 
                                     X 
                                   
                                    
                                   
                                     OP 
                                     N 
                                   
                                 
                                 ] 
                               
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             PHY_DELAY 
                             
                               N 
                               , 
                               min 
                             
                             
                               
                                 P 
                                 N 
                                 ′ 
                               
                               -&gt; 
                               
                                 P 
                                 N 
                               
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             ARB_RESPONSE 
                              
                             
                               _DELAY 
                               
                                 N 
                                 , 
                                 min 
                               
                               
                                 
                                   P 
                                   N 
                                 
                                 -&gt; 
                                 
                                   P 
                                   N 
                                   ′ 
                                 
                               
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           2 
                           · 
                           
                             Jitter 
                             N 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   107 
                   ) 
                 
               
             
           
         
       
     
         [0136]    PHY pinging provides a low level mechanism to directly measure round trip delays between two nodes by timing link initiated subactions. However, pinging does introduce some uncertainty in the measured delay. Any gap count algorithm which employs PHY pinging must compensate for such uncertainty.  FIG. 8  depicts a ping subaction issued by the link in Node X and directed to Node Y. 
         [0137]    The timing reference points t 1  through t 7  are identical to those used in the previous gap count derivations. Additionally:
       t 1 ′ Coincident with the rising SCLK edge in which the PHY first samples IDLE after a link transmission. t 1 ′ leads t 1  by LINK_TO_BUS_DELAY   t 7 ′ Coincident with the rising SCLK edge in which the PHY is driving the first RECEIVE indication to the link. (The PHY presumably drove RECEIVE off of the previous clock transition.) t 7 ′ lags t 7  by BUS_TO_LINK_DELAY       
 
         [0140]    The ping time measured by the link (in SCLK cycles) is then given by: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       
                         
                           Ping_Time 
                           meas 
                           
                             [ 
                             
                               
                                 P 
                                 X 
                               
                                
                               
                                 OP 
                                 Y 
                               
                             
                             ] 
                           
                         
                         = 
                           
                          
                         
                           
                             t 
                             7 
                             ′ 
                           
                           - 
                           
                             t 
                             1 
                             ′ 
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             BUS_TO 
                              
                             _LINK 
                              
                             
                               _DELAY 
                               
                                 X 
                                 , 
                                 meas 
                               
                             
                           
                           + 
                           
                             t 
                             7 
                           
                           - 
                           
                             t 
                             1 
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           LINK_TO 
                            
                           _BUS 
                            
                           
                             _DELAY 
                             
                               X 
                               , 
                               meas 
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             BUS_TO 
                              
                             _LINK 
                              
                             
                               _DELAY 
                               
                                 X 
                                 , 
                                 meas 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             LINK_TO 
                              
                             _BUS 
                              
                             
                               _DELAY 
                               
                                 X 
                                 , 
                                 meas 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             t 
                             0 
                           
                           + 
                           
                             
                               ∑ 
                               
                                 n 
                                 = 
                                 
                                   X 
                                   + 
                                   1 
                                 
                               
                               
                                 Y 
                                 - 
                                 1 
                               
                             
                              
                             
                               ( 
                               
                                 
                                   
                                     
                                       
                                         2 
                                         · 
                                         
                                           cable_delay 
                                           n 
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       
                                         PHY_DELAY 
                                         
                                           n 
                                           , 
                                           meas 
                                         
                                         
                                           
                                             P 
                                             n 
                                             ′ 
                                           
                                           -&gt; 
                                           
                                             P 
                                             n 
                                           
                                         
                                       
                                       + 
                                     
                                   
                                 
                                 
                                   
                                     
                                       ARB_RESPONSE 
                                        
                                       
                                         _DELAY 
                                         
                                           n 
                                           , 
                                           meas 
                                         
                                         
                                           
                                             P 
                                             n 
                                           
                                           -&gt; 
                                           
                                             P 
                                             n 
                                             ′ 
                                           
                                         
                                       
                                     
                                   
                                 
                               
                               ) 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             2 
                             · 
                             
                               cable_delay 
                               X 
                             
                           
                           + 
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             DATA_END 
                              
                             
                               _TIME 
                               
                                 
                                   Y 
                                   - 
                                   1 
                                 
                                 , 
                                 meas 
                               
                               
                                 P 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             RESPONSE_TIME 
                             
                               Y 
                               , 
                               meas 
                             
                             
                               P 
                               Y 
                               ′ 
                             
                           
                           - 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             t 
                             0 
                           
                           - 
                           
                             packet_length 
                             
                               packet_speed 
                               · 
                               
                                 BASERATE 
                                 X 
                               
                             
                           
                         
                       
                     
                   
                   
                     
                       
                         = 
                           
                          
                         
                           
                             BUS_TO 
                              
                             _LINK 
                              
                             
                               _DELAY 
                               
                                 X 
                                 , 
                                 meas 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             LINK_TO 
                              
                             _BUS 
                              
                             
                               _DELAY 
                               
                                 X 
                                 , 
                                 meas 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             Round_Trip 
                              
                             
                               _Delay 
                               meas 
                               
                                 [ 
                                 
                                   
                                     P 
                                     X 
                                   
                                    
                                   
                                     OP 
                                     Y 
                                   
                                 
                                 ] 
                               
                             
                           
                           + 
                           
                             PPM_delta 
                             
                               [ 
                               
                                 
                                   Y 
                                   - 
                                   1 
                                 
                                 , 
                                 X 
                               
                               ] 
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           
                             DATA_END 
                              
                             
                               _TIME 
                               
                                 
                                   Y 
                                   - 
                                   1 
                                 
                                 , 
                                 meas 
                               
                               
                                 P 
                                 
                                   Y 
                                   - 
                                   1 
                                 
                               
                             
                           
                           + 
                         
                       
                     
                   
                   
                     
                       
                           
                          
                         
                           RESPONSE_TIME 
                           
                             Y 
                             , 
                             meas 
                           
                           
                             P 
                             Y 
                             ′ 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   108 
                   ) 
                 
               
             
           
         
       
     
         [0141]    Solving for the measured Round_Trip_Delay gives: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       meas 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   = 
                   
                     
                       Ping_Time 
                       meas 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           
                               
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                     - 
                     
                       BUS_TO 
                        
                       _LINK 
                        
                       
                         _DELAY 
                         
                           X 
                           , 
                           meas 
                         
                       
                     
                     - 
                     
                       LINK_TO 
                        
                       _BUS 
                        
                       
                         _DELAY 
                         
                           X 
                           , 
                           meas 
                         
                       
                     
                     - 
                     
                       PPM_delta 
                       
                         [ 
                         
                           
                             Y 
                             - 
                             1 
                           
                           , 
                           X 
                         
                         ] 
                       
                     
                     - 
                     
                       DATA_END 
                        
                       
                         _TIME 
                         
                           
                             Y 
                             - 
                             1 
                           
                           , 
                           meas 
                         
                         
                           P 
                           
                             Y 
                             - 
                             1 
                           
                         
                       
                     
                     - 
                     
                       RESPONSE_TIME 
                       
                         Y 
                         , 
                         meas 
                       
                       
                         P 
                         Y 
                         ′ 
                       
                     
                   
                 
               
               
                 
                   ( 
                   109 
                   ) 
                 
               
             
           
         
       
     
         [0142]    Remembering that RESPONSE_TIME (min or max) absorbs PPM_delta, an upper and lower bound can be defined for Round_Trip_Delay: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       
                         Ping 
                         , 
                         max 
                       
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   = 
                   
                     
                       Ping_Time 
                       meas 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           
                               
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                     - 
                     
                       BUS_TO 
                        
                       _LINK 
                        
                       
                         _DELAY 
                         
                           X 
                           , 
                           min 
                         
                       
                     
                     - 
                     
                       LINK_TO 
                        
                       _BUS 
                        
                       
                         _DELAY 
                         
                           X 
                           , 
                           min 
                         
                       
                     
                     - 
                     
                       DATA_END 
                        
                       
                         _TIME 
                         
                           
                             Y 
                             - 
                             1 
                           
                           , 
                           min 
                         
                         
                           P 
                           
                             Y 
                             - 
                             1 
                           
                         
                       
                     
                     - 
                     
                       RESPONSE_TIME 
                       
                         Y 
                         , 
                         min 
                       
                       
                         P 
                         Y 
                         ′ 
                       
                     
                   
                 
               
               
                 
                   ( 
                   110 
                   ) 
                 
               
             
             
               
                 
                   
                       
                   
                    
                   and 
                 
               
               
                 
                     
                 
               
             
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       
                         Ping 
                         , 
                         min 
                       
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   = 
                   
                     
                       Ping_Time 
                       meas 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           
                               
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                     - 
                     
                       BUS_TO 
                        
                       _LINK 
                        
                       
                         _DELAY 
                         
                           X 
                           , 
                           max 
                         
                       
                     
                     - 
                     
                       LINK_TO 
                        
                       _BUS 
                        
                       
                         _DELAY 
                         
                           X 
                           , 
                           max 
                         
                       
                     
                     - 
                     
                       DATA_END 
                        
                       
                         _TIME 
                         
                           
                             Y 
                             - 
                             1 
                           
                           , 
                           max 
                         
                         
                           P 
                           
                             Y 
                             - 
                             1 
                           
                         
                       
                     
                     - 
                     
                       RESPONSE_TIME 
                       
                         Y 
                         , 
                         max 
                       
                       
                         P 
                         Y 
                         ′ 
                       
                     
                   
                 
               
               
                 
                   ( 
                   111 
                   ) 
                 
               
             
           
         
       
     
         [0000]    such that 
         [0000]      Round_Trip_Delay Ping,min   [P     X     OP     Y     ] ≦Round_Trip_Delay meas   [P     X     OP     Y     ] ≦Round_Trip_Delay Ping,max   [P     X     OP     Y     ]   (112) 
         [0143]    Using the Round_Trip_Delay properties and the Ping_Time relationships, the maximum Round_Trip_Delay between two given leaf nodes can be bounded for any possible topology. 
         [0144]    The simplest and most accurate Round_Trip_Delay determination is afforded when the Bus Manager is one of the leaf nodes in question as shown in  FIG. 9 . 
       From (92), 
       [0145]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             BM 
                           
                            
                           
                             OP 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   ≤ 
                   
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         
                           meas 
                           1 
                         
                         
                           [ 
                           
                             
                               P 
                               BM 
                             
                              
                             
                               OP 
                               Y 
                             
                           
                           ] 
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         n 
                         
                           ( 
                           
                             BM 
                             , 
                             Y 
                           
                           ) 
                         
                       
                        
                       
                         2 
                         · 
                         
                           Jitter 
                           n 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   113 
                   ) 
                 
               
             
           
         
       
     
         [0000]    And from (112), 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             BM 
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   ≤ 
                   
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         
                           Ping 
                           , 
                           max 
                         
                         
                           [ 
                           
                             
                               P 
                               BM 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               Y 
                             
                           
                           ] 
                         
                       
                     
                     + 
                     
                       
                         
                           ∑ 
                           n 
                         
                         
                           ( 
                           
                             BM 
                             , 
                             Y 
                           
                           ) 
                         
                       
                        
                       
                         2 
                         · 
                         
                           Jitter 
                           n 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   114 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Likewise, the reverse path is also bounded: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             Y 
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             BM 
                           
                         
                         ] 
                       
                     
                   
                   ≤ 
                   
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         
                           Ping 
                           , 
                           max 
                         
                         
                           [ 
                           
                             
                               P 
                               BM 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               Y 
                             
                           
                           ] 
                         
                       
                     
                     + 
                     
                       
                         
                           ∑ 
                           n 
                         
                         
                           ( 
                           
                             BM 
                             , 
                             Y 
                           
                           ) 
                         
                       
                        
                       
                         2 
                         · 
                         
                           Jitter 
                           n 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   115 
                   ) 
                 
               
             
           
         
       
     
         [0146]    The second topology to consider is when the bus manager is not a leaf but is part of the connecting path between the two leaves as illustrated in,  FIG. 10 . 
         [0147]    Expressing the max delay piecewise, 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   = 
                   
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         max 
                         
                           [ 
                           
                             
                               P 
                               X 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               BM 
                             
                           
                           ] 
                         
                       
                     
                     + 
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         max 
                         
                           [ 
                           
                             
                               P 
                               BM 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               Y 
                             
                           
                           ] 
                         
                       
                     
                     + 
                     
                       PHY_DELAY 
                       
                         BM 
                         , 
                         max 
                       
                       
                         
                           P 
                           BM 
                           ′ 
                         
                         → 
                         
                           P 
                           BM 
                         
                       
                     
                     + 
                     
                       ARB_RESPONSE 
                        
                       
                         _DELAY 
                         
                           BM 
                           , 
                           max 
                         
                         
                           
                             P 
                             BM 
                           
                           → 
                           
                             P 
                             BM 
                             ′ 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   116 
                   ) 
                 
               
             
           
         
       
     
         [0148]    Equations (92) and (96) allow: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   ≤ 
                   
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         meas 
                         
                           [ 
                           
                             
                               P 
                               BM 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               X 
                             
                           
                           ] 
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         n 
                         
                           ( 
                           
                             BM 
                             , 
                             X 
                           
                           ) 
                         
                       
                        
                       
                         2 
                         · 
                         
                           Jitter 
                           n 
                         
                       
                     
                     + 
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         meas 
                         
                           [ 
                           
                             
                               P 
                               BM 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               Y 
                             
                           
                           ] 
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         n 
                         
                           ( 
                           
                             BM 
                             , 
                             Y 
                           
                           ) 
                         
                       
                        
                       
                         2 
                         · 
                         
                           Jitter 
                           n 
                         
                       
                     
                     + 
                     
                       PHY_DELAY 
                       
                         BM 
                         , 
                         max 
                       
                       
                         
                           P 
                           BM 
                           ′ 
                         
                         → 
                         
                           P 
                           BM 
                         
                       
                     
                     + 
                     
                       ARB_RESPONSE 
                        
                       
                         _DELAY 
                         
                           BM 
                           , 
                           max 
                         
                         
                           
                             P 
                             BM 
                           
                           → 
                           
                             P 
                             BM 
                             ′ 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   117 
                   ) 
                 
               
             
           
         
       
     
         [0000]    And from (112), 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   ≤ 
                   
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         
                           Ping 
                           , 
                           max 
                         
                         
                           [ 
                           
                             
                               P 
                               BM 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               X 
                             
                           
                           ] 
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         n 
                         
                           ( 
                           
                             BM 
                             , 
                             X 
                           
                           ) 
                         
                       
                        
                       
                         2 
                         · 
                         
                           Jitter 
                           n 
                         
                       
                     
                     + 
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         
                           Ping 
                           , 
                           max 
                         
                         
                           [ 
                           
                             
                               P 
                               BM 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               Y 
                             
                           
                           ] 
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         n 
                         
                           ( 
                           
                             BM 
                             , 
                             Y 
                           
                           ) 
                         
                       
                        
                       
                         2 
                         · 
                         
                           Jitter 
                           n 
                         
                       
                     
                     + 
                     
                       PHY_DELAY 
                       
                         BM 
                         , 
                         max 
                       
                       
                         
                           P 
                           BM 
                           ′ 
                         
                         → 
                         
                           P 
                           BM 
                         
                       
                     
                     + 
                     
                       ARB_RESPONSE 
                        
                       
                         _DELAY 
                         
                           BM 
                           , 
                           max 
                         
                         
                           
                             P 
                             BM 
                           
                           → 
                           
                             P 
                             BM 
                             ′ 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   118 
                   ) 
                 
               
             
           
         
       
     
         [0149]    Likewise, the reverse path is also bounded: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   ≤ 
                   
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         
                           Ping 
                           , 
                           max 
                         
                         
                           [ 
                           
                             
                               P 
                               BM 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               X 
                             
                           
                           ] 
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         n 
                         
                           ( 
                           
                             BM 
                             , 
                             X 
                           
                           ) 
                         
                       
                        
                       
                         2 
                         · 
                         
                           Jitter 
                           n 
                         
                       
                     
                     + 
                     
                       Round_Trip 
                        
                       
                         _Delay 
                         
                           Ping 
                           , 
                           max 
                         
                         
                           [ 
                           
                             
                               P 
                               BM 
                             
                              
                             O 
                              
                             
                                 
                             
                              
                             
                               P 
                               Y 
                             
                           
                           ] 
                         
                       
                     
                     + 
                     
                       
                         ∑ 
                         n 
                         
                           ( 
                           
                             BM 
                             , 
                             Y 
                           
                           ) 
                         
                       
                        
                       
                         2 
                         · 
                         
                           Jitter 
                           n 
                         
                       
                     
                     + 
                     
                       PHY_DELAY 
                       
                         BM 
                         , 
                         max 
                       
                       
                         
                           P 
                           BM 
                           ′ 
                         
                         → 
                         
                           P 
                           BM 
                         
                       
                     
                     + 
                     
                       ARB_RESPONSE 
                        
                       
                         _DELAY 
                         
                           BM 
                           , 
                           max 
                         
                         
                           
                             P 
                             BM 
                           
                           → 
                           
                             P 
                             BM 
                             ′ 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   119 
                   ) 
                 
               
             
           
         
       
     
         [0150]    The final topology to consider is when the bus manager is not a leaf but is not part of the connecting path between the two leaves as illustrated in,  FIG. 11 . 
         [0151]    Expressing the max delay piecewise, 
         [0000]      Round_Trip_Delay max   [P     X     OP     Y     ] =Round_Trip_Delay max   [P     X     OP     N     ] +Round_Trip_Delay max   [P     N     OP     Y     ]   +PHY _Delay N,max   P′     N     →P     N     +ARB _RESPONSE_DELAY N,max   P     N     →P     N     (120) 
         [0152]    Equations (107) and (101) allow: 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   ≤ 
                   
                     
                       ( 
                       
                         
                           
                             
                               
                                 Round_Trip 
                                  
                                 
                                   _Delay 
                                   
                                     meas 
                                     1 
                                   
                                   
                                     [ 
                                     
                                       
                                         P 
                                         BM 
                                       
                                        
                                       O 
                                        
                                       
                                           
                                       
                                        
                                       
                                         P 
                                         Y 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               + 
                               
                                 
                                   ∑ 
                                   n 
                                   
                                     ( 
                                     
                                       BM 
                                       , 
                                       X 
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   2 
                                   · 
                                   
                                     Jitter 
                                     n 
                                   
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 Round_Trip 
                                  
                                 
                                   _Delay 
                                   
                                     meas 
                                     2 
                                   
                                   
                                     [ 
                                     
                                       
                                         P 
                                         BM 
                                       
                                        
                                       O 
                                        
                                       
                                           
                                       
                                        
                                       
                                         P 
                                         N 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               - 
                               
                                 PHY_DELAY 
                                 
                                   N 
                                   , 
                                   min 
                                 
                                 
                                   
                                     P 
                                     N 
                                     BM 
                                   
                                   → 
                                   
                                     P 
                                     N 
                                     ′ 
                                   
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 ARB_RESPONSE 
                                  
                                 
                                   _DELAY 
                                   
                                     N 
                                     , 
                                     min 
                                   
                                   
                                     
                                       P 
                                       N 
                                       ′ 
                                     
                                     → 
                                     
                                       
                                         P 
                                         . 
                                       
                                       N 
                                       BM 
                                     
                                   
                                 
                               
                               - 
                               
                                 2 
                                 · 
                                 
                                   Jitter 
                                   N 
                                 
                               
                             
                           
                         
                       
                       ) 
                     
                     + 
                     
                       ( 
                       
                         
                           
                             
                               
                                 Round_Trip 
                                  
                                 
                                   _Delay 
                                   
                                     meas 
                                     1 
                                   
                                   
                                     [ 
                                     
                                       
                                         P 
                                         BM 
                                       
                                        
                                       O 
                                        
                                       
                                           
                                       
                                        
                                       
                                         P 
                                         Y 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               + 
                               
                                 
                                   ∑ 
                                   n 
                                   
                                     ( 
                                     
                                       BM 
                                       , 
                                       Y 
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   2 
                                   · 
                                   
                                     Jitter 
                                     n 
                                   
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 Round_Trip 
                                  
                                 
                                   _Delay 
                                   
                                     meas 
                                     2 
                                   
                                   
                                     [ 
                                     
                                       
                                         P 
                                         BM 
                                       
                                        
                                       O 
                                        
                                       
                                           
                                       
                                        
                                       
                                         P 
                                         N 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               - 
                               
                                 PHY_DELAY 
                                 
                                   N 
                                   , 
                                   min 
                                 
                                 
                                   
                                     P 
                                     N 
                                     BM 
                                   
                                   → 
                                   
                                     P 
                                     N 
                                   
                                 
                               
                               - 
                             
                           
                         
                         
                           
                             
                               
                                 ARB_RESPONSE 
                                  
                                 
                                   _DELAY 
                                   
                                     N 
                                     , 
                                     min 
                                   
                                   
                                     
                                       
                                         P 
                                         . 
                                       
                                       N 
                                     
                                     → 
                                     
                                       P 
                                       N 
                                       BM 
                                     
                                   
                                 
                               
                               - 
                               
                                 2 
                                 · 
                                 
                                   Jitter 
                                   N 
                                 
                               
                             
                           
                         
                       
                       ) 
                     
                     + 
                     
                       PHY_DELAY 
                       
                         N 
                         , 
                         max 
                       
                       
                         
                           P 
                           N 
                           ′ 
                         
                         → 
                         
                           P 
                           N 
                         
                       
                     
                     + 
                     
                       ARB_RESPONSE 
                        
                       
                         _DELAY 
                         
                           N 
                           , 
                           max 
                         
                         
                           
                             P 
                             N 
                           
                           → 
                           
                             P 
                             N 
                             ′ 
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   121 
                   ) 
                 
               
             
           
         
       
     
         [0153]    And from (112), 
         [0000]    
       
         
           
             
               
                 
                   
                     Round_Trip 
                      
                     
                       _Delay 
                       max 
                       
                         [ 
                         
                           
                             P 
                             X 
                           
                            
                           O 
                            
                           
                               
                           
                            
                           
                             P 
                             Y 
                           
                         
                         ] 
                       
                     
                   
                   ≤ 
                   
                     
                       ( 
                       
                         
                           
                             
                               
                                 Round_Trip 
                                  
                                 
                                   _Delay 
                                   
                                     Ping 
                                     , 
                                     max 
                                   
                                   
                                     [ 
                                     
                                       
                                         P 
                                         BM 
                                       
                                        
                                       O 
                                        
                                       
                                           
                                       
                                        
                                       
                                         P 
                                         X 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               + 
                               
                                 
                                   ∑ 
                                   n 
                                   
                                     ( 
                                     
                                       BM 
                                       , 
                                       X 
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   2 
                                   · 
                                   
                                     Jitter 
                                     n 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 Round_Trip 
                                  
                                 
                                   _Delay 
                                   
                                     Ping 
                                     , 
                                     max 
                                   
                                   
                                     [ 
                                     
                                       
                                         P 
                                         BM 
                                       
                                        
                                       O 
                                        
                                       
                                           
                                       
                                        
                                       
                                         P 
                                         Y 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               + 
                               
                                 
                                   ∑ 
                                   n 
                                   
                                     ( 
                                     
                                       BM 
                                       , 
                                       Y 
                                     
                                     ) 
                                   
                                 
                                  
                                 
                                   2 
                                   · 
                                   
                                     Jitter 
                                     n 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 PHY_DELAY 
                                 
                                   N 
                                   , 
                                   max 
                                 
                                 
                                   
                                     P 
                                     N 
                                     ′ 
                                   
                                   → 
                                   
                                     P 
                                     N 
                                   
                                 
                               
                               + 
                               
                                 ARB_RESPONSE 
                                  
                                 
                                   _DELAY 
                                   
                                     N 
                                     , 
                                     max 
                                   
                                   
                                     
                                       P 
                                       N 
                                     
                                     → 
                                     
                                       P 
                                       N 
                                       ′ 
                                     
                                   
                                 
                               
                             
                           
                         
                       
                       ) 
                     
                     - 
                     
                       ( 
                       
                         
                           
                             
                               
                                 
                                   2 
                                   · 
                                   Round_Trip 
                                 
                                  
                                 
                                   _Delay 
                                   
                                     Ping 
                                     , 
                                     min 
                                   
                                   
                                     [ 
                                     
                                       
                                         P 
                                         BM 
                                       
                                        
                                       O 
                                        
                                       
                                           
                                       
                                        
                                       
                                         P 
                                         N 
                                       
                                     
                                     ] 
                                   
                                 
                               
                               + 
                               
                                 4 
                                 · 
                                 
                                   Jitter 
                                   N 
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 PHY_DELAY 
                                 
                                   N 
                                   , 
                                   min 
                                 
                                 
                                   
                                     P 
                                     N 
                                     BM 
                                   
                                   → 
                                   
                                     P 
                                     N 
                                     ′ 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 ARB_RESPONSE 
                                  
                                 
                                   _DELAY 
                                   
                                     N 
                                     , 
                                     min 
                                   
                                   
                                     
                                       P 
                                       N 
                                       ′ 
                                     
                                     → 
                                     
                                       P 
                                       N 
                                       BM 
                                     
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               
                                 PHY_DELAY 
                                 
                                   N 
                                   , 
                                   min 
                                 
                                 
                                   
                                     P 
                                     N 
                                     BM 
                                   
                                   → 
                                   
                                     P 
                                     N 
                                   
                                 
                               
                               + 
                             
                           
                         
                         
                           
                             
                               ARB_RESPONSE 
                                
                               
                                 _DELAY 
                                 
                                   N 
                                   , 
                                   min 
                                 
                                 
                                   
                                     P 
                                     N 
                                   
                                   → 
                                   
                                     P 
                                     N 
                                     BM 
                                   
                                 
                               
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   122 
                   ) 
                 
               
             
           
         
       
     
         [0000]    ARB_RESPONSE_DELAY is a difficult parameter to characterize. Proper PHY operation requires that arb signals propagate at least as fast as the data bits, otherwise the arbitration indications could shorten as they are repeated through a network. This fact places a bound on the maximum ARB_RESPONSE_DELAY: ARB_RESPONSE_DELAY between two ports at a particular instant must always be less than or equal to the data repeat delay at the very same instant. Although the distinction is subtle, this is not the same as saying the maximum ARB_RESPONSE_DELAY is PHY_DELAY. (PHY_DELAY only applies to the first bit of a packet and is known to have some jitter from one repeat operation to the next. Consequently, requiring ARB_RESPONSE_DELAY&lt;=PHY_DELAY doesn&#39;t force ARB_RESPONSE_DELAY to track the instantaneous PHY_DELAY nor does it allow ARB_RESPONSE_DELAY to track the data repeat time for the last bit of a packet which may actually exceed PHY_DELAY due to PPM drift.) Finally, the table approach to calculating gap_counta and gap_countb rely on ARB_RESPONSE_DELAY always being bounded by the maximum PHY_DELAY when determining the Round_Trip_Delay. 
         [0154]    The minimum ARB_RESPONSE_DELAY is only of significance when calculating Data_Arb_Mismatch as required by gap_countc and gap_countd. Ideally, Data_Arb_Mismatch should be a constant regardless of PHY_DELAY so that neither gap countc nor gap countd will begin to dominate the gap count setting as PHY_DELAY increases. Consequently, the minimum ARB_RESPONSE_DELAY should track the instantaneous PHY_DELAY with some offset for margin. Simply specifying the min value as a function of PHY_DELAY is ambiguous, however, since PHY_DELAY can be easily confused with the max DELAY reported in the register map. (For example, with DELAY at 144 ns, it would be easy to assume a min of PHY_DELAY −60 ns would be equivalent to 84 ns. But if the worst case first bit repeat delay was only 100 ns, arb signals repeating with a delay of 40 ns ought to be considered within spec even though the delay is &lt;84 ns.) 
         [0155]    Consequently, specifying an upper and a lower bound for ARB_RESPONSE_DELAY is best done in the standard with words rather than values. The minimum and maximum values for ARB_RESPONSE_DELAY include that between all ordered pairs of ports, the PHY shall repeat arbitration line states at least as fast as clocked data, but not more than 60 ns faster than clocked data. 
         [0156]    A better approach is to replace ARB_RESPONSE_DELAY with the parameter DELAY MISMATCH which is defined in the comment column as “Between all ordered pairs of ports, the instantaneous repeat delay for data less the instantaneous repeat delay for arbitration line states.” Then, the minimum would be given as 0 ns and the maximum would be 60 ns. 
         [0157]    For a table based calculation of Round_Trip_Delay, either approach above allows the use of PHY_DELAY(max) for ARB_RESPONSE_DELAY. Since Round_Trip_Delay considers the arbitration repeat delay in the direction opposite to the original packet flow, the return arbitration indication of interest is known to arrive at the receive port when the PHY is idle (all caught up with nothing to repeat). At that point, the instantaneous PHY_DELAY is the same as the first data bit repeat delay which is bounded by PHY_DELAY(max). Since ARB_RESPONSE_DELAY, is always bounded by the instantaneous PHY_DELAY, it to is bounded by PHY_DELAY(max) at the point the arbitration indication first arrives. 
         [0158]    The minimum bound on PHY_DELAY is used by the bus manager when determining the round_trip_delay between leaf nodes that are not separated by the bus manager. The more precise the minimum bound, the more accurate the pinging calculation can be. Ideally then, the bound may want to scale with increasing PHY_DELAY. Alternatively, the lower bound could be calculated by xamining the Delay field in the register map: if zero, the lower bound is assumed to be the fixed value specified (60 ns currently). If non-zero, the lower bound could then be determined by subtracting the jitter field (converted to ns) from the delay field (converted to ns). 
         [0159]    The “Jitter” field was introduced to aid in selection of gap_count via pinging by describing the uncertainty found in any empirical measurement of Round_Trip_Delay. Since Round_Trip_Delay encompasses an “outbound” PHY_DELAY and a “return” ARB_RESPONSE_DELAY, the jitter term should capture uncertainty in both. The needs of pinging can be met with the following description for jitter: Upper bound of the mean average of the worst case data repeat jitter (max/min variance) and the worst case arbitration repeat jitter (max/minvariance), expressed as 2*(jitter+1)/BASE_RATE. 
         [0160]    Note that from the discussion on minimum PHY_DELAY, it may be desirable to require that if the delay field is non-zero, then the slowest first data bit repeat delay can be calculated by subtracting the jitter value from the delay value.