[Epic-ID: ODUHIGH-462][Task-ID: ODUHIGH-472] Implementation of onduration timer
[o-du/l2.git] / src / cm / rgu.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:     LTE-MAC layer
22   
23      Type:     C source file
24   
25      Desc:     C source code for packing/unpacking of RGU interface
26                primitives.
27   
28      File:     rgu.c 
29   
30 **********************************************************************/
31
32 /** @file rgu.c
33 @brief This file contains the packing/unpacking code for the RGU interface 
34        primitives.
35 */
36
37 /* header include files (.h) */
38 #include "common_def.h"
39 #include "rgu.h"           /* RGU Interface defines */
40
41 /* header/extern include files (.x) */
42 #include "rgu.x"           /* RGU Interface includes */
43
44 #ifdef SS_RBUF
45 #include "ss_rbuf.h"
46 #include "ss_rbuf.x"
47 #endif
48
49 #ifdef LCRGU
50
51 \f
52 /**
53 * @brief Request from RLC to MAC to bind the interface saps
54 *
55 * @details
56 *
57 *     Function : cmPkRguBndReq
58 *
59 *  @param[in]   Pst*  pst
60 *  @param[in]   SuId  suId
61 *  @param[in]   SpId  spId
62 *  @return   S16
63 *      -# ROK
64 **/
65 S16 cmPkRguBndReq
66 (
67 Pst* pst,
68 SuId suId,
69 SpId spId
70 )
71 {
72    Buffer *mBuf = NULLP;
73
74    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
75 #if (ERRCLASS & ERRCLS_ADD_RES)      
76       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
77           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
78           (ErrVal)ERGU001, (ErrVal)0, "Packing failed");
79 #endif      
80       return RFAILED;
81    }
82    if (SPkS16(spId, mBuf) != ROK) {
83 #if (ERRCLASS & ERRCLS_ADD_RES)      
84       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
85           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
86           (ErrVal)ERGU002, (ErrVal)0, "Packing failed");
87 #endif      
88       SPutMsg(mBuf);
89       return RFAILED;
90    }
91    if (SPkS16(suId, mBuf) != ROK) {
92 #if (ERRCLASS & ERRCLS_ADD_RES)      
93       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
94           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
95           (ErrVal)ERGU003, (ErrVal)0, "Packing failed");
96 #endif      
97       SPutMsg(mBuf);
98       return RFAILED;
99    }
100    pst->event = (Event) EVTRGUBNDREQ;
101    return (SPstTsk(pst,mBuf));
102 }
103
104 \f
105 /**
106 * @brief Request from RLC to MAC to bind the interface saps
107 *
108 * @details
109 *
110 *     Function : cmUnpkRguBndReq
111 *
112 *  @param[in]   Pst*  pst
113 *  @param[in]   SuId  suId
114 *  @param[in]   SpId  spId
115 *  @return   S16
116 *      -# ROK
117 **/
118 S16 cmUnpkRguBndReq
119 (
120 RguBndReq func,
121 Pst *pst,
122 Buffer *mBuf
123 )
124 {
125    SuId suId;
126    SpId spId;
127
128    if (SUnpkS16(&suId, mBuf) != ROK) {
129 #if (ERRCLASS & ERRCLS_ADD_RES)      
130       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
131           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
132           (ErrVal)ERGU004, (ErrVal)0, "UnPacking failed");
133 #endif      
134       SPutMsg(mBuf);
135       return RFAILED;
136    }
137    if (SUnpkS16(&spId, mBuf) != ROK) {
138 #if (ERRCLASS & ERRCLS_ADD_RES)      
139       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
140           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
141           (ErrVal)ERGU005, (ErrVal)0, "UnPacking failed");
142 #endif      
143       SPutMsg(mBuf);
144       return RFAILED;
145    }
146    SPutMsg(mBuf);
147    return ((*func)(pst, suId, spId));
148 }
149
150 \f
151 /**
152 * @brief Request from RLC to MAC to Unbind the interface saps
153 *
154 * @details
155 *
156 *     Function : cmPkRguUbndReq
157 *
158 *  @param[in]   Pst*  pst
159 *  @param[in]   SpId  spId
160 *  @param[in]   Reason  reason
161 *  @return   S16
162 *      -# ROK
163 **/
164 S16 cmPkRguUbndReq
165 (
166 Pst* pst,
167 SpId spId,
168 Reason reason
169 )
170 {
171    Buffer *mBuf = NULLP;
172
173    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
174 #if (ERRCLASS & ERRCLS_ADD_RES)      
175       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
176           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
177           (ErrVal)ERGU006, (ErrVal)0, "Packing failed");
178 #endif      
179       return RFAILED;
180    }
181    if (SPkS16(reason, mBuf) != ROK) {
182 #if (ERRCLASS & ERRCLS_ADD_RES)      
183       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
184           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
185           (ErrVal)ERGU007, (ErrVal)0, "Packing failed");
186 #endif      
187       SPutMsg(mBuf);
188       return RFAILED;
189    }
190    if (SPkS16(spId, mBuf) != ROK) {
191 #if (ERRCLASS & ERRCLS_ADD_RES)      
192       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
193           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
194           (ErrVal)ERGU008, (ErrVal)0, "Packing failed");
195 #endif      
196       SPutMsg(mBuf);
197       return RFAILED;
198    }
199    pst->event = (Event) EVTRGUUBNDREQ;
200    return (SPstTsk(pst,mBuf));
201 }
202
203 \f
204 /**
205 * @brief Request from RLC to MAC to Unbind the interface saps
206 *
207 * @details
208 *
209 *     Function : cmUnpkRguUbndReq
210 *
211 *  @param[in]   Pst*  pst
212 *  @param[in]   SpId  spId
213 *  @param[in]   Reason  reason
214 *  @return   S16
215 *      -# ROK
216 **/
217 S16 cmUnpkRguUbndReq
218 (
219 RguUbndReq func,
220 Pst *pst,
221 Buffer *mBuf
222 )
223 {
224    SpId spId;
225    Reason reason;
226    
227
228    if (SUnpkS16(&spId, mBuf) != ROK) {
229 #if (ERRCLASS & ERRCLS_ADD_RES)      
230       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
231           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
232           (ErrVal)ERGU009, (ErrVal)0, "UnPacking failed");
233 #endif      
234       SPutMsg(mBuf);
235       return RFAILED;
236    }
237    if (SUnpkS16(&reason, mBuf) != ROK) {
238 #if (ERRCLASS & ERRCLS_ADD_RES)      
239       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
240           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
241           (ErrVal)ERGU010, (ErrVal)0, "UnPacking failed");
242 #endif      
243       SPutMsg(mBuf);
244       return RFAILED;
245    }
246    SPutMsg(mBuf);
247    return ((*func)(pst, spId, reason));
248 }
249
250 \f
251 /**
252 * @brief Confirmation from MAC to RLC for the bind/Unbind 
253  * request for the interface saps
254 *
255 * @details
256 *
257 *     Function : cmPkRguBndCfm
258 *
259 *  @param[in]   Pst*  pst
260 *  @param[in]   SuId  suId
261 *  @param[in]   uint8_t  status
262 *  @return   S16
263 *      -# ROK
264 **/
265 S16 cmPkRguBndCfm
266 (
267 Pst* pst,
268 SuId suId,
269 uint8_t status
270 )
271 {
272    Buffer *mBuf = NULLP;
273
274    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
275 #if (ERRCLASS & ERRCLS_ADD_RES)      
276       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
277           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
278           (ErrVal)ERGU011, (ErrVal)0, "Packing failed");
279 #endif      
280       return RFAILED;
281    }
282    if (oduUnpackUInt8(status, mBuf) != ROK) {
283 #if (ERRCLASS & ERRCLS_ADD_RES)      
284       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
285           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
286           (ErrVal)ERGU012, (ErrVal)0, "Packing failed");
287 #endif      
288       SPutMsg(mBuf);
289       return RFAILED;
290    }
291    if (SPkS16(suId, mBuf) != ROK) {
292 #if (ERRCLASS & ERRCLS_ADD_RES)      
293       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
294           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
295           (ErrVal)ERGU013, (ErrVal)0, "Packing failed");
296 #endif      
297       SPutMsg(mBuf);
298       return RFAILED;
299    }
300    pst->event = (Event) EVTRGUBNDCFM;
301    return (SPstTsk(pst,mBuf));
302 }
303
304 \f
305 /**
306 * @brief Confirmation from MAC to RLC for the bind/Unbind 
307  * request for the interface saps
308 *
309 * @details
310 *
311 *     Function : cmUnpkRguBndCfm
312 *
313 *  @param[in]   Pst*  pst
314 *  @param[in]   SuId  suId
315 *  @param[in]   uint8_t  status
316 *  @return   S16
317 *      -# ROK
318 **/
319 S16 cmUnpkRguBndCfm
320 (
321 RguBndCfm func,
322 Pst *pst,
323 Buffer *mBuf
324 )
325 {
326    SuId suId;
327    uint8_t status;
328
329    if (SUnpkS16(&suId, mBuf) != ROK) {
330 #if (ERRCLASS & ERRCLS_ADD_RES)      
331       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
332           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
333           (ErrVal)ERGU014, (ErrVal)0, "UnPacking failed");
334 #endif      
335       SPutMsg(mBuf);
336       return RFAILED;
337    }
338    if (oduPackUInt8(&status, mBuf) != ROK) {
339 #if (ERRCLASS & ERRCLS_ADD_RES)      
340       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
341           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
342           (ErrVal)ERGU015, (ErrVal)0, "UnPacking failed");
343 #endif      
344       SPutMsg(mBuf);
345       return RFAILED;
346    }
347    SPutMsg(mBuf);
348    return ((*func)(pst, suId, status));
349 }
350
351 /*rgu_c_001.main_5 - ADD - L2M & R9 Support */
352 #ifdef LTE_L2_MEAS
353
354 /***********************************************************
355 *
356 *     Func :cmPkRguL2MUlThrpMeasReqInfo 
357 *
358 *
359 * Status Response from RLC to MAC on UL dedicated logical channel for Uplink
360 * Scheduled throughput measurement
361 *
362 *
363 *     Ret  : S16
364 *
365 *     Notes:
366 *
367 *     File  : 
368 *
369 **********************************************************/
370 S16 cmPkRguL2MUlThrpMeasReqInfo 
371 (
372 RguL2MUlThrpMeasReqInfo* param,
373 Buffer *mBuf
374 )
375 {
376    S32 loop;
377
378    CMCHKPK(oduUnpackUInt8, param->enbMeas, mBuf);
379    for (loop=param->numLcId-1; loop >= 0; loop--)
380    {
381       CMCHKPK(oduUnpackUInt8, param->lcId[loop], mBuf);
382    }
383    CMCHKPK(cmPkLteLcId, param->numLcId, mBuf);
384    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
385    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
386    return ROK;
387 }
388
389
390 \f
391 /***********************************************************
392 *
393 *     Func :cmUnpkRguL2MUlThrpMeasReqInfo 
394 *
395 *
396 * Status Response from RLC to MAC on UL dedicated logical channel for Uplink
397 * Scheduled throughput measurement
398 *
399 *
400 *     Ret  : S16
401 *
402 *     Notes:
403 *
404 *     File  : 
405 *
406 **********************************************************/
407 S16 cmUnpkRguL2MUlThrpMeasReqInfo 
408 (
409 RguL2MUlThrpMeasReqInfo *param,
410 Buffer *mBuf
411 )
412 {
413    uint8_t loop;
414
415    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
416    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
417    CMCHKUNPK(cmUnpkLteLcId, &param->numLcId, mBuf);
418    for (loop=0; loop<param->numLcId; loop++)
419    {
420       CMCHKUNPK(oduPackUInt8, &param->lcId[loop], mBuf);
421    }
422    CMCHKUNPK(oduPackUInt8, &param->enbMeas, mBuf);
423    return ROK;
424 }
425
426 /**
427 * @brief Primitive invoked from RLC to MAC to 
428 * inform the On/Off status for Scheduled UL throughput 
429 * measurment for dedicated channels
430 *
431 * @details
432 *
433 *     Function :cmPkRguL2MUlThrpMeasReq 
434 *
435 *  @param[in]   Pst*  pst
436 *  @param[in]   SpId  spId
437 *  @param[in]   RguL2MUlThrpMeasReqInfo*  measReq
438 *  @return   S16
439 *      -# ROK
440 **/
441 S16 cmPkRguL2MUlThrpMeasReq 
442 (
443 Pst* pst,
444 SpId spId,
445 RguL2MUlThrpMeasReqInfo* measReq
446 )
447 {
448    Buffer *mBuf = NULLP;
449
450    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
451 #if (ERRCLASS & ERRCLS_ADD_RES)      
452       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
453           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
454           (ErrVal)ERGU049, (ErrVal)0, "Packing failed");
455 #endif      
456       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReq, sizeof(RguL2MUlThrpMeasReqInfo));
457       return RFAILED;
458    }
459    if (pst->selector == ODU_SELECTOR_LWLC)
460    {
461       CMCHKPK(oduPackPointer,(PTR) measReq, mBuf);
462    }
463    else
464    {
465       if (cmPkRguL2MUlThrpMeasReqInfo(measReq, mBuf) != ROK) {
466 #if (ERRCLASS & ERRCLS_ADD_RES)      
467          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
468              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
469              (ErrVal)ERGU050, (ErrVal)0, "Packing failed");
470 #endif      
471          SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReq, 
472                                     sizeof(RguL2MUlThrpMeasReqInfo));
473          SPutMsg(mBuf);
474          return RFAILED;
475       }
476       if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReq, 
477                            sizeof(RguL2MUlThrpMeasReqInfo)) != ROK) {
478 #if (ERRCLASS & ERRCLS_ADD_RES)      
479          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
480             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
481              (ErrVal)ERGU052, (ErrVal)0, "Packing failed");
482 #endif      
483          SPutMsg(mBuf);
484          return RFAILED;
485       }
486       measReq = NULLP;
487    }
488
489    if (SPkS16(spId, mBuf) != ROK) {
490 #if (ERRCLASS & ERRCLS_ADD_RES)      
491       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
492           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
493           (ErrVal)ERGU051, (ErrVal)0, "Packing failed");
494 #endif      
495       if (measReq != NULLP)
496       {
497          SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReq,
498                              sizeof(RguL2MUlThrpMeasReqInfo));
499       }
500       SPutMsg(mBuf);
501       return RFAILED;
502    }
503
504    pst->event = (Event) EVTRGUL2MULTHRPMEASREQ;
505    return (SPstTsk(pst,mBuf));
506 }
507
508 \f
509 /**
510 * @brief Primitive invoked from RLC to MAC to 
511 * inform the On/Off status for Scheduled UL throughput 
512 * measurment for dedicated channels
513 *
514 * @details
515 *
516 *     Function :cmUnpkRguL2MUlThrpMeasReq 
517 *
518 *  @param[in]   Pst*  pst
519 *  @param[in]   SpId  spId
520 *  @param[in]   RguL2MUlThrpMeasReqInfo  * measReq 
521 *  @return   S16
522 *      -# ROK
523 **/
524 S16 cmUnpkRguL2MUlThrpMeasReq 
525 (
526 RguL2MUlThrpMeasReq func,
527 Pst *pst,
528 Buffer *mBuf
529 )
530 {
531    SpId spId;
532    RguL2MUlThrpMeasReqInfo* measReq;
533    
534
535    if (SUnpkS16(&spId, mBuf) != ROK) {
536 #if (ERRCLASS & ERRCLS_ADD_RES)      
537       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
538           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
539           (ErrVal)ERGU053, (ErrVal)0, "UnPacking failed");
540 #endif      
541       SPutMsg(mBuf);
542       return RFAILED;
543    }
544    if (pst->selector == ODU_SELECTOR_LWLC)
545    {
546       CMCHKUNPK(oduUnpackPointer,(PTR *) &measReq, mBuf);
547    }
548    else 
549    {
550       if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&measReq,
551                               sizeof(RguL2MUlThrpMeasReqInfo))) != ROK) {
552 #if (ERRCLASS & ERRCLS_ADD_RES)      
553          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
554              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
555              (ErrVal)ERGU054, (ErrVal)0, "UnPacking failed");
556 #endif      
557          SPutMsg(mBuf);
558          return RFAILED;
559       }
560       if (cmUnpkRguL2MUlThrpMeasReqInfo(measReq, mBuf) != ROK) {
561 #if (ERRCLASS & ERRCLS_ADD_RES)      
562          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
563              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
564              (ErrVal)ERGU055, (ErrVal)0, "UnPacking failed");
565 #endif      
566          SPutMsg(mBuf);
567          SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)measReq, 
568                                 sizeof(RguL2MUlThrpMeasReqInfo));
569          return RFAILED;
570       }
571    }
572    SPutMsg(mBuf);
573    return ((*func)(pst, spId, measReq));
574 }
575
576 #endif
577
578
579    /*rgu_c_001.main_5 - ADD - L2M Support */
580 #ifdef LTE_L2_MEAS
581 \f
582 /**
583 * @brief Harq Status Indication from MAC to RLC  
584 *
585 * @details
586 *
587 *     Function : cmPkRguHqStaInd
588 *
589 *  @param[in]   Pst*  pst
590 *  @param[in]   SuId  suId
591 *  @param[in]   RguHarqStatusInd  *harqStatusInd
592 *  @return   S16
593 *      -# ROK
594 **/
595 S16 cmPkRguHqStaInd
596 (
597 Pst* pst,
598 SuId suId,
599 RguHarqStatusInd  *harqStatusInd
600 )
601 {
602
603    Buffer   *mBuf;
604    uint8_t  idx;
605    RguHarqStatusInd *harqStaInd = NULL;
606
607 #ifdef XEON_SPECIFIC_CHANGES
608    if (SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&harqStaInd, sizeof(RguHarqStatusInd)) != ROK)
609 #else      
610    if ((SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, 
611                (Data **)&harqStaInd, sizeof(RguHarqStatusInd),0)) != ROK)
612 #endif      
613    {
614 #if (ERRCLASS & ERRCLS_ADD_RES)      
615       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
616             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
617             (ErrVal)ERGU070, (ErrVal)0, "Packing failed");
618 #endif      
619       return RFAILED;
620    }
621
622    memcpy(harqStaInd, harqStatusInd, sizeof(RguHarqStatusInd));
623
624    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
625 #if (ERRCLASS & ERRCLS_ADD_RES)      
626       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
627             __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
628             (ErrVal)ERGU070, (ErrVal)0, "Packing failed");
629 #endif
630 #ifdef XEON_SPECIFIC_CHANGES
631       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd));
632 #else      
633       SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd), 0);
634 #endif      
635       return RFAILED;
636    }
637
638    if (pst->selector == ODU_SELECTOR_LWLC)
639    {
640       CMCHKPK(oduPackPointer,(PTR) harqStaInd, mBuf); 
641    }
642    else
643    {
644       for(idx = 0; idx < harqStaInd->numTbs; idx++)
645       {
646          CMCHKPK(oduUnpackUInt16, harqStaInd->status[idx], mBuf);
647       }
648       for(idx = 0; idx < harqStaInd->numTbs; idx++)
649       {
650          CMCHKPK(oduUnpackUInt32, harqStaInd->tbId[idx], mBuf);
651       }
652       CMCHKPK(oduUnpackUInt8, harqStaInd->numTbs, mBuf);
653       CMCHKPK(cmPkLteRnti, harqStaInd->ueId, mBuf);
654       CMCHKPK(cmPkLteCellId, harqStaInd->cellId, mBuf);
655    }
656    if (SPkS16(suId, mBuf) != ROK) {
657 #if (ERRCLASS & ERRCLS_ADD_RES)      
658       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
659           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
660           (ErrVal)ERGU071, (ErrVal)0, "Packing failed");
661 #endif
662 #ifdef XEON_SPECIFIC_CHANGES
663       SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)harqStaInd,
664               sizeof(RguHarqStatusInd));
665 #else      
666       SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)harqStaInd, sizeof(RguHarqStatusInd), 0);
667 #endif      
668       SPutMsg(mBuf);
669       return RFAILED;
670    }
671 #ifdef XEON_SPECIFIC_CHANGES
672    if (SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)harqStaInd,
673             sizeof(RguHarqStatusInd)) != ROK) {
674 #else   
675    if (pst->selector != ODU_SELECTOR_LWLC)
676    {
677       if(SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)harqStaInd, 
678                sizeof(RguHarqStatusInd), 0) != ROK)
679       {
680 #endif         
681 #if (ERRCLASS & ERRCLS_ADD_RES)      
682          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
683                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
684                (ErrVal)ERGU072, (ErrVal)0, "Packing failed");
685 #endif      
686          SPutMsg(mBuf);
687          return RFAILED;
688       }
689 #ifndef XEON_SPECIFIC_CHANGES      
690    }
691 #endif   
692
693    pst->event = (Event) EVTRGUHQSTAIND;
694    return (SPstTsk(pst,mBuf));
695 }
696 \f
697
698 /**
699 * @brief Harq Status Indication from MAC to RLC  
700 *
701 * @details
702 *
703 *     Function : cmUnpkRguHqStaInd
704 *
705 *  @param[in]  RguHqStaInd   func
706 *  @param[in]  Pst           *pst
707 *  @param[in]  Buffer        *mBuf
708 *  @return   S16
709 *      -# ROK
710 **/
711 S16 cmUnpkRguHqStaInd
712 (
713 RguHqStaInd  func,
714 Pst *pst,
715 Buffer *mBuf
716 )
717 {
718    RguHarqStatusInd    *hqStaInd;  
719    SuId    suId;
720    uint8_t idx;
721
722    if (SUnpkS16(&suId, mBuf) != ROK) {
723 #if (ERRCLASS & ERRCLS_ADD_RES)      
724       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
725           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
726           (ErrVal)ERGU073, (ErrVal)0, "UnPacking failed");
727 #endif      
728       SPutMsg(mBuf);
729       return RFAILED;
730    }
731 #ifdef XEON_SPECIFIC_CHANGES
732    if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&hqStaInd, 
733         sizeof(RguHarqStatusInd))) != ROK) {
734 #else   
735    if (pst->selector == ODU_SELECTOR_LWLC)
736    {
737       CMCHKUNPK(oduUnpackPointer,(PTR *) &hqStaInd, mBuf);
738    }  
739    else
740    {   
741       if ((SGetStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, 
742                   (Data **)&hqStaInd, sizeof(RguHarqStatusInd),0)) != ROK)
743       {
744 #endif         
745 #if (ERRCLASS & ERRCLS_ADD_RES)      
746          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
747                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
748                (ErrVal)ERGU074, (ErrVal)0, "UnPacking failed");
749 #endif      
750          SPutMsg(mBuf);
751          return RFAILED;
752       }
753       CMCHKUNPK(cmUnpkLteCellId, &hqStaInd->cellId, mBuf);
754       CMCHKUNPK(cmUnpkLteRnti, &hqStaInd->ueId, mBuf);
755       CMCHKUNPK(oduPackUInt8, &hqStaInd->numTbs, mBuf);
756       for(idx = hqStaInd->numTbs; idx > 0; idx--)
757       {
758          CMCHKUNPK(oduPackUInt32, &hqStaInd->tbId[idx - 1], mBuf);
759       }
760       for(idx = hqStaInd->numTbs; idx > 0; idx--)
761       {
762          CMCHKUNPK(oduPackUInt16, &hqStaInd->status[idx - 1], mBuf);
763       }
764 #ifndef XEON_SPECIFIC_CHANGES      
765    }
766 #endif   
767    SPutMsg(mBuf);
768    (*func)(pst, suId, hqStaInd);
769 #ifdef XEON_SPECIFIC_CHANGES
770    SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)hqStaInd, sizeof(RguHarqStatusInd));
771 #else   
772    SPutStaticBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)hqStaInd, sizeof(RguHarqStatusInd), 0);
773 #endif   
774    return ROK;
775 }
776 #endif /* LTE_L2_MEAS */
777
778 S16 cmPkRguLcFlowCntrlInfo
779 (
780 RguLcFlowCntrlInfo *param,
781 Buffer             *mBuf
782 )
783 {
784   CMCHKPK(oduUnpackUInt32, param->maxBo4FlowCtrl, mBuf);
785   CMCHKPK(oduUnpackUInt32, param->pktAdmitCnt, mBuf);
786   CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
787
788   return ROK;
789 }
790
791 S16 cmPkRguUeFlowCntrlInfo
792 (
793 RguUeFlowCntrlInfo *param,
794 Buffer             *mBuf
795 )
796 {
797   uint32_t idx;
798
799
800   for(idx=(param->numLcs - 1); idx >= 0; idx--)
801   {
802     cmPkRguLcFlowCntrlInfo(&param->lcInfo[idx],mBuf);
803   }
804   CMCHKPK(oduUnpackUInt32, param->numLcs, mBuf);
805   CMCHKPK(cmPkLteRnti, param->ueId, mBuf);
806   return ROK;
807 }
808
809 S16 cmPkRguFlowCntrlInfo
810 (
811 RguFlowCntrlInd *param, 
812 Buffer          *mBuf
813 )
814 {
815   uint32_t idx;
816
817   for (idx=(param->numUes - 1); idx >= 0; idx--)
818   {
819     cmPkRguUeFlowCntrlInfo(&param->ueFlowCntrlInfo[idx],mBuf);
820   }
821   CMCHKPK(oduUnpackUInt32, param->numUes, mBuf);
822   CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
823   return ROK;
824 }
825 \f
826 /**
827 * @brief Flow Cntrl Indication from MAC to RLC  
828  * Informs RLC of the LCs on which flow control
829  * to be performed.
830 *
831 * @details
832 *
833 *     Function : cmPkRguFlowCntrlInd
834 *
835 *  @param[in]   Pst*  pst
836 *  @param[in]   SuId  suId
837 *  @param[in]   RguFlowCntrlInd *staInd
838 *  @return   S16
839 *      -# ROK
840 **/
841 S16 cmPkRguFlowCntrlInd
842 (
843 Pst* pst,
844 SuId suId,
845 RguFlowCntrlInd  *flowCntrlInd
846 )
847 {
848    Buffer *mBuf = NULLP;
849
850    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
851 #if (ERRCLASS & ERRCLS_ADD_RES)      
852       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
853           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
854           (ErrVal)ERGU076, (ErrVal)0, "Packing failed");
855 #endif      
856       return RFAILED;
857    }
858    if (pst->selector == ODU_SELECTOR_LWLC)
859    {
860       CMCHKPK(oduPackPointer,(PTR) flowCntrlInd, mBuf);
861    }
862    else
863    {
864       if (cmPkRguFlowCntrlInfo(flowCntrlInd, mBuf) != ROK) {
865 #if (ERRCLASS & ERRCLS_ADD_RES)      
866            SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
867                __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
868                (ErrVal)ERGU077, (ErrVal)0, "Packing failed");
869 #endif      
870          SPutMsg(mBuf);
871          return RFAILED;
872       } 
873    }
874    if (SPkS16(suId, mBuf) != ROK) {
875 #if (ERRCLASS & ERRCLS_ADD_RES)      
876       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
877           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
878           (ErrVal)ERGU078, (ErrVal)0, "Packing failed");
879 #endif      
880       SPutMsg(mBuf);
881       return RFAILED;
882    }
883    
884    pst->event = (Event) EVTRGUFLOWCNTRLIND;
885    return (SPstTsk(pst,mBuf));
886 }
887
888 S16 cmUnpkRguLcFlowCntrlInfo
889 (
890 RguLcFlowCntrlInfo *param,
891 Buffer           *mBuf
892 )
893 {
894
895   CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
896   CMCHKUNPK(oduPackUInt32, &param->pktAdmitCnt, mBuf);
897   CMCHKUNPK(oduPackUInt32, &param->maxBo4FlowCtrl, mBuf);
898   
899   return ROK;
900 }
901 S16 cmUnpkRguUeFlowCntrlInfo
902 (
903 RguUeFlowCntrlInfo *param,
904 Buffer           *mBuf
905 )
906 {
907   uint32_t idx;
908   CMCHKUNPK(cmUnpkLteRnti, &param->ueId, mBuf);
909   CMCHKUNPK(oduPackUInt32, &param->numLcs, mBuf);
910   for(idx=0; idx < param->numLcs; idx++)
911   {
912     cmUnpkRguLcFlowCntrlInfo(&param->lcInfo[idx],mBuf);
913   }
914   return ROK;
915 }
916
917 S16 cmUnpkRguFlowCntrlInfo
918 (
919 RguFlowCntrlInd *param, 
920 Buffer           *mBuf
921 )
922 {
923   uint32_t idx; 
924   
925
926   CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
927   CMCHKUNPK(oduPackUInt32, &param->numUes, mBuf);
928   for (idx=0; idx < param->numUes; idx++)
929   {
930     cmUnpkRguUeFlowCntrlInfo(&param->ueFlowCntrlInfo[idx],mBuf);
931   }
932   return ROK;
933 }
934
935 /**
936 * @brief Flow control indication from MAC to RLC  
937 * Informs RLC of the LCs on which flow control to  
938 * be started
939 *
940 * @details
941 *
942 *     Function : cmUnpkRguFlowCntrlInd
943 *
944 *  @param[in]   RguFlowCntrlInd func
945 *  @param[in]   Pst    *pst
946 *  @param[in]   Buffer *mBuf
947 *  @return   S16
948 *      -# ROK
949 **/
950 S16 cmUnpkRguFlowCntrlInd
951 (
952 RguFlowCntrlIndInfo func,
953 Pst *pst,
954 Buffer *mBuf
955 )
956 {
957    SuId suId;
958    RguFlowCntrlInd *flowCntrlInd;
959
960    if (SUnpkS16(&suId, mBuf) != ROK) {
961 #if (ERRCLASS & ERRCLS_ADD_RES)      
962       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
963           __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
964           (ErrVal)ERGU080, (ErrVal)0, "UnPacking failed");
965 #endif      
966       SPutMsg(mBuf);
967       return RFAILED;
968    }
969    if (pst->selector == ODU_SELECTOR_LWLC)
970    {
971       CMCHKUNPK(oduUnpackPointer,(PTR *) &flowCntrlInd, mBuf);
972    }
973    else 
974    {
975       if ((SGetSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data **)&flowCntrlInd, sizeof(RguFlowCntrlInd))) != ROK) {
976 #if (ERRCLASS & ERRCLS_ADD_RES)      
977          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
978          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
979          (ErrVal)ERGU081, (ErrVal)0, "UnPacking failed");
980 #endif      
981          SPutMsg(mBuf);
982          return RFAILED;
983       }
984       if (cmUnpkRguFlowCntrlInfo(flowCntrlInd, mBuf) != ROK) {
985 #if (ERRCLASS & ERRCLS_ADD_RES)      
986          SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
987              __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
988              (ErrVal)ERGU082, (ErrVal)0, "UnPacking failed");
989 #endif      
990          SPutMsg(mBuf);
991          SPutSBufNewForDebug(__FILE__,__FUNCTION__,__LINE__,pst->region, pst->pool, (Data *)flowCntrlInd, sizeof(RguFlowCntrlInd));
992          return RFAILED;
993       }
994    }
995    SPutMsg(mBuf);
996    return ((*func)(pst, suId, flowCntrlInd));
997 }
998
999 /***********************************************************
1000 *
1001 *     Func : cmPkRguPduInfo
1002 *
1003 *
1004 *     Desc : RguPduInfo
1005  * PDU information given on a logical channel
1006 *
1007 *
1008 *     Ret  : S16
1009 *
1010 *     Notes:
1011 *
1012 *     File  : 
1013 *
1014 **********************************************************/
1015 S16 cmPkRguPduInfo
1016 (
1017 RguPduInfo *param,
1018 Buffer *mBuf
1019 )
1020 {
1021    S32 i;
1022
1023    for (i=param->numPdu-1; i >= 0; i--) {
1024      /* rgu_c_001.main_3: ccpu00111328: S16 is renamed as MsgLen */
1025       MsgLen msgLen = 0;
1026       if (SFndLenMsg(param->mBuf[i], &msgLen) != ROK)
1027          return RFAILED;
1028       if (SCatMsg(mBuf, param->mBuf[i], M1M2) != ROK)
1029          return RFAILED;
1030       SPutMsg(param->mBuf[i]);
1031       CMCHKPK(cmPkMsgLen, msgLen, mBuf);
1032    }
1033    CMCHKPK(oduUnpackUInt8, param->numPdu, mBuf);
1034    return ROK;
1035 }
1036
1037
1038 \f
1039 /***********************************************************
1040 *
1041 *     Func : cmUnpkRguPduInfo
1042 *
1043 *
1044 *     Desc : RguPduInfo
1045  * PDU information given on a logical channel
1046 *
1047 *
1048 *     Ret  : S16
1049 *
1050 *     Notes:
1051 *
1052 *     File  : 
1053 *
1054 **********************************************************/
1055 S16 cmUnpkRguPduInfo
1056 (
1057 RguPduInfo *param,
1058 Buffer *mBuf
1059 )
1060 {
1061    S32 i;
1062
1063
1064    CMCHKUNPK(oduPackUInt8, &param->numPdu, mBuf);
1065    for (i=0; i<param->numPdu; i++) {
1066       MsgLen msgLen, totalMsgLen;
1067       CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
1068       if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
1069          return RFAILED;
1070       if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->mBuf[i]) != ROK)
1071          return RFAILED;
1072    }
1073    return ROK;
1074 }
1075
1076
1077 \f
1078 /***********************************************************
1079 *
1080 *     Func : cmPkRguDBoReport
1081 *
1082 *
1083 *     Desc : RguDBoReport
1084  * Buffer Occupancy Report for dedicated logical channel
1085 *
1086 *
1087 *     Ret  : S16
1088 *
1089 *     Notes:
1090 *
1091 *     File  : 
1092 *
1093 **********************************************************/
1094 S16 cmPkRguDBoReport
1095 (
1096 RguDBoReport *param,
1097 Buffer *mBuf
1098 )
1099 {
1100
1101    CMCHKPK(oduUnpackUInt32, param->oldestSduArrTime, mBuf);
1102    CMCHKPK(oduUnpackUInt32, param->staPduBo, mBuf);
1103 #ifdef CCPU_OPT
1104    CMCHKPK(oduUnpackUInt8, param->staPduPrsnt, mBuf);
1105    CMCHKPK(oduUnpackUInt16, param->estRlcHdrSz, mBuf);
1106 #endif
1107    CMCHKPK(SPkS32, param->bo, mBuf);
1108    return ROK;
1109 }
1110
1111
1112 \f
1113 /***********************************************************
1114 *
1115 *     Func : cmUnpkRguDBoReport
1116 *
1117 *
1118 *     Desc : RguDBoReport
1119  * Buffer Occupancy Report for dedicated logical channel
1120 *
1121 *
1122 *     Ret  : S16
1123 *
1124 *     Notes:
1125 *
1126 *     File  : 
1127 *
1128 **********************************************************/
1129 S16 cmUnpkRguDBoReport
1130 (
1131 RguDBoReport *param,
1132 Buffer *mBuf
1133 )
1134 {
1135
1136
1137    CMCHKUNPK(SUnpkS32, &param->bo, mBuf);
1138 #ifdef CCPU_OPT
1139    CMCHKUNPK(oduPackUInt16, &param->estRlcHdrSz, mBuf);
1140    CMCHKUNPK(oduPackUInt8, &param->staPduPrsnt, mBuf);
1141 #endif
1142    
1143    CMCHKUNPK(oduPackUInt32, &param->staPduBo, mBuf);
1144    CMCHKUNPK(oduPackUInt32, &param->oldestSduArrTime, mBuf);
1145    return ROK;
1146 }
1147
1148 \f
1149 /***********************************************************
1150 *
1151 *     Func : cmPkRguCDatReqInfo
1152 *
1153 *
1154 *     Desc : RguCDatReqInfo
1155  * DatReq from RLC to MAC for Common Channels(BCCH, PCCH and CCCH)
1156 *
1157 *
1158 *     Ret  : S16
1159 *
1160 *     Notes:
1161 *
1162 *     File  : 
1163 *
1164 **********************************************************/
1165 S16 cmPkRguCDatReqInfo
1166 (
1167 RguCDatReqInfo *param,
1168 Buffer *mBuf
1169 )
1170 {
1171    MsgLen msgLen;
1172
1173    if (param->pdu != NULLP)
1174    {
1175       if (SFndLenMsg(param->pdu, &msgLen) != ROK)
1176          return RFAILED;
1177       if (SCatMsg(mBuf, param->pdu, M1M2) != ROK)
1178          return RFAILED;
1179       SPutMsg(param->pdu);
1180       CMCHKPK(cmPkMsgLen, msgLen, mBuf);
1181    }
1182    switch(param->lcType) {
1183       case CM_LTE_LCH_CCCH:
1184          CMCHKPK(cmPkLteRnti, param->u.rnti, mBuf);
1185          break;
1186       case CM_LTE_LCH_BCCH:
1187       case CM_LTE_LCH_PCCH:
1188          CMCHKPK(cmPkLteTimingInfo, &param->u.timeToTx, mBuf);
1189 #ifdef EMTC_ENABLE
1190         CMCHKPK(oduUnpackUInt8,param->pnb,mBuf);
1191 #endif
1192          break;
1193       default :
1194          return RFAILED;
1195    }
1196    CMCHKPK(oduUnpackUInt32, param->transId, mBuf);
1197    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
1198    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
1199    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1200    return ROK;
1201 }
1202
1203
1204 \f
1205 /***********************************************************
1206 *
1207 *     Func : cmUnpkRguCDatReqInfo
1208 *
1209 *
1210 *     Desc : RguCDatReqInfo
1211  * DatReq from RLC to MAC for Common Channels(BCCH, PCCH and CCCH)
1212 *
1213 *
1214 *     Ret  : S16
1215 *
1216 *     Notes:
1217 *
1218 *     File  : 
1219 *
1220 **********************************************************/
1221 S16 cmUnpkRguCDatReqInfo
1222 (
1223 RguCDatReqInfo *param,
1224 Buffer *mBuf
1225 )
1226 {
1227    MsgLen msgLen, totalMsgLen;
1228
1229
1230    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1231    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
1232    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
1233    CMCHKUNPK(oduPackUInt32, &param->transId, mBuf);
1234    switch(param->lcType) {
1235       case CM_LTE_LCH_BCCH:
1236       case CM_LTE_LCH_PCCH:
1237 #ifdef EMTC_ENABLE
1238          CMCHKUNPK(oduPackUInt8,&param->pnb, mBuf);
1239 #endif
1240          CMCHKUNPK(cmUnpkLteTimingInfo, &param->u.timeToTx, mBuf);
1241          break;
1242       case CM_LTE_LCH_CCCH:
1243          CMCHKUNPK(cmUnpkLteRnti, &param->u.rnti, mBuf);
1244          break;
1245       default :
1246          return RFAILED;
1247    }
1248    SFndLenMsg(mBuf, &msgLen);
1249    if (msgLen > 0)
1250    {
1251       CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
1252       if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
1253          return RFAILED;
1254       if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->pdu) != ROK)
1255          return RFAILED;
1256    }
1257    return ROK;
1258 }
1259
1260
1261 \f
1262 /***********************************************************
1263 *
1264 *     Func : cmPkRguLchDatReq
1265 *
1266 *
1267 *     Desc : RguLchDatReq
1268  * DatReq Information of a logical channel
1269 *
1270 *
1271 *     Ret  : S16
1272 *
1273 *     Notes:
1274 *
1275 *     File  : 
1276 *
1277 **********************************************************/
1278 S16 cmPkRguLchDatReq
1279 (
1280 RguLchDatReq *param,
1281 Buffer *mBuf
1282 )
1283 {
1284
1285 #ifdef L2_OPTMZ
1286    CMCHKPK(oduUnpackUInt8, param->freeBuff, mBuf);
1287 #endif
1288    CMCHKPK(oduUnpackUInt8, param->setMaxUlPrio, mBuf);
1289    CMCHKPK(cmPkRguPduInfo, &param->pdu, mBuf);
1290    CMCHKPK(cmPkRguDBoReport, &param->boReport, mBuf);
1291    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
1292    return ROK;
1293 }
1294
1295
1296 \f
1297 /***********************************************************
1298 *
1299 *     Func : cmUnpkRguLchDatReq
1300 *
1301 *
1302 *     Desc : RguLchDatReq
1303  * DatReq Information of a logical channel
1304 *
1305 *
1306 *     Ret  : S16
1307 *
1308 *     Notes:
1309 *
1310 *     File  : 
1311 *
1312 **********************************************************/
1313 S16 cmUnpkRguLchDatReq
1314 (
1315 RguLchDatReq *param,
1316 Buffer *mBuf
1317 )
1318 {
1319
1320    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
1321    CMCHKUNPK(cmUnpkRguDBoReport, &param->boReport, mBuf);
1322    CMCHKUNPK(cmUnpkRguPduInfo, &param->pdu, mBuf);
1323    CMCHKUNPK(oduPackUInt8, &param->setMaxUlPrio, mBuf);
1324 #ifdef L2_OPTMZ
1325    CMCHKUNPK(oduPackUInt8, &param->freeBuff, mBuf);
1326 #endif
1327    return ROK;
1328 }
1329
1330 \f
1331 /***********************************************************
1332 *
1333 *     Func : cmPkRguDatReqTb
1334 *
1335 *
1336 *     Desc : RguDatReqTb
1337 * DatReq from RLC to MAC for dedicated channels of a UE
1338 *
1339 *
1340 *     Ret  : S16
1341 *
1342 *     Notes:
1343 *
1344 *     File  : 
1345 *
1346 **********************************************************/
1347 S16 cmPkRguDatReqTb
1348 (
1349 RguDatReqTb *param,
1350 Buffer *mBuf
1351 )
1352 {
1353    S32 i;
1354
1355    /*rgu_c_001.main_5 - ADD - L2M Support */
1356 #ifdef LTE_L2_MEAS
1357    CMCHKPK(oduUnpackUInt32, param->tbId, mBuf);
1358 #endif
1359    for (i=param->nmbLch-1; i >= 0; i--) {
1360       CMCHKPK(cmPkRguLchDatReq, &param->lchData[i], mBuf);
1361    }
1362    CMCHKPK(oduUnpackUInt8, param->nmbLch, mBuf);
1363    return ROK;
1364 }
1365
1366
1367 \f
1368 /***********************************************************
1369 *
1370 *     Func : cmUnpkRguDatReqTb
1371 *
1372 *
1373 *     Desc : RguDatReqTb
1374  * DatReq from RLC to MAC for dedicated channels of a UE
1375 *
1376 *
1377 *     Ret  : S16
1378 *
1379 *     Notes:
1380 *
1381 *     File  : 
1382 *
1383 **********************************************************/
1384 #ifdef LTE_L2_MEAS
1385 S16 cmUnpkRguDatReqTb
1386 (
1387 Pst         *pst, 
1388 RguDatReqTb *param,
1389 Buffer *mBuf
1390 )
1391 #else
1392 S16 cmUnpkRguDatReqTb
1393 (
1394 RguDatReqTb *param,
1395 Buffer *mBuf
1396 )
1397 #endif
1398 {
1399    S32 i;
1400
1401
1402    CMCHKUNPK(oduPackUInt8, &param->nmbLch, mBuf);
1403    for (i=0; i<param->nmbLch; i++) {
1404       CMCHKUNPK(cmUnpkRguLchDatReq, &param->lchData[i], mBuf);
1405    }
1406    /*rgu_c_001.main_5 - ADD - L2M Support */
1407 #ifdef LTE_L2_MEAS
1408    CMCHKUNPK(oduPackUInt32, &param->tbId, mBuf);
1409 #endif
1410    return ROK;
1411 }
1412
1413 \f
1414 /***********************************************************
1415 *
1416 *     Func : cmPkRguDDatReqInfo
1417 *
1418 *
1419 *     Desc : RguDDatReqInfo
1420  * DatReq from RLC to MAC for dedicated channels of a UE
1421 *
1422 *
1423 *     Ret  : S16
1424 *
1425 *     Notes:
1426 *
1427 *     File  : 
1428 *
1429 **********************************************************/
1430    /*rgu_c_001.main_5 - ADD - L2M Support */
1431 #ifdef LTE_L2_MEAS
1432 S16 cmPkRguDDatReqInfo
1433 (
1434 Pst            *pst,
1435 RguDDatReqInfo *param,
1436 Buffer *mBuf
1437 )
1438 #else
1439 S16 cmPkRguDDatReqInfo
1440 (
1441 RguDDatReqInfo *param,
1442 Buffer *mBuf
1443 )
1444 #endif
1445 {
1446    S32 i;
1447    S32 idx;
1448
1449
1450    for(idx = (param->nmbOfUeGrantPerTti-1); idx >= 0; idx--)
1451    {
1452       RguDDatReqPerUe *datReq = &param->datReq[idx];
1453       for (i=RGU_MAX_TB-1; i >= 0; i--) 
1454       {
1455          CMCHKPK(cmPkRguDatReqTb, &datReq->datReqTb[i], mBuf);
1456       }
1457       CMCHKPK(oduUnpackUInt8, datReq->nmbOfTbs, mBuf);
1458       CMCHKPK(oduUnpackUInt32, datReq->transId, mBuf);
1459       CMCHKPK(cmPkLteRnti, datReq->rnti, mBuf);
1460    }
1461    CMCHKPK(oduUnpackUInt8, param->nmbOfUeGrantPerTti, mBuf);
1462    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1463    return ROK;
1464 }
1465
1466
1467 \f
1468 /***********************************************************
1469 *
1470 *     Func : cmUnpkRguDDatReqInfo
1471 *
1472 *
1473 *     Desc : RguDDatReqInfo
1474  * DatReq from RLC to MAC for dedicated channels of a UE
1475 *
1476 *
1477 *     Ret  : S16
1478 *
1479 *     Notes:
1480 *
1481 *     File  : 
1482 *
1483 **********************************************************/
1484 #ifdef LTE_L2_MEAS
1485 S16 cmUnpkRguDDatReqInfo
1486 (
1487 Pst            *pst, 
1488 RguDDatReqInfo *param,
1489 Buffer *mBuf
1490 )
1491 #else
1492 S16 cmUnpkRguDDatReqInfo
1493 (
1494 RguDDatReqInfo *param,
1495 Buffer *mBuf
1496 )
1497 #endif
1498 {
1499    S32 i;
1500   /* After Merging from 2.1 to 2.2 */
1501    /*rgu_c_001.main_5 - ADD - L2M Support */
1502 #ifdef LTE_L2_MEAS
1503    S16 retVal;
1504 #endif
1505    S32 idx;
1506
1507
1508   /* After Merging from 2.1 to 2.2 */
1509    /*rgu_c_001.main_5 - ADD - L2M Support */
1510 #ifdef LTE_L2_MEAS
1511    retVal = ROK;
1512 #endif
1513    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1514    CMCHKUNPK(oduPackUInt8, &param->nmbOfUeGrantPerTti, mBuf);
1515    for(idx = 0; idx < param->nmbOfUeGrantPerTti; idx++)
1516    { 
1517       RguDDatReqPerUe *datReq = &param->datReq[idx];
1518       CMCHKUNPK(cmUnpkLteRnti, &datReq->rnti, mBuf);
1519       CMCHKUNPK(oduPackUInt32, &datReq->transId, mBuf);
1520       CMCHKUNPK(oduPackUInt8, &datReq->nmbOfTbs, mBuf);
1521       /* rgu_c_001.main_4 - Changes for MIMO feature addition */
1522       for (i=0; i<RGU_MAX_TB; i++) 
1523       {
1524          /*rgu_c_001.main_5 - ADD - L2M Support */
1525 #ifdef LTE_L2_MEAS
1526          /* After Merging from 2.1 to 2.2 */
1527          retVal = cmUnpkRguDatReqTb(pst, &datReq->datReqTb[i], mBuf);
1528          if(retVal != ROK)
1529          {
1530             return RFAILED;
1531          }
1532 #else
1533          CMCHKUNPK(cmUnpkRguDatReqTb, &datReq->datReqTb[i], mBuf);
1534 #endif
1535       }
1536    }
1537    return ROK;
1538 }
1539
1540
1541 \f
1542 /***********************************************************
1543 *
1544 *     Func : cmPkRguCDatIndInfo
1545 *
1546 *
1547 *     Desc : RguCDatIndInfo
1548  * DatInd from MAC to RLC on CCCH
1549 *
1550 *
1551 *     Ret  : S16
1552 *
1553 *     Notes:
1554 *
1555 *     File  : 
1556 *
1557 **********************************************************/
1558 S16 cmPkRguCDatIndInfo
1559 (
1560 RguCDatIndInfo *param,
1561 Buffer *mBuf
1562 )
1563 {
1564    MsgLen msgLen;
1565
1566    if (SFndLenMsg(param->pdu, &msgLen) != ROK)
1567       return RFAILED;
1568    if (SCatMsg(mBuf, param->pdu, M1M2) != ROK)
1569       return RFAILED;
1570    SPutMsg(param->pdu);
1571    CMCHKPK(cmPkMsgLen, msgLen, mBuf);
1572    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
1573    CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
1574    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1575    return ROK;
1576 }
1577
1578
1579 \f
1580 /***********************************************************
1581 *
1582 *     Func : cmUnpkRguCDatIndInfo
1583 *
1584 *
1585 *     Desc : RguCDatIndInfo
1586  * DatInd from MAC to RLC on CCCH
1587 *
1588 *
1589 *     Ret  : S16
1590 *
1591 *     Notes:
1592 *
1593 *     File  : 
1594 *
1595 **********************************************************/
1596 S16 cmUnpkRguCDatIndInfo
1597 (
1598 RguCDatIndInfo *param,
1599 Buffer *mBuf
1600 )
1601 {
1602    MsgLen msgLen, totalMsgLen;
1603
1604
1605    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1606    CMCHKUNPK(cmUnpkLteRnti, &param->rnti, mBuf);
1607    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
1608    CMCHKUNPK(cmUnpkMsgLen, &msgLen, mBuf);
1609    if (SFndLenMsg(mBuf, &totalMsgLen) != ROK)
1610       return RFAILED;
1611    if (SSegMsg(mBuf, totalMsgLen-msgLen, &param->pdu) != ROK)
1612       return RFAILED;
1613    return ROK;
1614 }
1615
1616
1617 \f
1618 /***********************************************************
1619 *
1620 *     Func : cmPkRguLchDatInd
1621 *
1622 *
1623 *     Desc : RguLchDatInd
1624  * DatInd Information for a logical channel
1625 *
1626 *
1627 *     Ret  : S16
1628 *
1629 *     Notes:
1630 *
1631 *     File  : 
1632 *
1633 **********************************************************/
1634 S16 cmPkRguLchDatInd
1635 (
1636 RguLchDatInd *param,
1637 Buffer *mBuf
1638 )
1639 {
1640
1641    CMCHKPK(cmPkRguPduInfo, &param->pdu, mBuf);
1642    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
1643    return ROK;
1644 }
1645
1646
1647 \f
1648 /***********************************************************
1649 *
1650 *     Func : cmUnpkRguLchDatInd
1651 *
1652 *
1653 *     Desc : RguLchDatInd
1654  * DatInd Information for a logical channel
1655 *
1656 *
1657 *     Ret  : S16
1658 *
1659 *     Notes:
1660 *
1661 *     File  : 
1662 *
1663 **********************************************************/
1664 S16 cmUnpkRguLchDatInd
1665 (
1666 RguLchDatInd *param,
1667 Buffer *mBuf
1668 )
1669 {
1670
1671    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
1672    CMCHKUNPK(cmUnpkRguPduInfo, &param->pdu, mBuf);
1673    return ROK;
1674 }
1675
1676 \f
1677 /***********************************************************
1678 *
1679 *     Func : cmPkRguCStaRspInfo
1680 *
1681 *
1682 *     Desc : RguCStaRspInfo
1683  * Status Response from RLC to MAC  for common logical channel
1684 *
1685 *
1686 *     Ret  : S16
1687 *
1688 *     Notes:
1689 *
1690 *     File  : 
1691 *
1692 **********************************************************/
1693 S16 cmPkRguCStaRspInfo
1694 (
1695 RguCStaRspInfo *param,
1696 Buffer *mBuf
1697 )
1698 {
1699
1700
1701    switch(param->lcType) {
1702       case CM_LTE_LCH_CCCH:
1703          CMCHKPK(cmPkLteRnti, param->u.rnti, mBuf);
1704          break;
1705       case CM_LTE_LCH_BCCH:
1706       case CM_LTE_LCH_PCCH:
1707          CMCHKPK(cmPkLteTimingInfo, &param->u.timeToTx, mBuf);
1708 #ifdef EMTC_ENABLE
1709          CMCHKPK(oduUnpackUInt8,param->pnb,mBuf);
1710          CMCHKPK(oduUnpackUInt8,param->emtcDiReason,mBuf);
1711 #endif
1712          break;
1713       default :
1714          return RFAILED;
1715    }
1716    CMCHKPK(SPkS32, param->bo, mBuf);
1717    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
1718    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
1719    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1720    return ROK;
1721 }
1722
1723
1724 \f
1725 /***********************************************************
1726 *
1727 *     Func : cmUnpkRguCStaRspInfo
1728 *
1729 *
1730 *     Desc : RguCStaRspInfo
1731  * Status Response from RLC to MAC  for common logical channel
1732 *
1733 *
1734 *     Ret  : S16
1735 *
1736 *     Notes:
1737 *
1738 *     File  : 
1739 *
1740 **********************************************************/
1741 S16 cmUnpkRguCStaRspInfo
1742 (
1743 RguCStaRspInfo *param,
1744 Buffer *mBuf
1745 )
1746 {
1747
1748
1749    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1750    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
1751    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
1752    CMCHKUNPK(SUnpkS32, &param->bo, mBuf);
1753    switch(param->lcType) {
1754       case CM_LTE_LCH_BCCH:
1755       case CM_LTE_LCH_PCCH:
1756 #ifdef EMTC_ENABLE
1757          CMCHKUNPK(oduPackUInt8,&param->emtcDiReason , mBuf);
1758          CMCHKUNPK(oduPackUInt8,&param->pnb , mBuf);
1759 #endif
1760          CMCHKUNPK(cmUnpkLteTimingInfo, &param->u.timeToTx, mBuf);
1761          break;
1762       case CM_LTE_LCH_CCCH:
1763          CMCHKUNPK(cmUnpkLteRnti, &param->u.rnti, mBuf);
1764          break;
1765       default :
1766          return RFAILED;
1767    }
1768    return ROK;
1769 }
1770
1771 \f
1772 /***********************************************************
1773 *
1774 *     Func : cmPkRguLchStaInd
1775 *
1776 *
1777 *     Desc : RguLchStaInd
1778  * StaInd info for each logical channel of a UE
1779 *
1780 *
1781 *     Ret  : S16
1782 *
1783 *     Notes:
1784 *
1785 *     File  : 
1786 *
1787 **********************************************************/
1788 S16 cmPkRguLchStaInd
1789 (
1790 RguLchStaInd *param,
1791 Buffer *mBuf
1792 )
1793 {
1794
1795
1796    CMCHKPK(SPkS16, param->totBufSize, mBuf);
1797    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
1798    return ROK;
1799 }
1800
1801
1802 \f
1803 /***********************************************************
1804 *
1805 *     Func : cmUnpkRguLchStaInd
1806 *
1807 *
1808 *     Desc : RguLchStaInd
1809  * StaInd info for each logical channel of a UE
1810 *
1811 *
1812 *     Ret  : S16
1813 *
1814 *     Notes:
1815 *
1816 *     File  : 
1817 *
1818 **********************************************************/
1819 S16 cmUnpkRguLchStaInd
1820 (
1821 RguLchStaInd *param,
1822 Buffer *mBuf
1823 )
1824 {
1825
1826    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
1827    CMCHKUNPK(SUnpkS16, &param->totBufSize, mBuf);
1828    return ROK;
1829 }
1830
1831 \f
1832 /***********************************************************
1833 *
1834 *     Func : cmPkRguStaIndTb
1835 *
1836 *
1837 *     Desc : RguStaIndTb
1838 * StaInd from RLC to MAC for dedicated channels of a UE
1839 *
1840 *
1841 *     Ret  : S16
1842 *
1843 *     Notes:
1844 *
1845 *     File  : 
1846 *
1847 **********************************************************/
1848 S16 cmPkRguStaIndTb
1849 (
1850 RguStaIndTb *param,
1851 Buffer *mBuf
1852 )
1853 {
1854    S32 i;
1855
1856
1857 #ifdef LTE_L2_MEAS
1858    CMCHKPK(oduUnpackUInt16, param->status, mBuf);
1859    CMCHKPK(oduUnpackUInt32, param->tbId, mBuf);
1860 #endif   
1861    for (i=param->nmbLch-1; i >= 0; i--) {
1862       CMCHKPK(cmPkRguLchStaInd, &param->lchStaInd[i], mBuf);
1863    }
1864    CMCHKPK(oduUnpackUInt8, param->nmbLch, mBuf);
1865    return ROK;
1866 }
1867
1868
1869 \f
1870 /***********************************************************
1871 *
1872 *     Func : cmUnpkRguStaIndTb
1873 *
1874 *
1875 *     Desc : RguStaIndTb
1876 * StaInd from RLC to MAC for dedicated channels of a UE
1877 *
1878 *
1879 *     Ret  : S16
1880 *
1881 *     Notes:
1882 *
1883 *     File  : 
1884 *
1885 **********************************************************/
1886 S16 cmUnpkRguStaIndTb
1887 (
1888 RguStaIndTb *param,
1889 Buffer *mBuf
1890 )
1891 {
1892    S32 i;
1893
1894    CMCHKUNPK(oduPackUInt8, &param->nmbLch, mBuf);
1895    for (i=0; i<param->nmbLch; i++) {
1896       CMCHKUNPK(cmUnpkRguLchStaInd, &param->lchStaInd[i], mBuf);
1897    }
1898 #ifdef LTE_L2_MEAS
1899    CMCHKUNPK(oduPackUInt32, &param->tbId, mBuf);
1900    CMCHKUNPK(oduPackUInt16, &param->status, mBuf);
1901 #endif   
1902    return ROK;
1903 }
1904
1905 #endif
1906
1907 /**********************************************************************
1908          End of file
1909 **********************************************************************/