# Patent

## Title
Reduced parallel and pipelined high-order MIMO LMMSE receiver architecture

## Abstract

Disclosed is a LMMSE receiver that restores orthogonality of spreading codes in the downlink channel for a spread spectrum signal received over N receive antennas. The FFT-based chip equalizer tap solver reduces the direct matrix inverse of the prior art to the inverse of some submatrices of size N×N with the dimension of the receive antennas, and most efficiently reduces matrix inverses to no larger than 2×2. Complexity is further reduced over a conventional Fast Fourier Transform approach by Hermitian optimization to the inverse of submatrices and tree pruning. For a receiver with N=4 or N=2 with double oversampling, the resulting 4×4 matrices are partitioned into 2×2 block sub-matrices, inverted, and rebuilt into a 4×4 matrix. Common computations are found and repeated computations are eliminated to improve efficiency. Generic design architecture is derived from the special design blocks to eliminate redundancies in complex operations. Optimally, the architecture is parallel and pipelined.

## Background
FIELD OF THE INVENTION
The present invention relates generally to receivers and related methods for a spread spectrum communication system using multiple transmit and/or multiple receive antennas, and is particularly directed to a receiver using an equalizer, such as a linear minimum mean square error (LMMSE) based equalizer.
BACKGROUND
MIMO (Multiple Input Multiple Output) technology using multiple antennas at both the transmitter and receiver sides has recently emerged as one of the most significant technical breakthroughs in modern communications. The original MIMO is known as D-BLAST (see G. J. Foschini, “Layered space-time architecture for wireless communication in a fading environment when using multielement antennas”, Bell Labs Tech. J., pp. 41-59, 1996.) and a more realistic strategy as V-BLAST (see G. D. Golden, J. G. Foschini, R. A. Valenzuela, and P. W. Wolniansky, “DETECTION ALGORITHM AND INITIAL LABORATORY RESULTS USING V-BLAST SPACE-TIME COMMUNICATION ARCHITECTURE,” Electron. Lett., vol. 35, pp. 14-15, January 1999) by nulling and canceling with reasonable tradeoff between complexity and performance.
The original MIMO spatial multiplexing was proposed for narrow band and flat-fading channels. In a multipath-fading channel, the orthogonality of the spreading codes is destroyed and the Multiple-Access-Interference (MAI) along with the Inter-Symbol-Interference (ISI) is introduced. With a very short spreading gain, the conventional Rake receiver could not provide acceptable performance. The LMMSE (Linear-Minimum-Mean-Square-Error)-based chip equalizer is promising to restore the orthogonality of the spreading code, so as to suppress both the ISI and MAI. However, the LMMSE equalizers involve the inverse of a large correlation matrix with the general complexity of O((NF)3), where N is the number of Rx antenna and F is the channel length. This is very expensive for hardware implementation.
Earlier, the chip equalizer problem was solved in either of the following frameworks:

    
    
        (i) adaptive stochastic gradient algorithms such as LMS;
        (ii) Conjugate Gradient algorithm; and
        (iii) The FFT-based MIMO chip equalizer.

The algorithms of option (i) suffer from stability problems because the convergence depends on the choice of good step size (see M. J. Heikkila, K. Ruotsalainen and J. Lilleberg, “SPACE-TIME EQUALIZATION USING CONJUGATE-GRADIENT ALGORITHM IN WCDMA DOWNLINK”, IEEE Proceeding in PIMRC, pp. 673-677, 2002). The algorithms of option (ii) exhibit complexity at the order of O((NF)2), according to Levinson and Shur. For option (iii), the FFT-based equalizer reduces the (NF×NF) matrix inverse to LF submatrices inverse of size (NXN) (see J. Zhang, T. Bhatt, G. Mandyam, “EFFICIENT LINEAR EQUALIZATION FOR HIGH DATA RATE DOWNLINK CDMA SIGNALING”, Proceeding of IEEE Asilomar Conference on Signals, Systems and Computers, 2003).

    
    


The FFT-based fast algorithm noted above by Zhang, Bhatt and Mandyam uses a banded-Toeplitz structure of the correlation matrix. Although this FFT-based algorithm avoids the inverse of the original correlation matrix with the dimension of NF×NF, the inventors believe that some matrix inverse is inevitable for the MIMO receiver. For a MIMO receiver with high dimension, the complexity of a MIMO receiver increases dramatically with the number of antennas. The principle operation of interest is the architecture of many 4×4 matrix inverses in the frequency domain for the 1×4, 2×4 and 4×4 MIMO configurations or 1×2, 2×2 receivers with over sampling factor of 2. This is because these are seen to be the most likely deployed in the near future. The fact that the receiver must be embedded into a portable device makes the design of low complexity mobile receivers very critical for widespread commercial deployment of low cost products. For practical considerations, it is necessary to determine which range of possible matrix inverse architectures is most suitable for VLSI implementation.
What is needed in the art is a receiver architecture and corresponding method for reducing receiver complexity in a MIMO system while remaining within constraints imposed by portable wireless devices, mobile stations such as mobile telephones, PDAs with two-way communications, personal internet-access devices, and other such appliances.
SUMMARY OF THE INVENTION
This invention is a method and LMMSE receiver for restoring spreading code orthogonality in a multipath channel signal. An inverse of an overall NF×NF matrix of the prior art is avoided by inverting several sub-matrices of size N×N, where N is the number of receive antennas and F is the channel length parameter. The number and complexity of conventional FFTs design modules is reduced with Hermitian optimization and tree pruning, and the inverse of the sub-matrices are further simplified.
The present invention is in one aspect an equalizer that includes apparatus that generates a set of filter coefficients w from inverting a series of sub-matrices F. Each of the sub-matrices are of size no greater than 2×2, and each represents an element of an approximated correlation matrix Crr for a spread spectrum signal received over a multipath channel.
In another aspect, the present invention is a spread spectrum receiver having a Linear-Minimum-Mean-Square-Error LMMSE-based chip-level equalizer. The equalizer includes a Finite Impulse Response FIR filter coupled to an output of a correlation estimator and tap solver operable to combine Fourier transformed and inverted sub-matrix elements of a block circulant matrix Crr with a Fourier transformed channel matrix H. The block circulant matrix Crr is an approximation of a correlation matrix Rrr.
In another aspect, the invention is an equalizer that has a correlation estimator and tap solver means. These means have an output coupled to a Finite Impulse Response filter means, and are for executing a Fast Fourier Transform FFT and an inversion on sub-matrix elements of a block circulant matrix Crr and a Fourier transform on a channel matrix H,. As above, the block circulant matrix Crr is an approximation of a correlation matrix Rrr. The correlation estimator and tap solver means are further for combining the Fourier transformed and inverted sub-matrices and the Fourier transformed channel matrix. These correlation estimator and tap solver means invert matrices no greater than 2×2.
In another aspect, the invention is a method to receive a signal from a multipath channel. The method includes receiving the signal with at least two receive antennas, and equalizing the received signal by combining a Fourier transformed channel matrix with a Fourier transformed and inverted sub-matrix elements of a block circulant matrix Crr that is an approximation of a correlation matrix Rrr.
Other aspects of the invention include streamlining the calculation processing, parallelizing the calculations for the various filter coefficients, and pipelining the various parameters in time to reduce data path lengths and eliminate repeat calculations.
These and other features, aspects, and advantages of embodiments of the present invention will become apparent with reference to the following description in conjunction with the accompanying drawings. It is to be understood, however, that the drawings are designed solely for the purposes of illustration and not as a definition of the limits of the invention.



BRIEF DESCRIPTION OF THE DRAWINGS
The present invention is described below more particularly with reference to the following drawing figures, which are not to scale except where stipulated.
FIG. 1 is a system model of a MIMO Multi-code CDMA downlink.
FIG. 2 is a block diagram of LMMSE chip equalizer.
FIG. 3 is a block diagram of the VLSI architecture of the FFT-based MIMO equalizer tap solver.
FIG. 4 is a Hermitian optimized data path of merged 2×2 matrix inverse and channel multiplication.
FIG. 5(a) is a data dependency path of the partitioned 4×4 matrix inverse.
FIG. 5(b) is a data dependency of the Hermitian optimized 4×4 matrix inverse.
FIG. 6 is a VLSI design architecture using generic design modules T, M and HINV.
FIG. 7 is a parallel VLSI RTL architecture layout of the M(A,B) processing unit.
FIG. 8 is a RTL architecture layout of the T(A11, A21, A22) design block.



DETAILED DESCRIPTION
The following acronyms are used herein:

    
    
        LMMSE: Linear Minimum Mean Squared Error;
        CDMA: Code-Division Multiple Access;
        SIMO: Single Input Multiple Output;
        MIMO: Multiple Input Multiple Output;
        FPGA: Field Programmable Gate Array;
        VLSI: Very Large Scale Integrated circuit;
        ASIC: Application Specific Integrated Circuit;
        RTL: Register Transfer Layer;
        DSP: Digital Signal Processing;
        FFT: Fast Fourier Transform
    
    


As used herein, the term CDMA refers generically to a spread spectrum communication system unless specifically stated otherwise (e.g., CDMA2000). The operators [ ]T and [ ]* indicate transpose, and the operator [ ]H indicates a Hermitian operation as known in the art. As an overview, the present invention is a reduced complexity FFT-based linear equalizer and further includes a complete parallel VLSI architecture for a proposed MIMO receiver. To further reduce the complexity, Hermitian optimization is disclosed that utilizes the structures of the correlation coefficients and the FFT algorithm. The Hermitian feature is then applied in the inverse of submatrices. A reduced-state FFT module avoids duplicate computation of the symmetric coefficients and the zero coefficients, thereby reducing the number and complexity of conventional FFT design modules.
Of special interest is the partitioned 4×4 sub-matrices in the FFT-based chip equalizer tap solver and the generic RTL schematic. The 4×4 submatrices are partitioned into four mutually exclusive 2×2 submatrices for better adaptation to mobile devices. The 4×4 matrix inverse is then dramatically simplified by exploring the commonality in the partitioned 4×4 inverse. Generic architecture is derived from the special design blocks to eliminate the redundancies in the complex operations. The regulated model facilitates the design of efficient parallel VLSI modules such as “Complex-Hermitian-Multiplication”, “Hermitian Inverse” and “Diagonal Transform”. This leads to efficient architectures with 3× saving in complexity and more parallel and pipelined RTL schematic, which is verified in FPGA prototyping platform. Possible applications of this method include the downlink CDMA mobile devices that comply with either 1X EV-DV or MIMO-HSDPA standard.
The MIMO Multi-Code CDMA downlink system 10 using spatial multiplexing is described in FIG. 1. A number M of transmit (Tx) antennas 12 and N receive (Rx) antennas 14 are applied in the system 10, where usually M≦N. In a Multi-Code CDMA system, multiple spreading codes are assigned to a single user to achieve high data rate. First, the high data rate symbols are demultiplexed in a demultiplexor block 16 into K*M lower rate substreams, where K is the number of spreading codes used in the system for data transmission. The substreams are broken into M groups, where each substream in the group is spread in an associated spreader 18 with a spreading code of spreading gain G. The groups of substreams are then combined at summing nodes 20 and scrambled at scramblers 22 with long scrambling codes and transmitted through the mth Tx antenna 12 to the receiver 24 via the channel 26. The chip level signal at the mth transmit antenna is given by,




  
    
      
        
          
            
              d
              m
            
            ⁡
            
              (
              i
              )
            
          
          =
          
            
              
                ∑
                
                  k
                  =
                  1
                
                K
              
              ⁢
              
                
              
              ⁢
              
                
                  
                    s
                    m
                    k
                  
                  ⁡
                  
                    (
                    j
                    )
                  
                
                ·
                
                  
                    c
                    m
                    k
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
              
            
            +
            
              
                
                  s
                  m
                  P
                
                ⁡
                
                  (
                  j
                  )
                
              
              ·
              
                
                  c
                  m
                  P
                
                ⁡
                
                  [
                  i
                  ]
                
              
            
          
        
        ,
      
    
    
      
        [
        1
        ]
      
    
  




where j is the symbol index, i is chip index and k is the index of the composite spreading code. smk[j] is the jth symbol of the kth code at the mth substream. In the following, we focus on the jth symbol index and omit the index for simplicity. cmk[i]=ck[i]cm(s)[i] is the composite spreading code sequence for the kth code at the mth substream where ck[i] is the user specific Hadamard spreading code and cm(s)[i] is the antenna specific scrambling long code. smP[j] denotes the pilot symbols at the mth antenna. cmP[i]=cP[i]cm(s)[i] is the composite spreading code for pilot symbols at the mth antenna. The received chip level signal at the nth Rx antenna is given by





  
    
      
        
          
            
              r
              n
            
            ⁡
            
              (
              i
              )
            
          
          =
          
            
              
                ∑
                
                  m
                  =
                  1
                
                
                  M
                  T
                
              
              ⁢
              
                
                  ∑
                  
                    l
                    =
                    0
                  
                  
                    L
                    
                      m
                      ,
                      n
                    
                  
                
                ⁢
                
                  
                    
                      h
                      
                        m
                        ,
                        n
                      
                    
                    ⁡
                    
                      (
                      l
                      )
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      d
                      m
                    
                    ⁡
                    
                      (
                      
                        i
                        -
                        
                          τ
                          1
                        
                      
                      )
                    
                  
                
              
            
            +
            
              z
              ⁡
              
                (
                i
                )
              
            
          
        
        ,
      
    
    
      
        [
        2
        ]
      
    
  




where the channel is characterized by a channel matrix with elements taken from the channel coefficients between the mth Tx antenna and the nth Rx antenna as





  
    
      
        
          
            h
            
              m
              ,
              n
            
          
          ⁡
          
            (
            t
            )
          
        
        =
        
          
            ∑
            
              l
              =
              0
            
            
              L
              
                m
                ,
                n
              
            
          
          ⁢
          
            
              
                h
                
                  m
                  ,
                  n
                
              
              ⁡
              
                (
                l
                )
              
            
            ⁢
            
              
            
            ⁢
            
              
                δ
                ⁡
                
                  (
                  
                    t
                    -
                    
                      τ
                      
                        m
                        ,
                        n
                        ,
                        l
                      
                    
                  
                  )
                
              
              .
            
          
        
      
    
    
      
        [
        3
        ]
      
    
  




The ‘chip’ level signal refers to chip samples spread by the spreading code, as opposed to symbol samples. In a spread spectrum system, the chip equalizer acts as a front end (where the samples are spread by the spreading code) to deal with multi-path channel effects. In a typical receiver, a despreader follows the chip equalizer to detect the individual symbols after despreading. By packing the received chips, from all the receive antennas in a vector (i)=[rl(i), . . . rn(i), . . . rN(i)]T and collecting the LF=2F+1 consecutive chips (typically with center at the ith chip from all the N Rx antennas), we form a signal matrix as A(i)=[(i+F)T, . . . (i)T, . . . (i−F)T]T (where the character  over the letter designator such as X is used to represent a matrix). In the vector form, the received signal can be given by,




  
    
      
        
          
            
              r
              
                ↔
                _
              
            
            A
          
          ⁡
          
            (
            i
            )
          
        
        =
        
          
            ∑
            
              m
              =
              1
            
            M
          
          ⁢
          
            
              
                H
                ↔
              
              m
            
            ⁢
            
              
                
                  d
                  ↔
                
                m
              
              ⁡
              
                (
                i
                )
              
            
          
        
      
    
    
      
        [
        4
        ]
      
    
  




where m is a block Toeplitz matrix constructed from the channel coefficients. The multiple receive antennas' channel vector is defined as (l)=[hm,l(l), . . . hm,n(l), . . . hm,N(l)]T. The transmitted chip vector for the mth transmit antenna is given by M(l)=[dm,l(i+F), . . . dm,n(i), . . . dm,N(i−F−L )]T. The usage of multiple Tx antennas increases the spectrum efficiency dramatically. The achievable data rate increases almost linearly with the number of Tx antennas. For a fully loaded system (M+K=G), the achievable bit rate is determined by the Tx antenna configuration, the modulation scheme and the chip rate. Table I gives the achievable aggregate uncoded data rate for different number of transmit antennas with a spreading factor (SF) of G=16 and chip rate of 3.84 MHz.








TABLE I







Achievable Uncoded Data Rate (Mbps)












M
K
QPSK
16 QAM
















1
15
7.2
14.4 



2
14
13.44
26.88



4
12
23.04
46.08










Chip level equalization has been one of the most promising receivers in the single-user CDMA downlink. As shown in FIG. 2, the chip level equalizer 28 in the receiver 24 operates with a tap solver 30, and outputs a chip-level equalized signal to a descrambler/despreader 32 (shown as one functional block but in practice may be broken into two or more) that in turn outputs to a deinterleaver/decoder (also shown in a non-limiting illustration as one functional block). The chip level equalizer 28 estimates the transmitted chip samples by a set of linear FIR filter coefficients as,




  
    
      
        
          
            
              d
              
                ↔
                ^
              
            
            m
          
          ⁡
          
            (
            i
            )
          
        
        =
        
          
            
              w
              
                ↔
                ^
              
            
            m
            H
          
          ⁢
          
            
              
                r
                
                  ↔
                  _
                
              
              A
            
            ⁡
            
              [
              i
              ]
            
          
        
      
    
    
      
        [
        5
        ]
      
    
  




Current research consists of two major flavors of equalization, i.e., the non-adaptive linear equalizer and adaptive linear equalizers. Non-adaptive linear equalizers usually assume stationarity of the channel 26 in an observation window and design the equalizer 28 with criteria such as LMMSE or zero forcing. It is well known that the LMMSE solution is given by:




  
    
      
        
          
            
              
                
                  
                    w
                    
                      ↔
                      ^
                    
                  
                  m
                  opt
                
                =
                
                  arg
                  ⁢
                  
                    
                  
                  ⁢
                  min
                  ⁢
                  
                    
                  
                  ⁢
                  
                    E
                    [
                    
                      
                        
                        
                          
                            
                              
                                d
                                ↔
                              
                              m
                            
                            ⁡
                            
                              (
                              i
                              )
                            
                          
                          -
                          
                            
                              
                                w
                                
                                  ↔
                                  ^
                                
                              
                              m
                              H
                            
                            ⁢
                            
                              
                            
                            ⁢
                            
                              
                                
                                  r
                                  
                                    ↔
                                    _
                                  
                                
                                A
                              
                              ⁡
                              
                                [
                                i
                                ]
                              
                            
                          
                        
                        
                      
                      2
                    
                    ]
                  
                
              
              ,
            
          
        
        
          
            
              
                
              
              ⁢
              
                =
                
                  
                    
                      σ
                      d
                      2
                    
                    ⁡
                    
                      (
                      i
                      )
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    
                      
                        
                          R
                          ↔
                        
                        rr
                      
                      ⁡
                      
                        (
                        i
                        )
                      
                    
                    
                      -
                      1
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  
                    E
                    [
                    
                      
                        
                          
                            r
                            
                              ↔
                              _
                            
                          
                          A
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        
                      
                      ⁢
                      
                        
                          
                            d
                            
                              ↔
                              _
                            
                          
                          m
                          H
                        
                        ⁡
                        
                          (
                          i
                          )
                        
                      
                    
                    ]
                  
                
              
            
          
        
      
    
    
      
        [
        6
        ]
      
    
  




where the correlation matrix is given by the time-average with ergodicity assumption as





  
    
      
        
          
            R
            ↔
          
          rr
        
        =
        
          
            E
            ⁡
            
              [
              
                
                  
                    
                      r
                      
                        ↔
                        _
                      
                    
                    A
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                ⁢
                
                  
                    
                      r
                      
                        ↔
                        _
                      
                    
                    m
                    H
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
              ]
            
          
          =
          
            
              1
              N
            
            ⁢
            
              
                ∑
                
                  i
                  =
                  0
                
                
                  N
                  -
                  1
                
              
              ⁢
              
                
                  
                    
                      r
                      
                        ↔
                        _
                      
                    
                    A
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
                ⁢
                
                  
                
                ⁢
                
                  
                    
                      r
                      
                        ↔
                        _
                      
                    
                    A
                  
                  ⁡
                  
                    (
                    i
                    )
                  
                
              
            
          
        
      
    
    
      
        [
        7
        ]
      
    
  




and the channel coefficients are estimated as m=E[A[i]mH(i)] using the pilot symbols. In the HSDPA standard, about 10% of the total transmit power is dedicated to the Common Pilot Channel (CPICH). This will provide accurate channel estimation.

Using the stationarity of the channel and the convolution property, it is easy to show that the correlation matrix is a banded block Toeplitz matrix,




  
    
      R
      ↔
    
    rr
  
  =
  
    
      
        
          
            
              E
              ↔
            
            ⁡
            
              [
              0
              ]
            
          
        
        
          ...
        
        
          
            
              
                E
                ↔
              
              H
            
            ⁡
            
              [
              L
              ]
            
          
        
        
          ...
        
        
          0
        
      
      
        
          ⋮
        
        
          ⋰
        
        
          ⋰
        
        
          ⋰
        
        
          ⋮
        
      
      
        
          
            E
            ⁡
            
              [
              L
              ]
            
          
        
        
          ⋰
        
        
          ⋰
        
        
          ⋰
        
        
          
            
              E
              H
            
            ⁡
            
              [
              L
              ]
            
          
        
      
      
        
          ⋮
        
        
          ⋰
        
        
          ⋰
        
        
          ⋰
        
        
          ⋮
        
      
      
        
          0
        
        
          ...
        
        
          
            E
            ⁡
            
              [
              L
              ]
            
          
        
        
          ⋯
        
        
          
            E
            ⁡
            
              [
              0
              ]
            
          
        
      
    
    .
  




where [l]E[l] is a N×N block matrix with the correlation coefficients. It is shown that the correlation matrix rr can be approximated by a block-circulant matrix after we add two corner matrices as





  
    
      
        C
        ↔
      
      rr
    
    =
    
      
        
          R
          ↔
        
        rr
      
      +
      
        [
        
          
            
              0
            
            
              0
            
            
              
                
                  C
                  ↔
                
                L
                H
              
            
          
          
            
              0
            
            
              ⋰
            
            
              0
            
          
          
            
              
                
                  C
                  ↔
                
                L
              
            
            
              0
            
            
              0
            
          
        
        ]
      
    
  
  ,
  
    
      where
      ⁢
      
        
      
      ⁢
      
        
          C
          ↔
        
        L
      
    
    =
    
      
        [
        
          
            
              
                
                  
                    E
                    ↔
                  
                  H
                
                ⁡
                
                  [
                  L
                  ]
                
              
            
            
              0
            
            
              
                
              
            
          
          
            
              ⋮
            
            
              ⋰
            
            
              
                
              
            
          
          
            
              
                
                  
                    E
                    ↔
                  
                  H
                
                ⁡
                
                  [
                  L
                  ]
                
              
            
            
              
                
              
            
            
              
                
                  
                    E
                    ↔
                  
                  H
                
                ⁡
                
                  [
                  L
                  ]
                
              
            
          
        
        ]
      
      .
    
  




Using the extension of the diagonalization theorem, the block-circulant matrix can be decomposed as,




  
    
      
        
          
            
              C
              ↔
            
            rr
          
          =
          
            
              (
              
                
                  
                    D
                    ↔
                  
                  H
                
                ⊗
                
                  I
                  ↔
                
              
              )
            
            ⁢
            
              (
              
                
                  ∑
                  
                    i
                    =
                    0
                  
                  
                    
                      L
                      F
                    
                    -
                    1
                  
                
                ⁢
                
                  
                    
                      W
                      ↔
                    
                    i
                  
                  ⊗
                  
                    
                      E
                      ↔
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
              )
            
            ⁢
            
              (
              
                
                  
                    D
                    ↔
                  
                  H
                
                ⊗
                
                  I
                  ↔
                
              
              )
            
          
        
        ,
      
    
    
      
        [
        8
        ]
      
    
  




where =diag(1,WLF−1, . . . , WLF−(LF−1)), and WLF=ej(2π/LF) is the phase factor coefficient for the DFT computation. The operator {circle around (×)} denotes the Kronecker product and  is the DFT matrix. For an MIMO system, it can be shown that the MIMO equalizer taps are computed as the following equation,





  
    
      
        
          
            w
            
              ↔
              ^
            
          
          m
          opt
        
        ≈
        
          
            (
            
              
                
                  D
                  ↔
                
                H
              
              ⊗
              
                I
                ↔
              
            
            )
          
          ·
          
            
              F
              ↔
            
            
              -
              1
            
          
          ·
          
            
              (
              
                
                  D
                  ↔
                
                ⊗
                
                  I
                  ↔
                
              
              )
            
            .
          
        
      
    
    
      
        [
        9
        ]
      
    
  




=diag(0, 1, . . . , LF) is a block-diagonal matrix with elements taken from the element-wise FFT of the first column of a circular matrix. For a M×N MIMO system, this reduces the inverse of a (NLF×NLF) matrix to the inverse of sub-block matrices with size N×N.

SYSTEM LEVEL PIPELINING: To achieve real-time implementation, either DSP processors or VLSI architectures could be applied. The limited hardware resource and power supply of mobile device in general makes the hardware design more challenging, especially for the MIMO system. However, the straightforward implementation has many redundancies in computation. Many optimizations are needed to make it suitable for real-time implementation. The interaction between architecture, system partitioning and pipelining are emphasized with the following objectives: 1). Reduced computation complexity; 2). Minimum hardware resource; 3) Parallel and pipelined architecture for the critical computation parts.
To explore the efficient architecture, the tasks are elaborated as follows:

    
    
        Compute the independent correlation elements [[0], . . . , [L]], and form the first block column of circulant rr by adding the corner elements as rr(l)=[[0], . . . , [L], 0, . . . , 0, H[L], . . . , H[1]]T. Each element is an N×N sub block matrix.
        Take the element-wise FFT of rr(l) element vectors
    
    






  
    
      
        F
        ↔
      
      
        n1
        ,
        n2
      
    
    =
    
      FFT
      ⁢
      
        {
        
          
            E
            ↔
          
          
            n1
            ,
            n2
          
          
            (
            c
            )
          
        
        }
      
    
  
  ,




where

n1,n2(c)[i]=rr(l)[(n1−i−1)*N+n2−1], i=[0,LF], n1,n2ε[1,N]. 

    
    
        For m=[1, M], compute the dimension-wise FFT of the channel estimation as,

m=({circle around (×)})mFFT([0, . . . , 0, hm,n(L), . . . , hm,n(0), 0, . . . , 0).

nε[1,N]

        Compute the inverse of the N×N sub matrix [i], where

[i]−1=diag([0]−1, . . . , [LF−1]−1).

        Compute the matrix multiplication of the sub-matrices inverse with the FFT output of channel estimation coefficients m=−1m.
        Compute the dimension-wise IFFT of the matrix multiplication results mopt≈(H{circle around (×)})m.
    
    


With a timing and data dependency analysis, the top level design blocks for the MIMO equalizer 28 of the receiver 24 is shown in the block diagram of FIG. 3, which further shows the tap solver 30 within the dashed line block. The system-level pipeline is designed for better modularity. A correlation estimation block 36 takes, on one data path 40a, the multiple input samples from the receive antennas 14 for each chip to compute the correlation coefficients of the first column of rr. It is made circulant by adding corner to form the matrix [[0], [1], . . . , [L], 0, . . . , 0, [L]H, . . . , [1]H] at a rr matrix estimation block 38. The complete coefficients are written to DPRAMs 42 (storage media) and the N×N element-wise FFT module 44 computes [[0], . . . , [LF]]=FFT{[[0], . . . , [L], o, . . . o, [L]H, . . . , [1]H]}.
Another parallel data path 40b is for the channel estimation and the M×N dimension-wise FFTs on the channel coefficient vectors as in ({circle around (×)}){circumflex over ()}m. The pilot symbols from the parallel data path 40b are used to estimate the channel at a channel estimation block 45. These are assembled in a channel matrix block 46 into a matrix that estimates the full channel, of which a FFT is taken at another FFT module 48. A sub-matrix inverse and multiplication block 52 takes the FFT coefficients of both channels and correlations from DPRAMs 42 and carries out the computation as in −1({circle around (×)})m.
Finally, a M×N dimension-wise IFFT module 54 generates the results for the equalizer taps  and sends them to the M×N MIMO FIR block 56 for filtering. To reflect the correct timing, the correlation 36 and channel estimation 45 modules at the front-end will work in a throughput mode on the streaming input samples. The FFT/IFFT modules (44, 48, 54) in the dotted line block construct the post-processing of the tap solver 30. They are suitable to work in a block mode using dual-point RAM blocks to communicate the data. The MIMO FIR filtering 56 will also work in throughput mode on the buffered streaming input data.
HERMITIAN OPTIMIZATION & REDUCED-STATE FFT: From the circulant feature of the correlation matrix, the complexity of the FFT computation can be reduced with the following Lemma. Define the element-wise FFT of the correlation matrix as




  {
  
    
      
        E
        ↔
      
      ⁡
      
        [
        1
        ]
      
    
    ⁢
    
      ⇒
      FFT
    
    ⁢
    
      
        
          [
          
            
              
                F
                ↔
              
              
                i
                ,
                j
              
            
            ⁡
            
              [
              
                1
                :
                
                  L
                  F
                
              
              ]
            
          
          ]
        
        
          N
          ×
          N
        
      
      .
    
  




For both the SIMO and MIMO cases, the element-wise FFT result of the circulant correlation coefficients vectors admit Hermitian structure by using the features of FFT computation. The Hermitian feature is given by the following Lemma.

Lemma 1: i,j=conj(i,j). Thus the computation of j,i is redundant for j<i.
Lemma 2: Because the imaginary part of i,i equals to 0, the computation of i,i can be reduced to only L/LF of the full DFT. The computations related to i,i also reduce to real computation, saving 50% of complexity. Because the FFT algorithm applies the features of the rotation coefficients, the application of the Hermitian feature in Lemma 2 is not straightforward. Hardware-oriented optimization for the Reduced-State FFT (RS-FFT) can be derived with pruning operations bases on the standard Decimation-In-Time (DIT) FFT algorithm. The different type of butterfly units are differentiated based on the features of the output coefficients, and unnecessary computation branches are pruned in the butterfly tree. Notice that in the standard butterfly unit, each operation involves a full complex multiplication, which has four real multiplications and two real additions. Pruning increases efficiency in the reduced-state FFT architectures. Although the saving diminishes when the number of FFTs increases to a very large number, for the equalizer application, the length of FFT remains in the range of 64-point FFT. The RS-FFT saves roughly 50% of the real multiplication. Certain aspects of this invention utilize the Hermitian feature and focus on the optimization of the matrix inverse and multiplication module following the element-wise FFT modules in the block tap solver.
HERMITIAN MATRIX INVERSE ARCHITECTURES: Although the FFT-based tap solver avoids the direct matrix inverse of the original correlation matrix with the dimension of NF×NF, the inverse of the diagonal matrix  is inevitable. For a MIMO receiver with high receive dimension, the matrix inverse and multiplication in −1({circle around (×)})m is not trivial. Because of the diagonal feature of  matrix, it can be divided into the inverse of LF sub-matrices of size N×N as in −1=diag(0−1, 1−1, . . . , LF−1−1). A traditional N×N matrix inverse using Gaussian elimination has the complexity at O(N3) complex operations. From the Hermitian lemma above, it is clear that the elements of  are also Hermitian symmetric. There is a Lemma on the Hermitian eigen value decomposition: if εn×n is such that =H, there exist a unitary matrix εn×n, such that H=, where εn×n is a diagonal matrix of the eigen values of . Cholesky decomposition can be applied to facilitate the inverse of these matrices. However, this method requires arithmetic square root operations that are preferable to be avoided in hardware due to their complexity. The following detailed description considers two special cases individually, i.e., two and four Rx antennas, as these are most likely to be widely adopted. Adaptation of these teachings to different numbers of Rx antennas follows logically. Shown are complexity reduction schemes and efficient architectures suitable for VLSI (very large scale) implementation based on the exploration of block partitioning. The commonality of the partitioned block matrix inverse is extracted to design generic RTL modules for reusable modularity. The 4×4 receiver is designed by reusing the 2×2 block partitioning.
DUAL-ANTENNA MIMO/ST RECEIVER: From equation [9], a straightforward partitioning is at the matrix inversion for  and then the matrix multiplication of −1 and dimension-wise FFT of the channel coefficients. In this partitioning, the inverse of the entire sub-block matrix in  is first computed, followed by a matrix multiplication. However, this partitioning involves two separate loop structures. Since the two steps have same loop structure, it is more desirable to merge the two steps and reduce the overhead. The inverse of a 2×2 submatrix is given by,




  
    
      
        
          
            F
            ↔
          
          
            -
            1
          
        
        =
        
          
            
              [
              
                
                  
                    
                      
                        f
                        
                          0
                          ,
                          0
                        
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                  
                  
                    
                      
                        f
                        
                          0
                          ,
                          1
                        
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                  
                
                
                  
                    
                      
                        f
                        
                          1
                          ,
                          0
                        
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                  
                  
                    
                      
                        f
                        
                          1
                          ,
                          1
                        
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                  
                
              
              ]
            
            
              -
              1
            
          
          =
          
            
              
                1
                
                  
                    
                      
                        f
                        
                          0
                          ,
                          0
                        
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                    *
                    
                      
                        f
                        
                          1
                          ,
                          1
                        
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                  
                  -
                  
                    
                      
                        f
                        
                          0
                          ,
                          1
                        
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                    *
                    
                      
                        f
                        
                          1
                          ,
                          0
                        
                      
                      ⁡
                      
                        (
                        k
                        )
                      
                    
                  
                
              
              ⁡
              
                [
                
                  
                    
                      
                        
                          f
                          
                            1
                            ,
                            1
                          
                        
                        ⁡
                        
                          (
                          k
                          )
                        
                      
                    
                    
                      
                        -
                        
                          
                            f
                            
                              0
                              ,
                              1
                            
                          
                          ⁡
                          
                            (
                            k
                            )
                          
                        
                      
                    
                  
                  
                    
                      
                        -
                        
                          
                            f
                            
                              1
                              ,
                              0
                            
                          
                          ⁡
                          
                            (
                            k
                            )
                          
                        
                      
                    
                    
                      
                        
                          f
                          
                            0
                            ,
                            0
                          
                        
                        ⁡
                        
                          (
                          k
                          )
                        
                      
                    
                  
                
                ]
              
            
            .
          
        
      
    
    
      
        [
        10
        ]
      
    
  




Let =({circle around (×)})=[01 . . . LF-1], where k=[γ1(k)γ2(k)] is the combination of the kth elements of the dimension-wise FFT coefficients, then a merged computation of the matrix inverse and multiplication is given by




  
    
      
        
          
            
              
                G
                ↔
              
              =
              
                
                  
                    
                      F
                      ↔
                    
                    
                      -
                      1
                    
                  
                  ·
                  
                    (
                    
                      
                        D
                        ↔
                      
                      ⊗
                      
                        I
                        ↔
                      
                    
                    )
                  
                
                ⁢
                
                  h
                  ↔
                
              
            
          
        
        
          
            
              =
              
                
                  diag
                  (
                  
                    
                      
                        F
                        ↔
                      
                      0
                      
                        -
                        1
                      
                    
                    ,
                    
                      
                        F
                        ↔
                      
                      1
                      
                        -
                        1
                      
                    
                    ,
                    ,
                    ...
                    ⁢
                    
                      
                    
                    ,
                    
                      F
                      
                        
                          L
                          F
                        
                        -
                        1
                      
                      
                        -
                        1
                      
                    
                  
                  )
                
                ⁢
                
                  
                
                ⁢
                
                  Γ
                  ↔
                
              
            
          
        
        
          
            
              =
              
                
                  [
                  
                    
                      
                        
                          F
                          ↔
                        
                        0
                        
                          -
                          1
                        
                      
                      ⁢
                      
                        
                          Γ
                          ↔
                        
                        0
                        T
                      
                    
                    ,
                    
                      
                        
                          F
                          ↔
                        
                        1
                        
                          -
                          1
                        
                      
                      ⁢
                      
                        
                          Γ
                          ↔
                        
                        1
                        T
                      
                    
                    ,
                    ...
                    ⁢
                    
                      
                    
                    ,
                    
                      
                        
                          F
                          ↔
                        
                        
                          
                            L
                            F
                          
                          -
                          1
                        
                        
                          -
                          1
                        
                      
                      ⁢
                      
                        
                          Γ
                          ↔
                        
                        
                          
                            L
                            F
                          
                          -
                          1
                        
                        T
                      
                    
                  
                  ]
                
                T
              
            
          
        
      
    
    
      
        [
        11
        ]
      
    
  




Thus a single merged loop can be used to compute the final result of  instead of using separate loops. However, with the Hermitian features of 0,0, 1,1, we can reduce the number of real operations in the matrix inversion and multiplication module. This is a direct result from the features in Lemma 1 and Lemma 2 with differentiation of the real, half complex and complex multiplication/addition. It leads to a simplified equation for the kth element of the matrix G as shown,




  
    
      
        
          
            W
            ↔
          
          ⁡
          
            (
            k
            )
          
        
        =
        
          
            1
            
              
                
                  
                    f
                    
                      0
                      ,
                      0
                    
                  
                  ⁡
                  
                    (
                    k
                    )
                  
                
                ·
                
                  
                    f
                    
                      1
                      ,
                      1
                    
                  
                  ⁡
                  
                    (
                    k
                    )
                  
                
              
              -
              
                
                  
                  
                    
                      f
                      
                        o
                        ,
                        1
                      
                    
                    ⁡
                    
                      (
                      k
                      )
                    
                  
                  
                
                2
              
            
          
          ⁡
          
            [
            
              
                
                  
                    
                      
                        
                          f
                          
                            1
                            ,
                            1
                          
                        
                        ⁡
                        
                          (
                          k
                          )
                        
                      
                      ∘
                      
                        
                          γ
                          1
                        
                        ⁡
                        
                          (
                          k
                          )
                        
                      
                    
                    -
                    
                      
                        
                          f
                          
                            0
                            ,
                            1
                          
                        
                        ⁡
                        
                          (
                          k
                          )
                        
                      
                      *
                      
                        
                          γ
                          2
                        
                        ⁡
                        
                          (
                          k
                          )
                        
                      
                    
                  
                
              
              
                
                  
                    
                      
                        
                          f
                          
                            0
                            ,
                            0
                          
                        
                        ⁡
                        
                          (
                          k
                          )
                        
                      
                      ∘
                      
                        
                          γ
                          2
                        
                        ⁡
                        
                          (
                          k
                          )
                        
                      
                    
                    -
                    
                      
                        
                          
                            f
                            
                              0
                              ,
                              1
                            
                          
                          ⁡
                          
                            (
                            k
                            )
                          
                        
                        *
                      
                      *
                      
                        
                          γ
                          1
                        
                        ⁡
                        
                          (
                          k
                          )
                        
                      
                    
                  
                
              
            
            ]
          
        
      
    
    
      
        [
        12
        ]
      
    
  




where “a·b” means “real×real”; “a∘b” means “real×complex” and “a*b” means “complex×complex” multiplications. The complex division is replaced by a real division. From this, we derived the simplified data path with the Hermitian optimization as in FIG. 4. In this figure, f0,0(k) and f1,1(k) are real numbers. The single multiplier means a real multiplication. The multiplier with a circle means the “real×complex” multiplication and the multiplier with a rectangle is a “complex×complex” multiplication.

From FIG. 4, it is clear that the data path is significantly simplified as compared to the prior art full DMI. This facilitates the scaling in fixed point implementation and thus increases the stability of the algorithm. The complexity is compared as follows. The original matrix inverse and multiplication based on all complex numbers has 10 complex+2 real multiplications. This is equal to 42 real multiplications for one loop. For a block with FFT length of 32, there will be 42*32=1344 real multiplications. In the simplified data path, there are 2 complex+5 half complex+1 real multiplications. This is equal to 19 real multiplications in each loop, or 608 real multiplications in one block. Notice that the storage for the interface from element-wise FFTs is also reduced. We save four distribute DPRAMs for Im(f0,0), Im(f1,1), Re(f0,0), and Re(f1,1).
RECEIVER WITH 4 Rx ANTENNAS: This includes the 1×4, 2×4, 4×4 SIMO and MIMO scenarios. Note that the receiver diversity by over sampling also has the same mathematic format. So this may also be the case of 2 receive antennas with over sampling factor of 2. The principle operation of interest is the inverse of the 4×4 matrices (which are present for N=2 and oversampling factor of two), so it is necessary to determine which range of possible matrix architectures is most suitable to this application. In addition to minimizing the circuit area used, the design needs to work within a short time budget. An efficient computing architecture for this part saves the area and time resources. To start, partition the 4×4 sub matrices in [i] into four 2×2 block sub matrices as,




  
    
      
        
          
            
              F
              ↔
            
            ⁡
            
              [
              i
              ]
            
          
          
            4
            ×
            4
          
        
        =
        
          
            [
            
              
                
                  
                    
                      f
                      11
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      f
                      12
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      f
                      13
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      f
                      14
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
              
                
                  
                    
                      f
                      21
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      f
                      22
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      f
                      23
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      f
                      24
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
              
                
                  
                    
                      f
                      31
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      f
                      32
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      f
                      33
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      f
                      34
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
              
                
                  
                    
                      f
                      41
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      f
                      42
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      f
                      43
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      f
                      44
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
            
            ]
          
          =
          
            
              [
              
                
                  
                    
                      
                        
                          B
                          ↔
                        
                        11
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  
                    
                      
                        
                          B
                          ↔
                        
                        12
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
                
                  
                    
                      
                        
                          B
                          ↔
                        
                        21
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  
                    
                      
                        
                          B
                          ↔
                        
                        22
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
              
              ]
            
            k
          
        
      
    
    
      
        [
        13
        ]
      
    
  




The inverse of the 4×4 matrix can be carried out by sequential inverse of four 2×2 sub-matrices. For simplicity, we partition the 4×4 element matrix inverse as




  
    
      
        F
        ↔
      
      ⁡
      
        [
        i
        ]
      
    
    
      -
      1
    
  
  =
  
    
      [
      
        
          
            
              
                
                  C
                  ↔
                
                11
              
              ⁡
              
                [
                i
                ]
              
            
          
          
            
              
                
                  C
                  ↔
                
                12
              
              ⁡
              
                [
                i
                ]
              
            
          
        
        
          
            
              
                
                  C
                  ↔
                
                21
              
              ⁡
              
                [
                i
                ]
              
            
          
          
            
              
                
                  C
                  ↔
                
                22
              
              ⁡
              
                [
                i
                ]
              
            
          
        
      
      ]
    
    .
  




It can be shown that the sub-blocks are given by the following equations:





  
    
      
        {
        
          
            
              
                
                  
                    
                      C
                      ↔
                    
                    22
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                =
                
                  
                    (
                    
                      
                        
                          
                            B
                            ↔
                          
                          22
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      -
                      
                        
                          
                            
                              B
                              ↔
                            
                            21
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        ⁢
                        
                          
                            
                              
                                B
                                ↔
                              
                              11
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          
                            -
                            1
                          
                        
                        ⁢
                        
                          
                            
                              B
                              ↔
                            
                            12
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                      
                    
                    )
                  
                  
                    -
                    1
                  
                
              
            
          
          
            
              
                
                  
                    
                      C
                      ↔
                    
                    12
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                =
                
                  
                    -
                    
                      
                        
                          
                            B
                            ↔
                          
                          11
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      
                        -
                        1
                      
                    
                  
                  ⁢
                  
                    
                      
                        B
                        ↔
                      
                      12
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      
                        C
                        ↔
                      
                      22
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
            
          
          
            
              
                
                  
                    
                      C
                      ↔
                    
                    21
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                =
                
                  
                    -
                    
                      
                        
                          C
                          ↔
                        
                        22
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  ⁢
                  
                    
                      
                        B
                        ↔
                      
                      21
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      
                        
                          B
                          ↔
                        
                        11
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    
                      -
                      1
                    
                  
                
              
            
          
          
            
              
                
                  
                    
                      C
                      ↔
                    
                    11
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                =
                
                  
                    
                      
                        
                          B
                          ↔
                        
                        11
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    
                      -
                      1
                    
                  
                  -
                  
                    
                      
                        
                          C
                          ↔
                        
                        12
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        
                          B
                          ↔
                        
                        21
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        
                          
                            B
                            ↔
                          
                          11
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      
                        -
                        1
                      
                    
                  
                
              
            
          
        
      
    
    
      
        [
        14
        ]
      
    
  




Without looking into the data dependency, a straightforward computation will have eight complex matrix multiplications, two complex matrix inverses and two complex matrix subtractions, all of the size 2×2. But this is not very efficient. Examining the data dependency reveals some duplicate operations in the data path. For a general case without considering the Hermitian structure of the [i] matrix, it can be shown that a sequential computation has the dependency path of the data flow given by FIG. 5(a). The raw complexity is given by: six matrix multiplies, two inverses and two subtractions. From the data path flow, the critical path can be identified.
Now the Hermitian feature of the  matrix are utilized to derive more parallel and optimized computing architecture. Since the inverse of a Hermitian matrix is Hermitian, i.e., −1=[−1]H, it can be shown that,




  
    
      
        
          
            
              
                B
                ↔
              
              11
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              [
              
                
                  B
                  ↔
                
                11
                
                  -
                  1
                
              
              ]
            
            H
          
        
      
      
        
          
        
      
      
        
          
        
      
      
        
          
        
      
      
        
          
            
              
                C
                ↔
              
              11
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              [
              
                
                  C
                  ↔
                
                11
                
                  -
                  1
                
              
              ]
            
            H
          
        
      
    
    
      
        
          
            
              
                B
                ↔
              
              12
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              [
              
                
                  B
                  ↔
                
                21
                
                  -
                  1
                
              
              ]
            
            H
          
        
      
      
        
          
        
      
      
        ⇒
      
      
        
          
        
      
      
        
          
            
              
                C
                ↔
              
              12
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              [
              
                
                  C
                  ↔
                
                21
                
                  -
                  1
                
              
              ]
            
            H
          
        
      
    
    
      
        
          
            
              
                B
                ↔
              
              22
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              [
              
                
                  B
                  ↔
                
                22
                
                  -
                  1
                
              
              ]
            
            H
          
        
      
      
        
          
        
      
      
        
          
        
      
      
        
          
        
      
      
        
          
            
              
                C
                ↔
              
              22
              
                -
                1
              
            
            ⁡
            
              [
              i
              ]
            
          
          =
          
            
              [
              
                
                  C
                  ↔
                
                22
                
                  -
                  1
                
              
              ]
            
            H
          
        
      
    
  
  .




This leads to the data path by removing the duplicate computation blocks that has the Hermitian relationship. The reduced data path is shown in FIG. 5(b), where HINV means the inverse of a 2×2 Hermitian matrix and [ ]H is the Hermitian operation of a 2×2 matrix. This data path might be termed a straightforward Hermitian optimization architecture of the partitioned 4×4 matrix inverse.
However, this straightforward treatment still does not lead to the most efficient computing architecture. The data path is still constructed with a very long dependency path. To fully extract the commonality and regulate the design blocks in VLSI, we define the following special operators on the 2×2 matrices for the different type of complex number computations. These special operators will be mapped to VLSI Processing Units (PU) to deal with the special features of the Hermitian matrix. High-level modularity is achieved by extracting the commonality among the data path.

    
    
        Definition 1: “pPow(a b)=Re(a).Re(b)+Im(a).Im(b)” is defined as the pseudo-power function of two complex numbers and “Re(a,b)=Re(a).Re(b)−Im(a).Im(b)” is defined as the real part of a complex multiplication.
        Definition 2: For a general 2×2 matrix  and a Hermitian 2×2 matrix =H, we define the operator CHM (Complex-Hermitian-Multiplication) as
    
    






  
    M
    (
    
      
        A
        ↔
      
      ,
      
        B
        ↔
      
    
    )
  
  =
  
    
      
        A
        ↔
      
      ⁢
      
        B
        ↔
      
    
    =
    
      
        
          [
          
            
              
                
                  a
                  11
                
              
              
                
                  a
                  12
                
              
            
            
              
                
                  a
                  21
                
              
              
                
                  a
                  22
                
              
            
          
          ]
        
        ⁡
        
          [
          
            
              
                
                  b
                  11
                
              
              
                
                  b
                  21
                  *
                
              
            
            
              
                
                  b
                  21
                
              
              
                
                  b
                  22
                
              
            
          
          ]
        
      
      .
    
  




Note that all the numbers are complex except {b11,b22}∈.

    
    
        Definition 3: For a 2×2 Hermitian matrix
    
    






  
    
      B
      ↔
    
    =
    
      
        [
        
          
            
              
                b
                11
              
            
            
              
                b
                21
                *
              
            
          
          
            
              
                b
                21
              
            
            
              
                b
                22
              
            
          
        
        ]
      
      =
      
        
          B
          ↔
        
        H
      
    
  
  ,




define the Hermitian Inverse (HInv) operator as





  
    HInv
    ⁡
    
      (
      
        B
        ↔
      
      )
    
  
  =
  
    
      
        1
        
          (
          
            
              
                b
                11
              
              ⁢
              
                b
                22
              
            
            -
            
              
                
                
                  b
                  21
                
                
              
              2
            
          
        
      
      ⁡
      
        [
        
          
            
              
                b
                22
              
            
            
              
                -
                
                  b
                  21
                  *
                
              
            
          
          
            
              
                -
                
                  b
                  21
                
              
            
            
              
                b
                11
              
            
          
        
        ]
      
    
    .
  




This design can be achieved by simple real multiplications and divisions instead of complex multiplications and divisions.

    
    
        Definition 4: Given the 4×4 Hermitian  which is divided into four subblocks as
    
    






  
    
      A
      ↔
    
    =
    
      
        [
        
          
            
              
                
                  A
                  ↔
                
                11
              
            
            
              
                
                  A
                  ↔
                
                21
                *
              
            
          
          
            
              
                
                  A
                  ↔
                
                21
              
            
            
              
                
                  A
                  ↔
                
                22
              
            
          
        
        ]
      
      =
      
        
          A
          ↔
        
        H
      
    
  
  ,




the DT (Diagonal Transform) of  is defined as,





   
  
    
      
        
          
            
              
                
                  T
                  ⁡
                  
                    (
                    
                      A
                      ↔
                    
                    )
                  
                
                =
                
                  T
                  ⁡
                  
                    (
                    
                      
                        
                          A
                          ↔
                        
                        11
                      
                      ,
                      
                        
                          A
                          ↔
                        
                        21
                      
                      ,
                      
                        
                          A
                          ↔
                        
                        22
                      
                    
                    )
                  
                
              
            
          
          
            
              
                =
                
                  
                    
                      A
                      ↔
                    
                    22
                  
                  -
                  
                    
                      
                        A
                        ↔
                      
                      21
                    
                    ⁢
                    
                      
                        A
                        ↔
                      
                      11
                    
                    ⁢
                    
                      
                        A
                        ↔
                      
                      21
                      H
                    
                  
                
              
            
          
          
            
              
                =
                
                  
                    
                      A
                      ↔
                    
                    22
                  
                  -
                  
                    
                      M
                      ⁡
                      
                        (
                        
                          
                            
                              A
                              ↔
                            
                            21
                          
                          ,
                          
                            
                              A
                              ↔
                            
                            11
                          
                        
                        )
                      
                    
                    ⁢
                    
                      
                        A
                        ↔
                      
                      21
                      H
                    
                  
                
              
            
          
        
      
      
        
          [
          15
          ]
        
      
    
  




With these definitions, we regulate the inverse of the 4×4 Hermitian matrix =H into simplified operations on 2×2 matrices. After some manipulation, the partitioned subblock computation equations can be mapped to the following procedure using the defined operators.

inv=Hinv(11)=invH;  (1):

=M(21,inv);  (2):

22=Hinv(T(inv,21,22);  (3):

12=−M(H,22); because 12=21H=−(22)H=−H22  (4):

11[i]=Binv+H22=T(−22,H,inv)  (5):

This leads to the hardware mapping using the generic Processing Units in FIG. 6, which reveals that the overall computation complexity is 2HInv operations, 2 DTs, and 1 extra CHM block. Because the sign inverter and the Hermitian formatter [ ]H has no hardware resource at all, the computation complexity is determined by the three generic blocks. The data path of the computation shows the timing relationship between different design modules. This regulated block diagram facilitates the design of efficient parallel VLSI modules; whose details are given in the following.
PARALLEL ARCHITECTURE MODULES: Now we derive the efficient design modules for the generic  and  operations. To extract the commonality and reduce the redundancy, we need to explore the timing relationship of the basic computations involved in generic operations. Because the operation  is also embedded in the  transform, we need to design the interface in a way that the duplicate computations are removed and the efficient computing architecture is reused. The grouping of computations and the smart usage of interim registers will eliminate the redundancy and give simple and generic interface to the design modules. For a single (, ) module, let




   
  
    
      
        
          
            D
            ↔
          
          =
          
            [
            
              
                
                  
                    d
                    11
                  
                
                
                  
                    d
                    12
                  
                
              
              
                
                  
                    d
                    21
                  
                
                
                  
                    d
                    22
                  
                
              
            
            ]
          
        
      
    
    
      
        
          =
          
            M
            (
            
              
                A
                ↔
              
              ,
              
                B
                ↔
              
            
            )
          
        
      
    
    
      
        
          =
          
            
              [
              
                
                  
                    
                      
                        
                          a
                          11
                        
                        ∘
                        
                          b
                          11
                        
                      
                      +
                      
                        
                          a
                          11
                        
                        *
                        
                          b
                          12
                        
                      
                    
                  
                  
                    
                      
                        
                          a
                          11
                        
                        *
                        
                          b
                          21
                          *
                        
                      
                      +
                      
                        
                          a
                          12
                        
                        ∘
                        
                          b
                          22
                        
                      
                    
                  
                
                
                  
                    
                      
                        
                          a
                          21
                        
                        ∘
                        
                          b
                          11
                        
                      
                      +
                      
                        
                          a
                          22
                        
                        *
                        
                          b
                          21
                        
                      
                    
                  
                  
                    
                      
                        
                          a
                          21
                        
                        *
                        
                          b
                          21
                          *
                        
                      
                      +
                      
                        
                          a
                          22
                        
                        ∘
                        
                          b
                          22
                        
                      
                    
                  
                
              
              ]
            
            .
          
        
      
    
  




To extract the commonality in the  and  operations, we have the following lemma for Hermitian matrix. Lemma: If =H is a 2×2 Hermitian Matrix, then H is also a Hermitian matrix. The associated computation is given by 6 CMs (complex multiplications), 4 CRMs (complex-real multiplications), 4 pPow(a b) and 2 Re(a,b), where the 6 CMs are {a12*b21, a11*b21*, a22*b21, a21*b21*, d21*a11*, d22*a12*}, the 4 “CRM” operations are {tmp1=(a11∘b11), tmp3=(a12∘b22, tmp5=(a21∘b11), tmp7=(a22∘b22)}, and the 4 “pPow” operations are pPow(tmp1,a11*), pPow(tmp3,a12*), pPow(tmp5,a21*), pPow(tmp7,a22*) The two Re(a,b) operations are Re(tmp2,a11*), Re(tmp6,a21*).
Proof: Extend and group the computation of =H as follows,




   
  
    
      
        
          
            G
            ↔
          
          =
          
            [
            
              
                
                  
                    g
                    11
                  
                
                
                  
                    g
                    12
                  
                
              
              
                
                  
                    g
                    21
                  
                
                
                  
                    g
                    22
                  
                
              
            
            ]
          
        
      
    
    
      
        
          =
          
            
              A
              ↔
            
            ⁢
            
              B
              ↔
            
            ⁢
            
              
                A
                ↔
              
              H
            
          
        
      
    
    
      
        
          =
          
            
              M
              (
              
                
                  A
                  ↔
                
                ,
                
                  B
                  ↔
                
              
              )
            
            ⁢
            
              
                A
                ↔
              
              H
            
          
        
      
    
    
      
        
          =
          
            
              [
              
                
                  
                    
                      
                        
                          a
                          11
                        
                        ∘
                        
                          b
                          11
                        
                      
                      +
                      
                        
                          a
                          11
                        
                        *
                        
                          b
                          12
                        
                      
                    
                  
                  
                    
                      
                        
                          a
                          11
                        
                        *
                        
                          b
                          21
                          *
                        
                      
                      +
                      
                        
                          a
                          12
                        
                        ∘
                        
                          b
                          22
                        
                      
                    
                  
                
                
                  
                    
                      
                        
                          a
                          21
                        
                        ∘
                        
                          b
                          11
                        
                      
                      +
                      
                        
                          a
                          22
                        
                        *
                        
                          b
                          21
                        
                      
                    
                  
                  
                    
                      
                        
                          a
                          21
                        
                        *
                        
                          b
                          21
                          *
                        
                      
                      +
                      
                        
                          a
                          22
                        
                        ∘
                        
                          b
                          22
                        
                      
                    
                  
                
              
              ]
            
            ⁡
            
              [
              
                
                  
                    
                      a
                      11
                      *
                    
                  
                  
                    
                      a
                      21
                      *
                    
                  
                
                
                  
                    
                      a
                      12
                      *
                    
                  
                  
                    
                      a
                      22
                      *
                    
                  
                
              
              ]
            
          
        
      
    
  




which yields elements:

g11=(a11∘b11)*a11+[a12*b21*a11*+a11*b21**a12*]+(a12∘b22)*a12*;

g21=d21*a11*+d22*a12*;

g12=d21*a11*+d22*a12;

g22=(a21∘b21)*a21*+[a22*b21*a 21*+a21*b21**a22*]+(a22∘b22)*a22* 

In the equation, a*b denotes a “complex×complex” multiplication, and “a∘b” denotes a “complex×real” multiplication. Define the interim registers tmp1=(a11∘b11), tmp2=(a12∘b21), tmp3=(a12∘b22), tmp5=(a21∘b11), tmp6=a22*b21, tmp7=(a22∘b22) These interim values are added to generate d11, d12, d21, d22. However, instead of having a general complex multiplication of these interim values with the inputs to generate the final results, we can employ the relationship of these variables and use the special functional components. For example, it is easy to verify that (a11∘b11)*a11*=pPow(tmp1, a11) because the b11 is a scalar of the norm of a11. By changing the order of computation and combining common computations, we can finally show that  is a Hermitian matrix with the elements given by,




  {
  
    
      
        
          
            g
            11
          
          =
          
            
              pPow
              ⁡
              
                (
                
                  
                    tmp
                    ⁢
                    1
                  
                  ,
                  
                    a
                    11
                    *
                  
                
                )
              
            
            +
            
              2
              ⁢
              
                
              
              ⁢
              
                Re
                ⁡
                
                  (
                  
                    
                      tmp
                      ⁢
                      2
                    
                    ,
                    
                      a
                      11
                      *
                    
                  
                  )
                
              
            
            +
            
              pPow
              ⁡
              
                (
                
                  
                    tmp
                    ⁢
                    3
                  
                  ,
                  
                    a
                    12
                    *
                  
                
                )
              
            
          
        
      
    
    
      
        
          
            g
            21
          
          =
          
            
              
                d
                21
              
              *
              
                a
                11
                *
              
            
            +
            
              
                d
                22
              
              *
              
                a
                12
                *
              
            
          
        
      
    
    
      
        
          
            g
            12
          
          =
          
            g
            21
            *
          
        
      
    
    
      
        
          
            g
            22
          
          =
          
            
              pPow
              ⁡
              
                (
                
                  
                    tmp
                    ⁢
                    5
                  
                  ,
                  
                    a
                    21
                    *
                  
                
                )
              
            
            +
            
              2
              ⁢
              
                
              
              ⁢
              
                Re
                ⁡
                
                  (
                  
                    
                      tmp
                      ⁢
                      6
                    
                    ,
                    
                      a
                      21
                      *
                    
                  
                  )
                
              
            
            +
            
              pPow
              ⁡
              
                (
                
                  
                    tmp
                    ⁢
                    7
                  
                  ,
                  
                    a
                    22
                    *
                  
                
                )
              
            
          
        
      
    
  
   




Thus the simplified M(, ) RTL module can be design as FIG. 7, with the input of both real and imaginary parts of  {a11(r/i), a12(r/i), a21(r/i), a22(r/i)} and only the necessary elements of the Hermitian matrix  as in {b11(r), b21(r/i), b22(r)}. The output ports include {tmp1, tmp2, tmp3, tmp5, tmp6, tmp7}. There is no need to output tmp4 and tmp8. Moreover, although all these numbers have complex values, the products with the input values do not need to be complex multiplications. We also only need to compute d21, d22 to get the  elements. The redundant computations in {tmp4, tmp8, d21, d22} are eliminated from the M(, ) operation. Built from the simplified M(, ) module, the data path RTL module of the T(11, 21, 22) transform of the 4×4 Hermitian matrix is given by FIG. 8, with the simplified Functional Components {pPow(a,b), Re(a,b)} as defined. The output ports of the T(11, 21, 22) include the independent elements {t11, t21, t22}.
PERFORMANCE AND DESIGN: From the simplified generic design modules, the top level RTL schematic is designed as in FIG. 6. Compared with both the designs in FIG. 4 and FIG. 5, the architectures demonstrate better parallelism and reduced redundancy. Because the commonality of the  and  is extracted in the module designs, the RTL in the top level may be further optimized as shown in the following by eliminate the individual  module. Thus, the results of 11, 12 and 2, are generated from the second  module together. This design not only eliminates the redundancy to the best extent, but also facilitates the pipelining for multiple subcarriers. The data path is much better balanced to achieve a high-speed VLSI architecture.
The number of real multiplications may be further reduced by changing the numerical computation order of the complex multiplications in the  module. Traditionally, a complex multiplication is given by “c=cr+jci=(ar+jai)*(br+jbi)=(arbr−aibi)+j(arbi+aibr)”. This has four independent real multiplications and two real additions. By rearranging the computation order, we can extract the commonality and reduce the number of real multiplications as following:

p1=arbr; p2=aibi; s1=ar+ai; s2=br+bi;  (1)

crp1−p2; d=(p1+p2); s=s1s2;  (2)

ci=s−d.  (3)

This requires three RMs (real multiplications) and two RAs (real additions) in three steps. Considering the fact that RA is much cheaper than RM, the cost is worthwhile.

The number of RMs and RAs is summarized by utilizing the Hermitian feature of the matrix elements to reduce the redundant computation. The metrics of different fundamental computations are listed in Table II as a reference. It is clear that the inverse of a 2×2 Hermitian matrix requires seven RM and two RA, while the direct inverse of a general 2×2 matrix requires twenty-six RMs. The complex 2×2 matrix multiplication needs thirty-two RMs. If we use a traditional computing architecture of the 4×4 matrix inverse, we need 8*8*4+2*6.5*4=308 RMs and 8*8*4+2*1.5*2+2*4*2=150 RAs without utilizing the data dependency optimization (DO). Even with a straightforward data dependency optimization, the complexity is still 244 RMs and 102 RAs. However, a single  transform needs a total of 6*3+4*2+4*2+2*2=38 RMs for a 4×4 Hermitian matrix. All together, the number of real multiplications is 2×(38+7)=90 RMs to compute the 4×4 −1 with Hermitian structure. This is only less than one-third of the real multiplications for a traditional architecture to compute the inverse. Note that the critical data path is also dramatically shortened with better modularity and pipelining. The complexity reduction in terms of real multiplications is shown in Table III.







TABLE II







Number of RMs and RAs for Fundamental Operations











Operation
CMult
CAdd
RMult
RAdd














1/a = a*/|a|2
0.5
0.5
2
1


a * b
1
1
4
2


 
8
4
32 
24 


 −1
6.5
1.5
26 
3


HInv  
—
—
7
2
















TABLE III







Complexity Reduction for a 4 × 4 Matrix Inverse










Architecture
RM







Traditional w/o DO(4 × 4)
308 LF



Traditional w/ DO(4 × 4)
244 LF



Hermitian Opt(4 × 4)
 90 LF










Based on the above algorithmic optimization, the inventors have demonstrated the VLSI architecture and prototype of the RTL design on a Nallatech FPGA platform. The chip rate is in accordance with the WCDMA chip rate at 3.84 MHz, and the inventors applied a clock rate of 38.4 MHz for the Xilinx Virtex-II V6000 FPGA. The correlation window is set to 10 chips for all 4 receive antennas. The FFT size is 32-points. In the following are given the specification of the major design blocks: the throughput-mode correlation calculation, the multiple FFT/IFFT modules and the LF inverse of 4×4 submatrices. We utilize a Precision-C (now Catapult-C) based design methodology to study many area/time tradeoffs of the VLSI architecture design. For example, for the 16-FFT/IFFT modules, at one extreme, a fully parallel and pipelined architecture can be designed with parallel butterfly-units and complex multipliers laid out in the pattern of butterfly-tree. Since it is economically desirable to reduce the physical area, this is not practical. The merged multiple input multiple output FFT modules are designed to utilize the commonality in control logic and phase coefficient loading. Overall, only four multipliers are utilized to achieve area/time efficient design for this module. For the LF inverse of 4×4 Hermitian matrix, the latency is 38 Ãsec with 6 multipliers. This benefits from the afore-mentioned architectural optimization.







TABLE IV







Area/Time Specifications of the Major FPGA Design Modules












Architecture
Latency
CLB
ASICMult














Correlator
1 chip
22399 
80 


16 FFT32
44 Ãs 
2530
4


32 MatInvMult (4 × 4)
38 Ãs
4526
6









The current implementation of the invention is prototyped in FPGA platform, and the best mode is deemed to implement as ASIC architecture and integrate in the PHY processing engines in the communication chips. The current RTL can be targeted to the ASIC technology. The speed-critical elements include the scalable architectures for MIMO correlation, channel estimation, FIR filtering and the equalizer tap solver. An alternative would be to implement it in a high-end DSP processor. However, the DSP may not be able to provide enough parallelism and pipelining for the real-time processing of the time critical blocks with streaming input data.
The optimization reduces the number of FFTs and the number of real operations in the above sub-matrix inverse and multiplication. This facilitates the real-time implementation of the algorithm in VLSI architecture with reduced hardware resource. It also gives better stability to the fixed-point implementation. The principle operation of interest is the inverse many 4×4 matrices in the frequency domain. This leads to efficient architectures with 3× saving in complexity and more parallel and pipelined RTL schematic, which is verified in FPGA prototyping platform. This invention is deemed most advantageous for high-end CDMA devices with multiple antennas at both the transmitter and receiver. It is especially useful to simplify the receiver design with diversity order of up to 4, i.e., 4 receive antennas or 2 receive antennas with over sampling factor of 2, though the principles may be extended to other receivers with differing numbers of antennas.
Those skilled in the art should appreciate that an aspect of this invention pertains to a data storage medium storing program instructions to direct a data processor to equalize a signal received with at least two antennas from a multipath channel. The program instructions are operable to cause the data processor to perform an operation of equalizing the received signal by combining a Fourier transformed channel matrix with a Fourier transformed and inverted sub-matrix elements of a block circulant matrix Crr that is an approximation of a correlation matrix Rrr. The data storage medium may comprise part of a code division multiple access multiple input CDMA receiver.
While there has been illustrated and described what is at present considered to be preferred and alternative embodiments of the claimed invention, it will be appreciated that numerous changes and modifications are likely to occur to those skilled in the art. It is intended in the appended claims to cover all those changes and modifications that fall within the spirit and scope of the claimed invention.

## Claims

1. An apparatus configured to:
generate a set of filter coefficients w from inverting a series of sub-matrices F, each of the sub-matrices of size no greater than 2×2 and representing an element of an approximated correlation matrix Crr for a spread spectrum signal received over a multipath channel, where said sub-matrices are each a block-diagonal matrix with elements taken from an element-wise fast Fourier transform of a column of the approximated correlation matrix;
wherein the apparatus is configured to generate the set of filter coefficients by combining, as a matrix multiplication F−1H(D)m, the inverted sub-matrices F−1 with a fast Fourier transform of channel estimation coefficients h of a channel matrix H, where F−1 represents the inversion of the sub-matrices F;
the apparatus further configured to perform an inverse fast Fourier transform on the result of the multiplying to resolve a filter matrix W whose elements w comprise the set of filter coefficients; and
the apparatus is further configured, for each kth filter coefficient, to matrix multiply the inverted and fast Fourier transformed columnar elements





  
    
      F
      ↔
    
    
      -
      1
    
  
  =
  
    
      [
      
        
          
            
              
                f
                
                  0
                  ,
                  0
                
              
              ⁡
              
                (
                k
                )
              
            
          
          
            
              
                f
                
                  0
                  ,
                  1
                
              
              ⁡
              
                (
                k
                )
              
            
          
        
        
          
            
              
                f
                
                  1
                  ,
                  0
                
              
              ⁡
              
                (
                k
                )
              
            
          
          
            
              
                f
                
                  1
                  ,
                  1
                
              
              ⁡
              
                (
                k
                )
              
            
          
        
      
      ]
    
    
      -
      1
    
  




with a combination {umlaut over (Γ)}k=[γ1(k)γ2(k)] of the kth elements of the channel coefficients h in the Fourier transformed channel matrix H.

2. An apparatus as in claim 1, where said equalizer is a Linear-Minimum-Mean-Square-Error LMMSE equalizer.

3. An apparatus as in claim 1, where said equalizer is a Linear-Minimum-Mean-Square-Error LMMSE chip-level equalizer.

4. An apparatus as in claim 1, where said apparatus forms a part of a receiver that has either an even number of receive antennas greater than two or two receive antennas with oversampling at least twice per chip.

5. An apparatus as in claim 4, further configured to partition non-zero elements of the approximated correlation matrix Crr into mutually exclusive 2×2 sub-matrices B and to invert each of said partitioned sub-matrices.

6. An apparatus configured to:
generate a set of filter coefficients w by partitioning non-zero elements of an approximated correlation matrix Crr for a spread spectrum signal received over a multipath channel into mutually exclusive and inverted 2×2 sub-matrices B;
execute a fast Fourier transform on each of the partitioned sub-matrices;
thereafter to convert and combine the partitioned sub-matrices to form a matrix





  
    
      
        
          
            
              
                F
                ↔
              
              ⁡
              
                [
                i
                ]
              
            
            
              -
              1
            
          
          =
          
            [
            
              
                
                  
                    
                      
                        C
                        ↔
                      
                      11
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      
                        C
                        ↔
                      
                      12
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
              
                
                  
                    
                      
                        C
                        ↔
                      
                      21
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
                
                  
                    
                      
                        C
                        ↔
                      
                      22
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
            
            ]
          
        
        ,
        where
      
    
  
  
    
      
        {
        
          
            
              
                
                  
                    
                      
                        C
                        ↔
                      
                      22
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  =
                  
                    
                      (
                      
                        
                          
                            
                              B
                              ↔
                            
                            22
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        -
                        
                          
                            
                              
                                B
                                ↔
                              
                              21
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          ⁢
                          
                            
                              
                                
                                  B
                                  ↔
                                
                                11
                              
                              ⁡
                              
                                [
                                i
                                ]
                              
                            
                            
                              -
                              1
                            
                          
                          ⁢
                          
                            
                              
                                B
                                ↔
                              
                              12
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                        
                      
                      )
                    
                    
                      -
                      1
                    
                  
                
              
            
            
              
                
                  
                    
                      
                        C
                        ↔
                      
                      12
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  =
                  
                    
                      -
                      
                        
                          
                            
                              B
                              ↔
                            
                            11
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        
                          -
                          1
                        
                      
                    
                    ⁢
                    
                      
                        
                          B
                          ↔
                        
                        12
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        
                          C
                          ↔
                        
                        22
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                
              
            
            
              
                
                  
                    
                      
                        C
                        ↔
                      
                      21
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  =
                  
                    
                      -
                      
                        
                          
                            C
                            ↔
                          
                          22
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                    
                    ⁢
                    
                      
                        
                          B
                          ↔
                        
                        21
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        
                          
                            B
                            ↔
                          
                          11
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      
                        -
                        1
                      
                    
                  
                
              
            
            
              
                
                  
                    
                      
                        C
                        ↔
                      
                      11
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  =
                  
                    
                      
                        
                          
                            B
                            ↔
                          
                          11
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      
                        -
                        1
                      
                    
                    -
                    
                      
                        
                          
                            C
                            ↔
                          
                          12
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        
                          
                            B
                            ↔
                          
                          21
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      ⁢
                      
                        
                          
                            
                              B
                              ↔
                            
                            11
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        
                          -
                          1
                        
                      
                    
                  
                
              
            
          
          ;
        
      
    
  



and thereafter to multiply the matrix F−1 by a Fourier transformed channel matrix to yield F−1H(D)m, and thereafter to execute an inverse fast Fourier transform on F−1H(D)m.

7. The apparatus of claim 6, configured for each 2×2 sub-matrix B, to determine only three elements, to store at least the independently determined three elements, and to determine a fourth element from at least one of the stored three elements.

8. The apparatus as in claim 7 configured to generate the set of filter coefficients by three separate calculation operations on the three stored elements, the calculation operations comprising:
a diagonal transform T()=T(11, 2122)of an input 2×2 matrix ;
a Hermitian inverse operation HINV of an input 2×2 Hermitian matrix; and
a Complex-Hermitian-Multiplication





  
    M
    (
    
      
        A
        ↔
      
      ,
      
        B
        ↔
      
    
    )
  
  =
  
    
      
        A
        ↔
      
      ⁢
      
        B
        ↔
      
    
    =
    
      
        [
        
          
            
              
                a
                11
              
            
            
              
                a
                12
              
            
          
          
            
              
                a
                21
              
            
            
              
                a
                22
              
            
          
        
        ]
      
      ⁡
      
        [
        
          
            
              
                b
                11
              
            
            
              
                b
                21
                *
              
            
          
          
            
              
                b
                21
              
            
            
              
                b
                22
              
            
          
        
        ]
      
    
  




of two input 2×2 matrices.

9. The apparatus as in claim 8 disposed within a receiver, where the set of filter coefficients for each kth spreading code are


g11=(a11∘b11)*a11+[a12*b21*a11*+a11*b21*a12*]+(a12∘b22)*a12*;



g21=d21*a11*+d22*a12*;



g12=d21*a11*+d22*a12; and



g22=(a21∘b21)*a21*+[a22*b21*a21*+a21*b21*a22*]+(a22∘b22)*a22*.

10. The apparatus as in claim 9, configured to store at least some computational combinations for which the apparatus is configured to reuse in the determination of each kth spreading code filter coefficient.

11. The apparatus as in claim 10 where the set of filter coefficients for each kth spreading code are




  {
  
    
      
        
          
            
              g
              11
            
            =
            
              
                pPow
                ⁡
                
                  (
                  
                    
                      tmp
                      ⁢
                      1
                    
                    ,
                    
                      a
                      11
                      *
                    
                  
                  )
                
              
              +
              
                2
                ⁢
                
                  
                
                ⁢
                
                  Re
                  ⁡
                  
                    (
                    
                      
                        tmp
                        ⁢
                        2
                      
                      ,
                      
                        a
                        11
                        *
                      
                    
                    )
                  
                
              
              +
              
                pPow
                ⁡
                
                  (
                  
                    
                      tmp
                      ⁢
                      3
                    
                    ,
                    
                      a
                      12
                      *
                    
                  
                  )
                
              
            
          
        
      
      
        
          
            
              g
              21
            
            =
            
              
                
                  d
                  21
                
                *
                
                  a
                  11
                  *
                
              
              +
              
                
                  d
                  22
                
                *
                
                  a
                  12
                  *
                
              
            
          
        
      
      
        
          
            
              g
              12
            
            =
            
              g
              21
              *
            
          
        
      
      
        
          
            
              g
              22
            
            =
            
              
                pPow
                ⁡
                
                  (
                  
                    
                      tmp
                      ⁢
                      5
                    
                    ,
                    
                      a
                      21
                      *
                    
                  
                  )
                
              
              +
              
                2
                ⁢
                
                  
                
                ⁢
                
                  Re
                  ⁡
                  
                    (
                    
                      
                        tmp
                        ⁢
                        6
                      
                      ,
                      
                        a
                        21
                        *
                      
                    
                    )
                  
                
              
              +
              
                pPow
                ⁡
                
                  (
                  
                    
                      tmp
                      ⁢
                      7
                    
                    ,
                    
                      a
                      22
                      *
                    
                  
                  )
                
              
            
          
        
      
    
    ;
  



where tmp1, tmp2, tmp3, tmp5, tmp6, and tmp7 are values of computational combinations stored in memory, d21 and d22 are elements of a 2×2 matrix D resulting from a Complex Hermitian Multiplication of matrices B and A, and pPow(a)=Re(a).Re(b)+Im(a).Im(b) for two complex numbers a and b.

12. The apparatus of claim 1, where said apparatus comprises an equalizer that is implemented using circuitry.

13. The apparatus of claim 1, where said apparatus comprises an equalizer that is implemented using software.

14. The apparatus of claim 1, where said apparatus comprises an equalizer that is implemented using a combination of circuitry and software.

15. The apparatus of claim 1, where said apparatus comprises a multiple input code division multiple access CDMA receiver.

16. The apparatus of claim 1, where said apparatus comprises a multiple input, multiple output MIMO code division multiple access CDMA receiver.

17. The apparatus of claim 6, wherein the apparatus comprises a Linear-Minimum-Mean-Square-Error LMMSE equalizer.

18. The apparatus of claim 6, wherein the apparatus comprises a Linear-Minimum-Mean-Square-Error LMMSE chip-level equalizer.

19. The apparatus of claim 6, wherein the apparatus comprises an equalizer that forms a part of a code division multiple access CDMA receiver having a multiple input, multiple output MIMO architecture.

20. A method, comprising:
receiving a signal from a multipath channel with at least two receive antennas; and
equalizing the received signal by combining a Fourier transformed channel matrix with a Fourier transformed and inverted sub-matrix elements of a block circulant matrix Crr that is an approximation of a correlation matrix Rrr, where said combining comprises a matrix multiplication F−1H(D)m, where H is a channel matrix;
performing an inverse fast Fourier transform on F−1H(D)m resolve a filter matrix W whose elements w comprise a set of FIR filter coefficients;
for each kth filter coefficient, inverting the Fourier transformed sub-matrix elements





  
    
      
        F
        ↔
      
      
        -
        1
      
    
    =
    
      
        [
        
          
            
              
                
                  f
                  
                    0
                    ,
                    0
                  
                
                ⁡
                
                  (
                  k
                  )
                
              
            
            
              
                
                  f
                  
                    0
                    ,
                    1
                  
                
                ⁡
                
                  (
                  k
                  )
                
              
            
          
          
            
              
                
                  f
                  
                    1
                    ,
                    0
                  
                
                ⁡
                
                  (
                  k
                  )
                
              
            
            
              
                
                  f
                  
                    1
                    ,
                    1
                  
                
                ⁡
                
                  (
                  k
                  )
                
              
            
          
        
        ]
      
      
        -
        1
      
    
  
  ;




and
matrix multiplying the sub-matrix elements with a combination k=[γ1(k)γ2(k)] of the kth elements of the channel coefficients h in the Fourier transformed channel matrix H.

21. A method as in claim 20, where said combining a Fourier transformed channel matrix with a Fourier transformed and inverted sub-matrix elements of a block circulant matrix Crr is implemented by a tap solver having an output coupled to a Finite Impulse Response filter.

22. A method as in claim 20, where equalizing uses a Linear-Minimum-Mean-Square-Error LMMSE technique.

23. A method as in claim 20, where equalizing uses a Linear-Minimum-Mean-Square-Error LMMSE chip-level technique.

24. A method as in claim 20, where receiving and equalizing occur within a code division multiple access multiple input CDMA receiver.

25. A method as in claim 20 where all matrices that are inverted to resolve a set of filter coefficients are of dimensions 2×2.

26. A method as in claim 20 where the inverted sub-matrix elements are of dimension greater than 2×2, the method further comprising:
partitioning the sub-matrix elements into mutually exclusive block sub-matrices and inverting each.

27. A method comprising:
receiving a signal from a multipath channel with at least two receive antennas; and
equalizing the received signal by combining a Fourier transformed channel matrix H with Fourier transformed and inverted sub-matrix elements of a block circulant matrix Crr that is an approximation of a correlation matrix Rrr;
for the case where the inverted sub-matrix elements are of dimension greater than 2×2, partitioning the sub-matrix elements into mutually exclusive block sub-matrices and inverting each of the partitioned block sub-matrices, where the Fourier transform is executed on each of the partitioned sub-matrices B, which are converted and combined to form a matrix





  
    
      
        
          F
          ↔
        
        ⁡
        
          [
          i
          ]
        
      
      
        -
        1
      
    
    =
    
      [
      
        
          
            
              
                
                  C
                  ↔
                
                11
              
              ⁡
              
                [
                i
                ]
              
            
          
          
            
              
                
                  C
                  ↔
                
                12
              
              ⁡
              
                [
                i
                ]
              
            
          
        
        
          
            
              
                
                  C
                  ↔
                
                21
              
              ⁡
              
                [
                i
                ]
              
            
          
          
            
              
                
                  C
                  ↔
                
                22
              
              ⁡
              
                [
                i
                ]
              
            
          
        
      
      ]
    
  
  ,
  
    

  
  ⁢
  
    where
    ⁢
    
      
        
      
      ⁢
      
        
      
    
    ⁢
    
      {
      
        
          
            
              
                
                  
                    
                      C
                      ↔
                    
                    22
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                =
                
                  
                    (
                    
                      
                        
                          
                            B
                            ↔
                          
                          22
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      -
                      
                        
                          
                            
                              B
                              ↔
                            
                            21
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                        ⁢
                        
                          
                            
                              
                                B
                                ↔
                              
                              11
                            
                            ⁡
                            
                              [
                              i
                              ]
                            
                          
                          
                            -
                            1
                          
                        
                        ⁢
                        
                          
                            
                              B
                              ↔
                            
                            12
                          
                          ⁡
                          
                            [
                            i
                            ]
                          
                        
                      
                    
                    )
                  
                  
                    -
                    1
                  
                
              
            
          
          
            
              
                
                  
                    
                      C
                      ↔
                    
                    12
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                =
                
                  
                    -
                    
                      
                        
                          
                            B
                            ↔
                          
                          11
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      
                        -
                        1
                      
                    
                  
                  ⁢
                  
                    
                      
                        B
                        ↔
                      
                      12
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      
                        C
                        ↔
                      
                      22
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                
              
            
          
          
            
              
                
                  
                    
                      C
                      ↔
                    
                    21
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                =
                
                  
                    -
                    
                      
                        
                          C
                          ↔
                        
                        22
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                  
                  ⁢
                  
                    
                      
                        B
                        ↔
                      
                      21
                    
                    ⁡
                    
                      [
                      i
                      ]
                    
                  
                  ⁢
                  
                    
                      
                        
                          B
                          ↔
                        
                        11
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    
                      -
                      1
                    
                  
                
              
            
          
          
            
              
                
                  
                    
                      C
                      ↔
                    
                    11
                  
                  ⁡
                  
                    [
                    i
                    ]
                  
                
                =
                
                  
                    
                      
                        
                          B
                          ↔
                        
                        11
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    
                      -
                      1
                    
                  
                  -
                  
                    
                      
                        
                          C
                          ↔
                        
                        12
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        
                          B
                          ↔
                        
                        21
                      
                      ⁡
                      
                        [
                        i
                        ]
                      
                    
                    ⁢
                    
                      
                        
                          
                            B
                            ↔
                          
                          11
                        
                        ⁡
                        
                          [
                          i
                          ]
                        
                      
                      
                        -
                        1
                      
                    
                  
                
              
            
          
        
        ;
      
    
  




that is multiplied by the Fourier transformed channel matrix to yield F−1H(D)m, and
executing an inverse fast Fourier transform on F−1H(D)m.

28. A method as in claim 27 where the combining is executed by an arrangement of three separate calculation operations, the calculation operations comprising:
a diagonal transform T()=T(11, 2122) of an input 2×2 matrix ;
a Hermitian inverse operation HINV of an input 2×2 Hermitian matrix; and
a Complex-Hermitian-Multiplication





  
    M
    (
    
      
        A
        ↔
      
      ,
      
        B
        ↔
      
    
    )
  
  =
  
    
      
        A
        ↔
      
      ⁢
      
        B
        ↔
      
    
    =
    
      
        [
        
          
            
              
                a
                11
              
            
            
              
                a
                12
              
            
          
          
            
              
                a
                21
              
            
            
              
                a
                22
              
            
          
        
        ]
      
      ⁡
      
        [
        
          
            
              
                b
                11
              
            
            
              
                b
                21
                *
              
            
          
          
            
              
                b
                21
              
            
            
              
                b
                22
              
            
          
        
        ]
      
    
  




of two input 2×2 matrices.

29. A method as in claim 28 further comprising generating a set of filter coefficients from the combining, the filter coefficients comprising, for each kth spreading code of the received signal:


g11=(a11∘b11)*a11+[a12*b21*a11*+a11*b21*a12*]+(a12∘b22)*a12;



g21=d21*a11*+d22*a12;



g12=d21*a11*+d22*a12; and



g22=(a21∘b21)*a21*+[a22*b21*a21*+a21*b21*a22*]+(a22∘b22)*a22.

30. A method as in claim 29 further comprising generating a set of filter coefficients from the combining, the filter coefficients comprising, for each kth spreading code of the received signal:




  {
  
    
      
        
          
            
              g
              11
            
            =
            
              
                pPow
                ⁡
                
                  (
                  
                    
                      tmp
                      ⁢
                      1
                    
                    ,
                    
                      a
                      11
                      *
                    
                  
                  )
                
              
              +
              
                2
                ⁢
                
                  
                
                ⁢
                
                  Re
                  ⁡
                  
                    (
                    
                      
                        tmp
                        ⁢
                        2
                      
                      ,
                      
                        a
                        11
                        *
                      
                    
                    )
                  
                
              
              +
              
                pPow
                ⁡
                
                  (
                  
                    
                      tmp
                      ⁢
                      3
                    
                    ,
                    
                      a
                      12
                      *
                    
                  
                  )
                
              
            
          
        
      
      
        
          
            
              g
              21
            
            =
            
              
                
                  d
                  21
                
                *
                
                  a
                  11
                  *
                
              
              +
              
                
                  d
                  22
                
                *
                
                  a
                  12
                  *
                
              
            
          
        
      
      
        
          
            
              g
              12
            
            =
            
              g
              21
              *
            
          
        
      
      
        
          
            
              g
              22
            
            =
            
              
                pPow
                ⁡
                
                  (
                  
                    
                      tmp
                      ⁢
                      5
                    
                    ,
                    
                      a
                      21
                      *
                    
                  
                  )
                
              
              +
              
                2
                ⁢
                
                  
                
                ⁢
                
                  Re
                  ⁡
                  
                    (
                    
                      
                        tmp
                        ⁢
                        6
                      
                      ,
                      
                        a
                        21
                        *
                      
                    
                    )
                  
                
              
              +
              
                pPow
                ⁡
                
                  (
                  
                    
                      tmp
                      ⁢
                      7
                    
                    ,
                    
                      a
                      22
                      *
                    
                  
                  )
                
              
            
          
        
      
    
    ;
  



where tmp1, tmp2, tmp3, tmp5, tmp6, and tmp7 are values of computational combinations determined and stored in memory, d21 and d22 are elements of a 2×2 matrix D resulting from a Complex Hermitian Multiplication of matrices B and A, and pPow(a b)=Re(a).Re(b)+Im(a).Im(b) for two complex numbers a and b.

31. A data storage medium storing program instructions to direct a data processor to equalize a signal received with at least two antennas from a multipath channel, comprising an operation of equalizing the received signal by combining a Fourier transformed channel matrix with a Fourier transformed and inverted sub-matrix elements of a block circulant matrix Crr that is an approximation of a correlation matrix Rrr, where said combining comprises a matrix multiplication on F−1H(D)m, where H is a channel matrix;
performing an inverse fast Fourier transform on F−1H(D)m to resolve a filter matrix W whose elements w comprise a set of FIR filter coefficients;
for each kth filter coefficient, inverting the Fourier transformed sub-matrix elements





  
    
      
        F
        ↔
      
      
        -
        1
      
    
    =
    
      
        [
        
          
            
              
                
                  f
                  
                    0
                    ,
                    0
                  
                
                ⁡
                
                  (
                  k
                  )
                
              
            
            
              
                
                  f
                  
                    0
                    ,
                    1
                  
                
                ⁡
                
                  (
                  k
                  )
                
              
            
          
          
            
              
                
                  f
                  
                    1
                    ,
                    0
                  
                
                ⁡
                
                  (
                  k
                  )
                
              
            
            
              
                
                  f
                  
                    1
                    ,
                    1
                  
                
                ⁡
                
                  (
                  k
                  )
                
              
            
          
        
        ]
      
      
        -
        1
      
    
  
  ;




and matrix multiplying the sub-matrix elements with a combination k=[γ1(k)γ2(k)] of the kth elements of the channel coefficients h in the Fourier transformed channel matrix H.

32. A data storage medium as in claim 31, where the operation of combining the Fourier transformed channel matrix with the Fourier transformed and inverted sub-matrix elements of the block circulant matrix Crr comprises operating a tap solver having an output coupled to a Finite Impulse Response filter.

33. A data storage medium as in claim 31, where the equalizing operation uses a Linear-Minimum-Mean-Square-Error LMMSE technique.

34. A data storage medium as in claim 31, where the equalizing operation uses a Linear-Minimum-Mean-Square-Error LMMSE chip-level technique.

35. A data storage medium as in claim 31, where said data storage medium comprises part of a code division multiple access multiple input CDMA receiver.