d8d1dd84aff3c78f32a3eeb380caefaed8f24f5f
[o-du/l2.git] / src / 5gnrmac / lwr_mac_handle_phy.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 /* header include files (.h) */
20 #include "common_def.h"
21 #include "lrg.h"
22 #ifdef INTEL_FAPI
23 #include "fapi.h"
24 #include "fapi_vendor_extension.h"
25 #endif
26
27 /* header/extern include files (.x) */
28 #include "lrg.x"
29 #include "du_app_mac_inf.h"
30 #include "mac_sch_interface.h"
31 #include "lwr_mac.h"
32 #include "lwr_mac_fsm.h"
33 #include "lwr_mac_phy.h"
34 #include "lwr_mac_upr_inf.h"
35 #include "mac.h"
36 #include "mac_utils.h"
37 #include "lwr_mac_utils.h"
38
39 #ifdef INTEL_FAPI
40 /* Function pointer for slot indication from lower mac to mac */
41 SlotIndFunc sendSlotIndOpts[] =
42 {
43    packSlotInd,  /* packing for loosely coupled */
44    fapiMacSlotInd, /* packing for tightly coupled */
45    packSlotInd /* packing for light weight loosly coupled */
46 };
47
48 /* Function pointer for rach indication from lower mac to mac */ 
49 RachIndFunc sendRachIndOpts[] =
50 {
51    packRachInd,
52    fapiMacRachInd,
53    packRachInd
54 };
55
56 /* Function pointer for crc indication from lower mac to mac */
57 CrcIndFunc sendCrcIndOpts[] =
58 {
59    packCrcInd,
60    fapiMacCrcInd,
61    packCrcInd
62 };
63
64 /* Function pointer for Rx Data indication from lower mac to mac */
65 RxDataIndFunc sendRxDataIndOpts[] =
66 {
67    packRxDataInd,
68    fapiMacRxDataInd,
69    packRxDataInd
70 };
71
72 /* Function pointer for stop indication from lower mac to mac */ 
73 StopIndFunc sendStopIndOpts[] =
74 {
75    packStopInd,
76    fapiMacStopInd,
77    packStopInd
78 };
79
80 /* Function pointer for Uci indication from lower mac to mac */
81 UciIndFunc sendUciIndOpts[] =
82 {
83    packUciInd,
84    FapiMacUciInd,
85    packUciInd
86 };
87
88 /*******************************************************************
89  *
90  * @brief Processes Slot Indication from PHY and sends to MAC
91  *
92  * @details
93  *
94  *    Function : procSlotInd
95  *
96  *    Functionality:
97  *     Processes Slot Indication from PHY and sends to MAC
98  *
99  * @params[in] fapi_slot_ind_t pointer
100  * @return ROK     - success
101  *         RFAILED - failure
102  *
103  * ****************************************************************/
104 uint8_t procSlotInd(fapi_slot_ind_t *fapiSlotInd)
105 {
106    /* fill Pst structure to send to lwr_mac to MAC */
107    Pst pst;
108    uint16_t ret = 0;
109    SlotIndInfo *slotInd = {0};
110
111    MAC_ALLOC_SHRABL_BUF(slotInd, sizeof(SlotIndInfo));
112    if(slotInd)
113    {
114       slotInd->cellId = lwrMacCb.cellCb[0].cellId; 
115       slotInd->sfn = fapiSlotInd->sfn;
116       slotInd->slot = fapiSlotInd->slot;
117
118       FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_SLOT_IND_TO_MAC);
119       ret = (*sendSlotIndOpts[pst.selector])(&pst, slotInd);
120    }
121    else
122    {
123       DU_LOG("\nERROR  -->  LWR_MAC: Memory allocation failed in procSlotInd");
124       ret = RFAILED;
125    }
126    return ret;
127 }
128
129 /*******************************************************************
130  *
131  * @brief Handles stop indication recived from PHY
132  *
133  * @details
134  *
135  *    Function : procStopInd
136  *
137  *    Functionality:
138  *         Handles Stop Indication received from PHY
139  *
140  * @return ROK     - success
141  *         RFAILED - failure
142  *
143  * ****************************************************************/
144 uint8_t procStopInd()
145 {
146    Pst pst;
147    uint16_t *cellId = NULLP;
148
149    MAC_ALLOC_SHRABL_BUF(cellId, sizeof(uint16_t));
150    if(!cellId)
151    {
152       DU_LOG("\nERROR  -->  LWR_MAC: Memory Allocation failed in procStopInd");
153       return RFAILED;
154    }
155
156    *cellId = lwrMacCb.cellCb[0].cellId;
157    lwrMacCb.phyState = PHY_STATE_CONFIGURED;
158    lwrMacCb.cellCb[0].state = PHY_STATE_CONFIGURED;
159    DU_LOG("\nINFO  -->  LWR_MAC: PHY has moved to configured state");
160
161    FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_STOP_IND_TO_MAC);
162    return (*sendStopIndOpts[pst.selector])(&pst, cellId);
163 }
164
165 /*******************************************************************
166  *
167  * @brief Processes Rach Indication from PHY and sends to MAC
168  *
169  * @details
170  *
171  *    Function : procRachInd
172  *
173  *    Functionality:
174  *         Processes Rach Indication from PHY and sends to MAC
175  *
176  * @params[in] fapi_rach_indication_t pointer
177  * @return ROK     - success
178  *         RFAILED - failure
179  *
180  * ****************************************************************/
181 uint8_t procRachInd(fapi_rach_indication_t  *fapiRachInd)
182 {
183    Pst          pst;
184    uint8_t      pduIdx;
185    uint8_t      prmbleIdx;
186    RachPduInfo  *rachPdu = NULLP;
187    RachInd      *rachInd = NULLP;
188
189    MAC_ALLOC_SHRABL_BUF(rachInd, sizeof(RachInd));
190    if(!rachInd)
191    {
192       DU_LOG("\nERROR  -->  LWR_MAC : Memory Allocation failed in procRachInd");
193       return RFAILED;
194    }
195    if(!fapiRachInd->numPdus)
196    {
197       DU_LOG("\nDEBUG  -->  LWR_MAC : No PDU in RACH.indication at [%d, %d]", fapiRachInd->sfn, fapiRachInd->slot);
198       return ROK;
199    }
200
201    rachInd->cellId = lwrMacCb.cellCb[0].cellId;
202    rachInd->timingInfo.sfn = fapiRachInd->sfn;
203    rachInd->timingInfo.slot = fapiRachInd->slot;
204    rachInd->numPdu = fapiRachInd->numPdus;
205    for(pduIdx=0; pduIdx < rachInd->numPdu; pduIdx++)
206    {
207       rachPdu = &rachInd->rachPdu[pduIdx];
208       rachPdu->pci = fapiRachInd->rachPdu[pduIdx].phyCellId;
209       rachPdu->symbolIdx = fapiRachInd->rachPdu[pduIdx].symbolIndex;
210       rachPdu->slotIdx = fapiRachInd->rachPdu[pduIdx].slotIndex;
211       rachPdu->freqIdx = fapiRachInd->rachPdu[pduIdx].freqIndex;
212       rachPdu->numPream = fapiRachInd->rachPdu[pduIdx].numPreamble; 
213       for(prmbleIdx=0; prmbleIdx<rachPdu->numPream; prmbleIdx++)
214       {
215          rachPdu->preamInfo[prmbleIdx].preamIdx = \
216             fapiRachInd->rachPdu[pduIdx].preambleInfo[prmbleIdx].preambleIndex;
217          rachPdu->preamInfo[prmbleIdx].timingAdv = \
218             fapiRachInd->rachPdu[pduIdx].preambleInfo[prmbleIdx].timingAdvance;
219       }
220    }
221
222    /* Fill post and sent to MAC */
223    FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_RACH_IND_TO_MAC);
224    return (*sendRachIndOpts[pst.selector])(&pst, rachInd);
225 }/* handleRachInd */
226
227 /*******************************************************************
228  *
229  * @brief Handles CRC indication from PHY and sends to MAC
230  *
231  * @details
232  *
233  *    Function : procCrcInd
234  *
235  *    Functionality:
236  *      Handles CRC indication from PHY and sends to MAC
237  *
238  * @params[in] fapi_crc_ind_t message pointer
239  * @return ROK     - success
240  *         RFAILED - failure
241  *
242  * ****************************************************************/
243
244 uint8_t procCrcInd(fapi_crc_ind_t  *fapiCrcInd)
245 {
246    Pst          pst;
247    uint8_t      crcInfoIdx;
248    uint8_t      crcStatusIdx;
249    CrcInfo      *crcIndInfo = NULLP;
250    CrcInd       *crcInd = NULLP;
251
252    MAC_ALLOC_SHRABL_BUF(crcInd, sizeof(CrcInd));
253    if(!crcInd)
254    {
255       DU_LOG("\nERROR  -->  LWR_MAC : Memory Allocation failed in procCrcInd");
256       return RFAILED;
257    }
258    if(!fapiCrcInd->numCrcs)
259    {
260       DU_LOG("\nDEBUG  --> LWR_MAC : No CRC PDUs in CRC.indication at [%d, %d]", fapiCrcInd->sfn, fapiCrcInd->slot);
261       return ROK;
262    }
263
264    crcInd->cellId = lwrMacCb.cellCb[0].cellId;
265    crcInd->timingInfo.sfn = fapiCrcInd->sfn;
266    crcInd->timingInfo.slot = fapiCrcInd->slot;
267    crcInd->numCrc = fapiCrcInd->numCrcs;
268
269    for(crcInfoIdx = 0; crcInfoIdx < crcInd->numCrc; crcInfoIdx++)
270    {
271       crcIndInfo = &crcInd->crcInfo[crcInfoIdx];
272       crcIndInfo->handle      = fapiCrcInd->crc[crcInfoIdx].handle;
273       crcIndInfo->rnti        = fapiCrcInd->crc[crcInfoIdx].rnti;
274       crcIndInfo->harqId      = fapiCrcInd->crc[crcInfoIdx].harqId;
275       crcIndInfo->tbCrcStatus = fapiCrcInd->crc[crcInfoIdx].tbCrcStatus;
276       crcIndInfo->numCb       = fapiCrcInd->crc[crcInfoIdx].numCb;
277       for(crcStatusIdx = 0; crcStatusIdx < crcIndInfo->numCb; crcStatusIdx++)
278       {
279          crcIndInfo->cbCrcStatus[crcStatusIdx] = \
280             fapiCrcInd->crc[crcInfoIdx].cbCrcStatus[crcStatusIdx];
281       }
282       crcIndInfo->ul_cqi  = fapiCrcInd->crc[crcInfoIdx].ul_cqi;
283       crcIndInfo->timingAdvance = fapiCrcInd->crc[crcInfoIdx].timingAdvance;
284       crcIndInfo->rssi = fapiCrcInd->crc[crcInfoIdx].rssi;
285    }
286
287    /* Fill post and sent to MAC */
288    FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_CRC_IND_TO_MAC);
289    return (*sendCrcIndOpts[pst.selector])(&pst, crcInd);
290 } /* handleCrcInd */
291
292 /*******************************************************************
293  *
294  * @brief Handles Rx Data indication from PHY and sends to MAC
295  *
296  * @details
297  *
298  *    Function : procRxDataInd
299  *
300  *    Functionality:
301  *      Handles Rx Data indication from PHY and sends to MAC
302  *
303  * @params[in] fapi_rx_data_indication_t message pointer
304  * @return ROK     - success
305  *         RFAILED - failure
306  *
307  * ****************************************************************/
308
309 uint8_t procRxDataInd(fapi_rx_data_indication_t  *fapiRxDataInd)
310 {
311    Pst           pst;
312    uint8_t       pduIdx =0;
313    RxDataInd     *rxDataInd = NULLP;
314    RxDataIndPdu  *pdu = NULLP;   
315
316    MAC_ALLOC_SHRABL_BUF(rxDataInd, sizeof(RxDataInd));
317    if(!rxDataInd)
318    {
319       DU_LOG("\nERROR  -->  LWR_MAC : Memory Allocation failed in procRxDataInd");
320       return RFAILED;
321    }
322    if(!fapiRxDataInd->numPdus)
323    {
324       DU_LOG("\nDEBUG  -->  LWR_MAC : No PDU in RX_Data.indication at [%d, %d]", fapiRxDataInd->sfn, fapiRxDataInd->slot);
325       return ROK;
326    }
327
328    rxDataInd->cellId = lwrMacCb.cellCb[0].cellId;
329    rxDataInd->timingInfo.sfn = fapiRxDataInd->sfn; 
330    rxDataInd->timingInfo.slot = fapiRxDataInd->slot;
331    rxDataInd->numPdus = fapiRxDataInd->numPdus;
332
333    for(pduIdx = 0; pduIdx < rxDataInd->numPdus; pduIdx++)
334    {
335       pdu = &rxDataInd->pdus[pduIdx];
336       pdu->handle = fapiRxDataInd->pdus[pduIdx].handle;
337       pdu->rnti = fapiRxDataInd->pdus[pduIdx].rnti;
338       pdu->harqId = fapiRxDataInd->pdus[pduIdx].harqId;
339       pdu->pduLength = fapiRxDataInd->pdus[pduIdx].pdu_length;
340       pdu->ul_cqi = fapiRxDataInd->pdus[pduIdx].ul_cqi;
341       pdu->timingAdvance = fapiRxDataInd->pdus[pduIdx].timingAdvance;
342       pdu->rssi = fapiRxDataInd->pdus[pduIdx].rssi;
343
344       MAC_ALLOC_SHRABL_BUF(pdu->pduData, pdu->pduLength);
345       memcpy(pdu->pduData, fapiRxDataInd->pdus[pduIdx].pduData, pdu->pduLength);
346 #ifdef INTEL_WLS_MEM      
347       /* Free WLS memory allocated for Rx PDU */
348       WLS_MEM_FREE(fapiRxDataInd->pdus[pduIdx].pduData, LWR_MAC_WLS_BUF_SIZE);
349 #endif
350    }
351
352    /* Fill post and sent to MAC */
353    FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_RX_DATA_IND_TO_MAC);
354    return (*sendRxDataIndOpts[pst.selector])(&pst, rxDataInd);
355 }
356
357 /*******************************************************************
358  *
359  * @brief Fills Uci Ind Pdu Info carried on Pucch Format 0/Format 1
360  *
361  * @details
362  *
363  *    Function : fillUciIndPucchF0F1
364  *
365  *    Functionality:
366  *       Fills Uci Ind Pdu Info carried on Pucch Format 0/Format 1
367  *
368  *@params[in] UciPucchF0F1 *
369  *            fapi_uci_o_pucch_f0f1_t *
370  * @return ROK     - success
371  *         RFAILED - failure
372  *
373  * ****************************************************************/
374 uint8_t fillUciIndPucchF0F1(UciPucchF0F1 *pduInfo, fapi_uci_o_pucch_f0f1_t *fapiPduInfo)
375 {
376
377    uint8_t harqIdx;
378    uint8_t ret = ROK;
379    
380    pduInfo->handle        = fapiPduInfo->handle;
381    pduInfo->pduBitmap     = fapiPduInfo->pduBitmap;
382    pduInfo->pucchFormat   = fapiPduInfo->pucchFormat;
383    pduInfo->ul_cqi        = fapiPduInfo->ul_cqi;
384    pduInfo->crnti         = fapiPduInfo->rnti;
385    pduInfo->timingAdvance = fapiPduInfo->timingAdvance;
386    pduInfo->rssi          = fapiPduInfo->rssi;   
387    if(fapiPduInfo->srInfo.srIndication)
388    {
389       pduInfo->srInfo.srIndPres = fapiPduInfo->srInfo.srIndication;
390       pduInfo->srInfo.srConfdcLevel = fapiPduInfo->srInfo.srConfidenceLevel;
391    }
392    if(fapiPduInfo->harqInfo.numHarq)
393    {
394       pduInfo->harqInfo.numHarq = fapiPduInfo->harqInfo.numHarq;
395       pduInfo->harqInfo.harqConfdcLevel = fapiPduInfo->harqInfo.harqConfidenceLevel;
396       for(harqIdx = 0; harqIdx < pduInfo->harqInfo.numHarq; harqIdx++)
397       {
398          pduInfo->harqInfo.harqValue[harqIdx] = fapiPduInfo->harqInfo.harqValue[harqIdx];
399       }
400    }
401    return ret;
402 }
403
404 /*******************************************************************
405  *
406  * @brief Handles Uci indication from PHY and sends to MAC
407  *
408  * @details
409  *
410  *    Function : procUciInd
411  *
412  *    Functionality:
413  *      Handles Uci indication from PHY and sends to MAC
414  *
415  * @params[in] fapi_uci_indication_t message pointer
416  * @return ROK     - success
417  *         RFAILED - failure
418  *
419  * ****************************************************************/
420
421 uint8_t procUciInd(fapi_uci_indication_t  *fapiUciInd)
422 {
423    uint8_t pduIdx;
424    uint8_t ret = ROK;
425    Pst     pst;
426    UciInd  *macUciInd = NULLP;
427
428    MAC_ALLOC_SHRABL_BUF(macUciInd, sizeof(UciInd));
429    if(!macUciInd)
430    {
431       DU_LOG("\nERROR  -->  LWR_MAC: Memory Allocation failed in procUciInd");
432       return RFAILED;
433    }
434
435    DU_LOG("\nDEBUG  -->  LWR_MAC: Processing UCI Indication");
436    memset(macUciInd, 0, sizeof(UciInd));
437    macUciInd->cellId = lwrMacCb.cellCb[0].cellId;
438    macUciInd->slotInd.sfn = fapiUciInd->sfn; 
439    macUciInd->slotInd.slot = fapiUciInd->slot;
440    macUciInd->numUcis = fapiUciInd->numUcis;
441
442    for(pduIdx = 0; pduIdx < macUciInd->numUcis; pduIdx++)
443    {
444       macUciInd->pdus[pduIdx].pduType = fapiUciInd->uciPdu[pduIdx].pduType;
445       switch(macUciInd->pdus[pduIdx].pduType)
446       {
447          case UCI_IND_PUSCH:
448          break;
449          case UCI_IND_PUCCH_F0F1:
450          {
451             UciPucchF0F1 *pduInfo = NULLP;
452             macUciInd->pdus[pduIdx].pduSize = fapiUciInd->uciPdu[pduIdx].pduSize;
453             pduInfo = &macUciInd->pdus[pduIdx].uci.uciPucchF0F1;
454             ret = fillUciIndPucchF0F1(pduInfo, &fapiUciInd->uciPdu[pduIdx].uci.uciPucchF0F1);
455          }
456          break;
457          case UCI_IND_PUCCH_F2F3F4:
458             break;
459          default:
460             DU_LOG("\nERROR  -->  LWR_MAC: Invalid Pdu Type %d at procmacUciInd()", macUciInd->pdus[pduIdx].pduType);
461             ret = RFAILED;
462             break;
463       }
464    }
465    if(!ret)
466    {
467       FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_UCI_IND_TO_MAC);
468       ret = (*sendUciIndOpts[pst.selector])(&pst, macUciInd);
469    }
470    else
471    {
472       DU_LOG("\nERROR  -->  LWR_MAC: Failed sending UCI Ind to MAC");
473    }
474    return ret;
475 }
476 #endif /* FAPI */
477
478 /*******************************************************************
479  *
480  * @brief Processes message from PHY
481  *
482  * @details
483  *
484  *    Function : procPhyMessages
485  *
486  *    Functionality: Processes message from PHY
487  *
488  * @params[in] 
489  * @return ROK     - success
490  *         RFAILED - failure
491  *
492  * ****************************************************************/
493 void procPhyMessages(uint16_t msgType, uint32_t msgSize, void *msg)
494 {
495 #ifdef INTEL_FAPI
496    /* extract the header */
497    fapi_msg_t *header = NULLP;
498    header = (fapi_msg_t *)msg;
499
500    switch(header->msg_id)
501    {
502 #ifdef INTEL_TIMER_MODE
503       case FAPI_VENDOR_EXT_UL_IQ_SAMPLES:
504          {
505             DU_LOG("\nDEBUG  -->  LWR_MAC: Received FAPI_VENDOR_EXT_UL_IQ_SAMPLES");
506             //send config req
507             uint16_t cellId = 1;
508             sendToLowerMac(CONFIG_REQUEST, 0, (void *)&cellId);
509             break;
510          } 
511 #endif
512       case FAPI_PARAM_RESPONSE:
513          {
514             sendToLowerMac(PARAM_RESPONSE, msgSize, msg);
515             break;
516          }
517       case FAPI_CONFIG_RESPONSE:
518          {
519             sendToLowerMac(CONFIG_RESPONSE, msgSize, msg);
520             break;
521          }
522       case FAPI_SLOT_INDICATION:
523          {
524             if(lwrMacCb.phyState == PHY_STATE_CONFIGURED)
525             {
526                DU_LOG("\nINFO  -->  LWR_MAC: PHY has moved to running state");
527                lwrMacCb.phyState = PHY_STATE_RUNNING;
528                lwrMacCb.cellCb[0].state = PHY_STATE_RUNNING;
529             }
530
531             fapi_slot_ind_t *slotInd = NULLP;
532             slotInd  = (fapi_slot_ind_t *)msg;
533             procSlotInd(slotInd);
534             break;
535          }
536       case FAPI_ERROR_INDICATION:
537          {
538             break;
539          }
540       case FAPI_RX_DATA_INDICATION:
541          {
542             fapi_rx_data_indication_t *rxDataInd;
543             rxDataInd = (fapi_rx_data_indication_t *)msg;
544             procRxDataInd(rxDataInd);
545             break;
546          }  
547       case FAPI_CRC_INDICATION:
548          {
549             fapi_crc_ind_t  *crcInd;
550             crcInd = (fapi_crc_ind_t *)msg;
551             procCrcInd(crcInd);
552             break;
553          }  
554       case FAPI_UCI_INDICATION:
555          {
556             fapi_uci_indication_t *phyUciInd = NULLP;
557             phyUciInd = (fapi_uci_indication_t*)msg;
558             procUciInd(phyUciInd);
559             break;
560          }
561       case FAPI_SRS_INDICATION:
562          {
563             break;
564          }  
565       case FAPI_RACH_INDICATION:
566          {
567             fapi_rach_indication_t  *rachInd;
568             rachInd = (fapi_rach_indication_t *)msg;
569             procRachInd(rachInd);
570             break;
571          }
572       case FAPI_STOP_INDICATION:
573          {
574             DU_LOG("\nINFO  -->  LWR_MAC: Handling Stop Indication");
575             procStopInd();
576             break;
577          }  
578    }
579 #endif
580 }
581
582 /**********************************************************************
583   End of file
584  **********************************************************************/