# Patent

## Title
Downlink 8 Tx codebook sub-sampling for CSI feedback

## Abstract

This invention is codebook sub-sampling of the reporting of RI, CQI, W1 and W2. If CSI mode 1 is selected RI and W1 are jointly encoded using codebook sub-sampling in report 1. If CSI mode 2 is selected W1 and W2 are jointly encoded using codebook sub-sampling in report 2.

## Background
CLAIM OF PRIORITY
This application is a Continuation of application Ser. No. 14/248,199 filed Apr. 8, 2014, which is a Continuation of application Ser. No. 13/224,764 flied Sep. 2, 2011, which claims priority under 35 U.S.C. 119(e)(1) to U.S. Provisional Application No. 61/379,525 filed Sep. 2, 2010, U.S. Provisional Application No. 61/384,925 filed Sep. 21, 2010 and U.S. Provisional Application No. 61/385,671 filed Sep. 23, 2010.


TECHNICAL FIELD OF THE INVENTION
The technical field of this invention is wireless communication such as wireless telephony.
BACKGROUND OF THE INVENTION
This invention deals with the problem of signaling channel state information (CSI) between a user equipment (UE) and a base station (eNB).
SUMMARY OF THE INVENTION
This invention is codebook sub-sampling of the reporting of Rank Indicator (RI), Channel Quality Indicator (CQI), first precoding matrix (W1) and second precoding matrix (W2). If CSI mode 1 is selected RI and W1 are jointly encoded using codebook sub-sampling in report 1. If CSI mode 2 is selected W1 and W1 are jointly encoded using codebook sub-sampling in report 2.



BRIEF DESCRIPTION OF THE DRAWINGS
These and other aspects of this invention are illustrated in the drawings, in which:
FIG. 1 illustrates an exemplary prior art wireless communication system to which this application is applicable;
FIG. 2 shows the Evolved Universal Terrestrial Radio Access (E-UTRA) Time Division Duplex (TDD) frame structure of the prior art;
FIG. 3 illustrates the process of RI, CQI W1 and W2 reporting according to this invention; and
FIG. 4 is a block diagram illustrating internal details of a base station and a mobile user equipment in the network system of FIG. 1 suitable for implementing this invention.



DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS
FIG. 1 shows an exemplary wireless telecommunications network 100. The illustrative telecommunications network includes base stations 101, 102 and 103, though in operation, a telecommunications network necessarily includes many more base stations. Each of base stations 101, 102 and 103 (eNB) are operable over corresponding coverage areas 104, 105 and 106. Each base station's coverage area is further divided into cells. In the illustrated network, each base station's coverage area is divided into three cells. Handset or other user equipment (UE) 109 is shown in Cell A 108. Cell A 108 is within coverage area 104 of base station 101. Base station 101 transmits to and receives transmissions from UE 109. As UE 109 moves out of Cell A 108 and into Cell B 107, UE 109 may be handed over to base station 102. Because UE 109 is synchronized with base station 101, UE 109 can employ non-synchronized random access to initiate handover to base station 102.
Non-synchronized UE 109 also employs non-synchronous random access to request allocation of up-link 111 time or frequency or code resources. If UE 109 has data ready for transmission, which may be traffic data, measurements report, tracking area update, UE 109 can transmit a random access signal on up-link 111. The random access signal notifies base station 101 that UE 109 requires up-link resources to transmit the UEs data. Base station 101 responds by transmitting to UE 109 via down-link 110, a message containing the parameters of the resources allocated for UE 109 up-link transmission along with a possible timing error correction. After receiving the resource allocation and a possible timing advance message transmitted on down-link 110 by base station 101, UE 109 optionally adjusts its transmit timing and transmits the data on up-link 111 employing the allotted resources during the prescribed time interval.
Base station 101 configures UE 109 for periodic uplink sounding reference signal (SRS) transmission. Base station 101 estimates uplink channel quality information (CSI) from the SRS transmission.
FIG. 2 shows the Evolved Universal Terrestrial Radio Access (E-UTRA) time division duplex (TDD) Frame Structure. Different sub-frames are allocated for downlink (DL) or uplink (UL) transmissions. Table 1 shows applicable DL/UL subframe allocations. D refers to a downlink sub-frame, U refers to an uplink sub-frame, S refers to a special sub-frame for switching between downlink to uplink.









TABLE 1







Config-
Switch-point
Sub-frame number


















uration
periodicity
0
1
2
3
4
5
6
7
8
9





0
 5 ms
D
S
U
U
U
D
S
U
U
U


1
 5 ms
D
S
U
U
D
D
S
U
U
D


2
 5 ms
D
S
U
D
D
D
S
U
D
D


3
10 ms
D
S
U
U
U
D
D
D
D
D


4
10 ms
D
S
U
U
D
D
D
D
D
D


5
10 ms
D
S
U
D
D
D
D
D
D
D


6
10 ms
D
S
U
U
U
D
S
U
U
D









CSI (channel state information) feedback from UE to eNB consists of rank indicator (RI), precoding matrix indicator (PMI) and channel quality indicator (CQI). RI denotes the number of layers in data transmission recommended by the UE. PMI is the index to the recommended precoding matrix for data transmission, derived from a codebook. CQI is the channel quality when the reported RI/PMI are used for data transmission.
The 8 TX codebook for Rel. 10 downlink (DL) MIMO was adopted in the applicable standard for 8 antenna ports system. For 8 TX each precoding matrix is a multiplication of two component matrices denoted by W=W1*W2. The component codebook for W1 and W2 are denoted respectively C1 and C2. For CSI feedback, both W1 and W2 need to be reported. Because Physical Uplink Shared CHannel (PUCCH) payload is limited (maximum 11-bits), not all precoding matrices in the C1 and C2 codebook can be used in PUCCH feedback. Following the agreement on CSI reporting modes for PUCCH, the possibility of applying codebook sub-sampling needs to be investigated. This document outlines some possible codebook sub-sampling mechanisms in relation to PUCCH mode 1-1 for both CSI mode 1 and 2. This facilitates further comparison between CSI mode 1 and 2. The adopted reporting structure is given in Table 2. Table 2 shows the reporting structure for PUCCH mode 1-1. The notation x+y (as in RI+W1, W1+W2 indicates the possibility for joint encoding. Similarly the notation x/y (as in RI/WI, W1/W2 indicates the possibility for joint encoding.










TABLE 2







CSI mode 1
CSI mode 2




















Report 1
RI + W1
RI



Report 2
CQI, W2
CQI, W1 + W2










From Table 2 it is apparent that in CSI mode 1 report 2 simply follows the Rel. 8 Precoding Matrix Indicator (PMI) principle where W2 is analogous to the Rel. 8 PMI. In CSI mode 2 report 1 carries only the Rel. 8 RI making codebook sub-sampling irrelevant. Codebook sub-sampling is needed for CSI mode 1 report 1 and CSI mode 2 report 2. This will be discussed below.
FIG. 3 illustrates this process. FIG. 3 begins with start block 301. Test block 302 determines if CSI mode 1 or CSI mode 2 is selected. If CSI mode 1 is selected, then block 303 generates report 1. RI and W1 are jointly encoded. They are also codebook sub-sampled according to one of Tables 3 to 15 below. Block 304 generates report 2 with CQI and W2 separately encoded.
If CSI mode 2 is selected, then block 305 generates report 1. This includes the separately encoded RI. Block 306 generates report 2 with CQI, W1 and W2. W1 and W2 are jointly encoded with codebook sub-sampling according to one of Tables 16 to 19. FIG. 3 ends with continue block 306.
For CSI report on PUSCH, codebook sub-sampling may be performed on W2 as shown in Tables 21 to 25.
Codebook Sub-Sampling
Codebook sub-sampling is selected for the two scenarios mentioned above.
CSI Mode 1 Report 1 (RI+W1)
In this case, the total payload RI+W1 is kept within 5 bits to ensure that the effect of error propagation is not significant for any practical range of RI reporting interval. The following actions are performed to attain such goal when sub-sampling is performed on the codebook C1 for W1. First, joint encoding of RI and W1 follow the standard. This ensures efficient signaling of W1 with minimum overhead. Second, overlapping beams between two different W1 matrices can be skipped whenever appropriate as overlapping beam can be seen as an optimization feature. Third, since precoding gain is expected to be small for higher-rank transmission (rank>4), fixed precoding using only one W1 matrix may be appropriate.
Tables 3 to 15 show three exemplary W1 codebook sub-sampling schemes. These examples are ordered in increasing total number of hypotheses. It is possible to combine a part of one example with other parts from other examples. For example, for RI=1 to 4 example 1 may be used while for RI=5 to 8 example 3 may be used. While the total number of hypotheses differs, all these exemplary designs occupy a maximum of 5 bits for jointly coded RI and W1. Thus some additional encoding may be performed to reap the advantage of the design with the smallest number of hypotheses. For instance, example 1 can use an encoding technique to map 24 hypotheses onto 25=32 available code points. Otherwise, it seems more attractive to choose example 3 as the 5-bit payload carries more precoding hypotheses.
Table 3 shows a first example of sub-sampling of codebook C1 with 5-bit RI+W1.









TABLE 3







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8


2
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8


3
0, 2 (no overlap)
2


4
0, 2 (no overlap)
2


5
0 (fixed precoding)
1


6
0 (fixed precoding)
1


7
0 (fixed precoding)
1


8
0
1








Total no. hypotheses across ranks,
24, 5 bits


required coding bits









Table 4 shows a second example of sub-sampling of codebook C1 with 5-bit RI+W1.









TABLE 4







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8


2
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8


3
0, 1, 2, 3 (all)
4


4
0, 1, 2, 3 (all)
4


5
0 (fixed precoding)
1


6
0 (fixed precoding)
1


7
0 (fixed precoding)
1


8
0
1








Total no. hypotheses across ranks,
28, 5 bits


required coding bits









Table 5 shows a third example of sub-sampling of codebook C1 with 5-bit RI+W1.









TABLE 5







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8


2
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8


3
0, 1, 2, 3 (all)
4


4
0, 1, 2, 3 (all)
4


5
0, 1 (use 2 out of 4)
2


6
0, 1 (use 2 out of 4)
2


7
0, 1 (use 2 out of 4)
2


8
0
1








Total no. hypotheses across ranks, required
31, 5 bits


coding bits









Table 6 shows a fourth example of sub-sampling of codebook C1 with 5-bit RI+W1.









TABLE 6







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8


2
0-15
16 


3
0, 2 (no overlap)
2


4
0, 2 (no overlap)
2


5
0 (fixed precoding)
1


6
0 (fixed precoding)
1


7
0 (fixed precoding)
1


8
0
1








Total no. hypotheses across ranks, required
32, 5 bits


coding bits









Table 7 shows a fifth example of sub-sampling of codebook C1 with 5-bit RI+W1.









TABLE 7







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0-15
16 


2
0, 2, 4, 6, 8, 10, 12, 14 (no
8



overlap)


3
0, 2 (no overlap)
2


4
0, 2 (no overlap)
2


5
0 (fixed precoding)
1


6
0 (fixed precoding)
1


7
0 (fixed precoding)
1


8
0
1








Total no. hypotheses across ranks,
32, 5 bits


required coding bits









As an alternative, it is possible for the RI/W1 payload to be UE-specific. Thus the RI/W1 payload varies as a function of the UE category, such as a maximum number of layers supported in downlink data transmission in PDSCH or number of UE receive antennas. For example, if a UE has only two receive antennas or can receive up to 2 layers in downlink data transmission, RI+W1 reporting is limited to RI=1 or RI=2. Hence in Tables 3-7 the payload of RI/W1 is determined by the total entries in RI=1 and RI=2. This is already supported in Rel. 8 where the RI bit width can be 1 or 2 bits based on UE category. Thus the payload of RI/W1 may be reduced to 4 bits or sub-sampling may not be performed for 2 Rx and 4 Rx UE with 5-bits RI/W1. Tables 8 to 14 show a number of exemplary sub-sampling cases.
Table 8 shows a sub-sampling of codebook C1 for 4-bit RI+W1 for a 2-layer capable UE (2 RX).









TABLE 8







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8


2
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8








Total no. hypotheses across ranks,
16, 4 bits


required coding bits









Table 9 shows sub-sampling of codebook C1 for 5-bit RI+W1 for a 2-layer capable UE (2 RX) with no sub-sampling.









TABLE 9







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0-15
16


2
0-15
16








Total no. hypotheses across ranks,
32, 5 bits


required coding bits









Table 10 shows sub-sampling of codebook C1 for 5-bit RI+W1 for 2-layer capable UE (2 RX).









TABLE 10







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
 8


2
0-15
16








Total no. hypotheses across ranks,
24, 5 bits


required coding bits









Table 11 shows sub-sampling of codebook C1 for 5-bit RI+W1 for 2-layer capable UE (2 RX).









TABLE 11







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0-15
16


2
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
 8








Total no. hypotheses across ranks,
24, 5 bits


required coding bits









Table 12 shows sub-sampling of codebook C1 5-bit RI+W1 for 4-layer capable UE (4 RX).









TABLE 12







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8


2
0-15
16 


3
0-3
4


4
0-3
4








Total no. hypotheses across ranks,
32, 5 bits


required coding bits









Table 13 shows sub-sampling of codebook C1 with 5-bit RI+W1 for 4-layer capable UE (4 RX).









TABLE 13







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0-15
16 


2
0, 2, 4, 6, 8, 10, 12, 14 (no
8



overlap)


3
0-3
4


4
0-3
4








Total no. hypotheses across ranks,
32, 5 bits


required coding bits









Table 14 shows sub-sampling of codebook C for 5-bit RI+W1 for 4-layer capable UE (4 RX).









TABLE 14







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8


2
0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8


3
0-3
4


4
0-3
4










Total no. hypotheses across ranks,
24, 5 bits



required coding bits









The maximum payload associated with RI depends on the UE capability of the maximum number of layers. The codebook sub-sampling scheme for a given rank or across the ranks can be designed so that it is not dependent on the UE capability in terms of the maximum number of layers. Table 15 shows an example. For ranks 5 to 7, it is possible to utilize only one 1 of 4 available W1 matrices if fixed preceding is desired. This nets to a total of 24 hypotheses. This can be done if reducing the total number of hypotheses from 27 to 24 is beneficial despite the same payload of 5 bits. Such a scenario is possible if the reserved (unused) hypotheses can be used for other purposes. In addition the use of some additional channel coding is applied on top of the (20,N) Reed-Muller code to improve error protection.
Table 15 shows an example codebook sub-sampling scheme for CSI mode 1 report 1.









TABLE 15







No. W1


RI
Chosen W1 index for sub-sampling (i1)
hypotheses







1
0, 2, 4, 6, 8, 10, 12, 14 (no
8



overlapping beams)



2
0, 2, 4, 6, 8, 10, 12, 14 (no
8



overlapping beams)



3
0, 2 (no overlapping beams)
2


4
0, 2 (no overlapping beams)
2


5
0, 1 (use 2 out of 4)
2


6
0, 1 (use 2 out of 4)
2


7
0, 1 (use 2 out of 4)
2


8
0
1



Total no. W1 + RI hypotheses across
16, 4 bits



ranks 1-2 (max. layers = 2),




required coding bits




Total no. W1 + RI hypotheses across
20, 4 bits



ranks 1-4 (max. layers = 4),




required coding bits




Total no. W1 + RI hypotheses across
27, 5 bits



ranks 1-8 (max. layers = 8),




required coding bits









CSI Mode 2 Report 2 (CQI, W1+W2)

In this case, the total payload of CQI together with W1+W2 should not exceed 11 bits to ensure the same worst-case coverage as the Rel. 8 format 2/2a/2b. Hence, the following actions are performed to attain such goal when sub-sampling is performed on the codebook C1+C2 for W1+W2:
To maintain the maximum overhead of 11 bits:
RI=1: Since CQI occupies 4 bits, the payload for W1+W2 should not exceed 7 bits
RI>1: Since CQI occupies 7 bits, the payload for W1+W2 should not exceed 4 bits
Joint encoding of W1 and W2 should be performed whenever possible: This ensures efficient signaling of W1+W2 with minimum overhead.
Overlapping beams between two different W1 matrices can be skipped whenever appropriate as overlapping beam can be seen as an optimization feature.
Since precoding gain is expected to be small for higher-rank transmission (rank>4), fixed precoding (using only one W1 matrix) should also be considered whenever appropriate.
Sub-sampling of C1 and C2 can also be performed jointly rather than separately.
Keeping the above principles in mind, three exemplary W1+W2 codebook sub-sampling schemes are given below in Tables 16 to 19.
Table 16 shows a first example of sub-sampling of codebook C1+C2.










FIG. 16











No. W1 + W2


RI
Chosen W1 + W2 index for sub-sampling
hypotheses





1
W1: 0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8 × 8 = 64,



(i1)
6 bits



W2: for each W1, choose only Y = e1 and e3




with all 4 possible co-phasing [note:




this resembles (N, Nb) = (16, 1) design]




(i2 = 0-3, 8-11)



2
W1: 0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8 × 2 = 18,



(i1)
4 bits



W2: for each W1, choose only (Y1, Y2) = (e1, e1)




with all 2 possible co-phasing [note:




this resembles (N, Nb) = (8, 1) design]




(i2 = 0-1)



3
W1: 0, 2 (no overlap) (i1)
2 × 8 = 16,



W2: for each W1, choose only 8 out of 16
4 bits



possible (Y1, Y2), e.g. the even indexed




or the last 8




(i2 = 0, 2, . . . 14 or 8-15)



4
W1: 0, 2 (no overlap) (i1)
2 × 8 = 16



W2: all
4 bits


5
W1: 0 (fixed precoding) (i1)
1, 0 bit


6
W1: 0 (fixed precoding) (i1)
1, 0 bit


7
W1: 0 (fixed precoding) (i1)
1, 0 bit


8
W1: 0 (i1)
1, 0 bit









Table 17 shows a second example sub-sampling of codebook C1+C2.









TABLE 17







No. W1 + W2


RI
Chosen W1 + W2 index for sub-sampling
hypotheses







1
W1: all (i1)
16 × 4 = 64,



W2: for each W1, choose only Y = e1 with all 4
6 bits



possible co-phasing [note: this




resembles (N, Nb) = (16, 1) design]




(i2 = 0-3)



2
W1: 0, 2, 4, 6, 8, 10, 12, 14 (no overlap)
8 × 2 = 18,



(i1)
4 bits



W2: for each W1, choose only (Y1, Y2) = (e1, e1)




with all 2 possible co-phasing [note:




this resembles (N, Nb) = (8, 1) design]




(i2 = 0-1)



3
W1: 0, 2 (no overlap) (i1)
2 × 8 = 16,



W2: for each W1, choose only 8 out of 16
4 bits



possible (Y1, Y2), e.g. the even indexed




or the last 8




(i2 = 0, 2, . . . 14 or 8-15)



4
W1: 0, 2 (no overlap) (i1)
2 × 8 = 16,



W2: all
4 bits


5
W1: 0 (fixed precoding) (i1)
1, 0 bit


6
W1: 0 (fixed precoding) (i1)
1, 0 bit


7
W1: 0 (fixed precoding) (i1)
1, 0 bit


8
W1: 0 (i1)
1, 0 bit









Table 18 shows a third example of sub-sampling of codebook C1+C2.









TABLE 18







No. W1 + W2


RI
Chosen W1 + W2 index for sub-sampling
hypotheses







1
W1: 0, 2, 4, 6, 8, 10, 12, 14 (no
8 × 16 = 128,



overlap) (i1)
7 bits



W2: all [note: maximum refinement gain




for frequency selective




precoding]



2
W1: 0, 2, 4, 6, 8, 10, 12, 14 (no
8 × 2 = 16,



overlap) (i1)
4 bits



W2: for each W1, choose only




(Y1, Y2) = (e1, e1) with all 2




possible co-phasing [note: this




resembles (N, Nb) = (8, 1) design]




(i2 = 0-1)



3
W1: 0, 2 (no overlap) (i1)
2 × 8 = 16,



W2: for each W1, choose only 8 out of
4 bits



16 possible (Y1, Y2), e.g. the




even indexed or the last 8




(i2 = 0, 2, . . . 14 or 8-15)



4
W1: 0, 2 (no overlap) (i1)
2 × 8 = 16,



W2: all
4 bits


5
W1: 0 (fixed precoding) (i1)
1, 0 bit


6
W1: 0 (fixed precoding) (i1)
1, 0 bit


7
W1: 0 (fixed precoding) (i1)
1, 0 bit


8
W1: 0 (i1)
1, 0 bit









Table 19 shows a fourth example of sub-sampling of codebook C1+C2.









TABLE 19







No. W1 + W2


RI
Chosen W1 + W2 index for sub-sampling
hypotheses







1
W1: all (i1)
16 × 8 = 128,



W2: for each W1, choose only Y = e1 and
7 bits



e2 with all 4 possible co-phasing




[note: this resembles




(N, Nb) = (32, 1) design]




(i2 = 0-7)



2
W1: 0, 2, 4, 6, 8, 10, 12, 14 (no
8 × 2 = 18,



overlap) (i1)
4 bits



W2: for each W1, choose only




(Y1, Y2) = (e1, e1) with all 2




possible co-phasing [note: this




resembles (N, Nb) = (8, 1) design]




(i2 = 0-1)



3
W1: 0, 2 (no overlap) (i1)
2 × 8 = 16,



W2: for each W1, choose only 8 out of
4 bits



16 possible (Y1, Y2), e.g. the




even indexed or the last 8




(i2 = 0, 2, . . . 14 or 8-15)



4
W1: 0, 2 (no overlap) (i1)
2 × 8 = 16,



W2: all
4 bits


5
W1: 0 (fixed precoding) (i1)
1, 0 bit


6
W1: 0 (fixed precoding) (i1)
1, 0 bit


7
W1: 0 (fixed precoding) (i1)
1, 0 bit


8
W1: 0 (i1)
1, 0 bit









For any of the above exemplary designs, it is possible to combine a part of one example with other part(s) from other examples. Furthermore, it is possible to use more than one (e.g. 2 or all 4) W1 matrices for ranks 5, 6 and 7 for any of the above examples in Tables 16 to 19.
Feedback Payload Analysis
Based on the above codebook sub-sampling designs, the payload associated with each CSI mode can be compared below.
Table 20 shows a payload comparison for PUCCH mode 1-1 (bits).











TABLE 20








CSI mode 1

CSI mode 2












RI
Report 1
Report 2
Report 1
Report 2














1
5 (**)
8
3
10/11


2
5 (**)
11
3
11


3
5 (**)
11
3
11


4
5 (**)
10
3
11


5
5
7
3
7 to 9 (*)


6
5
7
3
7 to 9 (*)


7
5
7
3
7 to 9 (*)


8
5
7
3
 7





For entries marked with (*) the result depends on how many W1 precoding matrices are used for ranks 5, 6, and 7. Entries marked (**) may be reduced to 4 bits if RI/W1 payload is to be variable and UE-specific depending on the UE category, for example the number of UE receive antennas or the maximum number of layers.






Codebook Sub-Sampling for PUSCH

PUSCH feedback mode for 8 TX supports natural extension of Rel. 8 PUSCH reporting mode (1-2, 2-2, 3-1) under the double-codebook structure and considers Mode 3-2 with sub-band PMI+CQI for CQI accuracy enhancement in Rel. 10. Considering the potentially larger payload and the use of carrier aggregation, the feedback overhead is reduced via codebook sub-sampling even further especially for the modes with sub-band PMI such as mode 1-2 and 3-2. Since W1 is wideband, there is no need to apply codebook sub-sampling in this case as the overhead is small relative to the rests. Codebook sub-sampling is applied only to W2 in the context of PUSCH reporting modes 1-2 and 3-2.
Codebook sub-sampling may be more compelling for mode 3-2. This is because the sub-band W2 payload size is {4,4,4,3} bits for rank {1,2,3,4}, which is also comparable to the payload in Rel. 8 mode 1-2. On the other hand, mode 3-2 consists of both sub-band CQI and sub-band PMI.
For the standard 8 TX codebook, W2 codebook sub-sampling can be performed in different manners. The W1 codebook is not sub-sampled and all the possible W1 matrices are used. Some exemplary W2 codebook sub-sampling schemes for different sub-sampling size are given in Table 21. While this is not exhaustive, the schemes given in Table 21 are expected to perform well. Note the design in Table 21 satisfies a nested property, so that the 1-bit W2 codebook is a subset of 2-bit W2 codebook. Thus a 2-bit W2 codebook is a subset of the 3-bit W2 codebook.
Table 21 shows different W2 codebook sub-sampling schemes for PUSCH.








TABLE 21







W2 sub-



sampling
W2 sub-sampled codebook











size
Rank 1
Rank 2
Rank 3
Rank 4





1-bit
Y = e1 with
(Y1, Y2) = [e1, e1]
Choose only
Y = [e1 e5]



only 2 out
with all 2
2 out of 16
with all 2



of 4
co-phasing
possible
co-phasing



possible
(Note this
(Y1, Y2),
(Note this



co-phasing
corresponds to
e.g. (e1, [e1
corresponds



(e.g. BPSK
i2 = 0, 1)
e5]) or([e1
to i2 = 0, 1)



only +/−1)

e5], e5)




(Note this

(Note this




corresponds

corresponds




to i2 = 0, 2)

to i2 = 0, 2)



2-bit
Y = e1 with
(Y1, Y2) = [e1, e1]
Choose only
Y = [e1 e5] or



all 4
or [e3, e3] with
4 out of 16
[e3 e7] with



co-phasing
all 2
possible
all 2



(Note this
co-phasing
(Y1, Y2),
co-phasing



corresponds
(Note this
e.g. (e1, [e1
(Note this



to i2 = 0, 1,
corresponds to
e5]),
corresponds



2, 3)
i2 = 0, 1, 4, 5)
(e3, [e3
to i2 = 0, 1,





e7]), ([e1
4, 5)





e5], e5), or






([e3 e7], e7)






(Note this






corresponds






to i2 = 0, 2,






8, 10)



3-bit
Y = e1 or e3
(Y1, Y2) = [e1, e1]
Choose only
No



with all 4
or [e2,
8 out of 16
sub-sampling



co-phasing
e2], [e3, e3], or
possible
(full set)



(Note this
[e4, e4] with
(Y1, Y2),




corresponds
all 2
e.g. the




to i2 = 0-3
co-phasing
even indexed




and 8-11)
(Note this
or the last 8





corresponds to
(Note this





i2 = 0-7)
corresponds






to i2 = 0, 2, . . .






14, or






i2 = 8-15)



4-bit
No
No sub-sampling
No
n/a



sub-sampling
(full set)
sub-sampling




(full set)

(full set)









For rank-2 with 3-bit sub-sampling, instead of choosing (Y1,Y2)=[e1,e1] or [e2,e2], [e3,e3], or [e4,e4], this invention chooses a N1 precoders from {[e1,e1], [e2, e2], [e3,e3], [e4,e4]} with 2-co-phasing and chooses a N2 precoders from {[e1 e2], [e2 e3], [e1 e4], [e2 e4]} with 2 co-phasing, where N1+N2=8. Achieves a good performance tradeoff between ULA and XPD antenna configurations. Example:
W2={[e1,e1], [e3, e3], [e1,e2], and [e1,e4]}, with 2-co-phasing;
W2={[e1,e1], [e3, e3], [e1,e2], and [e2,e4]}, with 2-co-phasing; and
W2={[e1,e1], [e3, e3], [e1,e4], and [e2,e4]}, with 2-co-phasing.
In these examples, it is possible to replace {[e1,e1], [e3,e3]} with {[e2,e2, [e4,e4]}. It is also possible to replace [e1,e2] with [e2,e3]. Similarly, for rank-2 with 2-bit sub-sampling, it is possible to replace [e3,e3] with [e1,e2], or [e2,e3], or [e1,e4] or [e2,e4].
For rank-3, sub-sampling can be designed slightly differently. A few examples are listed in Table 22. For a 3-bit rank-3 codebook, this invention chooses 8 out of 16 possible codebook entries. The nested property can be ensured where the 1-bit W2 is a subset of the 2-bit W2, while 1⁄2 bit W2 are subsets of 3-bits W2 codebook. This is satisfied in examples 1, 2 and 3.
Table 22 shows different W2 codebook sub-sampling schemes for PUSCH for Rank-3.











TABLE 22





W2 sub-






sampling
Example 1
Example 2
Example 3
Example 4


size
Rank 3
Rank 3
Rank 3
Rank 3







1-bit
Choose only
Choose only
Choose only
Choose only



2 out of 16
2 out of 16
2 out of 16
2 out of 16



possible
possible
possible
possible



(Y1, Y2),
(Y1, Y2),
(Y1, Y2),
(Y1, Y2),



e.g. (e1, [e1
e.g. (e1, [e1
e.g. (e1, [e1
e.g. (e1, [e1



e5]) or([e1
e5]) or([e5
e5]) or([e1
e5]) or([e5



e5], e5)
e1], e1)
e5], e5)
e1], e1)



(Note this
(Note this
(Note this
(Note this



corresponds
corresponds
corresponds
corresponds



to i2 = 0, 2)
to i2 = 0, 3)
to i2 = 0, 2)
to i2 = 0, 3)


2-bit
Choose only
Choose only
Choose only
Choose only



4 out of 16
4 out of 16
4 out of 16
4 out of 16



possible
possible
possible
possible



(Y1, Y2),
(Y1, Y2),
(Y1, Y2),
(Y1, Y2),



e.g. (e1, [e1
e.g. (e1, [e1
e.g. (e1, [e1
e.g. (e1, [e1



e5]),
e5]),
e5]),
e5]),



(e3, [e3
(e3, [e3
(e3, [e3
(e3, [e3



e7]), ([e1
e7]), ([e5
e7]), ([e1
e7]), ([e5



e5], e5), or
e1], e1), or
e5], e5), or
e1], e1), or



([e3 e7], e7)
([e7 e3], e3)
([e3 e7], e7)
([e7 e3], e3)



(Note this
(Note this
(Note this
(Note this



corresponds
corresponds
corresponds
corresponds



to i2 = 0, 2,
to i2 = 0, 3,
to i2 = 0, 2,
to i2 = 0, 3,



8, 10)
8, 11)
8, 10)
8, 11)


3-bit
Choose 8 out
Choose 8 out
Choose only
Choose only



of 16
of 16
8 out of 16
8 out of 16



possible
possible
possible
possible



(Y1, Y2),
(Y1, Y2),
(Y1, Y2),
(Y1, Y2),



e.g. even
e.g. even
e.g. the
e.g. the



indexed
indexed
even indexed
even indexed



entries from
entries from
(Note this
(Note this



the codebook
the codebook
corresponds
corresponds



(Note this
(Note this
to i2 = 0,
to i2 = 0,



corresponds
corresponds
2, . . . 14
2, . . . 14



to i2 = 0, 1,
to i2 = 0, 1,





2, 3, 8, 9,
2, 3, 8, 9,





10, 11)
10, 11)




4-bit
No
No
No
No



sub-sampling
sub-sampling
sub-sampling
sub-sampling



(full set)
(full set)
(full set)
(full set)









We further note the following. For rank 1 it is possible to sub-sample the W2 such that Y=[e1] with all 4 co-phasing are chosen. In this case the effective rank-1 codebook becomes [N, Nb]=[16,1] design with no sub-sampling for W1. The payload size for subband W2 is then reduced to 2 bits. For rank 3 it is also possible to sub-sample the W2 codebook such that every 4th of the 16 possible (Y1, Y2) are chosen. This results in the following W2 codebook. The payload size of subband W2 is then reduced to 2-bits.




  
    
      
        W
        2
      
      ∈
      
        C
        2
      
    
    =
    
      {
      
        
          1
          
            2
          
        
        ⁡
        
          [
          
            
              
                
                  Y
                  1
                
              
              
                
                  Y
                  2
                
              
            
            
              
                
                  Y
                  1
                
              
              
                
                  -
                  
                    Y
                    2
                  
                
              
            
          
          ]
        
      
      }
    
  
  ,
  
    
      (
      
        
          Y
          1
        
        ,
        
          Y
          2
        
      
      )
    
    ∈
    
      {
      
        
          
            
              (
              
                
                  e
                  1
                
                ,
                
                  [
                  
                    
                      e
                      1
                    
                    ⁢
                    
                      e
                      5
                    
                  
                  ]
                
              
              )
            
          
        
        
          
            
              (
              
                
                  e
                  5
                
                ,
                
                  [
                  
                    
                      e
                      1
                    
                    ⁢
                    
                      e
                      5
                    
                  
                  ]
                
              
              )
            
          
        
        
          
            
              (
              
                
                  [
                  
                    
                      e
                      1
                    
                    ⁢
                    
                      e
                      5
                    
                  
                  ]
                
                ,
                
                  e
                  5
                
              
              )
            
          
        
        
          
            
              (
              
                
                  [
                  
                    
                      e
                      5
                    
                    ⁢
                    
                      e
                      1
                    
                  
                  ]
                
                ,
                
                  e
                  1
                
              
              )
            
          
        
      
      }
    
  




For rank-4, it is possible to further sub-sample the W2 codebook such that only [e1 e5] and [e3 e7] are chosen for [Y1, Y2]. The payload size of subband W2 is then reduced to 2 bits.





  
    
      
        W
        2
      
      ∈
      
        C
        2
      
    
    =
    
      {
      
        
          
            1
            
              2
            
          
          ⁡
          
            [
            
              
                
                  Y
                
                
                  Y
                
              
              
                
                  Y
                
                
                  
                    -
                    Y
                  
                
              
            
            ]
          
        
        ,
        
          
            1
            
              2
            
          
          ⁡
          
            [
            
              
                
                  Y
                
                
                  Y
                
              
              
                
                  jY
                
                
                  
                    -
                    jY
                  
                
              
            
            ]
          
        
      
      }
    
  
  ,
  
    Y
    ∈
    
      {
      
        
          [
          
            
              e
              1
            
            ⁢
            
              e
              5
            
          
          ]
        
        ,
        
          [
          
            
              e
              3
            
            ⁢
            
              e
              7
            
          
          ]
        
      
      }
    
  




Thus one may generate any sub-sampling scheme with a combination of the schemes given in Table 22, where the sub-sampling size for rank-n (n=1, . . . 8) are different possibly. Some examples are given in Tables 23 to 25.

Table 23 is an example of combination with different sizes across different ranks









TABLE 23







No. W2




hypotheses


RI
Chosen W2 index for sub-sampling
(bits)







1
Y = e1 with all 4 possible
W2 payload:



co-phasing
log2(4) = 2 bits


2
Choose only (Y1, Y2) = (e1, e1) with
W2 payload:



all 2 possible co-phasing
log2(2) = 1 bit


3
Choose only 4 out of 16 possible
W2 payload:



(Y1, Y2), e.g. every 4th entry
log2(4) = 2 bits


4
[Y1 Y2] = [e1, e5] and [e3 e7]
W2 payload:




log2(4) = 2 bits


5
All
1, 0 bit


6
All
1, 0 bit


7
All
1, 0 bit


8
All
1, 0 bit









Table 23 is an example of combination with different sizes across different ranks.









TABLE 24







No. W2




hypotheses


RI
Chosen W2 index for sub-sampling
(bits)







1
Y = e1 and e3 with all 4 possible
W2 payload:



co-phasing
log2(8) = 3 bits


2
Choose only (Y1, Y2) = (e1, e1) with
W2 payload:



all 2 possible co-phasing
log2(2) = 1 bits


3
Choose only 8 out of 16 possible
W2 payload:



(Y1, Y2), e.g. the even
log2(8) = 3 bits



indexed or the last 8



4
All
1, 0 bit


5
All
1, 0 bit


6
All
1, 0 bit


7
All
1, 0 bit


8
All
1, 0 bit









Table 25 is an example of this combination with different sizes across different ranks.









TABLE 25







No. W2



Chosen W2 index for
hypotheses


RI
sub-sampling
(bits)







1
Y = e1 and e3 with all 4
W2 payload:



possible co-phasing
log2(8) = 3 bits


2
Choose only (Y1, Y2) = (e1, e1) or
W2 payload:



(e3, e3) with all 2
log2(4) = 2 bits



co-phasing



3
Choose only 4 out of 16
W2 payload:



possible (Y1, Y2), e.g.
log2(4) = 2 bits



every 4th entry



4
[Y1 Y2] = [e1, e5] and [e3 e7]
W2 payload:




log2(4) = 2 bits


5
All
1, 0 bit


6
All
1, 0 bit


7
All
1, 0 bit


8
All
1, 0 bit









The agreed standard 8 TX codebook can be written as shown below. The composite precoder W is derived from W=W1*W2. The following notation is used:
ēn denotes a 4×1 selection vector with all zeros except for the n-th element with value 1; and
en denotes an 8×1 selection vector with all zeros except for the n-th element with value 1.
Rank 1 and 2:



  
    
      B
      =
      
        [
        
          
            b
            0
          
          ,
          
            
              b
              1
            
            ⁢
            
              
            
            ⁢
            ...
            ⁢
            
              
            
            ⁢
            
              b
              31
            
          
        
        ]
      
    
    ,
    
      
        
          [
          B
          ]
        
        
          
            1
            +
            m
          
          ,
          
            1
            +
            n
          
        
      
      =
      
        e
        
          j
          ⁢
          
            
              2
              ⁢
              π
              ⁢
              
                
              
              ⁢
              mn
            
            32
          
        
      
    
    ,
    
      m
      =
      0
    
    ,
    1
    ,
    2
    ,
    3
    ,
    
      n
      =
      0
    
    ,
    1
    ,
    ...
    ⁢
    
      
    
    ,
    
      
        31
        ⁢
        
          

        
        ⁢
        
          X
          
            (
            k
            )
          
        
      
      ∈
      
        {
        
          
            
              
                [
                
                  
                    b
                    
                      2
                      ⁢
                      k
                      ⁢
                      
                        
                      
                      ⁢
                      mod
                      ⁢
                      
                        
                      
                      ⁢
                      32
                    
                  
                  ⁢
                  
                    b
                    
                      
                        (
                        
                          
                            2
                            ⁢
                            k
                          
                          +
                          1
                        
                        )
                      
                      ⁢
                      mod
                      ⁢
                      
                        
                      
                      ⁢
                      32
                    
                  
                  ⁢
                  
                    b
                    
                      
                        (
                        
                          
                            2
                            ⁢
                            k
                          
                          +
                          2
                        
                        )
                      
                      ⁢
                      mod
                      ⁢
                      
                        
                      
                      ⁢
                      32
                    
                  
                  ⁢
                  
                    b
                    
                      
                        (
                        
                          
                            2
                            ⁢
                            k
                          
                          +
                          3
                        
                        )
                      
                      ⁢
                      mod
                      ⁢
                      
                        
                      
                      ⁢
                      32
                    
                  
                
                ]
              
              ⁢
              
                :
              
              ⁢
              
                
              
              ⁢
              k
            
            =
            0
          
          ,
          1
          ,
          ...
          ⁢
          
            
          
          ,
          15
        
        }
      
    
  




  
    
      
    
    ⁢
    
      
        
          W
          1
          
            (
            k
            )
          
        
        =
        
          [
          
            
              
                
                  X
                  
                    (
                    k
                    )
                  
                
              
              
                0
              
            
            
              
                0
              
              
                
                  X
                  
                    (
                    k
                    )
                  
                
              
            
          
          ]
        
      
      ,
      
        
          C
          1
        
        =
        
          
            {
            
              
                W
                1
                
                  (
                  0
                  )
                
              
              ,
              
                W
                1
                
                  (
                  1
                  )
                
              
              ,
              
                W
                1
                
                  (
                  2
                  )
                
              
              ,
              ...
              ⁢
              
                
              
              ,
              
                W
                1
                
                  (
                  15
                  )
                
              
            
            }
          
          ⁢
          
            

          
          ⁢
          
            
              
                Rank
                ⁢
                
                  
                
                ⁢
                1
                ⁢
                
                  :
                
                ⁢
                
                  
                
                ⁢
                
                  W
                  2
                
              
              ∈
              
                C
                2
              
            
            =
            
              {
              
                
                  
                    1
                    
                      2
                    
                  
                  ⁡
                  
                    [
                    
                      
                        
                          Y
                        
                      
                      
                        
                          Y
                        
                      
                    
                    ]
                  
                
                ,
                
                  
                    1
                    
                      2
                    
                  
                  ⁡
                  
                    [
                    
                      
                        
                          Y
                        
                      
                      
                        
                          jY
                        
                      
                    
                    ]
                  
                
                ,
                
                  
                    1
                    
                      2
                    
                  
                  ⁡
                  
                    [
                    
                      
                        
                          Y
                        
                      
                      
                        
                          
                            -
                            Y
                          
                        
                      
                    
                    ]
                  
                
                ,
                
                  
                    1
                    
                      2
                    
                  
                  ⁡
                  
                    [
                    
                      
                        
                          Y
                        
                      
                      
                        
                          
                            -
                            jY
                          
                        
                      
                    
                    ]
                  
                
              
              }
            
          
        
      
      ,
      
        

      
      ⁢
      
        
      
      ⁢
      
        Y
        ∈
        
          {
          
            
              
                e
                ~
              
              1
            
            ,
            
              
                e
                ~
              
              2
            
            ,
            
              
                e
                ~
              
              3
            
            ,
            
              
                e
                ~
              
              4
            
          
          }
        
      
    
  




  
    
      
        Rank
        ⁢
        
          
        
        ⁢
        2
        ⁢
        
          :
        
        ⁢
        
          
        
        ⁢
        
          W
          2
        
      
      ∈
      
        C
        2
      
    
    =
    
      {
      
        
          
            1
            
              2
            
          
          ⁡
          
            [
            
              
                
                  Y
                
              
              
                
                  Y
                
              
            
            ]
          
        
        ,
        
          
            1
            
              2
            
          
          ⁡
          
            [
            
              
                
                  Y
                
              
              
                
                  jY
                
              
            
            ]
          
        
        ,
        
          
            1
            
              2
            
          
          ⁡
          
            [
            
              
                
                  Y
                
              
              
                
                  
                    -
                    Y
                  
                
              
            
            ]
          
        
        ,
        
          
            1
            
              2
            
          
          ⁡
          
            [
            
              
                
                  Y
                
              
              
                
                  
                    -
                    jY
                  
                
              
            
            ]
          
        
      
      }
    
  




  
    
      (
      
        
          Y
          1
        
        ,
        
          Y
          1
        
      
      )
    
    ∈
    
      {
      
        
          (
          
            
              
                e
                ~
              
              1
            
            ,
            
              
                e
                ~
              
              1
            
          
          )
        
        ,
        
          (
          
            
              
                e
                ~
              
              2
            
            ,
            
              
                e
                ~
              
              2
            
          
          )
        
        ,
        
          (
          
            
              
                e
                ~
              
              3
            
            ,
            
              
                e
                ~
              
              3
            
          
          )
        
        ,
        
          (
          
            
              
                e
                ~
              
              4
            
            ,
            
              
                e
                ~
              
              4
            
          
          )
        
        ,
        
          (
          
            
              
                e
                ~
              
              1
            
            ,
            
              
                e
                ~
              
              2
            
          
          )
        
        ,
        
          (
          
            
              
                e
                ~
              
              2
            
            ,
            
              
                e
                ~
              
              3
            
          
          )
        
        ,
        
          (
          
            
              
                e
                ~
              
              1
            
            ,
            
              
                e
                ~
              
              4
            
          
          )
        
        ,
        
          (
          
            
              
                e
                ~
              
              2
            
            ,
            
              
                e
                ~
              
              4
            
          
          )
        
      
      }
    
  



Rank 3 and 4:




  
    
      
    
    ⁢
    
      
        B
        =
        
          [
          
            
              b
              0
            
            ,
            
              
                b
                1
              
              ⁢
              
                
              
              ⁢
              ...
              ⁢
              
                
              
              ⁢
              
                b
                15
              
            
          
          ]
        
      
      ,
      
        
          
            [
            B
            ]
          
          
            
              1
              +
              m
            
            ,
            
              1
              +
              n
            
          
        
        =
        
          e
          
            j
            ⁢
            
              
                2
                ⁢
                π
                ⁢
                
                  
                
                ⁢
                mn
              
              16
            
          
        
      
      ,
      
        

      
      ⁢
      
        
      
      ⁢
      
        m
        =
        0
      
      ,
      1
      ,
      2
      ,
      3
      ,
      
        n
        =
        0
      
      ,
      1
      ,
      ...
      ⁢
      
        
      
      ,
      15
    
  




  
    
      
    
    ⁢
    
      
        X
        
          (
          k
          )
        
      
      ∈
      
        {
        
          
            
              
                [
                
                  
                    b
                    
                      4
                      ⁢
                      k
                      ⁢
                      
                        
                      
                      ⁢
                      mod
                      ⁢
                      
                        
                      
                      ⁢
                      16
                    
                  
                  ⁢
                  
                    b
                    
                      
                        (
                        
                          
                            4
                            ⁢
                            k
                          
                          +
                          1
                        
                        )
                      
                      ⁢
                      mod
                      ⁢
                      
                        
                      
                      ⁢
                      16
                    
                  
                  ⁢
                  
                    
                  
                  ⁢
                  ...
                  ⁢
                  
                    
                  
                  ⁢
                  
                    b
                    
                      
                        (
                        
                          
                            4
                            ⁢
                            k
                          
                          +
                          7
                        
                        )
                      
                      ⁢
                      mod
                      ⁢
                      
                        
                      
                      ⁢
                      16
                    
                  
                
                ]
              
              ⁢
              
                :
              
              ⁢
              
                
              
              ⁢
              k
            
            =
            0
          
          ,
          1
          ,
          2
          ,
          3
        
        }
      
    
  




  
    
      
    
    ⁢
    
      
        
          W
          1
          
            (
            k
            )
          
        
        =
        
          [
          
            
              
                
                  X
                  
                    (
                    k
                    )
                  
                
              
              
                0
              
            
            
              
                0
              
              
                
                  X
                  
                    (
                    k
                    )
                  
                
              
            
          
          ]
        
      
      ,
      
        
          C
          1
        
        =
        
          {
          
            
              W
              1
              
                (
                0
                )
              
            
            ,
            
              W
              1
              
                (
                1
                )
              
            
            ,
            
              W
              1
              
                (
                2
                )
              
            
            ,
            ...
            ⁢
            
              
            
            ,
            
              W
              1
              
                (
                3
                )
              
            
          
          }
        
      
    
  




  
    
      
    
    ⁢
    
      
        
          
            Rank
            ⁢
            
              
            
            ⁢
            3
            ⁢
            
              :
            
            ⁢
            
              
            
            ⁢
            
              W
              2
            
          
          ∈
          
            C
            2
          
        
        =
        
          {
          
            
              1
              
                2
              
            
            ⁡
            
              [
              
                
                  
                    
                      Y
                      1
                    
                  
                  
                    
                      Y
                      2
                    
                  
                
                
                  
                    
                      Y
                      1
                    
                  
                  
                    
                      -
                      
                        Y
                        2
                      
                    
                  
                
              
              ]
            
          
          }
        
      
      ,
      
        

      
      ⁢
      
        
          (
          
            
              Y
              1
            
            ,
            
              Y
              2
            
          
          )
        
        ∈
        
          {
          
            
              
                
                  
                    (
                    
                      
                        e
                        1
                      
                      ,
                      
                        [
                        
                          
                            e
                            1
                          
                          ⁢
                          
                            e
                            5
                          
                        
                        ]
                      
                    
                    )
                  
                  ,
                  
                    (
                    
                      
                        e
                        2
                      
                      ,
                      
                        [
                        
                          
                            e
                            2
                          
                          ⁢
                          
                            e
                            6
                          
                        
                        ]
                      
                    
                    )
                  
                  ,
                  
                    (
                    
                      
                        e
                        3
                      
                      ,
                      
                        [
                        
                          
                            e
                            3
                          
                          ⁢
                          
                            e
                            7
                          
                        
                        ]
                      
                    
                    )
                  
                  ,
                  
                    (
                    
                      
                        e
                        4
                      
                      ,
                      
                        [
                        
                          
                            e
                            4
                          
                          ⁢
                          
                            e
                            8
                          
                        
                        ]
                      
                    
                    )
                  
                
              
            
            
              
                
                  
                    (
                    
                      
                        e
                        5
                      
                      ,
                      
                        [
                        
                          
                            e
                            1
                          
                          ⁢
                          
                            e
                            5
                          
                        
                        ]
                      
                    
                    )
                  
                  ,
                  
                    (
                    
                      
                        e
                        6
                      
                      ,
                      
                        [
                        
                          
                            e
                            2
                          
                          ⁢
                          
                            e
                            6
                          
                        
                        ]
                      
                    
                    )
                  
                  ,
                  
                    (
                    
                      
                        e
                        7
                      
                      ,
                      
                        [
                        
                          
                            e
                            3
                          
                          ⁢
                          
                            e
                            7
                          
                        
                        ]
                      
                    
                    )
                  
                  ,
                  
                    (
                    
                      
                        e
                        8
                      
                      ,
                      
                        [
                        
                          
                            e
                            4
                          
                          ⁢
                          
                            e
                            8
                          
                        
                        ]
                      
                    
                    )
                  
                
              
            
            
              
                
                  
                    (
                    
                      
                        [
                        
                          
                            e
                            1
                          
                          ⁢
                          
                            e
                            5
                          
                        
                        ]
                      
                      ,
                      
                        e
                        5
                      
                    
                    )
                  
                  ,
                  
                    (
                    
                      
                        [
                        
                          
                            e
                            2
                          
                          ⁢
                          
                            e
                            6
                          
                        
                        ]
                      
                      ,
                      
                        e
                        6
                      
                    
                    )
                  
                  ,
                  
                    (
                    
                      
                        [
                        
                          
                            e
                            3
                          
                          ⁢
                          
                            e
                            7
                          
                        
                        ]
                      
                      ,
                      
                        e
                        7
                      
                    
                    )
                  
                  ,
                  
                    (
                    
                      
                        [
                        
                          
                            e
                            4
                          
                          ⁢
                          
                            e
                            8
                          
                        
                        ]
                      
                      ,
                      
                        e
                        8
                      
                    
                    )
                  
                
              
            
            
              
                
                  
                    (
                    
                      
                        [
                        
                          
                            e
                            5
                          
                          ⁢
                          
                            e
                            1
                          
                        
                        ]
                      
                      ,
                      
                        e
                        1
                      
                    
                    )
                  
                  ,
                  
                    (
                    
                      
                        [
                        
                          
                            e
                            6
                          
                          ⁢
                          
                            e
                            2
                          
                        
                        ]
                      
                      ,
                      
                        e
                        2
                      
                    
                    )
                  
                  ,
                  
                    (
                    
                      
                        [
                        
                          
                            e
                            7
                          
                          ⁢
                          
                            e
                            3
                          
                        
                        ]
                      
                      ,
                      
                        e
                        3
                      
                    
                    )
                  
                  ,
                  
                    (
                    
                      
                        [
                        
                          
                            e
                            8
                          
                          ⁢
                          
                            e
                            4
                          
                        
                        ]
                      
                      ,
                      
                        e
                        4
                      
                    
                    )
                  
                
              
            
          
          }
        
      
    
  




  
    
      
    
    ⁢
    
      
        
          
            Rank
            ⁢
            
              
            
            ⁢
            4
            ⁢
            
              :
            
            ⁢
            
              
            
            ⁢
            
              W
              2
            
          
          ∈
          
            C
            2
          
        
        =
        
          {
          
            
              
                1
                
                  2
                
              
              ⁡
              
                [
                
                  
                    
                      Y
                    
                    
                      Y
                    
                  
                  
                    
                      Y
                    
                    
                      
                        -
                        Y
                      
                    
                  
                
                ]
              
            
            ,
            
              
                1
                
                  2
                
              
              ⁡
              
                [
                
                  
                    
                      Y
                    
                    
                      Y
                    
                  
                  
                    
                      jY
                    
                    
                      
                        -
                        jY
                      
                    
                  
                
                ]
              
            
          
          }
        
      
      ,
      
        

      
      ⁢
      
        
      
      ⁢
      
        Y
        ∈
        
          {
          
            
              [
              
                
                  e
                  1
                
                ⁢
                
                  e
                  5
                
              
              ]
            
            ,
            
              [
              
                
                  e
                  2
                
                ⁢
                
                  e
                  6
                
              
              ]
            
            ,
            
              [
              
                
                  e
                  3
                
                ⁢
                
                  e
                  7
                
              
              ]
            
            ,
            
              [
              
                
                  e
                  4
                
                ⁢
                
                  e
                  8
                
              
              ]
            
          
          }
        
      
    
  



Rank 5 to 7:




  
    
      
    
    ⁢
    
      
        X
        
          (
          k
          )
        
      
      =
      
        diag
        ⁢
        
          {
          
            1
            ,
            
              e
              
                j
                ⁢
                
                  π
                  8
                
                ⁢
                k
              
            
            ,
            
              e
              
                j
                ⁢
                
                  π
                  4
                
                ⁢
                k
              
            
            ,
            
              e
              
                j
                ⁢
                
                  
                    3
                    ⁢
                    π
                  
                  8
                
                ⁢
                k
              
            
          
          }
        
        ×
        
          [
          
            
              
                1
              
              
                1
              
              
                1
              
              
                1
              
            
            
              
                1
              
              
                j
              
              
                
                  -
                  1
                
              
              
                
                  -
                  j
                
              
            
            
              
                1
              
              
                
                  -
                  1
                
              
              
                1
              
              
                
                  -
                  1
                
              
            
            
              
                1
              
              
                
                  -
                  j
                
              
              
                
                  -
                  1
                
              
              
                j
              
            
          
          ]
        
      
    
  




  
    
      
        W
        1
      
      ∈
      
        C
        1
      
    
    =
    
      {
      
        
          [
          
            
              
                
                  X
                  
                    (
                    0
                    )
                  
                
              
              
                0
              
            
            
              
                0
              
              
                
                  X
                  
                    (
                    0
                    )
                  
                
              
            
          
          ]
        
        ,
        
          [
          
            
              
                
                  X
                  
                    (
                    1
                    )
                  
                
              
              
                0
              
            
            
              
                0
              
              
                
                  X
                  
                    (
                    1
                    )
                  
                
              
            
          
          ]
        
        ,
        
          [
          
            
              
                
                  X
                  
                    (
                    2
                    )
                  
                
              
              
                0
              
            
            
              
                0
              
              
                
                  X
                  
                    (
                    2
                    )
                  
                
              
            
          
          ]
        
        ,
        
          [
          
            
              
                
                  X
                  
                    (
                    3
                    )
                  
                
              
              
                0
              
            
            
              
                0
              
              
                
                  X
                  
                    (
                    3
                    )
                  
                
              
            
          
          ]
        
      
      }
    
  




  
    
      
    
    ⁢
    
      
        Rank
        ⁢
        
          
        
        ⁢
        5
        ⁢
        
          :
        
        ⁢
        
          
        
        ⁢
        
          W
          2
        
      
      =
      
        
          1
          
            2
          
        
        ⁡
        
          [
          
            
              
                
                  
                    e
                    ~
                  
                  1
                
              
              
                
                  
                    e
                    ~
                  
                  1
                
              
              
                
                  
                    e
                    ~
                  
                  2
                
              
              
                
                  
                    e
                    ~
                  
                  2
                
              
              
                
                  
                    e
                    ~
                  
                  3
                
              
            
            
              
                
                  
                    e
                    ~
                  
                  1
                
              
              
                
                  -
                  
                    
                      e
                      ~
                    
                    1
                  
                
              
              
                
                  
                    e
                    ~
                  
                  2
                
              
              
                
                  -
                  
                    
                      e
                      ~
                    
                    2
                  
                
              
              
                
                  
                    e
                    ~
                  
                  3
                
              
            
          
          ]
        
      
    
  




  
    
      
    
    ⁢
    
      
        Rank
        ⁢
        
          
        
        ⁢
        6
        ⁢
        
          :
        
        ⁢
        
          
        
        ⁢
        
          W
          2
        
      
      =
      
        
          1
          
            2
          
        
        ⁡
        
          [
          
            
              
                
                  
                    e
                    ~
                  
                  1
                
              
              
                
                  
                    e
                    ~
                  
                  1
                
              
              
                
                  
                    e
                    ~
                  
                  2
                
              
              
                
                  
                    e
                    ~
                  
                  2
                
              
              
                
                  
                    e
                    ~
                  
                  3
                
              
              
                
                  
                    e
                    ~
                  
                  3
                
              
            
            
              
                
                  
                    e
                    ~
                  
                  1
                
              
              
                
                  -
                  
                    
                      e
                      ~
                    
                    1
                  
                
              
              
                
                  
                    e
                    ~
                  
                  2
                
              
              
                
                  -
                  
                    
                      e
                      ~
                    
                    2
                  
                
              
              
                
                  
                    e
                    ~
                  
                  3
                
              
              
                
                  -
                  
                    
                      e
                      ~
                    
                    3
                  
                
              
            
          
          ]
        
      
    
  




  
    
      
    
    ⁢
    
      
        Rank
        ⁢
        
          
        
        ⁢
        7
        ⁢
        
          :
        
        ⁢
        
          
        
        ⁢
        
          W
          2
        
      
      =
      
        
          1
          
            2
          
        
        ⁡
        
          [
          
            
              
                
                  
                    e
                    ~
                  
                  1
                
              
              
                
                  
                    e
                    ~
                  
                  1
                
              
              
                
                  
                    e
                    ~
                  
                  2
                
              
              
                
                  
                    e
                    ~
                  
                  2
                
              
              
                
                  
                    e
                    ~
                  
                  3
                
              
              
                
                  
                    e
                    ~
                  
                  3
                
              
              
                
                  
                    e
                    ~
                  
                  4
                
              
            
            
              
                
                  
                    e
                    ~
                  
                  1
                
              
              
                
                  -
                  
                    
                      e
                      ~
                    
                    1
                  
                
              
              
                
                  
                    e
                    ~
                  
                  2
                
              
              
                
                  -
                  
                    
                      e
                      ~
                    
                    2
                  
                
              
              
                
                  
                    e
                    ~
                  
                  3
                
              
              
                
                  -
                  
                    
                      e
                      ~
                    
                    3
                  
                
              
              
                
                  
                    e
                    ~
                  
                  4
                
              
            
          
          ]
        
      
    
  



Rank 8:




  
    
      
    
    ⁢
    
      
        
          X
          
            (
            0
            )
          
        
        =
        
          [
          
            
              
                1
              
              
                1
              
              
                1
              
              
                1
              
            
            
              
                1
              
              
                j
              
              
                
                  -
                  1
                
              
              
                
                  -
                  j
                
              
            
            
              
                1
              
              
                
                  -
                  1
                
              
              
                1
              
              
                
                  -
                  1
                
              
            
            
              
                1
              
              
                
                  -
                  j
                
              
              
                
                  -
                  1
                
              
              
                j
              
            
          
          ]
        
      
      ,
      
        
          W
          1
        
        =
        
          [
          
            
              
                
                  X
                  
                    (
                    0
                    )
                  
                
              
              
                0
              
            
            
              
                0
              
              
                
                  X
                  
                    (
                    0
                    )
                  
                
              
            
          
          ]
        
      
    
  




  
    
      Rank
      ⁢
      
        
      
      ⁢
      8
      ⁢
      
        :
      
      ⁢
      
        
      
      ⁢
      
        W
        2
      
    
    =
    
      
        1
        
          2
        
      
      ⁡
      
        [
        
          
            
              
                
                  e
                  ~
                
                1
              
            
            
              
                
                  e
                  ~
                
                1
              
            
            
              
                
                  e
                  ~
                
                2
              
            
            
              
                
                  e
                  ~
                
                2
              
            
            
              
                
                  e
                  ~
                
                3
              
            
            
              
                
                  e
                  ~
                
                3
              
            
            
              
                
                  e
                  ~
                
                4
              
            
            
              
                
                  e
                  ~
                
                4
              
            
          
          
            
              
                
                  e
                  ~
                
                1
              
            
            
              
                -
                
                  
                    e
                    ~
                  
                  1
                
              
            
            
              
                
                  e
                  ~
                
                2
              
            
            
              
                -
                
                  
                    e
                    ~
                  
                  2
                
              
            
            
              
                
                  e
                  ~
                
                3
              
            
            
              
                -
                
                  
                    e
                    ~
                  
                  3
                
              
            
            
              
                
                  e
                  ~
                
                4
              
            
            
              
                -
                
                  
                    e
                    ~
                  
                  4
                
              
            
          
        
        ]
      
    
  



FIG. 4 is a block diagram illustrating internal details of an eNB 1002 and a mobile UE 1001 in the network system of FIG. 1. Mobile UE 1001 may represent any of a variety of devices such as a server, a desktop computer, a laptop computer, a cellular phone, a Personal Digital Assistant (PDA), a smart phone or other electronic devices. In some embodiments, the electronic mobile UE 1001 communicates with eNB 1002 based on a LTE or Evolved Universal Terrestrial Radio Access Network (E-UTRAN) protocol. Alternatively, another communication protocol now known or later developed can be used.
Mobile UE 1001 comprises a processor 1010 coupled to a memory 1012 and a transceiver 1020. The memory 1012 stores (software) applications 1014 for execution by the processor 1010. The applications could comprise any known or future application useful for individuals or organizations. These applications could be categorized as operating systems (OS), device drivers, databases, multimedia tools, presentation tools, Internet browsers, emailers, Voice-Over-Internet Protocol (VOIP) tools, file browsers, firewalls, instant messaging, finance tools, games, word processors or other categories. Regardless of the exact nature of the applications, at least some of the applications may direct the mobile UE 1001 to transmit UL signals to eNB (base-station) 1002 periodically or continuously via the transceiver 1020. In at least some embodiments, the mobile UE 1001 identifies a Quality of Service (QoS) requirement when requesting an uplink resource from eNB 1002. In some cases, the QoS requirement may be implicitly derived by eNB 1002 from the type of traffic supported by the mobile UE 1001. As an example, VOIP and gaming applications often involve low-latency uplink (UL) transmissions while High Throughput (HTP)/Hypertext Transmission Protocol (HTTP) traffic can involve high-latency uplink transmissions.
Transceiver 1020 includes uplink logic which may be implemented by execution of instructions that control the operation of the transceiver. Some of these instructions may be stored in memory 1012 and executed when needed by processor 1010. As would be understood by one of skill in the art, the components of the uplink logic may involve the physical (PHY) layer and/or the Media Access Control (MAC) layer of the transceiver 1020. Transceiver 1020 includes one or more receivers 1022 and one or more transmitters 1024.
Processor 1010 may send or receive data to various input/output devices 1026. A subscriber identity module (SIM) card stores and retrieves information used for making calls via the cellular system. A Bluetooth baseband unit may be provided for wireless connection to a microphone and headset for sending and receiving voice data. Processor 1010 may send information to a display unit for interaction with a user of mobile UE 1001 during a call process. The display may also display pictures received from the network, from a local camera, or from other sources such as a Universal Serial Bus (USB) connector. Processor 1010 may also send a video stream to the display that is received from various sources such as the cellular network via RF transceiver 1020 or the camera.
During transmission and reception of voice data or other application data, transmitter 1024 may be or become non-synchronized with its serving eNB. In this case, it sends a random access signal. As part of this procedure, it determines a preferred size for the next data transmission, referred to as a message, by using a power threshold value provided by the serving eNB, as described in more detail above. In this embodiment, the message preferred size determination is embodied by executing instructions stored in memory 1012 by processor 1010. In other embodiments, the message size determination may be embodied by a separate processor/memory unit, by a hardwired state machine, or by other types of control logic, for example.
eNB 1002 comprises a Processor 1030 coupled to a memory 1032, symbol processing circuitry 1038, and a transceiver 1040 via backplane bus 1036. The memory stores applications 1034 for execution by processor 1030. The applications could comprise any known or future application useful for managing wireless communications. At least some of the applications 1034 may direct eNB 1002 to manage transmissions to or from mobile UE 1001.
Transceiver 1040 comprises an uplink Resource Manager, which enables eNB 1002 to selectively allocate uplink Physical Uplink Shared CHannel (PUSCH) resources to mobile UE 1001. As would be understood by one of skill in the art, the components of the uplink resource manager may involve the physical (PHY) layer and/or the Media Access Control (MAC) layer of the transceiver 1040. Transceiver 1040 includes at least one receiver 1042 for receiving transmissions from various UEs within range of eNB 1002 and at least one transmitter 1044 for transmitting data and control information to the various UEs within range of eNB 1002.
The uplink resource manager executes instructions that control the operation of transceiver 1040. Some of these instructions may be located in memory 1032 and executed when needed on processor 1030. The resource manager controls the transmission resources allocated to each UE 1001 served by eNB 1002 and broadcasts control information via the PDCCH.
Symbol processing circuitry 1038 performs demodulation using known techniques. Random access signals are demodulated in symbol processing circuitry 1038.
During transmission and reception of voice data or other application data, receiver 1042 may receive a random access signal from a UE 1001. The random access signal is encoded to request a message size that is preferred by UE 1001. UE 1001 determines the preferred message size by using a message threshold provided by eNB 1002. In this embodiment, the message threshold calculation is embodied by executing instructions stored in memory 1032 by processor 1030. In other embodiments, the threshold calculation may be embodied by a separate processor/memory unit, by a hardwired state machine, or by other types of control logic, for example. Alternatively, in some networks the message threshold is a fixed value that may be stored in memory 1032, for example. In response to receiving the message size request, eNB 1002 schedules an appropriate set of resources and notifies UE 1001 with a resource grant.

## Claims

1. A transceiver, comprising:
a receiver for receiving; and
a transmitter for transmitting via a Physical Uplink Control CHannel (PUCCH) a Channel State Information feedback signal having:
a first mode with a first report jointly coding Rank Indicator (RI) and a first Precoding Matrix Indicator (PMI), and with a second report coding Channel Quality Indicator (CQI) and a second PMI, wherein said jointly coding the RI and the first PMI employs codebook sub-sampling into a maximum of 5 bits as follows:















RI
Codebook index (i1)








1
0, 2, 4, 6, 8, 10, 12, 14



2
0, 2, 4, 6, 8, 10, 12, 14



3
0, 2



4
0, 2








and
a second mode with a first report coding RI, and with a second report coding CQI and jointly coding the first PMI and the second PMI, wherein said jointly coding the first PMI and the second PMI employs codebook sub-sampling.

2. A transceiver, comprising:
a receiver for receiving; and
a transmitter for transmitting via a Physical Uplink Control CHannel (PUCCH) a Channel State Information feedback signal having:
a first mode with a first report jointly coding Rank Indicator (RI) and a first Precoding Matrix Indicator (PMI), and with a second report coding Channel Quality Indicator (CQI) and a second PMI, wherein for a 2-layer capable user equipment said jointly coding RI and the first PMI employs codebook sub-sampling into 4 bits as follows:















RI
Codebook index (i1)








1
0, 2, 4, 6, 8, 10, 12, 14



2
0, 2, 4, 6, 8, 10, 12, 14








and
a second mode with a first report coding RI, and with a second report coding CQI and jointly coding the first PMI and the second PMI, wherein said jointly coding the first PMI and the second PMI employs codebook sub-sampling.

3. A transceiver, comprising:
a receiver for receiving; and
a transmitter for transmitting via a Physical Uplink Control CHannel (PUCCH) a Channel State Information feedback signal having:
a first mode with a first report jointly coding Rank Indicator (RI) and a first Precoding Matrix Indicator (PMI), and with a second report coding Channel Quality Indicator (CQI) and a second PMI, wherein said jointly coding the RI and the first PMI employs codebook sub-sampling; and
a second mode with a first report coding RI, and with a second report coding CQI and jointly coding the first PMI and the second PMI, wherein said jointly coding the first PMI and the second PMI employs codebook sub-sampling as follows for the first PMI:















RI
Codebook index (i1)








1
0, 2, 4, 6, 8, 10, 12, 14



2
0, 2, 4, 6, 8, 10, 12, 14



3
0, 2



4
0, 2.

4. A transceiver, comprising:
a receiver for receiving; and
a transmitter for transmitting via a Physical Uplink Control CHannel (PUCCH) a Channel State Information feedback signal having:
a first mode with a first report jointly coding Rank Indicator (RI) and a first Precoding Matrix Indicator (PMI), and with a second report coding Channel Quality Indicator (CQI) and a second PMI, wherein said jointly coding the RI and the first PMI employs codebook sub-sampling; and
a second mode with a first report coding RI, and with a second report coding CQI and jointly coding the first PMI and the second PMI, wherein said jointly coding the first PMI and the second PMI employs codebook sub-sampling:
for RI equal one joint coding the first PMI and the second PMI employs 7 bits or less, and
for RI greater than one joint coding the first PMI and the second PMI employs 4 bits or less.