src/5gnrsch/sch_utils.c

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /************************************************************************
  20
  21      Name:     sch_utils.c
  22
  23      Type:     C source file
  24
  25      Desc:     C source code for scheduler utilities
  26
  27      File:     sch_utils.c
  28
  29 **********************************************************************/
  30
  31 /** @file sch_utils.c
  32 @brief This file implements the schedulers util functions.
  33 */
  34
  35 /* header files */
  36 #include "common_def.h"
  37 #include "du_app_mac_inf.h"
  38 #include "lrg.h"
  39 #include "tfu.h"
  40 #include "tfu.x"           /* TFU types */
  41 #include "lrg.x"           /* layer management typedefs for MAC */
  42 #include "mac_sch_interface.h"
  43 #include "sch.h"
  44 #include "sch_tmr.h"
  45 #include "sch_utils.h"
  46 #include "math.h"
  47
  48 #ifdef NR_TDD
  49 /* spec-38.213 Table 13-4 for SCS=30KHz */
  50 /* Note: Picking Table 13-4 and not 13-6 since band supported is n78 and
  51  * corresponding minimum B/W is 10 MHz */
  52 int8_t coresetIdxTable[MAX_CORESET_INDEX][4] = {
  53 {   1,   24,   2,   0}, /* index 0  */
  54 {   1,   24,   2,   1}, /* index 1  */
  55 {   1,   24,   2,   2}, /* index 2  */
  56 {   1,   24,   2,   3}, /* index 3  */
  57 {   1,   24,   2,   4}, /* index 4  */
  58 {   1,   24,   3,   0}, /* index 5  */
  59 {   1,   24,   3,   1}, /* index 6  */
  60 {   1,   24,   3,   2}, /* index 7  */
  61 {   1,   24,   3,   3}, /* index 8  */
  62 {   1,   24,   3,   4}, /* index 9  */
  63 {   1,   48,   1,  12}, /* index 10 */
  64 {   1,   48,   1,  14}, /* index 11 */
  65 {   1,   48,   1,  16}, /* index 12 */
  66 {   1,   48,   2,  12}, /* index 13 */
  67 {   1,   48,   2,  14}, /* index 14 */
  68 {   1,   48,   2,  16}, /* index 15 */
  69 };
  70 #else
  71 /* spec-38.213 Table 13-1 for SCS=15KHz */
  72 int8_t coresetIdxTable[MAX_CORESET_INDEX][4] = {
  73 {   1,   24,   2,   0}, /* index 0  */
  74 {   1,   24,   2,   2}, /* index 1  */
  75 {   1,   24,   2,   4}, /* index 2  */
  76 {   1,   24,   3,   0}, /* index 3  */
  77 {   1,   24,   3,   2}, /* index 4  */
  78 {   1,   24,   3,   4}, /* index 5  */
  79 {   1,   48,   1,  12}, /* index 6  */
  80 {   1,   48,   1,  16}, /* index 7  */
  81 {   1,   48,   2,  12}, /* index 8  */
  82 {   1,   48,   2,  16}, /* index 9  */
  83 {   1,   48,   3,  12}, /* index 10 */
  84 {   1,   48,   3,  16}, /* index 11 */
  85 {   1,   96,   1,  38}, /* index 12 */
  86 {   1,   96,   2,  38}, /* index 13 */
  87 {   1,   96,   3,  38}, /* index 14 */
  88 {   0,    0,   0,   0}, /* index 15 */
  89 };
  90 #endif
  91
  92 /* spec-38.213 Table 13-11 */
  93 /* m value is scaled to 2, when using it in formula, divide by 2 */
  94 /* firstSymbol will vary depends on i, hence not filled */
  95 int8_t searchSpaceIdxTable[MAX_SEARCH_SPACE_INDEX][4] = {
  96 {   0,    1,   2,   0}, /* index 0  */
  97 {   0,    2,   1,   0}, /* index 1  */
  98 {   2,    1,   2,   0}, /* index 2  */
  99 {   2,    2,   1,   0}, /* index 3  */
 100 {   5,    1,   2,   0}, /* index 4  */
 101 {   5,    2,   1,   0}, /* index 5  */
 102 {   7,    1,   2,   0}, /* index 6  */
 103 {   7,    2,   1,   0}, /* index 7  */
 104 {   0,    1,   4,   0}, /* index 8  */
 105 {   5,    1,   4,   0}, /* index 9  */
 106 {   0,    1,   2,   0}, /* index 10 */
 107 {   0,    1,   2,   0}, /* index 11 */
 108 {   2,    1,   2,   0}, /* index 12 */
 109 {   2,    1,   2,   0}, /* index 13 */
 110 {   5,    1,   2,   0}, /* index 14 */
 111 {   5,    1,   2,   0}, /* index 15 */
 112 };
 113
 114 /* RACH tables */
 115
 116 /* spec-38.211 Table 6.3.3.2-1 */
 117 /* Lra, delFRa, delF, numRb, k' */
 118 uint16_t numRbForPrachTable[MAX_RACH_NUM_RB_IDX][5] = {
 119 {   839,  1.25,  15,   6,   7    }, /* index 0 */
 120 {   839,  1.25,  30,   3,   1    }, /* index 1 */
 121 {   839,  1.25,  60,   2,   133  }, /* index 2 */
 122 {   839,  5,     15,   24,  12   }, /* index 3 */
 123 {   839,  5,     30,   12,  10   }, /* index 4 */
 124 {   839,  5,     60,   6,   7    }, /* index 5 */
 125 {   139,  15,    15,   12,  2    }, /* index 6 */
 126 {   139,  15,    30,   6,   2    }, /* index 7 */
 127 {   139,  15,    60,   3,   2    }, /* index 8 */
 128 {   139,  30,    15,   24,  2    }, /* index 9 */
 129 {   139,  30,    30,   12,  2    }, /* index 10 */
 130 {   139,  30,    60,   6,   2    }, /* index 11 */
 131 {   139,  60,    60,   12,  2    }, /* index 12 */
 132 {   139,  60,    120,  6,   2    }, /* index 13 */
 133 {   139,  120,   60,   24,  2    }, /* index 14 */
 134 {   139,  120,   120,  12,  2    }, /* index 15 */
 135 };
 136
 137 #ifdef NR_TDD
 138
 139 /* prach config index Table 6.3.3.2-3 spec 38.211
 140  * PRACH format given as follows:
 141  * 0 = 0
 142  * 1 = 1
 143  * 2 = 2
 144  * 3 = 3
 145  * 4 = A1
 146  * 5 = A2
 147  * 6 = A3
 148  * 7 = B1
 149  * 8 = B4
 150  * 9 = C0
 151  * 10 = C2
 152  * 11 = A1/B1
 153  * 12 = A2/B2
 154  * 13 = A3/B3
 155  * Subframe num is represented considering 0-9 bits and
 156  * value 1 corresponds to the subframe that is valid
 157  */
 158
 159 uint16_t prachCfgIdxTable[MAX_PRACH_CONFIG_IDX][8] = {
 160 { 0, 16,  1,  512,  0,  0,  0,  0 }, /* index 0   */
 161 { 0,  8,  1,  512,  0,  0,  0,  0 }, /* index 1   */
 162 { 0,  4,  1,  512,  0,  0,  0,  0 }, /* index 2   */
 163 { 0,  2,  0,  512,  0,  0,  0,  0 }, /* index 3   */
 164 { 0,  2,  1,  512,  0,  0,  0,  0 }, /* index 4   */
 165 { 0,  2,  0,   16,  0,  0,  0,  0 }, /* index 5   */
 166 { 0,  2,  1,   16,  0,  0,  0,  0 }, /* index 6   */
 167 { 0,  1,  0,  512,  0,  0,  0,  0 }, /* index 7   */
 168 { 0,  1,  0,  256,  0,  0,  0,  0 }, /* index 8   */
 169 { 0,  1,  0,  128,  0,  0,  0,  0 }, /* index 9   */
 170 { 0,  1,  0,   64,  0,  0,  0,  0 }, /* index 10  */
 171 { 0,  1,  0,   32,  0,  0,  0,  0 }, /* index 11  */
 172 { 0,  1,  0,   16,  0,  0,  0,  0 }, /* index 12  */
 173 { 0,  1,  0,    8,  0,  0,  0,  0 }, /* index 13  */
 174 { 0,  1,  0,    4,  0,  0,  0,  0 }, /* index 14  */
 175 { 0,  1,  0,   66,  0,  0,  0,  0 }, /* index 15  */
 176 { 0,  1,  0,   66,  7,  0,  0,  0 }, /* index 16  */
 177 { 0,  1,  0,  528,  0,  0,  0,  0 }, /* index 17  */
 178 { 0,  1,  0,  264,  0,  0,  0,  0 }, /* index 18  */
 179 { 0,  1,  0,  132,  0,  0,  0,  0 }, /* index 19  */
 180 { 0,  1,  0,  768,  0,  0,  0,  0 }, /* index 20  */
 181 { 0,  1,  0,  784,  0,  0,  0,  0 }, /* index 21  */
 182 { 0,  1,  0,  536,  0,  0,  0,  0 }, /* index 22  */
 183 { 0,  1,  0,  896,  0,  0,  0,  0 }, /* index 23  */
 184 { 0,  1,  0,  792,  0,  0,  0,  0 }, /* index 24  */
 185 { 0,  1,  0,  960,  0,  0,  0,  0 }, /* index 25  */
 186 { 0,  1,  0,  594,  0,  0,  0,  0 }, /* index 26  */
 187 { 0,  1,  0,  682,  0,  0,  0,  0 }, /* index 27  */
 188 { 1, 16,  1,  128,  0,  0,  0,  0 }, /* index 28  */
 189 { 1,  8,  1,  128,  0,  0,  0,  0 }, /* index 29  */
 190 { 1,  4,  1,  128,  0,  0,  0,  0 }, /* index 30  */
 191 { 1,  2,  0,  128,  0,  0,  0,  0 }, /* index 31  */
 192 { 1,  2,  1,  128,  0,  0,  0,  0 }, /* index 32  */
 193 { 1,  1,  0,  128,  0,  0,  0,  0 }, /* index 33  */
 194 { 2, 16,  1,   64,  0,  0,  0,  0 }, /* index 34  */
 195 { 2,  8,  1,   64,  0,  0,  0,  0 }, /* index 35  */
 196 { 2,  4,  1,   64,  0,  0,  0,  0 }, /* index 36  */
 197 { 2,  2,  0,   64,  7,  0,  0,  0 }, /* index 37  */
 198 { 2,  2,  1,   64,  7,  0,  0,  0 }, /* index 38  */
 199 { 2,  1,  0,   64,  7,  0,  0,  0 }, /* index 39  */
 200 { 3, 16,  1,  512,  0,  0,  0,  0 }, /* index 40  */
 201 { 3,  8,  1,  512,  0,  0,  0,  0 }, /* index 41  */
 202 { 3,  4,  1,  512,  0,  0,  0,  0 }, /* index 42  */
 203 { 3,  2,  0,  512,  0,  0,  0,  0 }, /* index 43  */
 204 { 3,  2,  1,  512,  0,  0,  0,  0 }, /* index 44  */
 205 { 3,  2,  0,   16,  0,  0,  0,  0 }, /* index 45  */
 206 { 3,  2,  1,   16,  0,  0,  0,  0 }, /* index 46  */
 207 { 3,  1,  0,  512,  0,  0,  0,  0 }, /* index 47  */
 208 { 3,  1,  0,  256,  0,  0,  0,  0 }, /* index 48  */
 209 { 3,  1,  0,  128,  0,  0,  0,  0 }, /* index 49  */
 210 { 3,  1,  0,   64,  0,  0,  0,  0 }, /* index 50  */
 211 { 3,  1,  0,   32,  0,  0,  0,  0 }, /* index 51  */
 212 { 3,  1,  0,   16,  0,  0,  0,  0 }, /* index 52  */
 213 { 3,  1,  0,    8,  0,  0,  0,  0 }, /* index 53  */
 214 { 3,  1,  0,    4,  0,  0,  0,  0 }, /* index 54  */
 215 { 3,  1,  0,   66,  0,  0,  0,  0 }, /* index 55  */
 216 { 3,  1,  0,   66,  7,  0,  0,  0 }, /* index 56  */
 217 { 3,  1,  0,  528,  0,  0,  0,  0 }, /* index 57  */
 218 { 3,  1,  0,  264,  0,  0,  0,  0 }, /* index 58  */
 219 { 3,  1,  0,  132,  0,  0,  0,  0 }, /* index 59  */
 220 { 3,  1,  0,  768,  0,  0,  0,  0 }, /* index 60  */
 221 { 3,  1,  0,  784,  0,  0,  0,  0 }, /* index 61  */
 222 { 3,  1,  0,  536,  0,  0,  0,  0 }, /* index 62  */
 223 { 3,  1,  0,  896,  0,  0,  0,  0 }, /* index 63  */
 224 { 3,  1,  0,  792,  0,  0,  0,  0 }, /* index 64  */
 225 { 3,  1,  0,  594,  0,  0,  0,  0 }, /* index 65  */
 226 { 3,  1,  0,  682,  0,  0,  0,  0 }, /* index 66  */
 227 { 4, 16,  1,  512,  0,  2,  6,  2 }, /* index 67  */
 228 { 4,  8,  1,  512,  0,  2,  6,  2 }, /* index 68  */
 229 { 4,  4,  1,  512,  0,  1,  6,  2 }, /* index 69  */
 230 { 4,  2,  1,  512,  0,  1,  6,  2 }, /* index 70  */
 231 { 4,  2,  1,  528,  7,  1,  3,  2 }, /* index 71  */
 232 { 4,  2,  1,  640,  7,  1,  3,  2 }, /* index 72  */
 233 { 4,  2,  1,  640,  0,  1,  6,  2 }, /* index 73  */
 234 { 4,  2,  1,  768,  0,  2,  6,  2 }, /* index 74  */
 235 { 4,  2,  1,  528,  0,  2,  6,  2 }, /* index 75  */
 236 { 4,  2,  1,  924,  0,  1,  6,  2 }, /* index 76  */
 237 { 4,  1,  0,  512,  0,  2,  6,  2 }, /* index 77  */
 238 { 4,  1,  0,  512,  7,  1,  3,  2 }, /* index 78  */
 239 { 4,  1,  0,  512,  0,  1,  6,  2 }, /* index 79  */
 240 { 4,  1,  0,  768,  0,  2,  6,  2 }, /* index 80  */
 241 { 4,  1,  0,  528,  0,  1,  6,  2 }, /* index 81  */
 242 { 4,  1,  0,  640,  7,  1,  3,  2 }, /* index 82  */
 243 { 4,  1,  0,  792,  0,  1,  6,  2 }, /* index 83  */
 244 { 4,  1,  0,  792,  0,  2,  6,  2 }, /* index 84  */
 245 { 4,  1,  0,  682,  0,  1,  6,  2 }, /* index 85  */
 246 { 4,  1,  0, 1023,  7,  1,  3,  2 }, /* index 86  */
 247 { 5, 16,  1,  512,  0,  2,  3,  4 }, /* index 87  */
 248 { 5,  8,  1,  512,  0,  2,  3,  4 }, /* index 88  */
 249 { 5,  4,  1,  512,  0,  1,  3,  4 }, /* index 89  */
 250 { 5,  2,  1,  640,  0,  1,  3,  4 }, /* index 90  */
 251 { 5,  2,  1,  768,  0,  2,  3,  4 }, /* index 91  */
 252 { 5,  2,  1,  640,  9,  1,  1,  4 }, /* index 92  */
 253 { 5,  2,  1,  528,  9,  1,  1,  4 }, /* index 93  */
 254 { 5,  2,  1,  528,  0,  2,  3,  4 }, /* index 94  */
 255 { 5,  2,  1,  924,  0,  1,  3,  4 }, /* index 95  */
 256 { 5,  1,  0,    4,  0,  1,  3,  4 }, /* index 96  */
 257 { 5,  1,  0,  128,  0,  1,  3,  4 }, /* index 97  */
 258 { 5,  2,  1,  512,  0,  1,  3,  4 }, /* index 98  */
 259 { 5,  1,  0,  512,  0,  2,  3,  4 }, /* index 99  */
 260 { 5,  1,  0,  512,  9,  1,  1,  4 }, /* index 100  */
 261 { 5,  1,  0,  512,  0,  1,  3,  4 }, /* index 101  */
 262 { 5,  1,  0,  132,  0,  1,  3,  4 }, /* index 102  */
 263 { 5,  1,  0,  768,  0,  2,  3,  4 }, /* index 103  */
 264 { 5,  1,  0,  528,  0,  1,  3,  4 }, /* index 104  */
 265 { 5,  1,  0,  640,  9,  1,  1,  4 }, /* index 105  */
 266 { 5,  1,  0,  792,  0,  1,  3,  4 }, /* index 106  */
 267 { 5,  1,  0,  792,  0,  2,  3,  4 }, /* index 107  */
 268 { 5,  1,  0,  682,  0,  1,  3,  4 }, /* index 108  */
 269 { 5,  1,  0, 1023,  9,  1,  1,  4 }, /* index 109  */
 270 { 6, 16,  1,  512,  0,  2,  2,  6 }, /* index 110  */
 271 { 6,  8,  1,  512,  0,  2,  2,  6 }, /* index 111  */
 272 { 6,  4,  1,  512,  0,  1,  2,  6 }, /* index 112  */
 273 { 6,  2,  1,  528,  7,  1,  1,  6 }, /* index 113  */
 274 { 6,  2,  1,  640,  7,  1,  1,  6 }, /* index 114  */
 275 { 6,  2,  1,  640,  0,  1,  2,  6 }, /* index 115  */
 276 { 6,  2,  1,  528,  0,  2,  2,  6 }, /* index 116  */
 277 { 6,  2,  1,  768,  0,  2,  2,  6 }, /* index 117  */
 278 { 6,  2,  1,  924,  0,  1,  2,  6 }, /* index 118  */
 279 { 6,  1,  0,    4,  0,  1,  2,  6 }, /* index 119  */
 280 { 6,  1,  0,  128,  0,  1,  2,  6 }, /* index 120  */
 281 { 6,  2,  1,  512,  0,  1,  2,  6 }, /* index 121  */
 282 { 6,  1,  0,  512,  0,  2,  2,  6 }, /* index 122  */
 283 { 6,  1,  0,  512,  7,  1,  1,  6 }, /* index 123  */
 284 { 6,  1,  0,  512,  0,  1,  2,  6 }, /* index 124  */
 285 { 6,  1,  0,  132,  0,  1,  2,  6 }, /* index 125  */
 286 { 6,  1,  0,  768,  0,  2,  2,  6 }, /* index 126  */
 287 { 6,  1,  0,  528,  0,  1,  2,  6 }, /* index 127  */
 288 { 6,  1,  0,  640,  7,  1,  1,  6 }, /* index 128  */
 289 { 6,  1,  0,  792,  0,  1,  2,  6 }, /* index 129  */
 290 { 6,  1,  0,  792,  0,  2,  2,  6 }, /* index 130  */
 291 { 6,  1,  0,  682,  0,  1,  2,  6 }, /* index 131  */
 292 { 6,  1,  0, 1023,  7,  1,  1,  6 }, /* index 132  */
 293 { 7,  4,  1,  512,  2,  1,  6,  2 }, /* index 133  */
 294 { 7,  2,  1,  512,  2,  1,  6,  2 }, /* index 134  */
 295 { 7,  2,  1,  640,  2,  1,  6,  2 }, /* index 135  */
 296 { 7,  2,  1,  528,  8,  1,  3,  2 }, /* index 136  */
 297 { 7,  2,  1,  528,  2,  2,  6,  2 }, /* index 137  */
 298 { 7,  1,  0,  512,  2,  2,  6,  2 }, /* index 138  */
 299 { 7,  1,  0,  512,  8,  1,  3,  2 }, /* index 139  */
 300 { 7,  1,  0,  512,  2,  1,  6,  2 }, /* index 140  */
 301 { 7,  1,  0,  768,  2,  2,  6,  2 }, /* index 141  */
 302 { 7,  1,  0,  528,  2,  1,  6,  2 }, /* index 142  */
 303 { 7,  1,  0,  640,  8,  1,  3,  2 }, /* index 143  */
 304 { 7,  1,  0,  682,  2,  1,  6,  2 }, /* index 144  */
 305 { 8, 16,  1,  512,  0,  2,  1, 12 }, /* index 145  */
 306 { 8,  8,  1,  512,  0,  2,  1, 12 }, /* index 146  */
 307 { 8,  4,  1,  512,  2,  1,  1, 12 }, /* index 147  */
 308 { 8,  2,  1,  512,  0,  1,  1, 12 }, /* index 148  */
 309 { 8,  2,  1,  512,  2,  1,  1, 12 }, /* index 149  */
 310 { 8,  2,  1,  640,  2,  1,  1, 12 }, /* index 150  */
 311 { 8,  2,  1,  528,  2,  1,  1, 12 }, /* index 151  */
 312 { 8,  2,  1,  528,  0,  2,  1, 12 }, /* index 152  */
 313 { 8,  2,  1,  768,  0,  2,  1, 12 }, /* index 153  */
 314 { 8,  2,  1,  924,  0,  1,  1, 12 }, /* index 154  */
 315 { 8,  1,  0,    2,  0,  1,  1, 12 }, /* index 155  */
 316 { 8,  1,  0,    4,  0,  1,  1, 12 }, /* index 156  */
 317 { 8,  1,  0,   16,  0,  1,  1, 12 }, /* index 157  */
 318 { 8,  1,  0,  128,  0,  1,  1, 12 }, /* index 158  */
 319 { 8,  1,  0,  512,  0,  1,  1, 12 }, /* index 159  */
 320 { 8,  1,  0,  512,  2,  1,  1, 12 }, /* index 160  */
 321 { 8,  1,  0,  512,  0,  2,  1, 12 }, /* index 161  */
 322 { 8,  1,  0,  528,  2,  1,  1, 12 }, /* index 162  */
 323 { 8,  1,  0,  640,  2,  1,  1, 12 }, /* index 163  */
 324 { 8,  1,  0,  768,  0,  2,  1, 12 }, /* index 164  */
 325 { 8,  1,  0,  792,  2,  1,  1, 12 }, /* index 165  */
 326 { 8,  1,  0,  682,  2,  1,  1, 12 }, /* index 166  */
 327 { 8,  1,  0, 1023,  0,  2,  1, 12 }, /* index 167  */
 328 { 8,  1,  0, 1023,  2,  1,  1, 12 }, /* index 168  */
 329 { 9, 16,  1,  512,  2,  2,  6,  2 }, /* index 169  */
 330 { 9,  8,  1,  512,  2,  2,  6,  2 }, /* index 170  */
 331 { 9,  4,  1,  512,  2,  1,  6,  2 }, /* index 171  */
 332 { 9,  2,  1,  512,  2,  1,  6,  2 }, /* index 172  */
 333 { 9,  2,  1,  768,  2,  2,  6,  2 }, /* index 173  */
 334 { 9,  2,  1,  640,  2,  1,  6,  2 }, /* index 174  */
 335 { 9,  2,  1,  640,  8,  1,  3,  2 }, /* index 175  */
 336 { 9,  2,  1,  528,  8,  1,  3,  2 }, /* index 176  */
 337 { 9,  2,  1,  528,  2,  2,  6,  2 }, /* index 177  */
 338 { 9,  2,  1,  924,  2,  1,  6,  2 }, /* index 178  */
 339 { 9,  1,  0,  512,  2,  2,  6,  2 }, /* index 179  */
 340 { 9,  1,  0,  512,  8,  1,  3,  2 }, /* index 180  */
 341 { 9,  1,  0,  512,  2,  1,  6,  2 }, /* index 181  */
 342 { 9,  1,  0,  768,  2,  2,  6,  2 }, /* index 182  */
 343 { 9,  1,  0,  528,  2,  1,  6,  2 }, /* index 183  */
 344 { 9,  1,  0,  640,  8,  1,  3,  2 }, /* index 184  */
 345 { 9,  1,  0,  792,  2,  1,  6,  2 }, /* index 185  */
 346 { 9,  1,  0,  792,  2,  2,  6,  2 }, /* index 186  */
 347 { 9,  1,  0,  682,  2,  1,  6,  2 }, /* index 187  */
 348 { 9,  1,  0, 1023,  8,  1,  3,  2 }, /* index 188  */
 349 {10, 16,  1,  512,  2,  2,  2,  6 }, /* index 189  */
 350 {10,  8,  1,  512,  2,  2,  2,  6 }, /* index 190  */
 351 {10,  4,  1,  512,  2,  1,  2,  6 }, /* index 191  */
 352 {10,  2,  1,  512,  2,  1,  2,  6 }, /* index 192  */
 353 {10,  2,  1,  768,  2,  2,  2,  6 }, /* index 193  */
 354 {10,  2,  1,  640,  2,  1,  2,  6 }, /* index 194  */
 355 {10,  2,  1,  640,  8,  1,  1,  6 }, /* index 195  */
 356 {10,  2,  1,  528,  8,  1,  1,  6 }, /* index 196  */
 357 {10,  2,  1,  528,  2,  2,  2,  6 }, /* index 197  */
 358 {10,  2,  1,  924,  2,  1,  2,  6 }, /* index 198  */
 359 {10,  8,  1,  512,  8,  2,  1,  6 }, /* index 199  */
 360 {10,  4,  1,  512,  8,  1,  1,  6 }, /* index 200  */
 361 {10,  1,  0,  512,  2,  2,  2,  6 }, /* index 201  */
 362 {10,  1,  0,  512,  8,  1,  1,  6 }, /* index 202  */
 363 {10,  1,  0,  512,  2,  1,  2,  6 }, /* index 203  */
 364 {10,  1,  0,  768,  2,  2,  2,  6 }, /* index 204  */
 365 {10,  1,  0,  528,  2,  1,  2,  6 }, /* index 205  */
 366 {10,  1,  0,  640,  8,  1,  1,  6 }, /* index 206  */
 367 {10,  1,  0,  792,  2,  1,  2,  6 }, /* index 207  */
 368 {10,  1,  0,  792,  2,  2,  2,  6 }, /* index 208  */
 369 {10,  1,  0,  682,  2,  1,  2,  6 }, /* index 209  */
 370 {10,  1,  0, 1023,  8,  1,  1,  6 }, /* index 210  */
 371 {11,  2,  1,  512,  2,  1,  6,  2 }, /* index 211  */
 372 {11,  2,  1,  528,  8,  1,  3,  2 }, /* index 212  */
 373 {11,  2,  1,  640,  8,  1,  3,  2 }, /* index 213  */
 374 {11,  2,  1,  640,  2,  1,  6,  2 }, /* index 214  */
 375 {11,  2,  1,  528,  2,  2,  6,  2 }, /* index 215  */
 376 {11,  2,  1,  768,  2,  2,  6,  2 }, /* index 216  */
 377 {11,  1,  0,  512,  2,  2,  6,  2 }, /* index 217  */
 378 {11,  1,  0,  512,  8,  1,  3,  2 }, /* index 218  */
 379 {11,  1,  0,  512,  2,  1,  6,  2 }, /* index 219  */
 380 {11,  1,  0,  768,  2,  2,  6,  2 }, /* index 220  */
 381 {11,  1,  0,  528,  2,  1,  6,  2 }, /* index 221  */
 382 {11,  1,  0,  640,  8,  1,  3,  2 }, /* index 222  */
 383 {11,  1,  0,  792,  2,  2,  6,  2 }, /* index 223  */
 384 {11,  1,  0,  682,  2,  1,  6,  2 }, /* index 224  */
 385 {11,  1,  0, 1023,  8,  1,  3,  2 }, /* index 225  */
 386 {12,  2,  1,  512,  0,  1,  3,  4 }, /* index 226  */
 387 {12,  2,  1,  528,  6,  1,  2,  4 }, /* index 227  */
 388 {12,  2,  1,  640,  6,  1,  2,  4 }, /* index 228  */
 389 {12,  2,  1,  528,  0,  2,  3,  4 }, /* index 229  */
 390 {12,  2,  1,  768,  0,  2,  3,  4 }, /* index 230  */
 391 {12,  1,  0,  512,  0,  2,  3,  4 }, /* index 231  */
 392 {12,  1,  0,  512,  6,  1,  2,  4 }, /* index 232  */
 393 {12,  1,  0,  512,  0,  1,  3,  4 }, /* index 233  */
 394 {12,  1,  0,  768,  0,  2,  3,  4 }, /* index 234  */
 395 {12,  1,  0,  528,  0,  1,  3,  4 }, /* index 235  */
 396 {12,  1,  0,  640,  6,  1,  2,  4 }, /* index 236  */
 397 {12,  1,  0,  792,  0,  1,  3,  4 }, /* index 237  */
 398 {12,  1,  0,  792,  0,  2,  3,  4 }, /* index 238  */
 399 {12,  1,  0,  682,  0,  1,  3,  4 }, /* index 239  */
 400 {12,  1,  0, 1023,  6,  1,  2,  4 }, /* index 240  */
 401 {13,  2,  1,  512,  0,  1,  2,  6 }, /* index 241  */
 402 {13,  2,  1,  528,  2,  1,  2,  6 }, /* index 242  */
 403 {13,  2,  1,  640,  0,  1,  2,  6 }, /* index 243  */
 404 {13,  2,  1,  640,  2,  1,  2,  6 }, /* index 244  */
 405 {13,  2,  1,  528,  0,  2,  2,  6 }, /* index 245  */
 406 {13,  2,  1,  768,  0,  2,  2,  6 }, /* index 246  */
 407 {13,  1,  0,  512,  0,  2,  2,  6 }, /* index 247  */
 408 {13,  1,  0,  512,  2,  1,  2,  6 }, /* index 248  */
 409 {13,  1,  0,  512,  0,  1,  2,  6 }, /* index 249  */
 410 {13,  1,  0,  768,  0,  2,  2,  6 }, /* index 250  */
 411 {13,  1,  0,  528,  0,  1,  2,  6 }, /* index 251  */
 412 {13,  1,  0,  640,  2,  1,  2,  6 }, /* index 252  */
 413 {13,  1,  0,  792,  0,  2,  2,  6 }, /* index 253  */
 414 {13,  1,  0,  682,  0,  1,  2,  6 }, /* index 254  */
 415 {13,  1,  0, 1023,  2,  1,  2,  6 }  /* index 255  */
 416 };
 417
 418 #else
 419 /* prach config index Table 6.3.3.2-2 spec 38.211
 420  * PRACH format given as follows:
 421  * 0 = 0
 422  * 1 = 1
 423  * 2 = 2
 424  * 3 = 3
 425  * 4 = A1
 426  * 5 = A2
 427  * 6 = A3
 428  * 7 = B1
 429  * 8 = B4
 430  * 9 = C0
 431  * 10 = C2
 432  * 11 = A1/B1
 433  * 12 = A2/B2
 434  * 13 = A3/B3
 435  * Subframe num is represented considering 0-9 bits and
 436  * value 1 corresponds to the subframe that is valid
 437  */
 438
 439 uint16_t prachCfgIdxTable[MAX_PRACH_CONFIG_IDX][8] = {
 440 { 0, 16,  1,    2,  0,  0,  0,  0 }, /* index 0   */
 441 { 0, 16,  1,   16,  0,  0,  0,  0 }, /* index 1   */
 442 { 0, 16,  1,  128,  0,  0,  0,  0 }, /* index 2   */
 443 { 0, 16,  1,  512,  0,  0,  0,  0 }, /* index 3   */
 444 { 0,  8,  1,    2,  0,  0,  0,  0 }, /* index 4   */
 445 { 0,  8,  1,   16,  0,  0,  0,  0 }, /* index 5   */
 446 { 0,  8,  1,  128,  0,  0,  0,  0 }, /* index 6   */
 447 { 0,  8,  1,  512,  0,  0,  0,  0 }, /* index 7   */
 448 { 0,  4,  1,    2,  0,  0,  0,  0 }, /* index 8   */
 449 { 0,  4,  1,   16,  0,  0,  0,  0 }, /* index 9   */
 450 { 0,  4,  1,  128,  0,  0,  0,  0 }, /* index 10  */
 451 { 0,  4,  1,  512,  0,  0,  0,  0 }, /* index 11  */
 452 { 0,  2,  1,    2,  0,  0,  0,  0 }, /* index 12  */
 453 { 0,  2,  1,   16,  0,  0,  0,  0 }, /* index 13  */
 454 { 0,  2,  1,  128,  0,  0,  0,  0 }, /* index 14  */
 455 { 0,  2,  1,  512,  0,  0,  0,  0 }, /* index 15  */
 456 { 0,  1,  0,    2,  0,  0,  0,  0 }, /* index 16  */
 457 { 0,  1,  0,   16,  0,  0,  0,  0 }, /* index 17  */
 458 { 0,  1,  0,  128,  0,  0,  0,  0 }, /* index 18  */
 459 { 0,  1,  0,   66,  0,  0,  0,  0 }, /* index 19  */
 460 { 0,  1,  0,  132,  0,  0,  0,  0 }, /* index 20  */
 461 { 0,  1,  0,  264,  0,  0,  0,  0 }, /* index 21  */
 462 { 0,  1,  0,  146,  0,  0,  0,  0 }, /* index 22  */
 463 { 0,  1,  0,  292,  0,  0,  0,  0 }, /* index 23  */
 464 { 0,  1,  0,  584,  0,  0,  0,  0 }, /* index 24  */
 465 { 0,  1,  0,  341,  0,  0,  0,  0 }, /* index 25  */
 466 { 0,  1,  0,  682,  0,  0,  0,  0 }, /* index 26  */
 467 { 0,  1,  0, 1023,  0,  0,  0,  0 }, /* index 27  */
 468 { 1, 16,  1,    2,  0,  0,  0,  0 }, /* index 28  */
 469 { 1, 16,  1,   16,  0,  0,  0,  0 }, /* index 29  */
 470 { 1, 16,  1,  128,  0,  0,  0,  0 }, /* index 30  */
 471 { 1, 16,  1,  512,  0,  0,  0,  0 }, /* index 31  */
 472 { 1,  8,  1,    2,  0,  0,  0,  0 }, /* index 32  */
 473 { 1,  8,  1,   16,  0,  0,  0,  0 }, /* index 33  */
 474 { 1,  8,  1,  128,  0,  0,  0,  0 }, /* index 34  */
 475 { 1,  8,  1,  512,  0,  0,  0,  0 }, /* index 35  */
 476 { 1,  4,  1,    2,  0,  0,  0,  0 }, /* index 36  */
 477 { 1,  4,  1,   16,  0,  0,  0,  0 }, /* index 37  */
 478 { 1,  4,  1,  128,  0,  0,  0,  0 }, /* index 38  */
 479 { 1,  4,  1,  512,  0,  0,  0,  0 }, /* index 39  */
 480 { 1,  2,  1,    2,  0,  0,  0,  0 }, /* index 40  */
 481 { 1,  2,  1,   16,  0,  0,  0,  0 }, /* index 41  */
 482 { 1,  2,  1,  128,  0,  0,  0,  0 }, /* index 42  */
 483 { 1,  2,  1,  512,  0,  0,  0,  0 }, /* index 43  */
 484 { 1,  1,  0,    2,  0,  0,  0,  0 }, /* index 44  */
 485 { 1,  1,  0,   16,  0,  0,  0,  0 }, /* index 45  */
 486 { 1,  1,  0,  128,  0,  0,  0,  0 }, /* index 46  */
 487 { 1,  1,  0,   64,  0,  0,  0,  0 }, /* index 47  */
 488 { 1,  1,  0,  132,  0,  0,  0,  0 }, /* index 48  */
 489 { 1,  1,  0,  264,  0,  0,  0,  0 }, /* index 49  */
 490 { 1,  1,  0,  146,  0,  0,  0,  0 }, /* index 50  */
 491 { 1,  1,  0,  292,  0,  0,  0,  0 }, /* index 51  */
 492 { 1,  1,  0,  584,  0,  0,  0,  0 }, /* index 52  */
 493 { 2, 16,  1,    2,  0,  0,  0,  0 }, /* index 53  */
 494 { 2,  8,  1,    2,  0,  0,  0,  0 }, /* index 54  */
 495 { 2,  4,  0,    2,  0,  0,  0,  0 }, /* index 55  */
 496 { 2,  2,  0,    2,  0,  0,  0,  0 }, /* index 56  */
 497 { 2,  2,  0,   32,  0,  0,  0,  0 }, /* index 57  */
 498 { 2,  1,  0,    2,  0,  0,  0,  0 }, /* index 58  */
 499 { 2,  1,  0,   32,  0,  0,  0,  0 }, /* index 59  */
 500 { 3, 16,  1,    2,  0,  0,  0,  0 }, /* index 60  */
 501 { 3, 16,  1,   16,  0,  0,  0,  0 }, /* index 61  */
 502 { 3, 16,  1,  128,  0,  0,  0,  0 }, /* index 62  */
 503 { 3, 16,  1,  512,  0,  0,  0,  0 }, /* index 63  */
 504 { 3,  8,  1,    2,  0,  0,  0,  0 }, /* index 64  */
 505 { 3,  8,  1,   16,  0,  0,  0,  0 }, /* index 65  */
 506 { 3,  8,  1,  128,  0,  0,  0,  0 }, /* index 66  */
 507 { 3,  4,  1,    2,  0,  0,  0,  0 }, /* index 67  */
 508 { 3,  4,  1,   16,  0,  0,  0,  0 }, /* index 68  */
 509 { 3,  4,  1,  128,  0,  0,  0,  0 }, /* index 69  */
 510 { 3,  4,  1,  512,  0,  0,  0,  0 }, /* index 70  */
 511 { 3,  2,  1,    2,  0,  0,  0,  0 }, /* index 71  */
 512 { 3,  2,  1,   16,  0,  0,  0,  0 }, /* index 72  */
 513 { 3,  2,  1,  128,  0,  0,  0,  0 }, /* index 73  */
 514 { 3,  2,  1,  512,  0,  0,  0,  0 }, /* index 74  */
 515 { 3,  1,  0,    2,  0,  0,  0,  0 }, /* index 75  */
 516 { 3,  1,  0,   16,  0,  0,  0,  0 }, /* index 76  */
 517 { 3,  1,  0,  128,  0,  0,  0,  0 }, /* index 77  */
 518 { 3,  1,  0,   66,  0,  0,  0,  0 }, /* index 78  */
 519 { 3,  1,  0,  132,  0,  0,  0,  0 }, /* index 79  */
 520 { 3,  1,  0,  264,  0,  0,  0,  0 }, /* index 80  */
 521 { 3,  1,  0,  146,  0,  0,  0,  0 }, /* index 81  */
 522 { 3,  1,  0,  292,  0,  0,  0,  0 }, /* index 82  */
 523 { 3,  1,  0,  584,  0,  0,  0,  0 }, /* index 83  */
 524 { 3,  1,  0,  341,  0,  0,  0,  0 }, /* index 84  */
 525 { 3,  1,  0,  682,  0,  0,  0,  0 }, /* index 85  */
 526 { 3,  1,  0, 1023,  0,  0,  0,  0 }, /* index 86  */
 527 { 4, 16,  0,  528,  0,  1,  6,  2 }, /* index 87  */
 528 { 4, 16,  1,   16,  0,  2,  6,  2 }, /* index 88  */
 529 { 4,  8,  0,  528,  0,  1,  6,  2 }, /* index 89  */
 530 { 4,  8,  1,   16,  0,  2,  6,  2 }, /* index 90  */
 531 { 4,  4,  0,  528,  0,  1,  6,  2 }, /* index 91  */
 532 { 4,  4,  1,  528,  0,  1,  6,  2 }, /* index 92  */
 533 { 4,  4,  0,   16,  0,  2,  6,  2 }, /* index 93  */
 534 { 4,  2,  0,  528,  0,  1,  6,  2 }, /* index 94  */
 535 { 4,  2,  0,    2,  0,  2,  6,  2 }, /* index 95  */
 536 { 4,  2,  0,   16,  0,  2,  6,  2 }, /* index 96  */
 537 { 4,  2,  0,  128,  0,  2,  6,  2 }, /* index 97  */
 538 { 4,  1,  0,   16,  0,  1,  6,  2 }, /* index 98  */
 539 { 4,  1,  0,   66,  0,  1,  6,  2 }, /* index 99  */
 540 { 4,  1,  0,  528,  0,  1,  6,  2 }, /* index 100  */
 541 { 4,  1,  0,    2,  0,  2,  6,  2 }, /* index 101  */
 542 { 4,  1,  0,  128,  0,  2,  6,  2 }, /* index 102  */
 543 { 4,  1,  0,  132,  0,  2,  6,  2 }, /* index 103  */
 544 { 4,  1,  0,  146,  0,  2,  6,  2 }, /* index 104  */
 545 { 4,  1,  0,  341,  0,  2,  6,  2 }, /* index 105  */
 546 { 4,  1,  0, 1023,  0,  2,  6,  2 }, /* index 106  */
 547 { 4,  1,  0,  682,  0,  2,  6,  2 }, /* index 107  */
 548 {11,  2,  0,  528,  0,  1,  7,  2 }, /* index 108  */
 549 {11,  2,  0,   16,  0,  2,  7,  2 }, /* index 109  */
 550 {11,  1,  0,   16,  0,  1,  7,  2 }, /* index 110  */
 551 {11,  1,  0,   66,  0,  1,  7,  2 }, /* index 111  */
 552 {11,  1,  0,  528,  0,  1,  7,  2 }, /* index 112  */
 553 {11,  1,  0,    2,  0,  2,  7,  2 }, /* index 113  */
 554 {11,  1,  0,  128,  0,  2,  7,  2 }, /* index 114  */
 555 {11,  1,  0,  146,  0,  2,  7,  2 }, /* index 115  */
 556 {11,  1,  0,  341,  0,  2,  7,  2 }, /* index 116  */
 557 { 5, 16,  1,  580,  0,  1,  3,  4 }, /* index 117  */
 558 { 5, 16,  1,   16,  0,  2,  3,  4 }, /* index 118  */
 559 { 5,  8,  1,  580,  0,  1,  3,  4 }, /* index 119  */
 560 { 5,  8,  1,   16,  0,  2,  3,  4 }, /* index 120  */
 561 { 5,  4,  0,  580,  0,  1,  3,  4 }, /* index 121  */
 562 { 5,  4,  0,   16,  0,  2,  3,  4 }, /* index 122  */
 563 { 5,  2,  1,  580,  0,  1,  3,  4 }, /* index 123  */
 564 { 5,  2,  0,    2,  0,  2,  3,  4 }, /* index 124  */
 565 { 5,  2,  0,   16,  0,  2,  3,  4 }, /* index 125  */
 566 { 5,  2,  0,  128,  0,  2,  3,  4 }, /* index 126  */
 567 { 5,  1,  0,   16,  0,  1,  3,  4 }, /* index 127  */
 568 { 5,  1,  0,   66,  0,  1,  3,  4 }, /* index 128  */
 569 { 5,  1,  0,  528,  0,  1,  3,  4 }, /* index 129  */
 570 { 5,  1,  0,    2,  0,  2,  3,  4 }, /* index 130  */
 571 { 5,  1,  0,  128,  0,  2,  3,  4 }, /* index 131  */
 572 { 5,  1,  0,  132,  0,  2,  3,  4 }, /* index 132  */
 573 { 5,  1,  0,  146,  0,  2,  3,  4 }, /* index 133  */
 574 { 5,  1,  0,  341,  0,  2,  3,  4 }, /* index 134  */
 575 { 5,  1,  0, 1023,  0,  2,  3,  4 }, /* index 135  */
 576 { 5,  1,  0,  682,  0,  2,  3,  4 }, /* index 136  */
 577 {12,  2,  1,  580,  0,  1,  3,  4 }, /* index 137  */
 578 {12,  2,  0,   16,  0,  2,  3,  4 }, /* index 138  */
 579 {12,  1,  0,   16,  0,  1,  3,  4 }, /* index 139  */
 580 {12,  1,  0,   66,  0,  1,  3,  4 }, /* index 140  */
 581 {12,  1,  0,  528,  0,  1,  3,  4 }, /* index 141  */
 582 {12,  1,  0,    2,  0,  2,  3,  4 }, /* index 142  */
 583 {12,  1,  0,  128,  0,  2,  3,  4 }, /* index 143  */
 584 {12,  1,  0,  146,  0,  2,  3,  4 }, /* index 144  */
 585 {12,  1,  0,  341,  0,  2,  3,  4 }, /* index 145  */
 586 {12,  1,  0, 1023,  0,  2,  3,  4 }, /* index 146  */
 587 { 6, 16,  1,  528,  0,  1,  2,  6 }, /* index 147  */
 588 { 6, 16,  1,   16,  0,  2,  2,  6 }, /* index 148  */
 589 { 6,  8,  1,  528,  0,  1,  2,  6 }, /* index 149  */
 590 { 6,  8,  1,   16,  0,  2,  2,  6 }, /* index 150  */
 591 { 6,  4,  0,  528,  0,  1,  2,  6 }, /* index 151  */
 592 { 6,  4,  0,   16,  0,  2,  2,  6 }, /* index 152  */
 593 { 6,  2,  1,  580,  0,  2,  2,  6 }, /* index 153  */
 594 { 6,  2,  0,    2,  0,  2,  2,  6 }, /* index 154  */
 595 { 6,  2,  0,   16,  0,  2,  2,  6 }, /* index 155  */
 596 { 6,  2,  0,  128,  0,  2,  2,  6 }, /* index 156  */
 597 { 6,  1,  0,   16,  0,  1,  2,  6 }, /* index 157  */
 598 { 6,  1,  0,   66,  0,  1,  2,  6 }, /* index 158  */
 599 { 6,  1,  0,  528,  0,  1,  2,  6 }, /* index 159  */
 600 { 6,  1,  0,    2,  0,  2,  2,  6 }, /* index 160  */
 601 { 6,  1,  0,  128,  0,  2,  2,  6 }, /* index 161  */
 602 { 6,  1,  0,  132,  0,  2,  2,  6 }, /* index 162  */
 603 { 6,  1,  0,  146,  0,  2,  2,  6 }, /* index 163  */
 604 { 6,  1,  0,  341,  0,  2,  2,  6 }, /* index 164  */
 605 { 6,  1,  0, 1023,  0,  2,  2,  6 }, /* index 165  */
 606 { 6,  1,  0,  682,  0,  2,  2,  6 }, /* index 166  */
 607 {13,  2,  1,  580,  0,  2,  2,  6 }, /* index 167  */
 608 {13,  2,  0,   16,  0,  2,  2,  6 }, /* index 168  */
 609 {13,  1,  0,   16,  0,  1,  2,  6 }, /* index 169  */
 610 {13,  1,  0,   66,  0,  1,  2,  6 }, /* index 170  */
 611 {13,  1,  0,  528,  0,  1,  2,  6 }, /* index 171  */
 612 {13,  1,  0,    2,  0,  2,  2,  6 }, /* index 172  */
 613 {13,  1,  0,  128,  0,  2,  2,  6 }, /* index 173  */
 614 {13,  1,  0,  146,  0,  2,  2,  6 }, /* index 174  */
 615 {13,  1,  0,  341,  0,  2,  2,  6 }, /* index 175  */
 616 {13,  1,  0, 1023,  0,  2,  2,  6 }, /* index 176  */
 617 { 7, 16,  0,  528,  0,  1,  7,  2 }, /* index 177  */
 618 { 7, 16,  1,   16,  0,  2,  7,  2 }, /* index 178  */
 619 { 7,  8,  0,  528,  0,  1,  7,  2 }, /* index 179  */
 620 { 7,  8,  1,   16,  0,  2,  7,  2 }, /* index 180  */
 621 { 7,  4,  0,  528,  0,  1,  7,  2 }, /* index 181  */
 622 { 7,  4,  1,  528,  0,  1,  7,  2 }, /* index 182  */
 623 { 7,  4,  0,   16,  0,  2,  7,  2 }, /* index 183  */
 624 { 7,  2,  0,  528,  0,  1,  7,  2 }, /* index 184  */
 625 { 7,  2,  0,    2,  0,  2,  7,  2 }, /* index 185  */
 626 { 7,  2,  0,   16,  0,  2,  7,  2 }, /* index 186  */
 627 { 7,  2,  0,  128,  0,  2,  7,  2 }, /* index 187  */
 628 { 7,  1,  0,   16,  0,  1,  7,  2 }, /* index 188  */
 629 { 7,  1,  0,   66,  0,  1,  7,  2 }, /* index 189  */
 630 { 7,  1,  0,  528,  0,  1,  7,  2 }, /* index 190  */
 631 { 7,  1,  0,    2,  0,  2,  7,  2 }, /* index 191  */
 632 { 7,  1,  0,  128,  0,  2,  7,  2 }, /* index 192  */
 633 { 7,  1,  0,  132,  0,  2,  7,  2 }, /* index 193  */
 634 { 7,  1,  0,  146,  0,  2,  7,  2 }, /* index 194  */
 635 { 7,  1,  0,  341,  0,  2,  7,  2 }, /* index 195  */
 636 { 7,  1,  0, 1023,  0,  2,  7,  2 }, /* index 196  */
 637 { 7,  1,  0,  682,  0,  2,  7,  2 }, /* index 197  */
 638 { 8, 16,  0,  528,  0,  2,  1, 12 }, /* index 198  */
 639 { 8, 16,  1,   16,  0,  2,  1, 12 }, /* index 199  */
 640 { 8,  8,  0,  528,  0,  2,  1, 12 }, /* index 200  */
 641 { 8,  8,  1,   16,  0,  2,  1, 12 }, /* index 201  */
 642 { 8,  4,  0,  528,  0,  2,  1, 12 }, /* index 202  */
 643 { 8,  4,  0,   16,  0,  2,  1, 12 }, /* index 203  */
 644 { 8,  4,  1,  528,  0,  2,  1, 12 }, /* index 204  */
 645 { 8,  2,  0,  528,  0,  2,  1, 12 }, /* index 205  */
 646 { 8,  2,  0,    2,  0,  2,  1, 12 }, /* index 206  */
 647 { 8,  2,  0,   16,  0,  2,  1, 12 }, /* index 207  */
 648 { 8,  2,  0,  128,  0,  2,  1, 12 }, /* index 208  */
 649 { 8,  1,  0,    2,  0,  2,  1, 12 }, /* index 209  */
 650 { 8,  1,  0,   16,  0,  2,  1, 12 }, /* index 210  */
 651 { 8,  1,  0,  128,  0,  2,  1, 12 }, /* index 211  */
 652 { 8,  1,  0,   66,  0,  2,  1, 12 }, /* index 212  */
 653 { 8,  1,  0,  132,  0,  2,  1, 12 }, /* index 213  */
 654 { 8,  1,  0,  528,  0,  2,  1, 12 }, /* index 214  */
 655 { 8,  1,  0,  146,  0,  2,  1, 12 }, /* index 215  */
 656 { 8,  1,  0,  341,  0,  2,  1, 12 }, /* index 216  */
 657 { 8,  1,  0, 1023,  0,  2,  1, 12 }, /* index 217  */
 658 { 8,  1,  0,  682,  0,  2,  1, 12 }, /* index 218  */
 659 { 9,  8,  1,   16,  0,  2,  7,  2 }, /* index 219  */
 660 { 9,  4,  1,  528,  0,  1,  7,  2 }, /* index 220  */
 661 { 9,  4,  0,   16,  0,  2,  7,  2 }, /* index 221  */
 662 { 9,  2,  0,  528,  0,  1,  7,  2 }, /* index 222  */
 663 { 9,  2,  0,    2,  0,  2,  7,  2 }, /* index 223  */
 664 { 9,  2,  0,   16,  0,  2,  7,  2 }, /* index 224  */
 665 { 9,  2,  0,  128,  0,  2,  7,  2 }, /* index 225  */
 666 { 9,  1,  0,   16,  0,  1,  7,  2 }, /* index 226  */
 667 { 9,  1,  0,   66,  0,  1,  7,  2 }, /* index 227  */
 668 { 9,  1,  0,  528,  0,  1,  7,  2 }, /* index 228  */
 669 { 9,  1,  0,    2,  0,  2,  7,  2 }, /* index 229  */
 670 { 9,  1,  0,  128,  0,  2,  7,  2 }, /* index 230  */
 671 { 9,  1,  0,  132,  0,  2,  7,  2 }, /* index 231  */
 672 { 9,  1,  0,  146,  0,  2,  7,  2 }, /* index 232  */
 673 { 9,  1,  0,  341,  0,  2,  7,  2 }, /* index 233  */
 674 { 9,  1,  0, 1023,  0,  2,  7,  2 }, /* index 234  */
 675 { 9,  1,  0,  682,  0,  2,  7,  2 }, /* index 235  */
 676 {10, 16,  1,  528,  0,  1,  2,  6 }, /* index 236  */
 677 {10, 16,  1,   16,  0,  2,  2,  6 }, /* index 237  */
 678 {10,  8,  1,  528,  0,  1,  2,  6 }, /* index 238  */
 679 {10,  8,  1,   16,  0,  2,  2,  6 }, /* index 239  */
 680 {10,  4,  0,  528,  0,  1,  2,  6 }, /* index 240  */
 681 {10,  4,  0,   16,  0,  2,  2,  6 }, /* index 241  */
 682 {10,  2,  1,  580,  0,  2,  2,  6 }, /* index 242  */
 683 {10,  2,  0,    2,  0,  2,  2,  6 }, /* index 243  */
 684 {10,  2,  0,   16,  0,  2,  2,  6 }, /* index 244  */
 685 {10,  2,  0,  128,  0,  2,  2,  6 }, /* index 245  */
 686 {10,  1,  0,   16,  0,  1,  2,  6 }, /* index 246  */
 687 {10,  1,  0,   66,  0,  1,  2,  6 }, /* index 247  */
 688 {10,  1,  0,  528,  0,  1,  2,  6 }, /* index 248  */
 689 {10,  1,  0,    2,  0,  2,  2,  6 }, /* index 249  */
 690 {10,  1,  0,  128,  0,  2,  2,  6 }, /* index 250  */
 691 {10,  1,  0,  132,  0,  2,  2,  6 }, /* index 251  */
 692 {10,  1,  0,  146,  0,  2,  2,  6 }, /* index 252  */
 693 {10,  1,  0,  341,  0,  2,  2,  6 }, /* index 253  */
 694 {10,  1,  0, 1023,  0,  2,  2,  6 }, /* index 254  */
 695 {10,  1,  0,  682,  0,  2,  2,  6 }  /* index 255  */
 696 };
 697 #endif
 698
 699 /* Defintion of delta value Table 6.1.2.1.1-5 spec 38.214 */
 700 uint8_t puschDeltaTable[MAX_MU_PUSCH] = { 2, 3, 4, 6 };
 701
 702 uint16_t tbSizeTable[TOTAL_TBSIZE_VALUES] = {
 703          24,    32,    40,    48,    56,    64,    72,    80,    88,    96, \
 704         104,   112,   120,   128,   136,   144,   152,   160,   168,   176, \
 705         184,   192,   208,   224,   240,   256,   272,   288,   304,   320, \
 706         336,   352,   368,   384,   408,   432,   456,   480,   504,   528, \
 707         552,   576,   608,   640,   672,   704,   736,   768,   808,   848, \
 708         888,   928,   984,  1032,  1064,  1128,  1160,  1192,  1224,  1256, \
 709        1288,  1320,  1352,  1416,  1480,  1544,  1608,  1672,  1736,  1800, \
 710        1864,  1928,  2024,  2088,  2152,  2216,  2280,  2408,  2472,  2536, \
 711        2600,  2664,  2728,  2792,  2856,  2976,  3104,  3240,  3368,  3496, \
 712        3624,  3752,  3824 };
 713
 714 uint16_t mcsTable[32][3] = {
 715       {   0,   2,   120},   /* mcs index  0 */
 716       {   1,   2,   157},   /* mcs index  1 */
 717       {   2,   2,   193},   /* mcs index  2 */
 718       {   3,   2,   251},   /* mcs index  3 */
 719       {   4,   2,   308},   /* mcs index  4 */
 720       {   5,   2,   379},   /* mcs index  5 */
 721       {   6,   2,   449},   /* mcs index  6 */
 722       {   7,   2,   526},   /* mcs index  7 */
 723       {   8,   2,   602},   /* mcs index  8 */
 724       {   9,   2,   679},   /* mcs index  9 */
 725       {  10,   4,   340},   /* mcs index 10 */
 726       {  11,   4,   378},   /* mcs index 11 */
 727       {  12,   4,   434},   /* mcs index 12 */
 728       {  13,   4,   490},   /* mcs index 13 */
 729       {  14,   4,   553},   /* mcs index 14 */
 730       {  15,   4,   616},   /* mcs index 15 */
 731       {  16,   4,   658},   /* mcs index 16 */
 732       {  17,   6,   438},   /* mcs index 17 */
 733       {  18,   6,   466},   /* mcs index 18 */
 734       {  19,   6,   517},   /* mcs index 19 */
 735       {  20,   6,   567},   /* mcs index 20 */
 736       {  21,   6,   616},   /* mcs index 21 */
 737       {  22,   6,   666},   /* mcs index 22 */
 738       {  23,   6,   719},   /* mcs index 23 */
 739       {  24,   6,   772},   /* mcs index 24 */
 740       {  25,   6,   822},   /* mcs index 25 */
 741       {  26,   6,   873},   /* mcs index 26 */
 742       {  27,   6,   910},   /* mcs index 27 */
 743       {  28,   6,   948},   /* mcs index 28 */
 744       {  29,   2,     0},   /* mcs index 29 */
 745       {  30,   4,     0},   /* mcs index 30 */
 746       {  31,   6,     0}};  /* mcs index 31 */
 747
 748 /* PUCCH resource sets before dedicated PUCCH resource configuration */
 749 /* Table 9.2.1-1 spec 38.213      */
 750 /*{PUCCH_Format, 1stSym, NumSym, PRBOffset, Num_CyclicShift}*/
 751 uint8_t pucchResourceSet[MAX_PUCCH_RES_SET_IDX][5] = {
 752 { 0,  12,  2,  0,  2 }, /* index  0 */
 753 { 0,  12,  2,  0,  3 }, /* index  1 */
 754 { 0,  12,  2,  3,  3 }, /* index  2 */
 755 { 1,  10,  4,  0,  2 }, /* index  3 */
 756 { 1,  10,  4,  0,  4 }, /* index  4 */
 757 { 1,  10,  4,  2,  4 }, /* index  5 */
 758 { 1,  10,  4,  4,  4 }, /* index  6 */
 759 { 1,   4, 10,  0,  2 }, /* index  7 */
 760 { 1,   4, 10,  0,  4 }, /* index  8 */
 761 { 1,   4, 10,  2,  4 }, /* index  9 */
 762 { 1,   4, 10,  4,  4 }, /* index 10 */
 763 { 1,   0, 14,  0,  2 }, /* index 11 */
 764 { 1,   0, 14,  0,  4 }, /* index 12 */
 765 { 1,   0, 14,  2,  4 }, /* index 13 */
 766 { 1,   0, 14,  4,  4 }, /* index 14 */
 767 { 1,   0, 14,  (MAX_NUM_RB/4),  4 }, /* index 15 */
 768 };
 769
 770 /*CQI Table From Spec 38.214 Table 5.2.2.1-2
 771  * {Modulation Scheme, CodeRate, Efficiency(bits per symbol)}
 772  * Modulation Scheme is numbered based on bit rate as follows
 773  * QPSK = 2, 16QAM = 4, 64QAM = 6
 774  * */
 775 float cqiTable1[MAX_NUM_CQI_IDX][3] = {
 776 { 0, 0, 0},        /*index 0*/
 777 { 2, 78, 0.1523},  /*index 1*/
 778 { 2, 120, 0.2344}, /*index 2*/
 779 { 2, 193, 0.3770}, /*index 3*/
 780 { 2, 308, 0.6016}, /*index 4*/
 781 { 2, 449, 0.8770}, /*index 5*/
 782 { 2, 602, 1.1758}, /*index 6*/
 783 { 4, 378, 1.4766}, /*index 7*/
 784 { 4, 490, 1.9141}, /*index 8*/
 785 { 4, 616, 2.4063}, /*index 9*/
 786 { 6, 466, 2.7305}, /*index 10*/
 787 { 6, 567, 3.3223}, /*index 11*/
 788 { 6, 666, 3.9023}, /*index 12*/
 789 { 6, 772, 4.5234}, /*index 13*/
 790 { 6, 873, 5.1152}, /*index 14*/
 791 { 6, 948, 5.5547}, /*index 15*/
 792 };
 793
 794 /*As per Spec 38.211 Table 7.3.2.1-1, using number of CCE per AggLevel
 795  * Num of RE for Agg Level = numCCEPerAggLevel * (6 REG) * (12 Subcarriers)
 796  */
 797 uint16_t totalRE_PerAggLevel[MAX_NUM_AGG_LVL]= {72, 144, 288, 576, 1152};
 798
 799
 800 /* Minimum Msg3 scheduling time should be calculated based on N1+N2+NTAmax+0.5
 801  * ms formula.
 802  * Refer spec 38.213 section 8.3.
 803  * Harcoding the minimum msg3 scheduling for now */
 804 uint8_t minMsg3SchTime[MAX_NUM_MU] = {6, 6, 6, 6};
 805
 806 uint8_t defaultUlAckTbl[DEFAULT_UL_ACK_LIST_COUNT]= {1, 2, 3 , 4, 5, 6, 7, 8};
 807
 808 uint8_t schCmnDlRvTbl[4] = {0, 2, 3, 1};
 809 /**
 810  * @brief Function to find first DMRS symbol in PDSCH
 811  *
 812  * @details
 813  *
 814  *     Function: findDmrsStartSymbol
 815  *
 816  *     This function finds first DMRS symbol using DMRS symbol
 817  *     position bitmap.
 818  *
 819  *  @param[in]  DMRS symbol position bitmap
 820  *  @return     Success : First DRMS symbol
 821  *              Failure : MAX_SYMB_PER_SLOT
 822  **/
 823 uint8_t findDmrsStartSymbol(uint16_t dlDmrsSymbBitMap)
 824 {
 825    uint8_t position = 0;
 826    uint16_t mask = 1;
 827
 828    while(position < MAX_SYMB_PER_SLOT)
 829    {
 830       if(dlDmrsSymbBitMap & mask)
 831          break;
 832       mask = mask << 1;
 833       position++;
 834    }
 835    return position;
 836 }
 837
 838 /**
 839  * @brief Function to add a node to a linked list
 840  *
 841  * @details
 842  *
 843  *     Function: addNodeToLList
 844  *
 845  *     This function adds a new node to the linked list
 846  *
 847  *  @param[in]  Pointer to the list
 848  *              Pointer to node to be added
 849  *              Pointer to current node
 850  *  @return     ROK
 851  *              RFAILED
 852  **/
 853 uint8_t addNodeToLList(CmLListCp *llist, void *blockToAdd, CmLList *currNode)
 854 {
 855    CmLList  *newNode;
 856
 857    SCH_ALLOC(newNode, sizeof(CmLList));
 858    if(newNode)
 859    {
 860       newNode->node = (PTR)blockToAdd;
 861
 862       if(currNode == NULLP)
 863          cmLListAdd2Tail(llist, newNode);
 864       else
 865       {
 866          llist->crnt = currNode;
 867          cmLListInsAfterCrnt(llist, newNode);
 868       }
 869       return ROK;
 870    }
 871    return RFAILED;
 872 }
 873
 874 /**
 875  * @brief Function to delete a node from linked list
 876  *
 877  * @details
 878  *
 879  *     Function: deleteNodeFromLList
 880  *
 881  *     This function deletes a node from the linked list
 882  *
 883  *  @param[in]  Pointer to the list
 884  *              Pointer to node to be deleted
 885  *  @return     Pointer to the deleted node
 886  **/
 887 uint8_t deleteNodeFromLList(CmLListCp *llist, CmLList *node)
 888 {
 889    node = cmLListDelFrm(llist, node);
 890    SCH_FREE(node, sizeof(CmLList));
 891
 892    return ROK;
 893 }
 894
 895 /**
 896  * @brief Checks if requested PRBs are free
 897  *
 898  * @details
 899  *
 900  *     Function: isPrbAvailable
 901  *
 902  *     This functions loops through all free PRB blocks and
 903  *     checks if request PRB block is available for allocation
 904  *
 905  *  @param[in]  List of free PRB blocks
 906  *              First PRB requested
 907  *              Total number of PRB requested
 908  *
 909  *  @return     Returns Pointer to free block
 910  *              NULL
 911  **/
 912 CmLList* isPrbAvailable(CmLListCp *freePrbBlockList, uint16_t startPrb, uint16_t numPrb)
 913 {
 914    uint16_t      endPrb = 0;
 915    CmLList       *node = NULLP;
 916    FreePrbBlock  *freeBlock = NULLP;
 917
 918    endPrb = startPrb + numPrb - 1;
 919
 920    /* Iterate through all blocks of free PRB to check if requested PRBs can be assigned */
 921    node = freePrbBlockList->first;
 922    while(node)
 923    {
 924       freeBlock = (FreePrbBlock *)node->node;
 925
 926       /* Check if requested number of blocks can be allocated from the current block */
 927       if(freeBlock->numFreePrb < numPrb)
 928       {
 929          DU_LOG("\nINFO   --> SCH: In isPrbAvailable, numFreePrb:%d is less than reqPrb:%d", freeBlock->numFreePrb, numPrb);
 930          node = node->next;
 931          continue;
 932       }
 933
 934       /* Check if requested PRBs belong within the range of current free block */
 935       if(((startPrb >= freeBlock->startPrb) && (startPrb <= freeBlock->endPrb)) && \
 936          ((endPrb >= freeBlock->startPrb) && (endPrb <= freeBlock->endPrb)))
 937       {
 938          return node;
 939       }
 940
 941       /* If current block is unable to provide resources, check the next block */
 942       node = node->next;
 943    }
 944    return NULLP;
 945 }
 946
 947 /**
 948  * @brief Function to update free PRB list
 949  *
 950  * @details
 951  *
 952  *     Function: removeAllocatedPrbFromFreePrbList
 953  *
 954  *     This function removes the allocated PRBs from the
 955  *     list of free PRBs
 956  *
 957  *  @param[in]  Pointer to the list
 958  *              Pointer to node from which PRB was allocated
 959  *              Start PRB allocated
 960  *              Number of PRBs allocated
 961  *  @return     void
 962  **/
 963 void removeAllocatedPrbFromFreePrbList(CmLListCp *freePrbBlockList, CmLList *node, uint16_t startPrb, uint16_t numPrb)
 964 {
 965    uint16_t      endPrb;
 966    FreePrbBlock  *newBlock = NULLP;
 967    FreePrbBlock  *freeBlock = (FreePrbBlock *)node->node;
 968
 969    if(!node)
 970       return;
 971
 972    endPrb = startPrb + numPrb -1;
 973
 974    /* If the whole block is allocated, remove it from linked list */
 975    if(freeBlock->numFreePrb == numPrb)
 976    {
 977       if(deleteNodeFromLList(freePrbBlockList, node) == ROK)
 978          SCH_FREE(freeBlock, sizeof(FreePrbBlock));
 979    }
 980
 981    /* If PRB is allocated from start of free block, move the start of free block
 982     * after last alloctaed PRB */
 983    else if(freeBlock->startPrb == startPrb)
 984    {
 985       freeBlock->startPrb = endPrb+1;
 986       freeBlock->numFreePrb = freeBlock->endPrb - freeBlock->startPrb +1;
 987    }
 988
 989    /* If PRB is allocated from end of free block, move the end of free block
 990     * before the first allocated PRB */
 991    else if(freeBlock->endPrb == endPrb)
 992    {
 993       freeBlock->endPrb = startPrb-1;
 994       freeBlock->numFreePrb = freeBlock->endPrb - freeBlock->startPrb +1;
 995    }
 996
 997    /* If PRBs are allocated somewhere in between the free block, split it into 2
 998     * nodes. Fist node contains free PRBs after the allocated PRBs. Second node
 999     * contains free PRBs present before the allocated PRBs */
1000    else
1001    {
1002       /* Block 2 */
1003       SCH_ALLOC(newBlock, sizeof(FreePrbBlock));
1004       if(newBlock)
1005       {
1006          newBlock->startPrb = freeBlock->startPrb;
1007          newBlock->endPrb = startPrb-1;
1008          newBlock->numFreePrb = newBlock->endPrb - newBlock->startPrb +1;
1009          addNodeToLList(freePrbBlockList, newBlock, node);
1010       }
1011
1012       /* Block 1 */
1013       freeBlock->startPrb = endPrb+1;
1014       freeBlock->numFreePrb = freeBlock->endPrb - freeBlock->startPrb +1;
1015    }
1016 }
1017
1018 /**
1019  * @brief frequency domain allocation function.
1020  *
1021  * @details
1022  *
1023  *     Function: schCalcTbSize
1024  *
1025  *     This function finds the TBSize from table Table 5.1.3.2-1 spec 38.214
1026  *
1027  *  @param[in]  payLoadSize - size of payload in bytes
1028  *  @return     TBsize from the Table in bytes
1029  **/
1030 uint16_t schCalcTbSize(uint32_t payLoadSize)
1031 {
1032    uint8_t tbsIndex = 0;
1033    uint16_t maxTbSize;
1034
1035    maxTbSize = tbSizeTable[TOTAL_TBSIZE_VALUES -1]/8;
1036    if(payLoadSize >= maxTbSize)
1037       return maxTbSize;
1038
1039    payLoadSize = payLoadSize*8;
1040    while(payLoadSize > tbSizeTable[tbsIndex])
1041    {
1042       tbsIndex++;
1043    }
1044
1045    /* return the TBsize in bytes */
1046    return (tbSizeTable[tbsIndex]/8);
1047 }
1048
1049 /**
1050  * @brief frequency domain allocation function.
1051  *
1052  * @details
1053  *
1054  *     Function: schCalcNumPrb
1055  *
1056  *     This function calculates the number of PRbs
1057  *
1058  *  @param[in]  tbSize in bytes
1059  *  @param[in]  mcs
1060  *  @param[in]  number of symbols
1061  *  @return   number PRBs
1062  **/
1063 uint16_t schCalcNumPrb(uint16_t tbSize, uint16_t mcs, uint8_t numSymbols)
1064 {
1065    uint16_t numPrb = 0;
1066    uint16_t nre = 0;
1067    uint16_t nreDash = 0;
1068    uint8_t  qm     = mcsTable[mcs][1];
1069    uint16_t rValue = mcsTable[mcs][2];
1070    uint8_t  numLayer = 1;       /* v value */
1071    uint8_t  numDmrsRePerPrb = 12;
1072
1073    tbSize = tbSize * 8; //Calculate tbSize in bits
1074
1075    /* formula used for calculation of rbSize, 38.214 section 5.1.3.2 *
1076     * Ninfo = S . Nre . R . Qm . v                                       *
1077     * Nre' = Nsc . NsymPdsch - NdmrsSymb - Noh                       *
1078     * Nre = min(156,Nre') . nPrb                                     */
1079
1080    nre = ceil( (float)tbSize * 1024 / (qm * rValue * numLayer));
1081
1082    nreDash = ceil( (12 * numSymbols) - numDmrsRePerPrb - 0);
1083
1084    if (nreDash > 156)
1085       nreDash = 156;
1086
1087    numPrb = ceil((float)nre / nreDash);
1088    return numPrb;
1089 }
1090
1091 /**
1092 * @brief calculation of transport block size.
1093 *
1094 * @details
1095 *
1096 *     Function: schCalcTbSizeFromNPrb
1097 *
1098 *     This function calculates the transport block size
1099 *
1100 *  @param[in]  nPrb is num PRB
1101 *  @param[in]  mcs
1102 *  @param[in]  number of symbols
1103 *  @return   tbSize
1104 **/
1105 uint16_t schCalcTbSizeFromNPrb(uint16_t numPrb, uint16_t mcs, uint8_t numSymbols)
1106 {
1107    uint8_t  qm     = mcsTable[mcs][1];
1108    uint16_t rValue = mcsTable[mcs][2];
1109    uint16_t tbsIndex = 0;
1110    uint32_t tbSize = 0;
1111    uint32_t nre = 0;
1112    uint32_t nreDash = 0;
1113    uint32_t nInfo = 0;
1114    uint32_t n = 0;
1115    uint32_t nInfoDash = 0;
1116    uint32_t c = 0;
1117    const uint8_t  numLayer = 1;
1118    const uint16_t numRbSc = 12;
1119    const uint16_t numDmrsRes = 12;
1120    const uint16_t sf = 1;
1121 //   uint16_t numPrbOvrHead = 0;
1122
1123   /* formula used for calculation of rbSize, 38.214 section 5.1.3.2  *
1124    * Ninfo = Nre . R . Qm . v   where [ NInfo is tbSize]             *
1125    * Nre' = Nsc . NsymPdsch - NdmrsSymb - Noh                        *
1126    * Nre = min(156,Nre') . nPrb                                      */
1127
1128    nreDash = MIN(156, ceil( (numRbSc * numSymbols) - numDmrsRes - 0));
1129    nre = nreDash * numPrb;
1130    nInfo = ceil(nre * qm * numLayer * rValue/(1024.0 * sf));
1131
1132    if(nInfo <= 3824)
1133    {
1134       n = MAX(3, (uint32_t)cmLog2(nInfo) - 6);
1135       nInfoDash = MAX(24, (1<<n)*(nInfo/(1<<n)));
1136       while(nInfoDash > tbSizeTable[tbsIndex])
1137       {
1138          tbsIndex++;
1139       }
1140       tbSize = tbSizeTable[tbsIndex];
1141    }
1142    else
1143    {
1144       n = (uint32_t)cmLog2(nInfo - 24) - 5;
1145       nInfoDash = MAX(3840, (1<<n)*ceil((nInfo - 24)/(1<<n)));
1146
1147       if(rValue<256)
1148       {
1149          c = ceil((nInfoDash + 24)/3816);
1150          tbSize = 8 * c * ceil((nInfoDash + 24)/(8 * c)) - 24;
1151       }
1152       else
1153       {
1154          if(nInfoDash > 8424)
1155          {
1156             c = ceil((nInfoDash + 24)/8424);
1157             tbSize = 8 * c * ceil((nInfoDash + 24)/(8 * c)) - 24;
1158          }
1159          else
1160          {
1161             tbSize = 8 * ceil((nInfoDash + 24)/(8)) - 24;
1162          }
1163       }
1164    }
1165    return tbSize;
1166 }
1167
1168 /**
1169  * @brief fetching ueCb from cellCb
1170  *
1171  * @details
1172  *
1173  *     Function: schGetUeCb
1174  *
1175  *     This function fetched UeCb based on crnti from cellCb
1176  *
1177  *  @param[in]  cellCb
1178  *  @param[in]  crnti
1179  *  @return     ueCb
1180  **/
1181 SchUeCb* schGetUeCb(SchCellCb *cellCb, uint16_t crnti)
1182 {
1183    uint16_t ueId;
1184    GET_UE_ID(crnti, ueId);
1185    return &(cellCb->ueCb[ueId -1]);
1186 }
1187
1188 /**
1189  * @brief initialize UL slot info
1190  *
1191  * @details
1192  *
1193  *     Function: schInitUlSlot
1194  *
1195  *     This function intializes UL slot of the cell
1196  *
1197  *  @param[in]  schUlSlotInfo
1198  *  @return     void
1199  **/
1200 void schInitUlSlot(SchUlSlotInfo *schUlSlotInfo)
1201 {
1202    CmLList *node = NULLP, *next = NULLP;
1203    FreePrbBlock *freeBlock;
1204
1205    /* Delete the old blocks */
1206    if(schUlSlotInfo->prbAlloc.freePrbBlockList.count)
1207    {
1208       node = schUlSlotInfo->prbAlloc.freePrbBlockList.first;
1209    }
1210    while(node)
1211    {
1212       next = node->next;
1213       freeBlock = (FreePrbBlock *)node->node;
1214       if(deleteNodeFromLList(&schUlSlotInfo->prbAlloc.freePrbBlockList, node) == ROK)
1215          SCH_FREE(freeBlock, sizeof(FreePrbBlock));
1216       node = next;
1217    }
1218
1219    /* Initilize UL Slot info and mark all PRBs as free */
1220    memset(schUlSlotInfo, 0, sizeof(SchUlSlotInfo));
1221    cmLListInit(&schUlSlotInfo->prbAlloc.freePrbBlockList);
1222    SCH_ALLOC(freeBlock, sizeof(FreePrbBlock));
1223    if(freeBlock)
1224    {
1225       freeBlock->numFreePrb = MAX_NUM_RB;
1226       freeBlock->startPrb = 0;
1227       freeBlock->endPrb = MAX_NUM_RB-1;
1228       addNodeToLList(&schUlSlotInfo->prbAlloc.freePrbBlockList, freeBlock, NULL);
1229    }
1230
1231    schUlSlotInfo->puschCurrentPrb = PUSCH_START_RB;
1232    schUlSlotInfo->schPuschInfo = NULLP;
1233 }
1234
1235 /**
1236  * @brief initialize DL slot info
1237  *
1238  * @details
1239  *
1240  *     Function: schInitDlSlot
1241  *
1242  *     This function intializes DL slot of the cell
1243  *
1244  *  @param[in]  schDlSlotInfo
1245  *  @return     void
1246  **/
1247 void schInitDlSlot(SchDlSlotInfo *schDlSlotInfo)
1248 {
1249    CmLList *node = NULLP, *next = NULLP;
1250    FreePrbBlock *freeBlock;
1251
1252    /* Delete the old blocks */
1253    if(schDlSlotInfo->prbAlloc.freePrbBlockList.count)
1254       node = schDlSlotInfo->prbAlloc.freePrbBlockList.first;
1255    while(node)
1256    {
1257       next = node->next;
1258       freeBlock = (FreePrbBlock *)node->node;
1259       if(deleteNodeFromLList(&schDlSlotInfo->prbAlloc.freePrbBlockList, node) == ROK)
1260          SCH_FREE(freeBlock, sizeof(FreePrbBlock));
1261       node = next;
1262    }
1263
1264    /* Initilize DL Slot info and mark all PRBs as free */
1265    memset(schDlSlotInfo, 0, sizeof(SchDlSlotInfo));
1266    cmLListInit(&schDlSlotInfo->prbAlloc.freePrbBlockList);
1267    SCH_ALLOC(freeBlock, sizeof(FreePrbBlock));
1268    if(freeBlock)
1269    {
1270       freeBlock->numFreePrb = MAX_NUM_RB;
1271       freeBlock->startPrb = 0;
1272       freeBlock->endPrb = MAX_NUM_RB-1;
1273       addNodeToLList(&schDlSlotInfo->prbAlloc.freePrbBlockList, freeBlock, NULL);
1274    }
1275 }
1276
1277 /**
1278  * @brief Fill resource bit map
1279  *
1280  * @details
1281  *
1282  *     Function: fillPrbBitmap
1283  *
1284  *     This function updates bitMap to mark the allocated PRBs
1285  *
1286  *  @param[in]  schDlSlotInfo
1287  *  @return     void
1288  **/
1289 bool fillPrbBitmap(uint64_t *prbBitMap, uint16_t startPrb, uint16_t numPrb)
1290 {
1291    uint16_t bitMapIdx = 0;
1292    uint16_t offsetInFirstIdx = 0;
1293    uint32_t numBitsToSetInFirstIdx = 0;
1294    uint64_t mask = MASK_BIT64_ON;
1295    uint64_t bitmapBackup[PRB_BITMAP_MAX_IDX];
1296
1297    /* Store backup of the bitmap in order to roll back if PRB allocation fails */
1298    memcpy(bitmapBackup, prbBitMap, sizeof(bitmapBackup));
1299
1300    /* Calculate the bitmap idx and offset of bit in that idx, to start
1301     * allocating PRBs from */
1302    bitMapIdx = startPrb / PRB_BITMAP_IDX_LEN;
1303    offsetInFirstIdx = startPrb % PRB_BITMAP_IDX_LEN;
1304
1305    /* If number of PRBs allocated >= number of unset bits in first idx starting from offset bit
1306     * then set all bits in first idx starting from offset bit
1307     * else set bits equal to number of PRBs allocated
1308     */
1309    numBitsToSetInFirstIdx = \
1310       (numPrb >= (PRB_BITMAP_IDX_LEN-offsetInFirstIdx)) ? (PRB_BITMAP_IDX_LEN-offsetInFirstIdx) : numPrb;
1311
1312    mask = mask >> (PRB_BITMAP_IDX_LEN-numBitsToSetInFirstIdx);
1313    mask = mask<<offsetInFirstIdx;
1314
1315    /* If PRBs to be allocated are not already in use, mark these PRBs as allocated */
1316    if(!(prbBitMap[bitMapIdx] & mask))
1317    {
1318       prbBitMap[bitMapIdx] = prbBitMap[bitMapIdx] | mask;
1319
1320       bitMapIdx++;
1321       numPrb = numPrb - numBitsToSetInFirstIdx;
1322       /* Set all bits in a bitMapIdx until remaining numPrb is less than PRB_BITMAP_IDX_LEN */
1323       while(numPrb > PRB_BITMAP_IDX_LEN)
1324       {
1325          if(prbBitMap[bitMapIdx])
1326          {
1327             memcpy(prbBitMap, bitmapBackup, sizeof(bitmapBackup));
1328             return RFAILED;
1329          }
1330          prbBitMap[bitMapIdx] = MASK_BIT64_ON;
1331          bitMapIdx++;
1332          numPrb = numPrb - PRB_BITMAP_IDX_LEN;
1333       }
1334
1335       /* Set bits for the remaining PRBs */
1336       if(numPrb)
1337       {
1338          mask = MASK_BIT64_ON;
1339          mask = mask >> (PRB_BITMAP_IDX_LEN-numPrb);
1340          if(!(prbBitMap[bitMapIdx] & mask))
1341          {
1342             prbBitMap[bitMapIdx] = prbBitMap[bitMapIdx] | mask;
1343          }
1344          else
1345          {
1346             memcpy(prbBitMap, bitmapBackup, sizeof(bitmapBackup));
1347             return RFAILED;
1348          }
1349       }
1350    }
1351    else
1352    {
1353       return RFAILED;
1354    }
1355
1356    return ROK;
1357 }
1358
1359
1360 /**************************************************************************
1361  *
1362  * @brief Update the LCID Node in LCLL as per ActionType
1363  *
1364  * @details
1365  *
1366  *    Function : handleLcLList
1367  *
1368  *    Functionality:
1369  *     Search LCID in LCLL or if not found, create,Delete, or return
1370  *     node for this LCID
1371  *
1372  * @params[in] I/P > lcLinkList pointer (LcInfo list)
1373  *             I/P > lcId
1374  *             I/P > ActionType (Create,Delete or Just search)
1375  *
1376  * @return lcNode > Pointer to the Node for that LcInfo
1377  *         If NULLP, FATAL FAILURE
1378  *
1379  * ***********************************************************************/
1380 LcInfo* handleLcLList(CmLListCp *lcLL, uint8_t lcId, ActionTypeLL action)
1381 {
1382    CmLList  *node = NULLP;
1383    LcInfo *lcNode = NULLP;
1384    bool found = FALSE;
1385
1386    if(lcLL == NULLP)
1387    {
1388       DU_LOG("\nERROR  -->  SCH: LcList doesnt exist");
1389       return NULLP;
1390    }
1391    node = lcLL->first;
1392
1393    /*Traversing the LC LinkList*/
1394    while(node)
1395    {
1396       lcNode = (LcInfo *)node->node;
1397       if(lcNode->lcId == lcId)
1398       {
1399          found = TRUE;
1400          break;
1401       }
1402       node = node->next;
1403    }//end of while
1404
1405    switch(action)
1406    {
1407       case SEARCH:
1408          {
1409             if(!found)
1410             {
1411                lcNode = NULLP;
1412             }
1413             return lcNode;
1414          }
1415
1416       case CREATE:
1417          {
1418             if(node != NULLP)
1419                return lcNode;
1420
1421             /*Need to add a new node for this LC*/
1422
1423             /*List is empty; Initialize the LL ControlPointer*/
1424             if(lcLL->count == 0)
1425             {
1426                cmLListInit(lcLL);
1427             }
1428
1429             lcNode = NULLP;
1430             /*Allocate the List*/
1431             SCH_ALLOC(lcNode, sizeof(LcInfo));
1432             if(lcNode)
1433             {
1434                lcNode->lcId = lcId;
1435                lcNode->reqBO = 0;
1436                lcNode->allocBO = 0;
1437                lcNode->allocPRB = 0;
1438             }
1439             else
1440             {
1441                DU_LOG("\nERROR  -->  SCH : Allocation of List failed,lcId:%d",lcId);
1442                return NULLP;
1443             }
1444
1445             if(addNodeToLList(lcLL, lcNode, NULLP) == RFAILED)
1446             {
1447                DU_LOG("\nERROR  -->  SCH : failed to Add Node,lcId:%d",lcId);
1448                SCH_FREE(lcNode, sizeof(LcInfo));
1449                return NULLP;
1450             }
1451             return lcNode;
1452          }
1453
1454       case DELETE:
1455          {
1456             if(!found ||  lcNode == NULLP)
1457             {
1458                DU_LOG("\nERROR  -->  SCH: LCID%d not found; thus Deletion unsuccessful",lcId);
1459             }
1460             else
1461             {
1462                if(deleteNodeFromLList(lcLL, node) == ROK)
1463                   SCH_FREE(lcNode, sizeof(LcInfo));
1464
1465                DU_LOG("\nDEBUG  -->  SCH: LCID%d Deleted successfully",lcId);
1466             }
1467             return NULLP;
1468          }
1469       case PRINT:
1470       case TRAVERSE_ALL:
1471         {
1472            break;
1473         }
1474       default:
1475          {
1476             DU_LOG("\nERROR  -->  SCH: Action type wrong: %d",action);
1477             break;
1478          }
1479    }
1480    return lcNode;
1481 }
1482
1483 /**************************************************************************
1484  *
1485  * @brief Update ReqPRB for a partiular LCID in LC Linklist
1486  *
1487  * @details
1488  *
1489  *    Function : updateLcListReqPRB
1490  *
1491  *    Functionality:
1492  *     Update ReqPRB for a partiular LCID in LC Linklist
1493  *
1494  * @params[in] I/P > lcLinkList pointer (LcInfo list)
1495  *             I/P > lcId
1496  *             I/P > reqPRB
1497  *             I/P > payloadSize
1498  *
1499  * @return ROK/RFAILED
1500  *
1501  * ***********************************************************************/
1502 uint8_t updateLcListReqPRB(CmLListCp *lcLL, uint8_t lcId, uint32_t payloadSize)
1503 {
1504    LcInfo    *lcNode = NULLP;
1505    lcNode = handleLcLList(lcLL, lcId, CREATE);
1506
1507    if(lcNode == NULLP)
1508    {
1509       DU_LOG("\nERROR  -->  SCH : LC is neither present nor able to create in List lcId:%d",lcId);
1510       return RFAILED;
1511    }
1512
1513    lcNode->reqBO = payloadSize;
1514    lcNode->allocBO = 0;
1515    lcNode->allocPRB = 0; /*Re-Initializing the AllocPRB*/
1516    return ROK;
1517 }
1518
1519 /**************************************************************************
1520  *
1521  * @brief Delete entire LC Linklist
1522  *
1523  * @details
1524  *
1525  *    Function : deleteLcLL
1526  *
1527  *    Functionality:
1528  *      Delete entire LC Linklist
1529  *
1530  * @params[in] lcLinkList pointer (LcInfo list)
1531  *
1532  * @return void
1533  *
1534  * ***********************************************************************/
1535 void deleteLcLL(CmLListCp *lcLL)
1536 {
1537    CmLList *node = NULLP, *next = NULLP;
1538    LcInfo *lcNode = NULLP;
1539
1540    if(lcLL == NULLP)
1541    {
1542       DU_LOG("\nERROR  -->  SCH: LcList doesnt exist");
1543       return;
1544    }
1545    node = lcLL->first;
1546
1547    while(node)
1548    {
1549       next = node->next;
1550       lcNode = (LcInfo *)node->node;
1551       if(deleteNodeFromLList(lcLL, node) == ROK)
1552          SCH_FREE(lcNode, sizeof(LcInfo));
1553       node = next;
1554    }
1555 }
1556
1557 /****************************************************************************
1558  *
1559  * @brief Calculate the Estimated TBS Size based on Spec 38.421 , Sec 5.3.1.2
1560  *
1561  * @details
1562  *
1563  *    Function : calculateEstimateTBSize
1564  *
1565  *    Functionality:
1566  *       TBS Size calculation requires numPRB. Since exactPRB for reqBO is unknown thus
1567  *       will give the PRB value(from 0 to maxRB) one by one and
1568  *       try to find the TBS size closest to reqBO
1569  *
1570  * @params[in] I/P > reqBO, mcsIdx, num PDSCH symbols,
1571  *             I/P > maxRB: Maximum PRB count to reach for calculating the TBS
1572  *             O/P > estPrb : Suitable PRB count for reaching the correct TBS
1573  *
1574  *
1575  * @return TBS Size > Size which will can be allocated for this LC
1576  *
1577  *
1578  *************************************************************************/
1579 uint32_t calculateEstimateTBSize(uint32_t reqBO, uint16_t mcsIdx, uint8_t numSymbols,\
1580                                    uint16_t maxPRB, uint16_t *estPrb)
1581 {
1582    uint32_t tbs = 0, effecBO = 0;
1583
1584    *estPrb = MIN_PRB;
1585    /*Loop Exit: Either estPRB reaches the maxRB or TBS is found greater than equal to reqBO*/
1586    do
1587    {
1588       tbs = schCalcTbSizeFromNPrb(*estPrb, mcsIdx, numSymbols);
1589
1590       /*TBS size calculated in above function is in Bits.
1591        * So to convert it into Bytes , we right shift by 3.
1592        * Eg: tbs=128 bits(1000 0000) ; Right Shift by 3: Tbs = 0001 0000(16 bytes)*/
1593       tbs = tbs >> 3;
1594       *estPrb += 1;
1595    }while((tbs < reqBO) && (*estPrb < maxPRB));
1596
1597    /*Effective BO is the Grant which can be provided for this LC.
1598     * Here,it is decided based on whether we can fully cater its requirment (reqBO)
1599     * or has to provide lesser grant due to resource limitation.
1600     * Thus effective BO/Grant for this LC will be min of TBS calculated and reqBO*/
1601    effecBO = MIN(tbs,reqBO);
1602    return (effecBO);
1603 }
1604
1605
1606 /*******************************************************************
1607 *
1608 * @brief deleting Page Info node from PageInfo List
1609 *
1610 * @details
1611 *
1612 *    Function : schDeleteFromPageInfoList
1613 *
1614 *    Functionality: deleting page Info node from Page Info List
1615 *
1616 * @params[in] CmLListCp *list, CmLList *node
1617 *
1618 * @return void
1619 *
1620 * ****************************************************************/
1621 void schDeleteFromPageInfoList(CmLListCp *list, CmLList *node)
1622 {
1623    SchPageInfo *pageInfo;
1624
1625    if(node != NULLP)
1626    {
1627       pageInfo = (SchPageInfo *)node->node;
1628       if(deleteNodeFromLList(list, node) == ROK)
1629          SCH_FREE(pageInfo, sizeof(SchPageInfo));
1630    }
1631 }
1632
1633 /*******************************************************************
1634 *
1635 * @brief searching for Page at a particular SFN
1636 *
1637 * @details
1638 *
1639 *    Function : schPageInfoSearchFromPageList
1640 *
1641 *    Functionality: searching for Page at a particular SFN
1642 *
1643 * @params[in] SlotTimingInfo slotInfo, CmLListCp *storedPageList
1644 *
1645 * @return pointer to SchPageInfo
1646 *
1647 * ****************************************************************/
1648 CmLList *schPageInfoSearchFromPageList(SlotTimingInfo slotInfo, CmLListCp *storedPageList)
1649 {
1650    CmLList         *node = NULLP;
1651    SchPageInfo     *pageInfo = NULLP;
1652
1653    if(storedPageList->count)
1654    {
1655       CM_LLIST_FIRST_NODE(storedPageList, node);
1656       while(node)
1657       {
1658          pageInfo = (SchPageInfo*)node->node;
1659          if(pageInfo == NULLP)
1660          {
1661             DU_LOG("\nERROR  --> SCH: PageInfo empty");
1662          }
1663          else if(pageInfo->pageTxTime.sfn == slotInfo.sfn &&
1664                (pageInfo->pageTxTime.slot == slotInfo.slot))
1665          {
1666             return node;
1667          }
1668          node = node->next;
1669       }
1670    }
1671    return NULLP;
1672 }
1673
1674 /*Below function for printing will be used in future so disabling it for now*/
1675 #if 0
1676 /****************************************************************************
1677  *
1678  * @brief Print the LC in list for debugging purpose
1679  *
1680  * @details
1681  *
1682  *    Function : printLcLL
1683  *
1684  *    Functionality:
1685  *            For debugging purpose, for printing the LC in the order and
1686  *            parameters
1687  *
1688  * @params[in] LcList pointer
1689  *
1690  * @return void
1691  *
1692  *************************************************************************/
1693 void printLcLL(CmLListCp *lcLL)
1694 {
1695    CmLList *node = NULLP;
1696    LcInfo *lcNode = NULLP;
1697
1698    if(lcLL == NULLP)
1699    {
1700       DU_LOG("\nINFO   -->  SCH: LcList doesnt exist");
1701       return;
1702    }
1703    node = lcLL->first;
1704    while(node)
1705    {
1706       lcNode = (LcInfo *)node->node;
1707       if(lcNode)
1708       {
1709          DU_LOG("\nINFO   -->  SCH : LcID:%d, [reqBO, allocBO, allocPRB]:[%d,%d,%d]",\
1710                lcNode->lcId,lcNode->reqBO, lcNode->allocBO, lcNode->allocPRB);
1711       }
1712
1713       node = node->next;
1714    }
1715 }
1716 #endif
1717
1718 #ifdef NR_TDD
1719
1720 /**
1721  * @brief determines slot/symbol format
1722  *
1723  * @details
1724  *
1725  *     Function : schGetSlotSymbFrmt
1726  *
1727  *      This API is invoked to determine if current slot is DL or UL
1728  *
1729  *  @param[in]  uint16_t slot
1730  *  @param[in]  uint32_t bitMap from cellCb
1731  *  @return  SlotConfig
1732  *      -# DL    - 0
1733  *      -# UL    - 1
1734  *      -# FLEXI - 2
1735  **/
1736 SlotConfig schGetSlotSymbFrmt(uint16_t slot, uint32_t bitMap)
1737 {
1738    uint32_t offset = (slot)*2;
1739    return (bitMap & 0x3<<offset)>>offset;
1740 #if 0
1741    SlotConfig slotFrmt;
1742    int mask1 = 0, mask2 = 0;
1743
1744    slot = (slot%n)*2;//n num of slots in defined periodicity or num of symbols
1745    mask1 = 1<<(slot);
1746    mask2 = 1<<(slot+1);
1747    slotFrmt = ((mask1 & bitMap)>>slot) + (2*((mask2 & bitMap)>>(slot+1)));
1748
1749    //printf("\n\n\n\n*****FormatType:%d Slot:%d****\n\n\n\n", slotFrmt, slot/2);
1750
1751    return slotFrmt;
1752 #endif
1753 }
1754
1755 /**
1756  * @brief Determine total length of configured slot pattern for specific
1757  *    periodicity for TDD
1758  *
1759  * @details
1760  *
1761  *     Function : calculateSlotPatternLength
1762  *
1763  *      Determine total length of configured slot pattern for specific periodicity based
1764  *      on slot duration for TDD
1765  *
1766  *  @param[in]  uint8_t scs, uint8_t periodicity
1767  *
1768  *  @return uint8_t slotPatternLength
1769  **/
1770
1771 uint8_t calculateSlotPatternLength(uint8_t scs, uint8_t periodicity)
1772 {
1773    uint8_t slotPatternLength =0;
1774    float   slotDuration = 0;
1775
1776    /* Calculating the slot duration with the help of SCS.
1777     * This will provides the slot duration in ms like 1, 0.5, 0.25, 0.125.
1778     * If scs value is SCS_30KHZ its enum value is 1,
1779     * slotDuration = pow(0.5, 1);
1780     * slotDuration = 0.5 */
1781
1782    slotDuration = pow(0.5,scs);
1783
1784    /* Calculating length of pattern based on Transmission Periodicity.
1785     * If periodicity = TX_PRDCTY_MS_5,
1786     * slotPatternLength = 5/0.5
1787     * slotPatternLength = 10 i.e. {length of slot pattern DDDDDDDFUU}*/
1788
1789    switch(periodicity)
1790    {
1791       case TX_PRDCTY_MS_0P5:
1792          slotPatternLength = 0.5/slotDuration;
1793          break;
1794       case TX_PRDCTY_MS_0P625:
1795          slotPatternLength = 0.625/slotDuration;
1796          break;
1797       case TX_PRDCTY_MS_1:
1798          slotPatternLength = 1/slotDuration;
1799          break;
1800       case TX_PRDCTY_MS_1P25:
1801          slotPatternLength = 1.25/slotDuration;
1802          break;
1803       case TX_PRDCTY_MS_2:
1804          slotPatternLength = 2/slotDuration;
1805          break;
1806       case TX_PRDCTY_MS_2P5:
1807          slotPatternLength = 2.5/slotDuration;
1808          break;
1809       case TX_PRDCTY_MS_5:
1810          slotPatternLength = 5/slotDuration;
1811          break;
1812       case TX_PRDCTY_MS_10:
1813          slotPatternLength = 10/slotDuration;
1814          break;
1815    }
1816    return slotPatternLength;
1817 }
1818 #endif
1819
1820 /**
1821  * @brief Function to find start Symbol Index of Coreset defined in SearchSpace(SS)
1822  *
1823  * @details
1824  *
1825  *     Function: findSsStartSymbol
1826  *
1827  *     This function finds first the startSymbol Index of a CORESET
1828  *     which is defined in SearchSpace.monitoringSymbolWithinSlot parameter
1829  *
1830  *  @param[in]  uint8_t mSymbolsWithinSlot[2]
1831  *        mSymbolsWithinSlot[0] >> MSB as 7th Symbol to LSB as 0th Symbol
1832  *        mSymbolsWithinSlot[1] >> 0th bit as 8th Symbol, 1st bit as 9th,
1833  *                                   ...,5th bit as 13th symbol
1834  *  @return     Success : First SS Symbol Index
1835  *              Failure : MAX_SYMB_PER_SLOT(Invalid value of SymbolIndex = 14)
1836 **/
1837 uint8_t findSsStartSymbol(uint8_t *mSymbolsWithinSlot)
1838 {
1839    uint8_t symbolIdx = 0;
1840    uint8_t i = 1, symPos = 0;
1841
1842    for(symbolIdx = 0; symbolIdx < MONITORING_SYMB_WITHIN_SLOT_SIZE; symbolIdx++)
1843    {
1844       i = 1, symPos = 0;
1845       while(i)
1846       {
1847          /*The first Symbol(or bit) enabled(set) is the StartSymbol of SS thus
1848           *returning if we find that bitPosition */
1849          if(mSymbolsWithinSlot[symbolIdx] & i)
1850          {
1851             /*Adding (SymbolIdx*8) for SymbolIndex between 8 and 13*/
1852             return (symPos + (symbolIdx * 8));
1853          }
1854          i = i << 1;
1855          symPos++;
1856       }
1857    }
1858    return(MAX_SYMB_PER_SLOT);
1859 }
1860
1861 /*
1862  *  @brief: Function will extract the StartPrb as per the given RBGIndex
1863  *
1864  *  Function: extractStartPrbForRBG
1865  *
1866  *  This function will extract the StartPrb of a rbgIndex. This RbgIndex doesnt
1867  *  have direct mapping with index in FreqDomRsrc instead it is mapping with
1868  *  those rbg which is set(i.e. available for PDCCH)
1869  *
1870  *  @param[in]  uint8_t freqDomainRsrc[6] (As per Spec 38.331, ControlResourceSet.frequencyDomainResources)
1871  *                 freqDomainRsrc[0] =RBG0 to RBG7
1872  *                 freqDomainRsrc[1] =RBG8 to RBG15
1873  *                 ...
1874  *                 freqDomainRsrc[5] =RBG40 to RBG47
1875  *                 (Every RBG has 6 PRBs)
1876  *
1877  *              uint8_t rbgIndex
1878  *
1879  *
1880  *         [return]: startPrb of that rbgIndex
1881  * */
1882 uint16_t extractStartPrbForRBG(uint8_t *freqDomainRsrc, uint8_t rbgIndex)
1883 {
1884    uint8_t freqIdx = 0, idx = 0;
1885    uint8_t count = 0, bitPos = 0;
1886    uint8_t totalPrbPerFreqIdx = NUM_PRBS_PER_RBG * 8; /*8 = no. of Bits in uint8_t*/
1887    uint16_t startPrb = MAX_NUM_RB;
1888
1889    for(freqIdx = 0; freqIdx < FREQ_DOM_RSRC_SIZE; freqIdx++)
1890    {
1891       if(freqDomainRsrc[freqIdx] & 0xFF)
1892       {
1893          /*Tracking from the 7th Bit because in FreqDomRsrc , lowestPRB is
1894           * stored in MSB and so on*/
1895          idx = 128;
1896          bitPos = 0;
1897          while(idx)
1898          {
1899            if(freqDomainRsrc[freqIdx] & idx)
1900            {
1901                if(count == rbgIndex)
1902                {
1903                   startPrb = (totalPrbPerFreqIdx * freqIdx) + (bitPos * NUM_PRBS_PER_RBG);
1904                   return startPrb;
1905                }
1906                count++;
1907            }
1908            bitPos++;
1909            idx = idx >> 1;
1910          }
1911       }
1912    }
1913    return startPrb;
1914 }
1915 /**
1916  * @brief Function to count number of RBG from Coreset's FreqDomainResource
1917  *
1918  * @details
1919  *
1920  *     Function: countRBGFrmCoresetFreqRsrc
1921  *
1922  * This function counts RBG for calculating the coresetSize using CORESET.freqDomainResource
1923  * In this, we will find the number of RBG groups which are allowed for this
1924  * coreset
1925  *
1926  *  @param[in]  uint8_t freqDomainRsrc[6] (As per Spec 38.331, ControlResourceSet.frequencyDomainResources)
1927  *              freqDomainRsrc[0] =RBG0 to RBG7
1928  *              freqDomainRsrc[1] =RBG8 to RBG15
1929  *              ...
1930  *              freqDomainRsrc[5] =RBG40 to RBG47
1931  *              (Every RBG has 6 PRBs)
1932  *  @return     Success : Total Number of RGBs in CORESET which can be allocated
1933  *              Failure : 0
1934 **/
1935 uint8_t countRBGFrmCoresetFreqRsrc(uint8_t *freqDomainRsrc)
1936 {
1937    uint8_t freqIdx = 0, idx = 0;
1938    uint8_t count = 0;
1939
1940    for(freqIdx = 0; freqIdx < FREQ_DOM_RSRC_SIZE; freqIdx++)
1941    {
1942       if(freqDomainRsrc[freqIdx] & 0xFF)
1943       {
1944          idx = 1;
1945          while(idx)
1946          {
1947            if(freqDomainRsrc[freqIdx] & idx)
1948            {
1949                count++;
1950            }
1951            idx = idx << 1;
1952          }
1953       }
1954    }
1955    return count;
1956 }
1957
1958 /*
1959  * @brief Function to calculate the DciSize in bits for format 1_0
1960  *
1961  * @details
1962  *
1963  *   Function: calcUeDciSizeFormat1_0
1964  *   Calculates the totalBit Size for sending this DCI format 1_0
1965  *   Spec Reference: 38.212, Format 1_0 scrambled using C_RNTI
1966  *
1967  * @Params[in] : CoresetSize (for calculating Frequency domain
1968  *          resource assignment)
1969  **/
1970
1971 uint16_t calcUeDciSizeFormat1_0(uint16_t coresetSize)
1972 {
1973    uint16_t dciSizeInBits = 0;
1974
1975    /* Size(in bits) of each field in DCI format 1_0 */
1976    /*Below fields are identified from 3gpp spec 38.212, 38.213, 38.214*/
1977    uint8_t dciFormatIdSize    = 1;
1978    uint8_t freqDomResAssignSize = 0;
1979    uint8_t timeDomResAssignSize = 4;
1980    uint8_t VRB2PRBMapSize       = 1;
1981    uint8_t modNCodSchemeSize    = 5;
1982    uint8_t ndiSize              = 1;
1983    uint8_t redundancyVerSize    = 2;
1984    uint8_t harqProcessNumSize   = 4;
1985    uint8_t dlAssignmentIdxSize  = 2;
1986    uint8_t pucchTpcSize         = 2;
1987    uint8_t pucchResoIndSize     = 3;
1988    uint8_t harqFeedbackIndSize  = 3;
1989
1990    freqDomResAssignSize = ceil(log2(coresetSize * (coresetSize + 1) / 2));
1991
1992    dciSizeInBits = (dciFormatIdSize + freqDomResAssignSize\
1993          + timeDomResAssignSize + VRB2PRBMapSize + modNCodSchemeSize\
1994          + ndiSize + redundancyVerSize + harqProcessNumSize + dlAssignmentIdxSize\
1995          + pucchTpcSize + pucchResoIndSize + harqFeedbackIndSize);
1996
1997    return(dciSizeInBits);
1998 }
1999
2000 /*
2001  * @brief Function to calculate the aggLvl mapping with CQI index
2002  *
2003  * @details
2004  *
2005  *   Function: fillCqiAggLvlMapping
2006  *
2007  *   Fills the CQI index and Agg level mapping based on 3gpp 38.214,Table 5.2.2.1-2
2008  *   The mapping will be later during PDCCH allocation
2009  *   [Step 1]: Calculate the DciSize in bits. This will be UE-specific as it depends
2010  *             on CORESETsize
2011  *   [Step 2]: Starting from CqiIdx = 0, calculate the efficientPdcchBits which
2012  *   can be sent for that CQI and check if the availBits for each agg level is
2013  *   sufficient for that pdcch required bits.
2014  *        > If the bits required by PDCCH can be contained with Agg Level's
2015  *        availBits then that is assigned.
2016  *  Note:: Good channel, CQI (high value) then Aggrevation level is assigned
2017  *  less(less number of CCE is sufficient) and vice versa for low CQI
2018  *
2019  *  @param[in]: PDCCH Info inside ueCb
2020  *
2021  *       [return]: void
2022  **/
2023
2024 void fillCqiAggLvlMapping(SchPdcchInfo *pdcchInfo)
2025 {
2026    uint8_t cqiIdx = 0, aggLvlIdx =0;
2027    uint16_t numOfBitsAvailForAggLevel = 0, dciSize = 0, pdcchBits = 0;
2028
2029    /*[Step 1]:*/
2030    dciSize = calcUeDciSizeFormat1_0(pdcchInfo->totalPrbs);
2031
2032    /* Initializing the map array*/
2033    memset(pdcchInfo->cqiIndxAggLvlMap, 0, MAX_NUM_CQI_IDX);
2034
2035    /*Note: For CqiIdx = 0, aggLevel is marked as 0 which means that Channel
2036     * Quality is not suitable for any transmission*/
2037    for(cqiIdx = 1; cqiIdx < MAX_NUM_CQI_IDX; cqiIdx++)
2038    {
2039       /*CQI table number 1 is used Spec 38.214 Table 5.2.2.1-2 by default.
2040        *TODO: cqi-table param in CSI-RepotConfig(3gpp 38.331) will report
2041        * which table to be used*/
2042       pdcchBits = ceil(dciSize / cqiTable1[cqiIdx][2]);
2043       for(aggLvlIdx = 0; (aggLvlIdx < MAX_NUM_AGG_LVL) && (pdcchBits != 0); aggLvlIdx++)
2044       {
2045          numOfBitsAvailForAggLevel = (totalRE_PerAggLevel[aggLvlIdx] * cqiTable1[cqiIdx][0]);
2046          /*Check if AggLevel has sufficient bits available for pdcchBits*/
2047          if(pdcchBits < numOfBitsAvailForAggLevel)
2048          {
2049             pdcchInfo->cqiIndxAggLvlMap[cqiIdx] = 1 << aggLvlIdx;
2050             break;
2051          }
2052       }
2053
2054       /*Below case will hit when required pdcchBits is not accomated by any Agg
2055        * Levl which means Channel quality is worse. Thus transmission has to be
2056        * most aggressive thus highest value of Agg level will be used.*/
2057       if(!pdcchInfo->cqiIndxAggLvlMap[cqiIdx])
2058          pdcchInfo->cqiIndxAggLvlMap[cqiIdx] = 16;
2059    }
2060 }
2061
2062 /*
2063  * @brief Function to calculate Value Y
2064  *
2065  *   Function: schCalY
2066  *
2067  *   Calculates value of YpKp as per [10.1,TS38.213].
2068  *   A0 is for first CS, A1 for second CS and A2 is for third CS
2069  *
2070  *   @params[in]: coresetId and Previous Y
2071  * */
2072 uint32_t schCalY(uint8_t csId, uint32_t prevY)
2073 {
2074    uint32_t A0 = 39827, A1 = 39829, A2 = 39839;
2075    uint32_t D = 65537;
2076
2077    switch(csId % 3)
2078    {
2079       case 0:
2080         {
2081            return((A0 * prevY) % D);
2082         }
2083       case 1:
2084         {
2085            return((A1 * prevY) % D);
2086         }
2087       case 2:
2088         {
2089            return((A2 * prevY) % D);
2090         }
2091       default:
2092         {
2093            DU_LOG("\nERROR  --> SCH: Issue in calculating value of Y");
2094            return(0);
2095         }
2096    }
2097    return 0;
2098 }
2099
2100 /*
2101  * @brief Function to calculate the value Y used for CCE Index formula
2102  *
2103  *   Function: schUpdValY
2104  *
2105  *   As per Spec 38.213, Sec 10.1 Formula for CCE Index contains a coefficient
2106  *   value called 'Y' and storing the same in the ueCb which will be later used
2107  *   in pdcch allocation
2108  *
2109  * @params[in] : SchUeCb, PdcchInfo
2110  *    [return] : uint8_t ROK, RFAILED : Memory allocation status
2111  *
2112  * */
2113 uint8_t schUpdValY(SchUeCb *ueCb, SchPdcchInfo *pdcchInfo)
2114 {
2115    uint8_t slotIdx = 0;
2116
2117    SCH_ALLOC(pdcchInfo->y, (sizeof(uint32_t) *  ueCb->cellCb->numSlots));
2118    if(pdcchInfo->y == NULLP)
2119    {
2120       DU_LOG("\nERROR  --> SCH: Memory Allocation of Y failed");
2121       return RFAILED;
2122    }
2123
2124    for(slotIdx= 0 ; slotIdx < ueCb->cellCb->numSlots; slotIdx++)
2125    {
2126       if(slotIdx == 0)
2127       {
2128          pdcchInfo->y[slotIdx] = schCalY(pdcchInfo->cRSetRef->cRSetId, ueCb->crnti);
2129       }
2130       else
2131       {
2132          pdcchInfo->y[slotIdx] = schCalY(pdcchInfo->cRSetRef->cRSetId, pdcchInfo->y[slotIdx - 1]);
2133       }
2134    }
2135    return ROK;
2136 }
2137
2138 /*
2139  *  @brief : Function to convert SlotPeriodicity to Value
2140  *
2141  *  Function: schConvertSlotPeriodicityEnumToValue
2142  *
2143  *  @param[IN]: SchMSlotPeriodicity enum
2144  *        [return]: slotOffsetVal
2145  * */
2146 uint16_t schConvertSlotPeriodicityEnumToValue(SchMSlotPeriodicity slotPeriod)
2147 {
2148    uint16_t slotPeriodVal = 0;
2149
2150    switch(slotPeriod)
2151    {
2152       case SLOT_PERIODICITY_SL_1:
2153       {
2154          slotPeriodVal = 1;
2155          break;
2156       }
2157       case SLOT_PERIODICITY_SL_2:
2158       {
2159          slotPeriodVal = 2;
2160          break;
2161       }
2162       case SLOT_PERIODICITY_SL_4:
2163       {
2164          slotPeriodVal = 4;
2165          break;
2166       }
2167       case SLOT_PERIODICITY_SL_5:
2168       {
2169          slotPeriodVal = 5;
2170          break;
2171       }
2172       case SLOT_PERIODICITY_SL_8:
2173       {
2174          slotPeriodVal = 8;
2175          break;
2176       }
2177       case SLOT_PERIODICITY_SL_10:
2178       {
2179          slotPeriodVal = 10;
2180          break;
2181       }
2182       case SLOT_PERIODICITY_SL_16:
2183       {
2184          slotPeriodVal = 16;
2185          break;
2186       }
2187       case SLOT_PERIODICITY_SL_20:
2188       {
2189          slotPeriodVal = 20;
2190          break;
2191       }
2192       case SLOT_PERIODICITY_SL_40:
2193       {
2194          slotPeriodVal = 40;
2195          break;
2196       }
2197       case SLOT_PERIODICITY_SL_80:
2198       {
2199          slotPeriodVal = 80;
2200          break;
2201       }
2202       case SLOT_PERIODICITY_SL_160:
2203       {
2204          slotPeriodVal = 160;
2205          break;
2206       }
2207       case SLOT_PERIODICITY_SL_320:
2208       {
2209          slotPeriodVal = 320;
2210          break;
2211       }
2212       case SLOT_PERIODICITY_SL_640:
2213       {
2214          slotPeriodVal = 640;
2215          break;
2216       }
2217       case SLOT_PERIODICITY_SL_1280:
2218       {
2219          slotPeriodVal = 1280;
2220          break;
2221       }
2222       case SLOT_PERIODICITY_SL_2560:
2223       {
2224          slotPeriodVal = 2560;
2225          break;
2226       }
2227       default:
2228       {
2229          slotPeriodVal = 0;
2230          break;
2231       }
2232    }
2233    return slotPeriodVal;
2234 }
2235
2236 /*
2237  *  @brief: Function to extract the numCandidates from aggLevel.
2238  *
2239  *  Function: extractNumOfCandForAggLvl
2240  *
2241  *  @params[IN]: SearchSpace, aggLevel
2242  *         [RETURN]: numCandidates.
2243  * */
2244 uint8_t extractNumOfCandForAggLvl(SchSearchSpace *searchSpace, uint8_t aggLvl)
2245 {
2246    uint8_t numCand = 0;
2247
2248    switch(aggLvl)
2249    {
2250       case 1:
2251       {
2252          numCand = searchSpace->numCandidatesAggLevel1;
2253          break;
2254       }
2255       case 2:
2256       {
2257          numCand = searchSpace->numCandidatesAggLevel2;
2258          break;
2259       }
2260       case 4:
2261       {
2262          numCand = searchSpace->numCandidatesAggLevel4;
2263          break;
2264       }
2265       case 8:
2266       {
2267          numCand = searchSpace->numCandidatesAggLevel8;
2268          break;
2269       }
2270       case 16:
2271       {
2272          numCand = searchSpace->numCandidatesAggLevel16;
2273          break;
2274       }
2275       default:
2276       {
2277          numCand = 0;
2278       }
2279       /*AGGREGATION_LEVEL_N8 enum Value is 7 thus hardcoding the correct Value
2280        * (8)*/
2281       if(numCand == AGGREGATION_LEVEL_N8)
2282       {
2283          numCand = 8;
2284       }
2285    }
2286    return numCand;
2287 }
2288 /**********************************************************************
2289          End of file
2290 **********************************************************************/