Abstract:
Conventional methods using signal test patterns to identify wiring errors are difficult to apply to interfaces encoding information as signal state transitions rather than directly as signal states. A system utilizing excitation of wires with selected transition coded patterns and evaluation of received results is described to identify failed wire connections. This approach may be advantageously used to provide fault detection and redundant path selection in systems incorporating stacked chip interconnections using Through Silicon Vias.

Description:
[0001]    This application claims priority to U.S. Provisional Application 62/015,172, filed Jun. 20, 2014, entitled “System for Generating a Test Pattern to Detect and Isolate Stuck Faults for an Interface using Transition Coding,” which is herein incorporated by reference in its entirety for all purposes. 
     
    
     REFERENCES 
       [0002]    The following materials are herein incorporated by reference in their entirety for all purposes: 
         [0003]    US Publication 2015/0092532 of U.S. patent application Ser. No. 14/498,957, filed on Sep. 26, 2014 by Amin Shokrollahi and Roger Ulrich, entitled “Fault Tolerant Chip-to-Chip Communication with Advanced Voltage Regulator” (hereinafter Shokrollahi I). 
       BACKGROUND 
       [0004]    This disclosure is relevant to interfaces which encode and decode data values as transitions on the interconnect medium and have redundant resources to bypass faulty connections. Examples of such codes are described in Shokrollahi I, including the FTTL4 code utilized as a descriptive example herein. Efficient hardware-based identification of faulty connections is desired to facilitate automated reconfiguration of the redundant resources. The disclosed invention is relevant generally to any interface using transition codes, but is of particular interest to interfaces of 3D chip stacks where the interconnect is composed of stacked Thru-Silicon Vias (TSVs). 
         [0005]      FIG. 1  provides a model of the general case, where the transmission of data across an interface is characterized by the number of wires (n) and the number of allowed electrical states on each wire (s). The term “wire” is used within this disclosure to refer generally to one element of the interconnect medium, without limitation to e.g. metallic electrical connection for such medium.) For a state based code, data values of m bits width are encoded into corresponding codewords represented by a unique combination of states on the n wires. The state levels of the wires are detected at the receive end of the interface and decoded to reproduce the original data value. 
         [0006]    Note that in the general case m and n are not necessarily equal. If the number of possible electrical states s of each wire is greater than 2 (i.e. multi-level signaling is employed), then it is possible to encode m data bits into n wires where n&lt;m. 
         [0007]    Another method of encoding data bits onto the wires of the interface is to define codewords based on whether or not a transition occurs on each wire rather than the actual state of the wire. The current state of the wire is irrelevant to a transition code; the receiver detects whether transitions occur on each wire and decodes the codeword accordingly. 
         [0008]    If s&gt;2, then it is possible to define more than one type of transition. The receiver can differentiate between types of transitions based on the origin and terminal states of the wire. This expands the available code space such that transition codes where n&lt;m are possible. 
         [0009]    Transition codes are one type of code that can be used on interfaces between chips of a three dimensional (3D) chip stack. The 3D chip stack for a typical application is shown in  FIG. 2  where a controller chip on the bottom of the stack connects to multiple DRAM chips. In one such embodiment, write data is broadcast by the controller chip to DRAM chips (egress path), and DRAM chips respond on a tri-state bus to the controller chip (ingress path). The interconnections between chips are composed of Thru-Silicon Vias (TSVs) which provide a high density of I/O for a given chip area. However, TSV yield is a significant factor in the manufacturing process for 3D chip stacks, and interconnect redundancy is desirable to mitigate yield impacts. 
         [0010]      FIG. 3  illustrates an embodiment of the data transmission path of  FIG. 1  with data steering stages added to support an interconnect that has one redundant wire available. Since the codeword requires n wires, and n+1 wires are available, then a fault on any one wire can be bypassed. Other embodiments may include more than one redundant wire, and thus may support correction of additional faults. 
         [0011]    It is desirable to transmit a test pattern over the interface in  FIG. 3  and check the pattern at the receive end to determine if the n wires being used are free from faults. Such test patterns may be implemented as a Built-In-Self-Test (BIST) feature of the interface, or may be generated external to the chip and applied by manufacturing test equipment to test the interface as part of a manufacturing or assembly process. If a fault is detected, it is desirable for the Pattern Checker to isolate which wire contains the fault based on the received test pattern. The data steering can be reconfigured based on this detection to bypass the wire with the fault. Known techniques exist for detecting and isolating stuck faults on wires using binary state-based codes. However, these techniques do not work with transition codes where the mapping between data bits and wires is not one-for-one. 
         [0012]    Furthermore, it is desirable to minimize the required test circuitry incorporated into the DRAM chips shown in the application in  FIG. 2 . Toward this end, the DRAM is simplified to loopback the egress path to the ingress path with minimal processing as shown for the Data Loopback  420  in the loopback path of  FIG. 4 . The Pattern Generator  410  and Pattern Checker  430  are both located on the controller chip. This architecture places the additional burden on the test pattern, in that faults on the egress path must be distinguishable from faults on the ingress path. 
       BRIEF DESCRIPTION 
       [0013]    Given an arbitrary transition code meeting the disclosed requirements, an embodiment comprises: 
         [0014]    A system for constructing a test pattern to be transmitted by the Pattern Generator  410  as shown in  FIG. 4 ; 
         [0015]    A system for a Pattern Checker  430  as shown in  FIG. 4  to determine whether faults exist, and if faults exist then isolate which wire contains the fault, based on the codewords received in the test pattern; 
         [0016]    A system for Data Loopback logic  420  in the test path as shown in  FIG. 4  to loopback data from the egress path to the ingress path such that the Pattern Checker can differentiate between faults on the egress path and faults on the ingress path. 
         [0017]    At least one embodiment disclosed herein is a Pattern Generator and Pattern Checker for a single interconnect segment as shown in  FIG. 3 . Another embodiment is a Pattern Generator, Data Loopback, and Pattern Checker used to test cascaded interconnect segments as shown in  FIG. 4 . A further embodiment allowing cascading of the interconnect segments can also be applied to a bidirectional data bus between the controller and DRAM chips of  FIG. 2  by segmenting the bus during test modes such half of the data bus is used as an egress path, and half of the data bus is used as an ingress path. 
         [0018]    Embodiments in accordance with the disclosure may be implemented by Built-In-Self-Test (BIST) circuits on the chip, or by external test equipment interfacing to the chip being tested. 
         [0019]    At least one embodiment uses the FTTL4 transition code described in Shokrollahi I. No limitation is implied, however, as other embodiments may in general use any transition code that meets the requirements described. 
     
    
     
       BRIEF DESCRIPTION OF FIGURES 
         [0020]      FIG. 1  illustrates an interface where data is encoded for transmission across an interconnection consisting of an arbitrary number of wires to a receiver where the codewords on the interface are decoded to reproduce the original data. 
           [0021]      FIG. 2  illustrates a three dimensional (3D) stack consisting of a controller chip and DRAM chips, and illustrating an egress datapath from the controller to the DRAM chips, and an ingress datapath from the DRAM chips back to the controller chip. 
           [0022]      FIG. 3  illustrates the interface of  FIG. 1  with the addition of a redundant wire and data steering stages to utilize the redundant wire to bypass a fault on any of the interconnect wires. 
           [0023]      FIG. 4  illustrates an embodiment in which the interface of  FIG. 3  has been cascaded for the egress and the ingress data path segments of  FIG. 2 , illustrating the placement of Pattern Generator  410  and Pattern Checker  430  on the controller chip, and the placement of Data Loopback  420  in the test path on the DRAM chip. 
           [0024]      FIG. 5  illustrates an embodiment of Pattern Generator  410  in  FIG. 4  for an FTTL4 code. 
           [0025]      FIG. 6  illustrates an embodiment of Data Loopback  420  in  FIG. 4  for an FTTL4 code. 
           [0026]      FIG. 7  illustrates an embodiment of Pattern Checker  430  in  FIG. 4  for an FTTL4 code. 
           [0027]      FIG. 8  illustrates another embodiment of a Pattern Checker for an FTTL4 code. 
           [0028]      FIG. 9  illustrates an example System Management Interface circuit for an FTTL4 code. 
           [0029]      FIG. 10  illustrates an example embodiment of a Data Steering Circuit for an FTTL4 code. 
           [0030]      FIG. 11  illustrates a method in accordance with at least one embodiment. 
       
    
    
     DETAILED DESCRIPTION 
       [0031]    The disclosed embodiments describe a system of constructing a test pattern for an arbitrary transmission code that can quickly identify whether a wire on the interface failed, and identify which wire failed using a simple detection circuit so that the interface can use spare resources to bypass the failed wire. One embodiment of the disclosed systems and methods includes constructing a Pattern Generator, Pattern Checker, and Data Loopback function that can be used with the FTTL4 transition code in a 3D chip stack application. The dominant failure mechanism for such interfaces is stuck faults due to open connections at TSVs. 
         [0032]    For descriptive purposes and without implying limitation, assumptions are made that: 
         [0000]    1. The interface contains at most one fault. Test pattern errors will occur if multiple faults exist, but aliasing may occur such that the failing path cannot be properly identified. Known pattern generation techniques capable of distinguishing multiple errors without aliasing may be combined with the described systems and methods.
 
2. Failures can be adequately modeled using the stuck-fault model prevalently used in Design-For-Test strategies. This assumption is generally valid for the target application (TSVs of a 3D chip stack) since the dominant circuit fault is an open connection. Other known failure modeling methods may also be applied to address other failure modes.
 
         [0033]    This disclosure develops a mathematical description of an arbitrary transition code, and describes properties of the codewords of the arbitrary code. The disclosed system utilizes these properties to group codewords into sets of codewords transmitted by the Pattern Generator and sets of codewords detected by the Pattern Checker and utilized for fault isolation. The detection and processing that may be implemented by the Data Loopback function is also defined. One embodiment is described for the FTTL4 transition code as described in Shokrollahi I. 
       Transition Functions and Properties of Codewords 
       [0034]    Assume a transition code with n wires and s states per wire, where the states of a wire represent signal levels on the transmission media. The data being transmitted on the interface is coded based on which wires make transitions, and the origin and terminal wire states of those transitions. Assume a transition function: 
         [0000]        W   0   =T   i ( W   −1 )  [Eqn. 1]
 
         [0035]    The function (T i ) describes the new state of the wire (W 0 ) based on the previous state of the wire (W −1 ). This function is applied to specific wires when encoding specific data values. A transition code may define several possible transition functions that are applied to the n wires based on the data value being encoded. The number of wires and the number of uniquely identifiable transition functions determines the number of data bits that can be coded on n wires. The greater the number of wire states s, the greater the number of transition functions that can be defined and uniquely identified at the receiver. 
         [0036]    Assume a transition code has defined f transition functions {T 0 , T 1 , . . . T f-1 }. The definition of the T 0  function is reserved and is defined as the null function where the wire does not change state: 
         [0000]        W   0   =T   0 ( W   −1 )= W   −1   [Eqn. 2]
 
         [0037]    All other transition functions involve a change of state for wire i. 
         [0038]    The transition code maps data values to codewords that are constructed by defining a transition function for each of n wires: (T i1 , T i2 , . . . T in ), where each T ij ∈{T 0 , T 1 , . . . T f-1 }. 
         [0039]    Note that some transition functions can be aliases of other transition functions. A transition function defines the new state of a wire W 0  based on the previous state of a wire W −1 . The transition function is defined by the transitions of wire states (W −1 , W 0 ) for all s possible values of wire state W −1 . Given two transition functions, if there exists a transition (W −1 , W 0 ) where the state values of W −1  and W 0  are the same for both functions, then the transition functions are aliases of each other. 
         [0040]    Now define a property called transition count (TC) of a given codeword of a transition code as the total number of the n wires for which T ij ∈{T 1 , . . . T f-1 } and T ij ∉{T 0 }. The transition count represents the total number of wires that are making state transitions for a given codeword. 
       Sets of Codewords 
       [0041]    Given the definition of the property TC, codewords of the transition code can be grouped into sets with similar values of TC. A transition code can contain codewords with any TC in the range 0≦TC≦n. Let: 
         [0000]    GROUP(c)←set of valid transition codewords of the transition code for which TC=c, where 2≦c≦n.
 
GROUP(c−1)←set of valid transition codewords of the transition code for which TC=c−1.
 
         [0042]    Valid values of c are restricted to ensure that the codewords of GROUP(c−1) contain at least one transition. This is necessary to allow identification of the bad wire. For completeness, the following set is defined: 
         [0000]    GROUP(TC&gt;c|TC&lt;c−1)←egress-fault identification codewords that are not members of GROUP (c) or GROUP (c−1). 
         [0043]    Next define: 
         [0000]    FAULT(c, w)←set of codewords that result from a stuck fault on a codeword from GROUP(c). 
         [0044]    The FAULT(c, w) set is constructed for each wire associated with wire index w in the range 1≦w≦n by taking each member of GROUP(c), and changing the transition function for wire associated with wire index w to T 0 , and adding the resulting codeword to FAULT(c, w) using the following rules:
       1. If the codeword is the same as the original codeword (transition function for wire associated with wire index w was already T 0 ), then do not include the resulting codeword in set FAULT(c, w).   2. If the codeword is not the same as the original codeword then add the codeword to FAULT(c, w).   3. If the codeword in step 2 contains transition functions that can be aliased by other transition functions, then add additional codewords to FAULT(c, w) for every possible permutation of a transition function being replaced by its alias function.       
 
         [0048]    The following algorithm provides a formalized description of the construction of the FAULT(c, w) sets: 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 for each wire index w do /* construct sets FAULT(c, w) */ 
               
               
                   FAULT(c, w) := { }; 
               
               
                   for each codeword ∈ GROUP(c) for which TC = c do 
               
               
                     new_codeword ← codeword modified by changing Tiw := T 0 ; 
               
               
                     if codeword ≠ new_codeword then 
               
               
                       add new_codeword to set FAULT(c, w); 
               
               
                       for each wire index v where v ≠ w do 
               
               
                         add aliases of new_codeword to set FAULT(c, w); 
               
               
                       end for; 
               
               
                     end if; 
               
               
                   end for; 
               
               
                   end for; 
               
               
                   
               
             
          
         
       
     
         [0049]    All of the codewords in FAULT(c, w) have the property that TC=c−1. The number of elements in FAULT(c, w) can be larger than the number of elements in GROUP(c) if some transition functions can alias other transition functions. 
         [0050]    The OVERLAP(c, w) set for each wire w is defined as: 
         [0000]    OVERLAP(c, w)←FAULT(c, w)∩GROUP(c−1) 
         [0051]    This set determines valid reduced-transition codewords that will be decoded at the receiver in the presence of stuck faults, and can be used to detect the fault and identify a wire index associated with the wire on which the stuck fault has occurred. 
         [0052]    The GENERATE(c) set is defined as the valid transition codewords in GROUP(c) which, when a stuck fault occurs on wire associated with wire index w, result in a codeword that is contained in one of the sets OVERLAP(c, w). This set determines the codewords that may be transmitted in the constructed test pattern. 
         [0053]    Finally, the function DATA(S) is introduced for notation purposes, and is defined as the decoded data values corresponding to codeword(s) of argument S. Likewise, the function CODE(S) is defined as the set of encoded codewords corresponding to the data value(s) of argument S. 
       Test Pattern Construction 
       [0054]    In order to construct a test pattern for the Pattern Generator, it is necessary that the definition of the transition code meet the following requirements: 
         [0000]    1. There is a value c in the range 2≦c≦n for which GROUP(c)≠{ } and GROUP(c−1)≠{ }.
 
2. For each wire associated with wire index w in the range 1≦w≦n, OVERLAP(c, w)≠{ }. (OVERLAP sets are not empty.)
 
3. For each wire index w 1  in the range 1≦w 1 ≦n, and wire index w 2  in the range 1≦w 2 ≦n, w 1 ≠w 2 : OVERLAP(c, w 1 )≠OVERLAP(c, w 2 ). (OVERLAP sets are unique.)
 
4. If the test pattern must propagate through cascaded segments of the interface, then:
 
GROUP(TC&gt;c|TC&lt;c−1)≠{ }.
 
         [0055]    Given a transition code that meets the above requirements the Pattern Generator is constructed by sending random data values∈DATA(GENERATE(c)) to generate valid transition codewords∈GENERATE(c). 
         [0056]    If there are no stuck faults on the interface, the Pattern Checker only receives valid transition codewords∈GROUP(c). If a stuck fault exists, then valid reduced-transition codewords∈OVERLAP(c, w) where w corresponds to a wire index associated with the wire with the fault are also received. Additionally, invalid codewords may be received. The Pattern Checker can therefore be constructed such that it detects data words where: 
         [0000]    rx_dataword∈DATA(OVERLAP(c, 0)∪OVERLAP(c, 1)∪ . . . ∪OVERLAP(c, n)) 
         [0057]    The Pattern Checker determines which wire contains a fault based upon which of the above codewords (or data values) are detected. This is based upon the behavior that in the presence of a single stuck fault on the wire associated with wire index w, at least some of the codewords received match elements in set OVERLAP(c, w) and will be decoded successfully. Given a test pattern that exercises all possible transitions of wire states on all wires, the Pattern Checker will eventually detect all of the valid reduced-transition codewords in set OVERLAP(c, w). While some of these codewords may also exist in other OVERLAP sets, in general at least some elements of other sets will not have been encountered by the Pattern Checker. 
         [0058]    A special case exists if the OVERLAP set for one wire is a subset of the OVERLAP set for another wire. Transition code requirements do not exclude this case. In this case, the Pattern Checker may encounter all valid reduced-transition codewords of the OVERLAP sets for both wires; indicating that the wire with the stuck fault is the wire represented by the OVERLAP set with the most elements. If the fault were on the wire corresponding to the smaller set, then some valid reduced-transition codewords in the larger set would not have been encountered. 
         [0059]    Pattern Checker implements data processing that is specified by the following algorithm: 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 /* initialize */ 
               
               
                 wire_fault := none; 
               
               
                 set_size := 0; 
               
               
                 segment := ingress; /* if data propagates through a loopback, determine 
               
               
                 segment that failed */ 
               
               
                 for each element i ∈ OVERLAP(c, w) for any w do 
               
               
                   cw_hit(w, i) := false; 
               
               
                 end for; 
               
               
                 /* run test */ 
               
               
                 for each rx_dataword received in the test pattern do 
               
               
                   codeword := CODE(rx_dataword); 
               
               
                   if codeword ∈ OVERLAP(c, w) for any w then cw_hit 
               
               
                   (w, codeword) := true; 
               
               
                   if codeword ∈ GROUP(TC &gt; c | TC &lt; c−1) then segment := egress; 
               
               
                   if codeword is an invalid codeword then ignore it; 
               
               
                 end for; 
               
               
                 /* post processing */ 
               
               
                 for each wire w do 
               
               
                   if all cw_hit(w, i) = 1 for set OVERLAP(c, w) then 
               
               
                     this_set_size := number of elements in set OVERLAP(c, w); 
               
               
                     if this_set_size &gt; set_size then 
               
               
                       wire_fault := w; /* fault is on wire w */ 
               
               
                       set_size := this_set_size; 
               
               
                     end if; 
               
               
                   end if; 
               
               
                 end for; /* stuck fault is on wire w of segment */ 
               
               
                   
               
             
          
         
       
     
         [0060]    The Pattern Checker described by the above algorithm also identifies whether the stuck fault was in an egress or an ingress segment as described in the next section. 
       Data Loopback 
       [0061]    It is desirable in the 3D chip stack configuration shown in  FIG. 2  to minimize test logic on the DRAM chip by looping test data from the egress data path onto the ingress datapath as shown in  FIG. 4 , and performing both pattern generation and pattern checking on the controller chip. The Data Loopback function in  FIG. 4  must do some minimal checking of the test pattern received from the egress interface and some minimal modification of the test pattern sent on the ingress interface; the purpose of this is to provide a means for the Pattern Checker to distinguish between faults on the egress versus ingress paths. 
         [0062]    The Data Loopback implements data processing that is specified by the following algorithm: 
         [0000]    
       
         
               
             
           
               
                   
               
             
             
               
                 /* initialize */ 
               
               
                 for each element i ∈ OVERLAP(c, w) 
               
               
                   for any w do 
               
               
                     cw_toggle(w, i) := 0; 
               
               
                   end for; 
               
               
                 /* run test */ 
               
               
                 for each rx_dataword received in test pattern do 
               
               
                   codeword := CODE(rx_dataword); 
               
               
                   if codeword ∈ OVERLAP(c, w) for any w 
               
               
                     then cw_toggle(w, i) := (cw_toggle(w, i) + 1) mod 2; 
               
               
                     if cw_toggle(w, i) ≠ 0 then 
               
               
                       /* alternate insertion of egress-fault indication codeword to 
               
               
                       indicate fault is on egress */ 
               
               
                       tx_dataword := any i ∈ DATA(GROUP 
               
               
                       (TC &gt; c | TC &lt; c−1)); 
               
               
                     else /* alternate propagation of valid reduced-transition 
               
               
                     codeword */ 
               
               
                       tx_dataword := rx_dataword; 
               
               
                     end if; 
               
               
                   else if codeword is an invalid codeword then 
               
               
                       /* suppress propagation of invalid codewords */ 
               
               
                       tx_dataword := any i ∈ DATA(GROUP(c)); 
               
               
                     else 
               
               
                       tx_dataword := rx_dataword; 
               
               
                     end if; 
               
               
                 end for; 
               
               
                   
               
             
          
         
       
     
         [0063]    As described above, the Data Loopback propagates valid transition codewords (including valid reduced-transition codewords from the OVERLAP(c, w) sets) through the loopback path. However, if codewords from the OVERLAP(c, w) sets are detected then the propagation of these codewords is alternated with the propagation of one or more egress-fault indication codewords from the GROUP(TC&gt;c|TC&lt;c−1) set. The presence or absence of codewords from GROUP(TC&gt;c|TC&lt;c−1) is used by the Pattern Checker at the controller to determine whether the stuck fault is on the controller to DRAM (egress) path or on the DRAM to controller (ingress) path. This detection is supported by the algorithm implemented by the Pattern Checker presented previously. 
         [0064]    The Data Loopback also suppresses any invalid codewords that are received from the egress path and substitutes a valid codeword on the return path. This is to avoid any unpredictable behavior. 
       Embodiment Using FTTL4 Transition Code 
       [0065]    Referring to Shokrollahi I, the FTTL4 code defines n=3 wires with s=3 states (0, 1, 2). The following transition functions are defined: 
         [0000]        T   NULL  Function: W   0   =T   NULL    T   NULL ( W   −1 )= W   −1    
         [0000]        T   INC  Function: W   0   =T   INC ( W   −1 )=( W   −1 +1)mod 3 
         [0000]        T   DEC  Function: W   0   =T   DEC ( W   −1 )=( W   −1 −1)mod 3
 
         [0000]        T   MID  Function: W   0   =T   MID ( W   −1 )=( W   −1 −1)if  W   −1 =1,2
 
         [0000]      ( W   −1 +1)if  W   −1 =0 
         [0066]    Table I is a truth table for the code: 
         [0000]    
       
         
               
             
               
               
               
             
           
               
                 TABLE I 
               
             
             
               
                   
               
               
                 truth table for FTTL4 code 
               
             
          
           
               
                   
                 Data 
                 Code 
               
               
                   
                   
               
               
                   
                 0000 
                 T NULL , T INC , T INC   
               
               
                   
                 1000 
                 T INC , T INC , T NULL   
               
               
                   
                 0001 
                 T NULL , T INC , T DEC   
               
               
                   
                 1001 
                 T INC , T DEC , T NULL   
               
               
                   
                 0010 
                 T NULL , T DEC , T INC   
               
               
                   
                 1010 
                 T DEC , T INC , T NULL   
               
               
                   
                 0011 
                 T NULL , T DEC , T DEC   
               
               
                   
                 1011 
                 T DEC , T DEC , T NULL   
               
               
                   
                 0100 
                 T INC , T NULL , T INC   
               
               
                   
                 1100 
                 T MID , T NULL , T NULL   
               
               
                   
                 0101 
                 T INC , T NULL , T DEC   
               
               
                   
                 1101 
                 T NULL , T NULL , T MID   
               
               
                   
                 0110 
                 T DEC , T NULL , T INC   
               
               
                   
                 1110 
                 T NULL , T MID , T NULL   
               
               
                   
                 0111 
                 T DEC , T NULL , T DEC   
               
               
                   
                 1111 
                 T NULL , T NULL , T NULL   
               
               
                   
                   
               
             
          
         
       
     
         [0067]    This contains the following sets of valid transition codewords for c=2: 
       GROUP(TC=2)= 
       [0000]    
       
         
           
             {(T NULL , T INC , T INC ), (T NULL , T INC , T DEC ), (T NULL , T DEC , T INC ), (T NULL , T DEC , T DEC ), (T INC , T NULL , T INC ), (T INC , T NULL , T DEC ), (T DEC , T NULL , T INC ), (T DEC , T NULL , T DEC ), (T INC , T INC , T NULL ), (T INC , T DEC , T NULL ), (T DEC , T INC , T NULL ), (T DEC , T DEC , T NULL )} 
           
         
       
     
       GROUP(TC=1)= 
       [0000]    
       
         
           
             {(T MID , T NULL , T NULL ), (T NULL , T NULL , T MID ), (T NULL , T MID , T NULL )} 
           
         
       
     
       GROUP(TC&gt;2|TC&lt;1)={(T NULL , T NULL , T NULL )} 
       [0070]    The T INC  and T DEC  can alias as T MID  at the receiver. The fault sets including aliasing, assuming c=2 are: 
         [0000]    FAULT(c=2, w=1)=
       {(T NULL , T NULL , T INC ), (T NULL , T NULL , T DEC ), (T NULL , T NULL , T MID ), (T NULL , T INC , T NULL ), (T NULL , T DEC , T NULL ), (T NULL , T MID , T NULL )}
 
FAULT(c=2, w=2)=
   {(T NULL , T NULL , T INC ), (T NULL , T NULL , T DEC ), (T NULL , T NULL , T MID ), (T INC , T NULL , T NULL ), (T DEC , T NULL , T NULL ), (T MID , T NULL , T NULL )}
 
FAULT(c=2, w=3)=
   {(T NULL , T INC , T NULL ), (T NULL , T DEC , T NULL ), (T NULL , T MID , T NULL ), (T INC , T NULL , T NULL ), (T DEC , T NULL , T NULL ), (T MID , T NULL , T NULL )}
 
and the intersection of the FAULT sets and SET(TC=1) are:
 
OVERLAP(c=2, w=1)={(T NULL , T NULL , T MID ), (T NULL , T MID , T NULL )}
 
OVERLAP(c=2, w=2)={(T NULL , T NULL , T MID ), (T MID , T NULL , T NULL )}
 
OVERLAP(c=2, w=3)={(T NULL , T MID , T NULL ), (T MID , T NULL , T NULL )}
       
 
         [0074]    The Data Loopback circuit on the DRAM will alternate the insertion of the codeword: GROUP(TC&gt;2|TC&lt;1)={(T NULL , T NULL , T NULL )} 
         [0075]    This set corresponds to the set of data words: 
         [0000]    DATA(GROUP(TC&gt;2|TC&lt;1))={b1111} 
         [0076]    The Pattern Checker on the controller may interpret the codewords received for data values as wire faults as shown in Table II. 
         [0000]    
       
         
               
             
               
               
             
           
               
                 TABLE II 
               
             
             
               
                   
               
               
                 Error condition decode to wire faults 
               
             
          
           
               
                 Wire with fault 
                 Codewords received for data values 
               
               
                   
               
               
                 Egress wire #1 
                 b1101, b1110, b1111 all occur 
               
               
                 Egress wire #2 
                 b1100, b1101, b1111 all occur 
               
               
                 Egress wire #3 
                 b1100, b1110, b1111 all occur 
               
               
                 Ingress wire #1 
                 b1101 and b1110 both occur, b1111 does not occur 
               
               
                 Ingress wire #2 
                 b1100 and b1101 both occur, b1111 does not occur 
               
               
                 Ingress wire #3 
                 b1100 and b1110 both occur, b1111 does not occur 
               
               
                 No faults 
                 Never occur: b1100, b1101, b1110, b1111 
               
               
                 Multiple Faults 
                 b1100, b1101, b1110 all occur 
               
               
                   
               
             
          
         
       
     
         [0077]    The FAULT sets correspond to the following GENERATE set, which is equivalent to SET(TC=2) for this code: 
       GENERATE(2)= 
       [0000]    
       
         
           
             {(T NULL , T INC , T INC ), (T NULL , T INC , T DEC ), (T NULL , T DEC , T INC ), (T NULL , T DEC , T DEC ), (T INC , T NULL , T INC ), (T INC , T NULL , T DEC ), (T DEC , T NULL , T INC ), (T DEC , T NULL , T DEC ), (T INC , T INC , T NULL ), (T INC , T DEC , T NULL ), (T DEC , T INC , T NULL ), (T DEC , T DEC , T NULL )} 
           
         
       
     
         [0079]    The corresponding set of data values for the Pattern Generator are: 
       DATA(GENERATE(2))= 
       [0000]    
       
         
           
             {b0000, b0001, b0010, b0011, b0100, b0101, b0110, b0111, b1000, b1001, b1010, b1011} 
           
         
       
     
         [0081]    The Pattern Generator randomly generates data words from this set. The Data Loopback can substitute any of these data words on the ingress interface when an invalid codeword is detected on the egress interface. 
         [0082]    The preferred embodiments of the Pattern Generator  410 , Data Loopback  420 , and Pattern Checker  430  in  FIG. 4  for an FTTL4 transition code are shown in  FIGS. 5 ,  6 , and  7  respectively. Those skilled in the art will understand that other logic representations and implementation variations are possible to implement the specified behavior described for the disclosed systems and methods. 
         [0083]    An embodiment of the Pattern Generator  410  in  FIG. 4  for an FTTL4 transition code is shown in  FIG. 5 . The circuit shown includes a Pseudo-Random Bit Sequence (PRBS) Generator  510  with a four bit output, and combinatorial encoder logic  520 . The PRBS Generator produces pseudo-random data in the range {b0000 . . . b1111}. The encoder logic detects codes in the range {b1100 . . . b1111} which are not members of the DATA(GENERATE(2)) set, and substitutes a member of this set by forcing either bit  3  or bit  2  to “0”. The bit to be forced is randomly determined by another bit of the PRBS generator output. Implementations are also possible using fewer logic gates, which remove the randomization and always force either bit  3  or bit  2 . 
         [0084]    An embodiment of the Data Loopback  420  in  FIG. 4  for an FTTL4 transition code is shown in  FIG. 6 . The decoded data from the decoder on the egress path of  FIG. 4  is presumed to have a 4-bit data output and an “Invalid decode” signal, which indicates the codeword received was not valid. The Data Loopback detects valid reduced-transition codewords that are members of the OVERLAP sets using AND gates  610 . When one of these gates detects a valid reduced-transition codeword in an OVERLAP set, it asserts the T input of toggle flip-flops  620  such that the flip-flop inverts its state value on the next clock edge. If the current state of the flip-flop is “0”, then the Data Loopback does not alter the data in the loopback path. If the current state of the flip-flop is “1”, then AND gates  630 , OR gate  640 , and OR gates  650  force bits 1:0 to “11” such that the data on the loopback path is b1111. (Bits 3:2 must already be “11” for the data to be part of an OVERLAP set.) The insertion of b1111 (an egress-fault indication codeword of the DATA(GROUP(TC&gt;2|TC&lt;1)) set) indicates that the fault exists before the Data Loopback circuit. 
         [0085]      FIG. 6  also illustrates using the “Invalid decode” condition to force the loopback data to be a valid codeword. This is done by forcing bit  3  to “0” such that the resulting data must be in the range {b0000 . . . b0111}, all values of which are members of the DATA(GENERATE(2)) set. 
         [0086]    An embodiment of the Pattern Checker  430  in  FIG. 4  for an FTTL4 transition code is shown in  FIG. 7 . The decoded data is applied to the inputs of AND gates  710  which detect valid reduced-transition codewords that are members of the OVERLAP sets and egress-fault indication codewords that are part of the DATA(GROUP(TC&gt;2|TC&lt;1)) set. When a codeword is detected, the AND gate output is applied to the corresponding Set input of flip-flops  720 . These flip-flops are reset before the start of the test sequence; when Set is asserted they transition to a set state and hold this state for the remainder of the test. The output of flip-flops  720  is decoded by gates  730  to determine the wire index associated with the location of the fault according to the truth table presented earlier in this section. The condition where multiple faults exist is decoded by gate  740 . 
         [0087]    It should be noted that certain embodiments may not be configured to detect the location of the fault in only the pattern checker. In some embodiments, pattern checking could occur on both the transmit side and receive side, in which case an egress-fault indication codeword is not necessary. A more general case of identifying the location of the fault is given in  FIG. 8 . Similarly to  FIG. 7 , decoded data is applied to AND gates  810 , which detect codewords that are members of the OVERLAP sets. When a codeword is detected, the AND gate output is applied to the corresponding Set input of flip-flops  820 . These flip-flops are reset before the start of the test sequence; when Set is asserted they transition to a set state and hold this state for the remainder of the test. The output of flip-flops  820  is decoded by gates  830  to determine the wire index of the wire fault. The condition where multiple faults exist is decoded by gate  840 . Note that the example circuit given in  FIG. 8  differs in that it is determining the wire index only, rather than determining an egress or ingress path associated with the fault. This simplified circuit allows embodiments to check faults on the egress and ingress paths independently, allowing detection of more potential wire faults. 
       Data Steering Circuit 
       [0088]    In at least one embodiment, outputs of AND gates  730  or AND gates  830  are input into a System Management Interface  910 , as shown in  FIG. 9 .  FIG. 9  shows the inputs  905  representing signals corresponding to wire faults identified on wires  1 ,  2 , or  3 . It should be known that any subset of inputs comprising outputs of AND gates  730  or AND gates  830  can be used. System Management Interface  910  is configured to generate control signals  915  A, B, C, D, and E based on inputs  905 . In at least one embodiment, a data steering circuit configured to bypass a wire affected by a fault uses these control signals. 
         [0089]    An example embodiment of a data steering circuit is shown in  FIG. 10 . Encoder  1010  receives Transmit Data  1005 , and encodes the data into information to be sent on wires w1, w2, and w3. In at least one embodiment, a data steering circuit comprises transmit multiplexers  1015  and receive multiplexers  1040 , each multiplexer accepting a control signal  915  from the System Management Interface  910 . The multiplexers  1015  are configured to bypass an affected wire based on control signals A and B. A portion of Drivers  1020  and receivers  1025  are activated based on control signals  915  to transmit data on the selected wires. Decoder  1030  receives outputs of multiplexers  1040 , based on control signals C, D, and E. Table III below shows an example of possible control signals  915  generated according to inputs  905 , and which wires are utilized in each case: 
         [0000]    
       
         
               
               
               
               
               
               
               
               
               
             
           
               
                 TABLE III 
               
               
                   
               
               
                 Fault on 
                 Fault on 
                 Fault on 
                   
                   
                   
                   
                   
                   
               
               
                 Wire 1 
                 Wire 2 
                 Wire 3 
                 A 
                 B 
                 C 
                 D 
                 E 
                 Wire being used: 
               
               
                   
               
             
             
               
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 0 
                 {w1, w2, w3} 
               
               
                 1 
                 0 
                 0 
                 0 
                 0 
                 1 
                 0 
                 0 
                 {w_spare, w2, w3} 
               
               
                 0 
                 1 
                 0 
                 1 
                 0 
                 1 
                 1 
                 0 
                 {w_spare, w1, w3} 
               
               
                 0 
                 0 
                 1 
                 1 
                 1 
                 1 
                 1 
                 1 
                 {w_spare, w1, w2} 
               
               
                   
               
             
          
         
       
     
         [0090]    The examples illustrate the use of transitions codes in the fault detection of integrated circuit interconnections. At least one embodiment uses the FTTL4 transition code described in Shokrollahi I. At least one embodiment addresses Through-Silicon-Via interconnection faults between stacked integrated circuit devices. No limitation is implied, however, as other embodiments may in general use any transition code and/or interconnection means satisfying the basic requirements described herein. The methods disclosed in this application may be equally applicable to other encoding methods, and to communication media including optical and wireless communications. Thus, descriptive terms such as “voltage” or “signal level” should be considered to include both electrical equivalents such as “current”, and also equivalents in other measurement systems, such as “optical intensity”, “RF modulation”, etc. Specific examples provided herein are for purposes of description, and do not imply a limitation. 
         [0091]    As used herein, “physical signal” includes any suitable behavior and/or attribute of a physical phenomenon capable of conveying information. In accordance with at least one embodiment, physical signals may be tangible and non-transitory. 
       Embodiments 
       [0092]    In at least one embodiment, a system comprises: a decoder configured to decode a sequence of received transition codewords of a transition code into a plurality of sets of m data bits, each codeword corresponding to one set of m data bits, the received transition codewords corresponding to test codewords having been transmitted via an egress path, each test codeword comprising n elements and having c transitions, and wherein any set of c−1 transitions of the c transitions corresponds to a valid reduced-transition codeword, wherein n and c, and m are an integers greater than or equal to 2; a data loopback circuit configured to receive the plurality of sets of m data bits and to determine, for each set, if the m data bits correspond to a reduced-transition codeword, and responsively generate a plurality of sets of m response bits based on the determinations. In at least one embodiment, the data loopback circuit generates at least one set of m response bits corresponding to an egress-fault indication codeword in response to receiving data bits corresponding to a reduced-transition codeword. In at least one embodiment, the egress-fault indication codeword is an error-signaling transition codeword having TC number of transitions, wherein TC is an integer according to: c&lt;TC or TC&lt;c−1. In at least one embodiment, the data loopback circuit generates a subset of the plurality of sets of m response bits by retransmitting a subset of the received plurality of sets of m data bits. In at least one embodiment, the data loopback circuit is configured to generate a listing of received reduced-transition codewords, and to responsively determine a wire index of a wire fault. 
         [0093]    In at least one embodiment, a system comprises: a pattern generator configured to generate a bit pattern comprising a plurality of sets of m data bits representing a sequence of valid transition codewords of a transition code, each valid transition codeword comprising n elements and having c transitions, wherein any set of c−1 transitions of the c transitions corresponds to a valid reduced-transition codeword, and wherein m, n, and c, are integers greater than or equal to 2; an encoder configured to generate the sequence of valid transition codewords based on the bit pattern and transmit the sequence on an egress path; a decoder configured to receive a sequence of response codewords on an ingress path and decode them into a plurality of sets of m bits; and, a pattern checker configured to receive the m bits and generate a listing of received reduced-transition codewords, and to responsively determine (i) a wire index of a wire fault and (ii) a path associated with the wire fault based on the listing. In at least one embodiment, the listing corresponds to a combination of states of state elements. In at least one embodiment, the state elements are flip-flops. In at least one embodiment, the pattern checker comprises a logic circuit configured receive the combination of states and responsively generate signals identifying the wire index and path associated with the wire fault. In at least one embodiment, the system further comprises a data steering circuit configured to receive the signals representing the wire index and path identified by the wire fault and responsively bypass a communication wire identified by the wire index on the path. 
         [0094]    In at least one embodiment, a method  1100  as shown in  FIG. 11  comprises generating, at block  1102 , a plurality of sets of m data bits, each set of m data bits corresponding to a valid transition codeword of a transition code, each valid transition codeword comprising n elements and c transitions, wherein any set of c−1 transitions of the c transitions corresponds to a valid reduced-transition codeword, and wherein m, n, and c are integers greater than or equal to 2, encoding, at block  1104  the plurality of sets of m data bits into a sequence of valid transition codewords, transmitting, at block  1106 , the sequence of valid transition codewords on a transmission path, decoding, at block  1108  the sequence of valid transition codewords into sets of m received bits, and, determining, at block  1110 , a wire fault is present on the transmission path by determining, for each set of m received bits, if the set of m received bits corresponds to a valid reduced-transition codeword. In at least one embodiment, the method further comprises generating a plurality of sets of m response bits based on the determinations. In at least one embodiment, at least one of the sets m response bits represents a path-fault indication codeword. In at least one embodiment, the path-fault indication codeword represents a valid transition codeword having TC number of transitions, wherein TC is an integer according to: c&lt;TC or TC&lt;c−1. In at least one embodiment, the method further comprises identifying a set of m data bits representing a path-fault indication codeword. In at least one embodiment, the method further comprises generating a listing of valid reduced-transition codewords. In at least one embodiment, the method further comprises identifying a wire index of a wire fault based on the listing. In at least one embodiment, the listing is represented by a combination of states. In at least one embodiment, the transition code is an FTTL4 code. In at least one embodiment, the method further comprises identifying a set of m data bits representing an invalid codeword, and suppressing the invalid codeword by substituting a set of m response bits representing a valid transition codeword having c transitions.