9d2dc3a1963d417321eb145537cf59ca74392010
[o-du/l2.git] / src / cm / crg.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 \f
19
20 /************************************************************************
21  
22      Name:     LTE-MAC layer
23   
24      Type:     C source file
25   
26      Desc:     C source code for pack/unpack of CRG interface primitives. 
27   
28      File:     crg.c 
29   
30 **********************************************************************/
31
32 /** @file crg.c
33 @brief This file contains the packing/unpacking code for the CRG interface 
34        primitives.
35 */
36 /* header include files (.h) */
37 #include "envopt.h"        /* environment options */
38 #include "envdep.h"        /* environment dependent */
39 #include "envind.h"        /* environment independent */
40 #include "gen.h"           /* general */
41 #include "ssi.h"           /* system services */
42 #include "cm_tkns.h"       /* Common Token Defines */
43 #include "cm_llist.h"      /* Common Link List Defines */
44 #include "cm_hash.h"       /* Common Hash List Defines */
45 #include "cm_lte.h"        /* Common LTE Defines */
46 #include "crg.h"           /* CRG Interface defines */
47
48 /* header/extern include files (.x) */
49 #include "gen.x"           /* general */
50 #include "ssi.x"           /* system services */
51 #include "cm_tkns.x"       /* Common Token Definitions */
52 #include "cm_llist.x"      /* Common Link List Definitions */
53 #include "cm_lib.x"        /* Common Library Definitions */
54 #include "cm_hash.x"       /* Common Hash List Definitions */
55 #include "cm_lte.x"        /* Common LTE Defines */
56 #include "crg.x"           /* CRG Interface includes */
57
58
59 #ifdef LCCRG
60 \f
61 /**
62 * @brief Request from RRC to MAC to bind the interface saps
63 *
64 * @details
65 *
66 *     Function : cmPkCrgBndReq
67 *
68 *  @param[in]   Pst*  pst
69 *  @param[in]   SuId  suId
70 *  @param[in]   SpId  spId
71 *  @return   S16
72 *      -# ROK
73 **/
74 #ifdef ANSI
75 PUBLIC S16 cmPkCrgBndReq
76 (
77 Pst* pst,
78 SuId suId,
79 SpId spId
80 )
81 #else
82 PUBLIC S16 cmPkCrgBndReq(pst, suId, spId)
83 Pst* pst;
84 SuId suId;
85 SpId spId;
86 #endif
87 {
88    Buffer *mBuf = NULLP;
89    TRC3(cmPkCrgBndReq)
90
91    if (SGetMsg(pst->region, pst->pool, &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)ECRG001, (ErrVal)0, "Packing failed");
96 #endif
97       RETVALUE(RFAILED);
98    }
99    if (SPkS16(spId, mBuf) != ROK) {
100 #if (ERRCLASS & ERRCLS_ADD_RES)
101       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
102          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
103          (ErrVal)ECRG002, (ErrVal)0, "Packing failed");
104 #endif
105       SPutMsg(mBuf);
106       RETVALUE(RFAILED);
107    }
108    if (SPkS16(suId, mBuf) != ROK) {
109 #if (ERRCLASS & ERRCLS_ADD_RES)
110       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
111          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
112          (ErrVal)ECRG003, (ErrVal)0, "Packing failed");
113 #endif
114       SPutMsg(mBuf);
115       RETVALUE(RFAILED);
116    }
117    pst->event = (Event) EVTCRGBNDREQ;
118    RETVALUE(SPstTsk(pst,mBuf));
119 }
120
121 \f
122 /**
123 * @brief Request from RRC to MAC to bind the interface saps
124 *
125 * @details
126 *
127 *     Function : cmUnpkCrgBndReq
128 *
129 *  @param[in]   Pst*  pst
130 *  @param[in]   SuId  suId
131 *  @param[in]   SpId  spId
132 *  @return   S16
133 *      -# ROK
134 **/
135 #ifdef ANSI
136 PUBLIC S16 cmUnpkCrgBndReq
137 (
138 CrgBndReq func,
139 Pst *pst,
140 Buffer *mBuf
141 )
142 #else
143 PUBLIC S16 cmUnpkCrgBndReq(func, pst, mBuf)
144 CrgBndReq func;
145 Pst *pst;
146 Buffer *mBuf;
147 #endif
148 {
149    SuId suId;
150    SpId spId;
151    
152    TRC3(cmUnpkCrgBndReq)
153
154    if (SUnpkS16(&suId, mBuf) != ROK) {
155       SPutMsg(mBuf);
156 #if (ERRCLASS & ERRCLS_ADD_RES)
157       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
158          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
159          (ErrVal)ECRG004, (ErrVal)0, "Packing failed");
160 #endif
161       RETVALUE(RFAILED);
162    }
163    if (SUnpkS16(&spId, mBuf) != ROK) {
164       SPutMsg(mBuf);
165 #if (ERRCLASS & ERRCLS_ADD_RES)
166       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
167          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
168          (ErrVal)ECRG005, (ErrVal)0, "Packing failed");
169 #endif
170       RETVALUE(RFAILED);
171    }
172    SPutMsg(mBuf);
173    RETVALUE((*func)(pst, suId, spId));
174 }
175
176 \f
177 /**
178 * @brief Confirmation from MAC to RRC for the bind/Unbind 
179  * request for the interface saps
180 *
181 * @details
182 *
183 *     Function : cmPkCrgBndCfm
184 *
185 *  @param[in]   Pst*  pst
186 *  @param[in]   SuId  suId
187 *  @param[in]   U8  status
188 *  @return   S16
189 *      -# ROK
190 **/
191 #ifdef ANSI
192 PUBLIC S16 cmPkCrgBndCfm
193 (
194 Pst* pst,
195 SuId suId,
196 U8 status
197 )
198 #else
199 PUBLIC S16 cmPkCrgBndCfm(pst, suId, status)
200 Pst* pst;
201 SuId suId;
202 U8 status;
203 #endif
204 {
205    Buffer *mBuf = NULLP;
206    TRC3(cmPkCrgBndCfm)
207
208    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
209 #if (ERRCLASS & ERRCLS_ADD_RES)
210       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
211          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
212          (ErrVal)ECRG006, (ErrVal)0, "Packing failed");
213 #endif
214       RETVALUE(RFAILED);
215    }
216    if (SPkU8(status, mBuf) != ROK) {
217 #if (ERRCLASS & ERRCLS_ADD_RES)
218       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
219          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
220          (ErrVal)ECRG007, (ErrVal)0, "Packing failed");
221 #endif
222       SPutMsg(mBuf);
223       RETVALUE(RFAILED);
224    }
225    if (SPkS16(suId, mBuf) != ROK) {
226 #if (ERRCLASS & ERRCLS_ADD_RES)
227       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
228          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
229          (ErrVal)ECRG008, (ErrVal)0, "Packing failed");
230 #endif
231       SPutMsg(mBuf);
232       RETVALUE(RFAILED);
233    }
234    pst->event = (Event) EVTCRGBNDCFM;
235    RETVALUE(SPstTsk(pst,mBuf));
236 }
237
238 \f
239 /**
240 * @brief Confirmation from MAC to RRC for the bind/Unbind 
241  * request for the interface saps
242 *
243 * @details
244 *
245 *     Function : cmUnpkCrgBndCfm
246 *
247 *  @param[in]   Pst*  pst
248 *  @param[in]   SuId  suId
249 *  @param[in]   U8  status
250 *  @return   S16
251 *      -# ROK
252 **/
253 #ifdef ANSI
254 PUBLIC S16 cmUnpkCrgBndCfm
255 (
256 CrgBndCfm func,
257 Pst *pst,
258 Buffer *mBuf
259 )
260 #else
261 PUBLIC S16 cmUnpkCrgBndCfm(func, pst, mBuf)
262 CrgBndCfm func;
263 Pst *pst;
264 Buffer *mBuf;
265 #endif
266 {
267    SuId suId;
268    U8 status;
269    
270    TRC3(cmUnpkCrgBndCfm)
271
272    if (SUnpkS16(&suId, mBuf) != ROK) {
273       SPutMsg(mBuf);
274 #if (ERRCLASS & ERRCLS_ADD_RES)
275       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
276          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
277          (ErrVal)ECRG009, (ErrVal)0, "Packing failed");
278 #endif
279       RETVALUE(RFAILED);
280    }
281    if (SUnpkU8(&status, mBuf) != ROK) {
282       SPutMsg(mBuf);
283 #if (ERRCLASS & ERRCLS_ADD_RES)
284       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
285          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
286          (ErrVal)ECRG010, (ErrVal)0, "Packing failed");
287 #endif
288       RETVALUE(RFAILED);
289    }
290    SPutMsg(mBuf);
291    RETVALUE((*func)(pst, suId, status));
292 }
293
294 \f
295 /**
296 * @brief Request from RRC to MAC to Unbind the interface saps
297 *
298 * @details
299 *
300 *     Function : cmPkCrgUbndReq
301 *
302 *  @param[in]   Pst*  pst
303 *  @param[in]   SpId  spId
304 *  @param[in]   Reason  reason
305 *  @return   S16
306 *      -# ROK
307 **/
308 #ifdef ANSI
309 PUBLIC S16 cmPkCrgUbndReq
310 (
311 Pst* pst,
312 SpId spId,
313 Reason reason
314 )
315 #else
316 PUBLIC S16 cmPkCrgUbndReq(pst, spId, reason)
317 Pst* pst;
318 SpId spId;
319 Reason reason;
320 #endif
321 {
322    Buffer *mBuf = NULLP;
323    TRC3(cmPkCrgUbndReq)
324
325    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
326 #if (ERRCLASS & ERRCLS_ADD_RES)
327       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
328          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
329          (ErrVal)ECRG011, (ErrVal)0, "Packing failed");
330 #endif
331       RETVALUE(RFAILED);
332    }
333    if (SPkS16(reason, mBuf) != ROK) {
334 #if (ERRCLASS & ERRCLS_ADD_RES)
335       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
336          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
337          (ErrVal)ECRG012, (ErrVal)0, "Packing failed");
338 #endif
339       SPutMsg(mBuf);
340       RETVALUE(RFAILED);
341    }
342    if (SPkS16(spId, mBuf) != ROK) {
343 #if (ERRCLASS & ERRCLS_ADD_RES)
344       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
345          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
346          (ErrVal)ECRG013, (ErrVal)0, "Packing failed");
347 #endif
348       SPutMsg(mBuf);
349       RETVALUE(RFAILED);
350    }
351    pst->event = (Event) EVTCRGUBNDREQ;
352    RETVALUE(SPstTsk(pst,mBuf));
353 }
354
355 \f
356 /**
357 * @brief Request from RRC to MAC to Unbind the interface saps
358 *
359 * @details
360 *
361 *     Function : cmUnpkCrgUbndReq
362 *
363 *  @param[in]   Pst*  pst
364 *  @param[in]   SpId  spId
365 *  @param[in]   Reason  reason
366 *  @return   S16
367 *      -# ROK
368 **/
369 #ifdef ANSI
370 PUBLIC S16 cmUnpkCrgUbndReq
371 (
372 CrgUbndReq func,
373 Pst *pst,
374 Buffer *mBuf
375 )
376 #else
377 PUBLIC S16 cmUnpkCrgUbndReq(func, pst, mBuf)
378 CrgUbndReq func;
379 Pst *pst;
380 Buffer *mBuf;
381 #endif
382 {
383    SpId spId;
384    Reason reason;
385    
386    TRC3(cmUnpkCrgUbndReq)
387
388    if (SUnpkS16(&spId, mBuf) != ROK) {
389       SPutMsg(mBuf);
390 #if (ERRCLASS & ERRCLS_ADD_RES)
391       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
392          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
393          (ErrVal)ECRG014, (ErrVal)0, "Packing failed");
394 #endif
395       RETVALUE(RFAILED);
396    }
397    if (SUnpkS16(&reason, mBuf) != ROK) {
398       SPutMsg(mBuf);
399 #if (ERRCLASS & ERRCLS_ADD_RES)
400       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
401          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
402          (ErrVal)ECRG015, (ErrVal)0, "Packing failed");
403 #endif
404       RETVALUE(RFAILED);
405    }
406    SPutMsg(mBuf);
407    RETVALUE((*func)(pst, spId, reason));
408 }
409
410 \f
411 /**
412 * @brief Configuration Request from RRC to MAC for 
413  * configuring Cell/Ue/Lc
414 *
415 * @details
416 *
417 *     Function : cmPkCrgCfgReq
418 *
419 *  @param[in]   Pst*  pst
420 *  @param[in]   SpId  spId
421 *  @param[in]   CrgCfgTransId  transId
422 *  @param[in]   CrgCfgReqInfo  *  cfgReqInfo
423 *  @return   S16
424 *      -# ROK
425 **/
426 #ifdef ANSI
427 PUBLIC S16 cmPkCrgCfgReq
428 (
429 Pst* pst,
430 SpId spId,
431 CrgCfgTransId transId,
432 CrgCfgReqInfo  * cfgReqInfo
433 )
434 #else
435 PUBLIC S16 cmPkCrgCfgReq(pst, spId, transId, cfgReqInfo)
436 Pst* pst;
437 SpId spId;
438 CrgCfgTransId transId;
439 CrgCfgReqInfo  * cfgReqInfo;
440 #endif
441 {
442    Buffer *mBuf = NULLP;
443    TRC3(cmPkCrgCfgReq)
444
445    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
446 #if (ERRCLASS & ERRCLS_ADD_RES)
447       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
448          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
449          (ErrVal)ECRG016, (ErrVal)0, "Packing failed");
450 #endif
451       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
452       RETVALUE(RFAILED);
453    }
454    if (cmPkCrgCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
455 #if (ERRCLASS & ERRCLS_ADD_RES)
456       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
457          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
458          (ErrVal)ECRG017, (ErrVal)0, "Packing failed");
459 #endif
460       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
461       SPutMsg(mBuf);
462       RETVALUE(RFAILED);
463    }
464 /* crg_c_001.main_5: MOD - Updating ERR code */
465    if (cmPkCrgCfgTransId(&transId, 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)ECRG018, (ErrVal)0, "Packing failed");
470 #endif
471       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
472       SPutMsg(mBuf);
473       RETVALUE(RFAILED);
474    }
475    if (SPkS16(spId, mBuf) != ROK) {
476 #if (ERRCLASS & ERRCLS_ADD_RES)
477       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
478          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
479          (ErrVal)ECRG019, (ErrVal)0, "Packing failed");
480 #endif
481       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
482       SPutMsg(mBuf);
483       RETVALUE(RFAILED);
484    }
485    if (SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo)) != ROK) {
486 #if (ERRCLASS & ERRCLS_ADD_RES)
487       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
488          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
489          (ErrVal)ECRG020, (ErrVal)0, "Packing failed");
490 #endif
491       SPutMsg(mBuf);
492       RETVALUE(RFAILED);
493    }
494    pst->event = (Event) EVTCRGCFGREQ;
495    RETVALUE(SPstTsk(pst,mBuf));
496 }
497
498 \f
499 /**
500 * @brief Configuration Request from RRC to MAC for 
501  * configuring Cell/Ue/Lc
502 *
503 * @details
504 *
505 *     Function : cmUnpkCrgCfgReq
506 *
507 *  @param[in]   Pst*  pst
508 *  @param[in]   SpId  spId
509 *  @param[in]   CrgCfgTransId  transId
510 *  @param[in]   CrgCfgReqInfo  *  cfgReqInfo
511 *  @return   S16
512 *      -# ROK
513 **/
514 #ifdef ANSI
515 PUBLIC S16 cmUnpkCrgCfgReq
516 (
517 CrgCfgReq func,
518 Pst *pst,
519 Buffer *mBuf
520 )
521 #else
522 PUBLIC S16 cmUnpkCrgCfgReq(func, pst, mBuf)
523 CrgCfgReq func;
524 Pst *pst;
525 Buffer *mBuf;
526 #endif
527 {
528    SpId spId;
529    CrgCfgTransId transId;
530    CrgCfgReqInfo *cfgReqInfo;
531    
532    TRC3(cmUnpkCrgCfgReq)
533
534    if (SUnpkS16(&spId, mBuf) != ROK) {
535       SPutMsg(mBuf);
536 #if (ERRCLASS & ERRCLS_ADD_RES)
537       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
538          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
539          (ErrVal)ECRG021, (ErrVal)0, "Packing failed");
540 #endif
541       RETVALUE(RFAILED);
542    }
543    if (cmUnpkCrgCfgTransId(&transId, mBuf) != ROK) {
544       SPutMsg(mBuf);
545 #if (ERRCLASS & ERRCLS_ADD_RES)
546       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
547          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
548          (ErrVal)ECRG022, (ErrVal)0, "Packing failed");
549 #endif
550       RETVALUE(RFAILED);
551    }
552    if ((SGetSBuf(pst->region, pst->pool, (Data **)&cfgReqInfo, sizeof(CrgCfgReqInfo))) != ROK) {
553 #if (ERRCLASS & ERRCLS_ADD_RES)
554       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
555          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
556          (ErrVal)ECRG023, (ErrVal)0, "Packing failed");
557 #endif
558       SPutMsg(mBuf);
559       RETVALUE(RFAILED);
560    }
561     
562    if (cmUnpkCrgCfgReqInfo(cfgReqInfo, mBuf) != ROK) {
563       SPutSBuf(pst->region, pst->pool, (Data *)cfgReqInfo, sizeof(CrgCfgReqInfo));
564       SPutMsg(mBuf);
565 #if (ERRCLASS & ERRCLS_ADD_RES)
566       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
567          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
568          (ErrVal)ECRG024, (ErrVal)0, "Packing failed");
569 #endif
570       RETVALUE(RFAILED);
571    }
572    SPutMsg(mBuf);
573    RETVALUE((*func)(pst, spId, transId, cfgReqInfo));
574 }
575
576 \f
577 /**
578 * @brief Configuration Confirm from MAC to RRC
579 *
580 * @details
581 *
582 *     Function : cmPkCrgCfgCfm
583 *
584 *  @param[in]   Pst*  pst
585 *  @param[in]   SuId  suId
586 *  @param[in]   CrgCfgTransId  transId
587 *  @param[in]   U8  status
588 *  @return   S16
589 *      -# ROK
590 **/
591 #ifdef ANSI
592 PUBLIC S16 cmPkCrgCfgCfm
593 (
594 Pst* pst,
595 SuId suId,
596 CrgCfgTransId transId,
597 U8 status
598 )
599 #else
600 PUBLIC S16 cmPkCrgCfgCfm(pst, suId, transId, status)
601 Pst* pst;
602 SuId suId;
603 CrgCfgTransId transId;
604 U8 status;
605 #endif
606 {
607    Buffer *mBuf = NULLP;
608    TRC3(cmPkCrgCfgCfm)
609
610    if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
611 #if (ERRCLASS & ERRCLS_ADD_RES)
612       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
613          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
614          (ErrVal)ECRG025, (ErrVal)0, "Packing failed");
615 #endif
616       RETVALUE(RFAILED);
617    }
618 /* crg_c_001.main_5 - ADD - Added the packing for status. */
619    if (SPkU8(status, mBuf) != ROK) {
620 #if (ERRCLASS & ERRCLS_ADD_RES)
621       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
622          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
623          (ErrVal)ECRG026, (ErrVal)0, "Packing failed");
624 #endif
625       SPutMsg(mBuf);
626       RETVALUE(RFAILED);
627    }
628    if (cmPkCrgCfgTransId(&transId, mBuf) != ROK) {
629 #if (ERRCLASS & ERRCLS_ADD_RES)
630       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
631          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
632          (ErrVal)ECRG027, (ErrVal)0, "Packing failed");
633 #endif
634       SPutMsg(mBuf);
635       RETVALUE(RFAILED);
636    }
637    if (SPkS16(suId, mBuf) != ROK) {
638 #if (ERRCLASS & ERRCLS_ADD_RES)
639       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
640          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
641          (ErrVal)ECRG028, (ErrVal)0, "Packing failed");
642 #endif
643       SPutMsg(mBuf);
644       RETVALUE(RFAILED);
645    }
646    pst->event = (Event) EVTCRGCFGCFM;
647    RETVALUE(SPstTsk(pst,mBuf));
648 }
649
650 \f
651 /**
652 * @brief Configuration Confirm from MAC to RRC
653 *
654 * @details
655 *
656 *     Function : cmUnpkCrgCfgCfm
657 *
658 *  @param[in]   Pst*  pst
659 *  @param[in]   SuId  suId
660 *  @param[in]   CrgCfgTransId  transId
661 *  @param[in]   U8  status
662 *  @return   S16
663 *      -# ROK
664 **/
665 #ifdef ANSI
666 PUBLIC S16 cmUnpkCrgCfgCfm
667 (
668 CrgCfgCfm func,
669 Pst *pst,
670 Buffer *mBuf
671 )
672 #else
673 PUBLIC S16 cmUnpkCrgCfgCfm(func, pst, mBuf)
674 CrgCfgCfm func;
675 Pst *pst;
676 Buffer *mBuf;
677 #endif
678 {
679    SuId suId;
680    CrgCfgTransId transId;
681    U8 status;
682    
683    TRC3(cmUnpkCrgCfgCfm)
684
685    if (SUnpkS16(&suId, mBuf) != ROK) {
686       SPutMsg(mBuf);
687 #if (ERRCLASS & ERRCLS_ADD_RES)
688       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
689          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
690          (ErrVal)ECRG029, (ErrVal)0, "Packing failed");
691 #endif
692       RETVALUE(RFAILED);
693    }
694    if (cmUnpkCrgCfgTransId(&transId, mBuf) != ROK) {
695       SPutMsg(mBuf);
696 #if (ERRCLASS & ERRCLS_ADD_RES)
697       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
698          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
699          (ErrVal)ECRG030, (ErrVal)0, "Packing failed");
700 #endif
701       RETVALUE(RFAILED);
702    }
703    if (SUnpkU8(&status, mBuf) != ROK) {
704       SPutMsg(mBuf);
705 #if (ERRCLASS & ERRCLS_ADD_RES)
706       SLogError(pst->srcEnt, pst->srcInst, pst->srcProcId,
707          __FILE__, __LINE__, (ErrCls)ERRCLS_ADD_RES,
708          (ErrVal)ECRG031, (ErrVal)0, "Packing failed");
709 #endif
710       RETVALUE(RFAILED);
711    }
712    SPutMsg(mBuf);
713    RETVALUE((*func)(pst, suId, transId, status));
714 }
715
716 \f
717 /***********************************************************
718 *
719 *     Func : cmPkCrgCfgTransId
720 *
721 *
722 *     Desc : Transaction ID between MAC and RRC
723 *
724 *
725 *     Ret  : S16
726 *
727 *     Notes:
728 *
729 *     File  : 
730 *
731 **********************************************************/
732 #ifdef ANSI
733 PUBLIC S16 cmPkCrgCfgTransId
734 (
735 CrgCfgTransId *param,
736 Buffer *mBuf
737 )
738 #else
739 PUBLIC S16 cmPkCrgCfgTransId(param, mBuf)
740 CrgCfgTransId *param;
741 Buffer *mBuf;
742 #endif
743 {
744
745    S32 i;
746    TRC3(cmPkCrgCfgTransId)
747
748    for (i=CRG_CFG_TRANSID_SIZE-1; i >= 0; i--) {
749       CMCHKPK(SPkU8, param->trans[i], mBuf);
750    }
751    RETVALUE(ROK);
752 }
753
754
755 \f
756 /***********************************************************
757 *
758 *     Func : cmUnpkCrgCfgTransId
759 *
760 *
761 *     Desc : Transaction ID between MAC and RRC
762 *
763 *
764 *     Ret  : S16
765 *
766 *     Notes:
767 *
768 *     File  : 
769 *
770 **********************************************************/
771 #ifdef ANSI
772 PUBLIC S16 cmUnpkCrgCfgTransId
773 (
774 CrgCfgTransId *param,
775 Buffer *mBuf
776 )
777 #else
778 PUBLIC S16 cmUnpkCrgCfgTransId(param, mBuf)
779 CrgCfgTransId *param;
780 Buffer *mBuf;
781 #endif
782 {
783
784    S32 i;
785    TRC3(cmUnpkCrgCfgTransId)
786
787    for (i=0; i<CRG_CFG_TRANSID_SIZE; i++) {
788       CMCHKUNPK(SUnpkU8, &param->trans[i], mBuf);
789    }
790    RETVALUE(ROK);
791 }
792
793
794 \f
795 /***********************************************************
796 *
797 *     Func : cmPkCrgBwCfg
798 *
799 *
800 *     Desc : Bandwidth configuration per cell
801 *
802 *
803 *     Ret  : S16
804 *
805 *     Notes:
806 *
807 *     File  : 
808 *
809 **********************************************************/
810 #ifdef ANSI
811 PUBLIC S16 cmPkCrgBwCfg
812 (
813 CrgBwCfg *param,
814 Buffer *mBuf
815 )
816 #else
817 PUBLIC S16 cmPkCrgBwCfg(param, mBuf)
818 CrgBwCfg *param;
819 Buffer *mBuf;
820 #endif
821 {
822
823    TRC3(cmPkCrgBwCfg)
824
825    CMCHKPK(SPkU8, param->ulTotalBw, mBuf);
826    CMCHKPK(SPkU8, param->dlTotalBw, mBuf);
827    RETVALUE(ROK);
828 }
829
830
831 \f
832 /***********************************************************
833 *
834 *     Func : cmUnpkCrgBwCfg
835 *
836 *
837 *     Desc : Bandwidth configuration per cell
838 *
839 *
840 *     Ret  : S16
841 *
842 *     Notes:
843 *
844 *     File  : 
845 *
846 **********************************************************/
847 #ifdef ANSI
848 PUBLIC S16 cmUnpkCrgBwCfg
849 (
850 CrgBwCfg *param,
851 Buffer *mBuf
852 )
853 #else
854 PUBLIC S16 cmUnpkCrgBwCfg(param, mBuf)
855 CrgBwCfg *param;
856 Buffer *mBuf;
857 #endif
858 {
859
860    TRC3(cmUnpkCrgBwCfg)
861
862    CMCHKUNPK(SUnpkU8, &param->dlTotalBw, mBuf);
863    CMCHKUNPK(SUnpkU8, &param->ulTotalBw, mBuf);
864    RETVALUE(ROK);
865 }
866
867
868 \f
869 /***********************************************************
870 *
871 *     Func : cmPkCrgRachCfg
872 *
873 *
874 *     Desc : RACH configuration per cell
875 *
876 *
877 *     Ret  : S16
878 *
879 *     Notes:
880 *
881 *     File  : 
882 *
883 **********************************************************/
884 #ifdef ANSI
885 PUBLIC S16 cmPkCrgRachCfg
886 (
887 CrgRachCfg *param,
888 Buffer *mBuf
889 )
890 #else
891 PUBLIC S16 cmPkCrgRachCfg(param, mBuf)
892 CrgRachCfg *param;
893 Buffer *mBuf;
894 #endif
895 {
896
897    TRC3(cmPkCrgRachCfg)
898
899    CMCHKPK(SPkU8, param->maxMsg3Tx, mBuf);
900    RETVALUE(ROK);
901 }
902
903
904 \f
905 /***********************************************************
906 *
907 *     Func : cmUnpkCrgRachCfg
908 *
909 *
910 *     Desc : RACH configuration per cell
911 *
912 *
913 *     Ret  : S16
914 *
915 *     Notes:
916 *
917 *     File  : 
918 *
919 **********************************************************/
920 #ifdef ANSI
921 PUBLIC S16 cmUnpkCrgRachCfg
922 (
923 CrgRachCfg *param,
924 Buffer *mBuf
925 )
926 #else
927 PUBLIC S16 cmUnpkCrgRachCfg(param, mBuf)
928 CrgRachCfg *param;
929 Buffer *mBuf;
930 #endif
931 {
932
933    TRC3(cmUnpkCrgRachCfg)
934
935    CMCHKUNPK(SUnpkU8, &param->maxMsg3Tx, mBuf);
936    RETVALUE(ROK);
937 }
938
939
940 \f
941 /***********************************************************
942 *
943 *     Func : cmPkCrgCellCfg
944 *
945 *
946 *     Desc : Cell configuration
947 *
948 *
949 *     Ret  : S16
950 *
951 *     Notes:
952 *
953 *     File  : 
954 *
955 **********************************************************/
956 #ifdef ANSI
957 PUBLIC S16 cmPkCrgCellCfg
958 (
959 CrgCellCfg *param,
960 Buffer *mBuf
961 )
962 #else
963 PUBLIC S16 cmPkCrgCellCfg(param, mBuf)
964 CrgCellCfg *param;
965 Buffer *mBuf;
966 #endif
967 {
968
969    TRC3(cmPkCrgCellCfg)
970
971 #ifdef EMTC_ENABLE
972    CMCHKPK(SPkU8, param->emtcEnable, mBuf);
973 #endif
974 #ifdef TENB_MULT_CELL_SUPPRT
975    CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
976    CMCHKPK(SPkS16, param->rguUlSapId, mBuf);
977 #endif
978    CMCHKPK(cmPkCrgBwCfg, &param->bwCfg, mBuf);
979    CMCHKPK(cmPkCrgRachCfg, &param->rachCfg, mBuf);
980    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
981    RETVALUE(ROK);
982 }
983
984
985 \f
986 /***********************************************************
987 *
988 *     Func : cmUnpkCrgCellCfg
989 *
990 *
991 *     Desc : Cell configuration
992 *
993 *
994 *     Ret  : S16
995 *
996 *     Notes:
997 *
998 *     File  : 
999 *
1000 **********************************************************/
1001 #ifdef ANSI
1002 PUBLIC S16 cmUnpkCrgCellCfg
1003 (
1004 CrgCellCfg *param,
1005 Buffer *mBuf
1006 )
1007 #else
1008 PUBLIC S16 cmUnpkCrgCellCfg(param, mBuf)
1009 CrgCellCfg *param;
1010 Buffer *mBuf;
1011 #endif
1012 {
1013
1014    TRC3(cmUnpkCrgCellCfg)
1015
1016    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1017    CMCHKUNPK(cmUnpkCrgRachCfg, &param->rachCfg, mBuf);
1018    CMCHKUNPK(cmUnpkCrgBwCfg, &param->bwCfg, mBuf);
1019 #ifdef TENB_MULT_CELL_SUPPRT
1020    CMCHKUNPK(SUnpkS16, &param->rguUlSapId, mBuf);
1021    CMCHKUNPK(SUnpkS16, &param->rguDlSapId, mBuf);
1022 #endif
1023 #ifdef EMTC_ENABLE
1024    CMCHKUNPK(SUnpkU8, &param->emtcEnable, mBuf);
1025 #endif
1026    RETVALUE(ROK);
1027 }
1028
1029
1030 \f
1031 /***********************************************************
1032 *
1033 *     Func : cmPkCrgUeUlHqCfg
1034 *
1035 *
1036 *     Desc : Uplink HARQ configuration per UE
1037 *
1038 *
1039 *     Ret  : S16
1040 *
1041 *     Notes:
1042 *
1043 *     File  : 
1044 *
1045 **********************************************************/
1046 #ifdef ANSI
1047 PUBLIC S16 cmPkCrgUeUlHqCfg
1048 (
1049 CrgUeUlHqCfg *param,
1050 Buffer *mBuf
1051 )
1052 #else
1053 PUBLIC S16 cmPkCrgUeUlHqCfg(param, mBuf)
1054 CrgUeUlHqCfg *param;
1055 Buffer *mBuf;
1056 #endif
1057 {
1058
1059    TRC3(cmPkCrgUeUlHqCfg)
1060
1061    CMCHKPK(SPkU8, param->maxUlHqTx, mBuf);
1062    RETVALUE(ROK);
1063 }
1064
1065 #ifdef LTE_ADV
1066 /***********************************************************
1067 *
1068 *     Func : cmPkCrgUeSCellCfg
1069 *
1070 *
1071 *     Desc : Secondary Cell information of the UE
1072 *
1073 *
1074 *     Ret  : S16
1075 *
1076 *     Notes:
1077 *
1078 *     File  : 
1079 *
1080 **********************************************************/
1081 #ifdef ANSI
1082 PRIVATE S16 cmPkCrgUeSCellCfg
1083 (
1084 CrgUeSCellInfo *param,
1085 Buffer *mBuf
1086 )
1087 #else
1088 PRIVATE S16 cmPkCrgUeSCellCfg(param, mBuf)
1089 CrgUeSCellInfo *param;
1090 Buffer *mBuf;
1091 #endif
1092 {
1093    CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
1094    CMCHKPK(SPkS16, param->rguUlSapId, mBuf);
1095    CMCHKPK(SPkU8, param->macInst, mBuf);
1096    CMCHKPK(SPkU16, param->sCellId, mBuf);
1097
1098    RETVALUE(ROK);
1099 }
1100 /***********************************************************
1101 *
1102 *     Func : cmUnpkCrgUeSCellCfg
1103 *
1104 *
1105 *     Desc : Secondary Cell information of the UE
1106 *
1107 *
1108 *     Ret  : S16
1109 *
1110 *     Notes:
1111 *
1112 *     File  : 
1113 *
1114 **********************************************************/
1115 #ifdef ANSI
1116 PRIVATE S16 cmUnpkCrgUeSCellCfg
1117 (
1118 CrgUeSCellInfo *param,
1119 Buffer *mBuf
1120 )
1121 #else
1122 PRIVATE S16 cmUnpkCrgUeSCellCfg(param, mBuf)
1123 CrgUeSCellInfo *param;
1124 Buffer *mBuf;
1125 #endif
1126 {
1127    CMCHKUNPK(SUnpkU16, &param->sCellId, mBuf);
1128    CMCHKUNPK(SUnpkU8, &param->macInst, mBuf);
1129    CMCHKUNPK(SUnpkS16, &param->rguUlSapId, mBuf);
1130    CMCHKUNPK(SUnpkS16, &param->rguDlSapId, mBuf);
1131    RETVALUE(ROK);
1132 }
1133 /***********************************************************
1134 *
1135 *     Func : cmPkCrgUeSecCellInfo
1136 *
1137 *
1138 *     Desc : Secondary Cell information of the UE
1139 *
1140 *
1141 *     Ret  : S16
1142 *
1143 *     Notes:
1144 *
1145 *     File  : 
1146 *
1147 **********************************************************/
1148 #ifdef ANSI
1149 PUBLIC S16 cmPkCrgUeSecCellInfo
1150 (
1151 CrgUeSecCellInfo *param,
1152 Buffer *mBuf
1153 )
1154 #else
1155 PUBLIC S16 cmPkCrgUeSecCellInfo(param, mBuf)
1156 CrgUeSecCellInfo *param;
1157 Buffer *mBuf;
1158 #endif
1159 {
1160    S8 idx;
1161    for(idx = param->numSCells - 1; idx >= 0; idx--)
1162    {
1163       CMCHKPK(cmPkCrgUeSCellCfg, &param->ueSCellCfg[(U8)idx], mBuf);
1164    }
1165
1166    CMCHKPK(SPkU8, param->numSCells, mBuf);
1167    CMCHKPK(SPkU8, param->isSCellCfgPres, mBuf);
1168
1169    RETVALUE(ROK);
1170 }
1171
1172 /***********************************************************
1173 *
1174 *     Func : cmUnpkCrgUeSecCellInfo
1175 *
1176 *
1177 *     Desc : Secondary Cell information of the UE
1178 *
1179 *
1180 *     Ret  : S16
1181 *
1182 *     Notes:
1183 *
1184 *     File  : 
1185 *
1186 **********************************************************/
1187 #ifdef ANSI
1188 PUBLIC S16 cmUnpkCrgUeSecCellInfo
1189 (
1190 CrgUeSecCellInfo *param,
1191 Buffer *mBuf
1192 )
1193 #else
1194 PUBLIC S16 cmUnpkCrgUeSecCellInfo(param, mBuf)
1195 CrgUeSecCellInfo *param;
1196 Buffer *mBuf;
1197 #endif
1198 {
1199    U8 idx;
1200
1201    CMCHKUNPK(SUnpkU8, &param->isSCellCfgPres, mBuf);
1202    if(TRUE == param->isSCellCfgPres)
1203    {
1204       CMCHKUNPK(SUnpkU8, &param->numSCells, mBuf);
1205
1206       for(idx = 0; idx < param->numSCells; idx++)
1207       {
1208          CMCHKUNPK(cmUnpkCrgUeSCellCfg, &param->ueSCellCfg[idx],mBuf);
1209       }
1210    }
1211
1212    RETVALUE(ROK);
1213 }
1214
1215 #endif /* LTE_ADV */
1216
1217 \f
1218 /***********************************************************
1219 *
1220 *     Func : cmUnpkCrgUeUlHqCfg
1221 *
1222 *
1223 *     Desc : Uplink HARQ configuration per UE
1224 *
1225 *
1226 *     Ret  : S16
1227 *
1228 *     Notes:
1229 *
1230 *     File  : 
1231 *
1232 **********************************************************/
1233 #ifdef ANSI
1234 PUBLIC S16 cmUnpkCrgUeUlHqCfg
1235 (
1236 CrgUeUlHqCfg *param,
1237 Buffer *mBuf
1238 )
1239 #else
1240 PUBLIC S16 cmUnpkCrgUeUlHqCfg(param, mBuf)
1241 CrgUeUlHqCfg *param;
1242 Buffer *mBuf;
1243 #endif
1244 {
1245
1246    TRC3(cmUnpkCrgUeUlHqCfg)
1247
1248    CMCHKUNPK(SUnpkU8, &param->maxUlHqTx, mBuf);
1249    RETVALUE(ROK);
1250 }
1251
1252
1253 \f
1254 /***********************************************************
1255 *
1256 *     Func : cmPkCrgUeCfg
1257 *
1258 *
1259 *     Desc : UE configuration
1260 *
1261 *
1262 *     Ret  : S16
1263 *
1264 *     Notes:
1265 *
1266 *     File  : 
1267 *
1268 **********************************************************/
1269 #ifdef ANSI
1270 PUBLIC S16 cmPkCrgUeCfg
1271 (
1272 CrgUeCfg *param,
1273 Buffer *mBuf
1274 )
1275 #else
1276 PUBLIC S16 cmPkCrgUeCfg(param, mBuf)
1277 CrgUeCfg *param;
1278 Buffer *mBuf;
1279 #endif
1280 {
1281
1282    TRC3(cmPkCrgUeCfg)
1283 #ifdef TENB_MULT_CELL_SUPPRT
1284    CMCHKPK(SPkS16, param->rguDlSapId, mBuf);
1285    CMCHKPK(SPkS16, param->rguUlSapId, mBuf);
1286 #endif
1287    CMCHKPK(SPkU32, param->txMode.tm, mBuf);
1288    CMCHKPK(SPkU8, param->txMode.pres, mBuf);
1289    CMCHKPK(cmPkCrgUeUlHqCfg, &param->ueUlHqCfg, mBuf);
1290    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
1291    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1292    RETVALUE(ROK);
1293 }
1294
1295
1296 \f
1297 /***********************************************************
1298 *
1299 *     Func : cmUnpkCrgUeCfg
1300 *
1301 *
1302 *     Desc : UE configuration
1303 *
1304 *
1305 *     Ret  : S16
1306 *
1307 *     Notes:
1308 *
1309 *     File  : 
1310 *
1311 **********************************************************/
1312 #ifdef ANSI
1313 PUBLIC S16 cmUnpkCrgUeCfg
1314 (
1315 CrgUeCfg *param,
1316 Buffer *mBuf
1317 )
1318 #else
1319 PUBLIC S16 cmUnpkCrgUeCfg(param, mBuf)
1320 CrgUeCfg *param;
1321 Buffer *mBuf;
1322 #endif
1323 {
1324    U32 tmpEnum;
1325    
1326    TRC3(cmUnpkCrgUeCfg)
1327
1328    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1329    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
1330    CMCHKUNPK(cmUnpkCrgUeUlHqCfg, &param->ueUlHqCfg, mBuf);
1331    CMCHKUNPK(SUnpkU8, &param->txMode.pres, mBuf);
1332    CMCHKUNPK(SUnpkU32, (U32 *)&tmpEnum, mBuf);
1333    param->txMode.tm = (CrgTxMode) tmpEnum;
1334 #ifdef TENB_MULT_CELL_SUPPRT
1335    CMCHKUNPK(SUnpkS16, &param->rguUlSapId, mBuf);
1336    CMCHKUNPK(SUnpkS16, &param->rguDlSapId, mBuf);
1337 #endif
1338    RETVALUE(ROK);
1339 }
1340
1341
1342 \f
1343 /***********************************************************
1344 *
1345 *     Func : cmPkCrgDlLchCfg
1346 *
1347 *
1348 *     Desc : Logical channel configuration info for downlink logical channels
1349 *
1350 *
1351 *     Ret  : S16
1352 *
1353 *     Notes:
1354 *
1355 *     File  : 
1356 *
1357 **********************************************************/
1358 #ifdef ANSI
1359 PUBLIC S16 cmPkCrgDlLchCfg
1360 (
1361 CrgDlLchCfg *param,
1362 Buffer *mBuf
1363 )
1364 #else
1365 PUBLIC S16 cmPkCrgDlLchCfg(param, mBuf)
1366 CrgDlLchCfg *param;
1367 Buffer *mBuf;
1368 #endif
1369 {
1370
1371    TRC3(cmPkCrgDlLchCfg)
1372
1373    CMCHKPK(SPkU8, param->dlTrchType, mBuf);
1374    RETVALUE(ROK);
1375 }
1376
1377
1378 \f
1379 /***********************************************************
1380 *
1381 *     Func : cmUnpkCrgDlLchCfg
1382 *
1383 *
1384 *     Desc : Logical channel configuration info for downlink logical channels
1385 *
1386 *
1387 *     Ret  : S16
1388 *
1389 *     Notes:
1390 *
1391 *     File  : 
1392 *
1393 **********************************************************/
1394 #ifdef ANSI
1395 PUBLIC S16 cmUnpkCrgDlLchCfg
1396 (
1397 CrgDlLchCfg *param,
1398 Buffer *mBuf
1399 )
1400 #else
1401 PUBLIC S16 cmUnpkCrgDlLchCfg(param, mBuf)
1402 CrgDlLchCfg *param;
1403 Buffer *mBuf;
1404 #endif
1405 {
1406
1407    TRC3(cmUnpkCrgDlLchCfg)
1408
1409    CMCHKUNPK(SUnpkU8, &param->dlTrchType, mBuf);
1410    RETVALUE(ROK);
1411 }
1412
1413
1414 \f
1415 /***********************************************************
1416 *
1417 *     Func : cmPkCrgUlLchCfg
1418 *
1419 *
1420 *     Desc : Logical channel configuration info for uplink logical channels
1421 *
1422 *
1423 *     Ret  : S16
1424 *
1425 *     Notes:
1426 *
1427 *     File  : 
1428 *
1429 **********************************************************/
1430 #ifdef ANSI
1431 PUBLIC S16 cmPkCrgUlLchCfg
1432 (
1433 CrgUlLchCfg *param,
1434 Buffer *mBuf
1435 )
1436 #else
1437 PUBLIC S16 cmPkCrgUlLchCfg(param, mBuf)
1438 CrgUlLchCfg *param;
1439 Buffer *mBuf;
1440 #endif
1441 {
1442
1443    TRC3(cmPkCrgUlLchCfg)
1444
1445    CMCHKPK(SPkU8, param->lcgId, mBuf);
1446    CMCHKPK(SPkU8, param->ulTrchType, mBuf);
1447    RETVALUE(ROK);
1448 }
1449
1450
1451 \f
1452 /***********************************************************
1453 *
1454 *     Func : cmUnpkCrgUlLchCfg
1455 *
1456 *
1457 *     Desc : Logical channel configuration info for uplink logical channels
1458 *
1459 *
1460 *     Ret  : S16
1461 *
1462 *     Notes:
1463 *
1464 *     File  : 
1465 *
1466 **********************************************************/
1467 #ifdef ANSI
1468 PUBLIC S16 cmUnpkCrgUlLchCfg
1469 (
1470 CrgUlLchCfg *param,
1471 Buffer *mBuf
1472 )
1473 #else
1474 PUBLIC S16 cmUnpkCrgUlLchCfg(param, mBuf)
1475 CrgUlLchCfg *param;
1476 Buffer *mBuf;
1477 #endif
1478 {
1479
1480    TRC3(cmUnpkCrgUlLchCfg)
1481
1482    CMCHKUNPK(SUnpkU8, &param->ulTrchType, mBuf);
1483    CMCHKUNPK(SUnpkU8, &param->lcgId, mBuf);
1484    RETVALUE(ROK);
1485 }
1486
1487
1488 \f
1489 /***********************************************************
1490 *
1491 *     Func : cmPkCrgLchCfg
1492 *
1493 *
1494 *     Desc : Logical channel configuration info for common and dedicated channels
1495 *
1496 *
1497 *     Ret  : S16
1498 *
1499 *     Notes:
1500 *
1501 *     File  : 
1502 *
1503 **********************************************************/
1504 #ifdef ANSI
1505 PUBLIC S16 cmPkCrgLchCfg
1506 (
1507 CrgLchCfg *param,
1508 Buffer *mBuf
1509 )
1510 #else
1511 PUBLIC S16 cmPkCrgLchCfg(param, mBuf)
1512 CrgLchCfg *param;
1513 Buffer *mBuf;
1514 #endif
1515 {
1516
1517    TRC3(cmPkCrgLchCfg)
1518 /* crg_c_001.main_5 - ADD - Added the packing for LTE_L2_MEAS. */
1519 #ifdef LTE_L2_MEAS
1520    CMCHKPK(SPkU8, param->qci, mBuf);
1521 #endif
1522    CMCHKPK(cmPkCrgUlLchCfg, &param->ulInfo, mBuf);
1523    CMCHKPK(cmPkCrgDlLchCfg, &param->dlInfo, mBuf);
1524    CMCHKPK(SPkU8, param->dir, mBuf);
1525    CMCHKPK(cmPkLteLcType, param->lcType, mBuf);
1526    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
1527    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
1528    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1529    RETVALUE(ROK);
1530 }
1531
1532
1533 \f
1534 /***********************************************************
1535 *
1536 *     Func : cmUnpkCrgLchCfg
1537 *
1538 *
1539 *     Desc : Logical channel configuration info for common and dedicated channels
1540 *
1541 *
1542 *     Ret  : S16
1543 *
1544 *     Notes:
1545 *
1546 *     File  : 
1547 *
1548 **********************************************************/
1549 #ifdef ANSI
1550 PUBLIC S16 cmUnpkCrgLchCfg
1551 (
1552 CrgLchCfg *param,
1553 Buffer *mBuf
1554 )
1555 #else
1556 PUBLIC S16 cmUnpkCrgLchCfg(param, mBuf)
1557 CrgLchCfg *param;
1558 Buffer *mBuf;
1559 #endif
1560 {
1561
1562    TRC3(cmUnpkCrgLchCfg)
1563
1564    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1565    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
1566    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
1567    CMCHKUNPK(cmUnpkLteLcType, &param->lcType, mBuf);
1568    CMCHKUNPK(SUnpkU8, &param->dir, mBuf);
1569    CMCHKUNPK(cmUnpkCrgDlLchCfg, &param->dlInfo, mBuf);
1570    CMCHKUNPK(cmUnpkCrgUlLchCfg, &param->ulInfo, mBuf);
1571 /* crg_c_001.main_5 - ADD - Added the unpacking for LTE_L2_MEAS. */
1572 #ifdef LTE_L2_MEAS
1573    CMCHKUNPK(SUnpkU8, &param->qci, mBuf);
1574 #endif
1575    RETVALUE(ROK);
1576 }
1577
1578
1579 \f
1580 /***********************************************************
1581 *
1582 *     Func : cmPkCrgCfg
1583 *
1584 *
1585 *     Desc : Basic configuration info for MAC
1586 *
1587 *
1588 *     Ret  : S16
1589 *
1590 *     Notes:
1591 *
1592 *     File  : 
1593 *
1594 **********************************************************/
1595 #ifdef ANSI
1596 PUBLIC S16 cmPkCrgCfg
1597 (
1598 CrgCfg *param,
1599 Buffer *mBuf
1600 )
1601 #else
1602 PUBLIC S16 cmPkCrgCfg(param, mBuf)
1603 CrgCfg *param;
1604 Buffer *mBuf;
1605 #endif
1606 {
1607
1608    TRC3(cmPkCrgCfg)
1609
1610       switch(param->cfgType) {
1611          case CRG_LCH_CFG:
1612             CMCHKPK(cmPkCrgLchCfg, &param->u.lchCfg, mBuf);
1613             break;
1614          case CRG_UE_CFG:
1615             CMCHKPK(cmPkCrgUeCfg, &param->u.ueCfg, mBuf);
1616             break;
1617          case CRG_CELL_CFG:
1618             CMCHKPK(cmPkCrgCellCfg, &param->u.cellCfg, mBuf);
1619             break;
1620          default :
1621             RETVALUE(RFAILED);
1622       }
1623    CMCHKPK(SPkU8, param->cfgType, mBuf);
1624    RETVALUE(ROK);
1625 }
1626
1627
1628 \f
1629 /***********************************************************
1630 *
1631 *     Func : cmUnpkCrgCfg
1632 *
1633 *
1634 *     Desc : Basic configuration info for MAC
1635 *
1636 *
1637 *     Ret  : S16
1638 *
1639 *     Notes:
1640 *
1641 *     File  : 
1642 *
1643 **********************************************************/
1644 #ifdef ANSI
1645 PUBLIC S16 cmUnpkCrgCfg
1646 (
1647 CrgCfg *param,
1648 Buffer *mBuf
1649 )
1650 #else
1651 PUBLIC S16 cmUnpkCrgCfg(param, mBuf)
1652 CrgCfg *param;
1653 Buffer *mBuf;
1654 #endif
1655 {
1656
1657    TRC3(cmUnpkCrgCfg)
1658
1659    CMCHKUNPK(SUnpkU8, &param->cfgType, mBuf);
1660       switch(param->cfgType) {
1661          case CRG_CELL_CFG:
1662             CMCHKUNPK(cmUnpkCrgCellCfg, &param->u.cellCfg, mBuf);
1663             break;
1664          case CRG_UE_CFG:
1665             CMCHKUNPK(cmUnpkCrgUeCfg, &param->u.ueCfg, mBuf);
1666             break;
1667          case CRG_LCH_CFG:
1668             CMCHKUNPK(cmUnpkCrgLchCfg, &param->u.lchCfg, mBuf);
1669             break;
1670          default :
1671             RETVALUE(RFAILED);
1672       }
1673    RETVALUE(ROK);
1674 }
1675
1676
1677 \f
1678 /***********************************************************
1679 *
1680 *     Func : cmPkCrgCellRecfg
1681 *
1682 *
1683 *     Desc : Cell reconfiguration info
1684 *
1685 *
1686 *     Ret  : S16
1687 *
1688 *     Notes:
1689 *
1690 *     File  : 
1691 *
1692 **********************************************************/
1693 #ifdef ANSI
1694 PUBLIC S16 cmPkCrgCellRecfg
1695 (
1696 CrgCellRecfg *param,
1697 Buffer *mBuf
1698 )
1699 #else
1700 PUBLIC S16 cmPkCrgCellRecfg(param, mBuf)
1701 CrgCellRecfg *param;
1702 Buffer *mBuf;
1703 #endif
1704 {
1705
1706    TRC3(cmPkCrgCellRecfg)
1707
1708    CMCHKPK(cmPkCrgRachCfg, &param->rachRecfg, mBuf);
1709    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1710    RETVALUE(ROK);
1711 }
1712
1713
1714 \f
1715 /***********************************************************
1716 *
1717 *     Func : cmUnpkCrgCellRecfg
1718 *
1719 *
1720 *     Desc : Cell reconfiguration info
1721 *
1722 *
1723 *     Ret  : S16
1724 *
1725 *     Notes:
1726 *
1727 *     File  : 
1728 *
1729 **********************************************************/
1730 #ifdef ANSI
1731 PUBLIC S16 cmUnpkCrgCellRecfg
1732 (
1733 CrgCellRecfg *param,
1734 Buffer *mBuf
1735 )
1736 #else
1737 PUBLIC S16 cmUnpkCrgCellRecfg(param, mBuf)
1738 CrgCellRecfg *param;
1739 Buffer *mBuf;
1740 #endif
1741 {
1742
1743    TRC3(cmUnpkCrgCellRecfg)
1744
1745    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1746    CMCHKUNPK(cmUnpkCrgRachCfg, &param->rachRecfg, mBuf);
1747    RETVALUE(ROK);
1748 }
1749
1750
1751 \f
1752 /***********************************************************
1753 *
1754 *     Func : cmPkCrgUeRecfg
1755 *
1756 *
1757 *     Desc : UE reconfiguration info
1758 *
1759 *
1760 *     Ret  : S16
1761 *
1762 *     Notes:
1763 *
1764 *     File  : 
1765 *
1766 **********************************************************/
1767 #ifdef ANSI
1768 PUBLIC S16 cmPkCrgUeRecfg
1769 (
1770 CrgUeRecfg *param,
1771 Buffer *mBuf
1772 )
1773 #else
1774 PUBLIC S16 cmPkCrgUeRecfg(param, mBuf)
1775 CrgUeRecfg *param;
1776 Buffer *mBuf;
1777 #endif
1778 {
1779
1780    TRC3(cmPkCrgUeRecfg)
1781 #ifdef LTE_ADV
1782    if(TRUE == param->crgSCellCfg.isSCellCfgPres)
1783    {
1784       CMCHKPK(cmPkCrgUeSecCellInfo, &param->crgSCellCfg, mBuf);
1785    }
1786    else
1787    {
1788       CMCHKPK(SPkU8, param->crgSCellCfg.isSCellCfgPres, mBuf);
1789    }
1790 #endif /* LTE_ADV */
1791    CMCHKPK(SPkU32, param->txMode.tm, mBuf);
1792    CMCHKPK(SPkU8, param->txMode.pres, mBuf);
1793    CMCHKPK(cmPkCrgUeUlHqCfg, &param->ueUlHqRecfg, mBuf);
1794    CMCHKPK(cmPkLteRnti, param->newCrnti, mBuf);
1795    CMCHKPK(cmPkLteRnti, param->oldCrnti, mBuf);
1796    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1797    RETVALUE(ROK);
1798 }
1799
1800
1801 \f
1802 /***********************************************************
1803 *
1804 *     Func : cmUnpkCrgUeRecfg
1805 *
1806 *
1807 *     Desc : UE reconfiguration info
1808 *
1809 *
1810 *     Ret  : S16
1811 *
1812 *     Notes:
1813 *
1814 *     File  : 
1815 *
1816 **********************************************************/
1817 #ifdef ANSI
1818 PUBLIC S16 cmUnpkCrgUeRecfg
1819 (
1820 CrgUeRecfg *param,
1821 Buffer *mBuf
1822 )
1823 #else
1824 PUBLIC S16 cmUnpkCrgUeRecfg(param, mBuf)
1825 CrgUeRecfg *param;
1826 Buffer *mBuf;
1827 #endif
1828 {
1829
1830    TRC3(cmUnpkCrgUeRecfg)
1831
1832    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1833    CMCHKUNPK(cmUnpkLteRnti, &param->oldCrnti, mBuf);
1834    CMCHKUNPK(cmUnpkLteRnti, &param->newCrnti, mBuf);
1835    CMCHKUNPK(cmUnpkCrgUeUlHqCfg, &param->ueUlHqRecfg, mBuf);
1836    CMCHKUNPK(SUnpkU8, &param->txMode.pres, mBuf);
1837    CMCHKUNPK(SUnpkU32, (U32 *)&param->txMode.tm, mBuf);
1838 #ifdef LTE_ADV 
1839       CMCHKUNPK(cmUnpkCrgUeSecCellInfo, &param->crgSCellCfg, mBuf);
1840 #endif /* LTE_ADV */
1841    RETVALUE(ROK);
1842 }
1843
1844
1845 \f
1846 /***********************************************************
1847 *
1848 *     Func : cmPkCrgLchRecfg
1849 *
1850 *
1851 *     Desc : Logical channel reconfiguration info for dedicated channels only
1852 *
1853 *
1854 *     Ret  : S16
1855 *
1856 *     Notes:
1857 *
1858 *     File  : 
1859 *
1860 **********************************************************/
1861 #ifdef ANSI
1862 PUBLIC S16 cmPkCrgLchRecfg
1863 (
1864 CrgLchRecfg *param,
1865 Buffer *mBuf
1866 )
1867 #else
1868 PUBLIC S16 cmPkCrgLchRecfg(param, mBuf)
1869 CrgLchRecfg *param;
1870 Buffer *mBuf;
1871 #endif
1872 {
1873
1874    TRC3(cmPkCrgLchRecfg)
1875
1876       CMCHKPK(SPkU8, param->ulRecfg.lcgId, mBuf);
1877    CMCHKPK(cmPkLteLcId, param->lcId, mBuf);
1878    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
1879    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
1880    RETVALUE(ROK);
1881 }
1882
1883
1884 \f
1885 /***********************************************************
1886 *
1887 *     Func : cmUnpkCrgLchRecfg
1888 *
1889 *
1890 *     Desc : Logical channel reconfiguration info for dedicated channels only
1891 *
1892 *
1893 *     Ret  : S16
1894 *
1895 *     Notes:
1896 *
1897 *     File  : 
1898 *
1899 **********************************************************/
1900 #ifdef ANSI
1901 PUBLIC S16 cmUnpkCrgLchRecfg
1902 (
1903 CrgLchRecfg *param,
1904 Buffer *mBuf
1905 )
1906 #else
1907 PUBLIC S16 cmUnpkCrgLchRecfg(param, mBuf)
1908 CrgLchRecfg *param;
1909 Buffer *mBuf;
1910 #endif
1911 {
1912
1913    TRC3(cmUnpkCrgLchRecfg)
1914
1915    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
1916    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
1917    CMCHKUNPK(cmUnpkLteLcId, &param->lcId, mBuf);
1918       CMCHKUNPK(SUnpkU8, &param->ulRecfg.lcgId, mBuf);
1919    RETVALUE(ROK);
1920 }
1921
1922
1923 \f
1924 /***********************************************************
1925 *
1926 *     Func : cmPkCrgRecfg
1927 *
1928 *
1929 *     Desc : Basic reconfiguration info for MAC
1930 *
1931 *
1932 *     Ret  : S16
1933 *
1934 *     Notes:
1935 *
1936 *     File  : 
1937 *
1938 **********************************************************/
1939 #ifdef ANSI
1940 PUBLIC S16 cmPkCrgRecfg
1941 (
1942 CrgRecfg *param,
1943 Buffer *mBuf
1944 )
1945 #else
1946 PUBLIC S16 cmPkCrgRecfg(param, mBuf)
1947 CrgRecfg *param;
1948 Buffer *mBuf;
1949 #endif
1950 {
1951
1952    TRC3(cmPkCrgRecfg)
1953
1954       switch(param->recfgType) {
1955          case CRG_LCH_CFG:
1956             CMCHKPK(cmPkCrgLchRecfg, &param->u.lchRecfg, mBuf);
1957             break;
1958          case CRG_UE_CFG:
1959             CMCHKPK(cmPkCrgUeRecfg, &param->u.ueRecfg, mBuf);
1960             break;
1961          case CRG_CELL_CFG:
1962             CMCHKPK(cmPkCrgCellRecfg, &param->u.cellRecfg, mBuf);
1963             break;
1964          default :
1965             RETVALUE(RFAILED);
1966       }
1967    CMCHKPK(SPkU8, param->recfgType, mBuf);
1968    RETVALUE(ROK);
1969 }
1970
1971
1972 \f
1973 /***********************************************************
1974 *
1975 *     Func : cmUnpkCrgRecfg
1976 *
1977 *
1978 *     Desc : Basic reconfiguration info for MAC
1979 *
1980 *
1981 *     Ret  : S16
1982 *
1983 *     Notes:
1984 *
1985 *     File  : 
1986 *
1987 **********************************************************/
1988 #ifdef ANSI
1989 PUBLIC S16 cmUnpkCrgRecfg
1990 (
1991 CrgRecfg *param,
1992 Buffer *mBuf
1993 )
1994 #else
1995 PUBLIC S16 cmUnpkCrgRecfg(param, mBuf)
1996 CrgRecfg *param;
1997 Buffer *mBuf;
1998 #endif
1999 {
2000
2001    TRC3(cmUnpkCrgRecfg)
2002
2003    CMCHKUNPK(SUnpkU8, &param->recfgType, mBuf);
2004       switch(param->recfgType) {
2005          case CRG_CELL_CFG:
2006             CMCHKUNPK(cmUnpkCrgCellRecfg, &param->u.cellRecfg, mBuf);
2007             break;
2008          case CRG_UE_CFG:
2009             CMCHKUNPK(cmUnpkCrgUeRecfg, &param->u.ueRecfg, mBuf);
2010             break;
2011          case CRG_LCH_CFG:
2012             CMCHKUNPK(cmUnpkCrgLchRecfg, &param->u.lchRecfg, mBuf);
2013             break;
2014          default :
2015             RETVALUE(RFAILED);
2016       }
2017    RETVALUE(ROK);
2018 }
2019
2020
2021 \f
2022 /***********************************************************
2023 *
2024 *     Func : cmPkCrgDel
2025 *
2026 *
2027 *     Desc : Basic Delete info for MAC
2028 *
2029 *
2030 *     Ret  : S16
2031 *
2032 *     Notes:
2033 *
2034 *     File  : 
2035 *
2036 **********************************************************/
2037 #ifdef ANSI
2038 PUBLIC S16 cmPkCrgDel
2039 (
2040 CrgDel *param,
2041 Buffer *mBuf
2042 )
2043 #else
2044 PUBLIC S16 cmPkCrgDel(param, mBuf)
2045 CrgDel *param;
2046 Buffer *mBuf;
2047 #endif
2048 {
2049
2050    TRC3(cmPkCrgDel)
2051
2052       switch(param->delType) {
2053          case CRG_LCH_CFG:
2054             CMCHKPK(SPkU8, param->u.lchDel.dir, mBuf);
2055             CMCHKPK(cmPkLteLcId, param->u.lchDel.lcId, mBuf);
2056             CMCHKPK(cmPkLteRnti, param->u.lchDel.crnti, mBuf);
2057             CMCHKPK(cmPkLteCellId, param->u.lchDel.cellId, mBuf);
2058          break;
2059          case CRG_UE_CFG:
2060             CMCHKPK(cmPkLteRnti, param->u.ueDel.crnti, mBuf);
2061             CMCHKPK(cmPkLteCellId, param->u.ueDel.cellId, mBuf);
2062          break;
2063          case CRG_CELL_CFG:
2064             CMCHKPK(cmPkLteCellId, param->u.cellDel.cellId, mBuf);
2065          break;
2066          default :
2067             RETVALUE(RFAILED);
2068       }
2069    CMCHKPK(SPkU8, param->delType, mBuf);
2070    RETVALUE(ROK);
2071 }
2072
2073
2074 \f
2075 /***********************************************************
2076 *
2077 *     Func : cmUnpkCrgDel
2078 *
2079 *
2080 *     Desc : Basic Delete info for MAC
2081 *
2082 *
2083 *     Ret  : S16
2084 *
2085 *     Notes:
2086 *
2087 *     File  : 
2088 *
2089 **********************************************************/
2090 #ifdef ANSI
2091 PUBLIC S16 cmUnpkCrgDel
2092 (
2093 CrgDel *param,
2094 Buffer *mBuf
2095 )
2096 #else
2097 PUBLIC S16 cmUnpkCrgDel(param, mBuf)
2098 CrgDel *param;
2099 Buffer *mBuf;
2100 #endif
2101 {
2102
2103    TRC3(cmUnpkCrgDel)
2104
2105    CMCHKUNPK(SUnpkU8, &param->delType, mBuf);
2106       switch(param->delType) {
2107          case CRG_CELL_CFG:
2108             CMCHKUNPK(cmUnpkLteCellId, &param->u.cellDel.cellId, mBuf);
2109          break;
2110          case CRG_UE_CFG:
2111             CMCHKUNPK(cmUnpkLteCellId, &param->u.ueDel.cellId, mBuf);
2112             CMCHKUNPK(cmUnpkLteRnti, &param->u.ueDel.crnti, mBuf);
2113          break;
2114          case CRG_LCH_CFG:
2115             CMCHKUNPK(cmUnpkLteCellId, &param->u.lchDel.cellId, mBuf);
2116             CMCHKUNPK(cmUnpkLteRnti, &param->u.lchDel.crnti, mBuf);
2117             CMCHKUNPK(cmUnpkLteLcId, &param->u.lchDel.lcId, mBuf);
2118             CMCHKUNPK(SUnpkU8, &param->u.lchDel.dir, mBuf);
2119          break;
2120          default :
2121             RETVALUE(RFAILED);
2122       }
2123    RETVALUE(ROK);
2124 }
2125
2126
2127 \f
2128 /***********************************************************
2129 *
2130 *     Func : cmPkCrgRst
2131 *
2132 *
2133 *     Desc : UE RESET info for MAC
2134 *
2135 *
2136 *     Ret  : S16
2137 *
2138 *     Notes:
2139 *
2140 *     File  : 
2141 *
2142 **********************************************************/
2143 #ifdef ANSI
2144 PUBLIC S16 cmPkCrgRst
2145 (
2146 CrgRst *param,
2147 Buffer *mBuf
2148 )
2149 #else
2150 PUBLIC S16 cmPkCrgRst(param, mBuf)
2151 CrgRst *param;
2152 Buffer *mBuf;
2153 #endif
2154 {
2155
2156    TRC3(cmPkCrgRst)
2157
2158    CMCHKPK(cmPkLteRnti, param->crnti, mBuf);
2159    CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
2160    RETVALUE(ROK);
2161 }
2162
2163
2164 \f
2165 /***********************************************************
2166 *
2167 *     Func : cmUnpkCrgRst
2168 *
2169 *
2170 *     Desc : UE RESET info for MAC
2171 *
2172 *
2173 *     Ret  : S16
2174 *
2175 *     Notes:
2176 *
2177 *     File  : 
2178 *
2179 **********************************************************/
2180 #ifdef ANSI
2181 PUBLIC S16 cmUnpkCrgRst
2182 (
2183 CrgRst *param,
2184 Buffer *mBuf
2185 )
2186 #else
2187 PUBLIC S16 cmUnpkCrgRst(param, mBuf)
2188 CrgRst *param;
2189 Buffer *mBuf;
2190 #endif
2191 {
2192
2193    TRC3(cmUnpkCrgRst)
2194
2195    CMCHKUNPK(cmUnpkLteCellId, &param->cellId, mBuf);
2196    CMCHKUNPK(cmUnpkLteRnti, &param->crnti, mBuf);
2197    RETVALUE(ROK);
2198 }
2199
2200
2201 \f
2202 /***********************************************************
2203 *
2204 *     Func : cmPkCrgCfgReqInfo
2205 *
2206 *
2207 *     Desc : Config/Reconfig/Delete info for MAC
2208 *
2209 *
2210 *     Ret  : S16
2211 *
2212 *     Notes:
2213 *
2214 *     File  : 
2215 *
2216 **********************************************************/
2217 #ifdef ANSI
2218 PUBLIC S16 cmPkCrgCfgReqInfo
2219 (
2220 CrgCfgReqInfo *param,
2221 Buffer *mBuf
2222 )
2223 #else
2224 PUBLIC S16 cmPkCrgCfgReqInfo(param, mBuf)
2225 CrgCfgReqInfo *param;
2226 Buffer *mBuf;
2227 #endif
2228 {
2229
2230    TRC3(cmPkCrgCfgReqInfo)
2231
2232       switch(param->action) {
2233          case CRG_RESET:
2234             CMCHKPK(cmPkCrgRst, &param->u.rstInfo, mBuf);
2235             break;
2236          case CRG_DELETE:
2237             CMCHKPK(cmPkCrgDel, &param->u.delInfo, mBuf);
2238             break;
2239          case CRG_RECONFIG:
2240             CMCHKPK(cmPkCrgRecfg, &param->u.recfgInfo, mBuf);
2241             break;
2242          case CRG_CONFIG:
2243             CMCHKPK(cmPkCrgCfg, &param->u.cfgInfo, mBuf);
2244             break;
2245          default :
2246             RETVALUE(RFAILED);
2247       }
2248    CMCHKPK(SPkU8, param->action, mBuf);
2249    RETVALUE(ROK);
2250 }
2251
2252
2253 \f
2254 /***********************************************************
2255 *
2256 *     Func : cmUnpkCrgCfgReqInfo
2257 *
2258 *
2259 *     Desc : Config/Reconfig/Delete info for MAC
2260 *
2261 *
2262 *     Ret  : S16
2263 *
2264 *     Notes:
2265 *
2266 *     File  : 
2267 *
2268 **********************************************************/
2269 #ifdef ANSI
2270 PUBLIC S16 cmUnpkCrgCfgReqInfo
2271 (
2272 CrgCfgReqInfo *param,
2273 Buffer *mBuf
2274 )
2275 #else
2276 PUBLIC S16 cmUnpkCrgCfgReqInfo(param, mBuf)
2277 CrgCfgReqInfo *param;
2278 Buffer *mBuf;
2279 #endif
2280 {
2281
2282    TRC3(cmUnpkCrgCfgReqInfo)
2283
2284    CMCHKUNPK(SUnpkU8, &param->action, mBuf);
2285       switch(param->action) {
2286          case CRG_CONFIG:
2287             CMCHKUNPK(cmUnpkCrgCfg, &param->u.cfgInfo, mBuf);
2288             break;
2289          case CRG_RECONFIG:
2290             CMCHKUNPK(cmUnpkCrgRecfg, &param->u.recfgInfo, mBuf);
2291             break;
2292          case CRG_DELETE:
2293             CMCHKUNPK(cmUnpkCrgDel, &param->u.delInfo, mBuf);
2294             break;
2295          case CRG_RESET:
2296             CMCHKUNPK(cmUnpkCrgRst, &param->u.rstInfo, mBuf);
2297             break;
2298          default :
2299             RETVALUE(RFAILED);
2300       }
2301    RETVALUE(ROK);
2302 }
2303 #endif
2304
2305 /**********************************************************************
2306          End of file
2307 **********************************************************************/