Cleanup of BuildAndSendULRRCMessageTransfer and BuildAndSendRRCSetupReq
[o-du/l2.git] / src / mt / ss_rbuf.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   Steps to Add a new Ring Buffer
21
22 1. Add Buffer Id to enum in ss_rbuf.h
23 2. Update Static SsRngCfgTbl below for ring and element size. Add a macro in ss_rbuf.h
24 3. typedef a structure for element type if not available in ss_rbuf.h
25 4. Call SCreateSRngBuf for new Buffer id from bcInitRingBuffers() in bc_cpu_init.c
26 5. Call SAttachSRngBuf from producer and consumer ActvInit
27 6. Call SEnqSRngBuf and SDeqSRngBuf from producer and consumer respectively
28  
29 */
30 #include "envopt.h"        /* environment options     */
31 #include "envdep.h"        /* environment dependent   */
32 #include "envind.h"        /* environment independent */
33 #include "gen.h"           /* general                 */
34 #include "ssi.h"           /* system services         */
35 #include "cm_err.h"       
36 #include <stdlib.h>
37 #include "gen.x"           /* general layer */
38 #include "ssi.x"           /* system services */
39 #include "ss_rbuf.h"
40 #include "ss_rbuf.x"
41
42 U32 ssRngBufStatus = 0;
43
44 /* Global Ring Loop Up Table */
45 SsRngBufTbl SsRngInfoTbl[SS_RNG_BUF_MAX];
46
47
48 PUBLIC Void SsRngBufEnable(Void)
49 {
50   ssRngBufStatus = TRUE;
51 }
52
53
54 PUBLIC Void SsRngBufDisable(Void)
55 {
56   ssRngBufStatus = FALSE;
57
58 }
59 /*
60 Func: SCreateSRngBuf
61 Desc: Creates Ring Buffer for the given Id.
62       Ring Structure is allocated from given 
63       Region and Pool
64 */
65 #ifdef ANSI
66 PUBLIC S16 SCreateSRngBuf
67 (
68 U32 id,  
69 Region region,
70 Pool pool,
71 U32 elmSize,
72 U32 rngSize
73 )
74 #else
75 PUBLIC S16 SCreateSRngBuf (id, region, pool, elmSize, rngSize)
76 U32 id; 
77 Region region;
78 Pool pool;
79 U32 elmSize;
80 U32 rngSize;
81 #endif
82 {
83    SsRngBuf* ring;
84
85    /* Validate Id */
86    if(id >= SS_RNG_BUF_MAX)
87    {
88 #if (ERRCLASS & ERRCLS_DEBUG)
89       SSLOGERROR(ERRCLS_DEBUG, ESSXXX, id, "Invalid RBUF ID");
90 #endif
91       RETVALUE(RFAILED);
92    }
93    if(SsRngInfoTbl[id].r_addr != 0)
94    {
95 #if (ERRCLASS & ERRCLS_DEBUG)
96       SSLOGERROR(ERRCLS_DEBUG, ESSXXX, id, 
97             "Failed to Create Ring Buffer Id Ring already exist");
98 #endif
99       RETVALUE(RFAILED);
100    }
101    /* Get Element Size */
102    
103    /* Get Ring Size    */
104    /* Allocate memory for Ring structure */
105    ring = (SsRngBuf* )malloc(sizeof(SsRngBuf));
106    if(ring == NULLP)
107    {
108 #if (ERRCLASS & ERRCLS_DEBUG)
109       SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "Allocating Ring  Failed!!!")
110 #endif
111       RETVALUE(RFAILED);
112    }
113 #if (ERRCLASS & ERRCLS_DEBUG)
114       SSLOGERROR(ERRCLS_DEBUG, ESSXXX, ring, 
115             "Failed to Create Ring Buffer Id Ring already exist");
116 #endif
117
118    ring->size  = rngSize; /* No empty elem */
119    ring->read  = 0;
120    ring->write = 0;
121    ring->type  = elmSize;
122
123    /* Allocate elements memory */
124    ring->elem  = calloc(ring->size, ring->type);
125    if(ring->elem == NULLP)
126     {
127 #if (ERRCLASS & ERRCLS_DEBUG)
128       SSLOGERROR(ERRCLS_INT_PAR, ESSXXX, ERRZERO, "Allocating Ring  Failed!!!")
129 #endif
130       free(ring);
131       RETVALUE(RFAILED);
132     }
133     /* Update Buffer Id Table */
134     SsRngInfoTbl[id].r_addr   = ring;
135     SsRngInfoTbl[id].rngState = SS_RNG_CREATED;
136     SsRngInfoTbl[id].n_write  = 0;
137     SsRngInfoTbl[id].n_read   = 0;
138
139 #ifndef ALIGN_64BIT
140     printf("Ring Buffer Created with id =%ld rSize:%ld eSize:%ld %lx\n",id,ring->size,ring->type,(PTR)ring);
141 #else
142     printf("Ring Buffer Created with id =%d rSize:%d eSize:%d %lx\n",id,ring->size,ring->type,(PTR)ring);
143 #endif
144     RETVALUE(ROK);
145 }
146
147 /*
148 Func: SAttachSRngBuf
149 Desc: Attach the calling Entity to a ring buffer 
150       as consumer(Rx) or producer (Tx)
151 */
152 #ifdef ANSI
153 PUBLIC S16 SAttachSRngBuf
154 (
155 U32 id,  
156 U32 ent,
157 U32 txRx
158 )
159 #else
160 PUBLIC S16 SAttachSRngBuf (id, ent, txRx)
161 U32 id;
162 U32 ent;
163 U32 txRx;
164 #endif
165 {
166     /* Retrive Buffer from Global Info Table */
167     if( id >= SS_RNG_BUF_MAX)
168     {
169 #if (ERRCLASS & ERRCLS_DEBUG)
170       SSLOGERROR(ERRCLS_DEBUG, ESSXXX, id, "Invalid RBUF ID");
171 #endif
172        RETVALUE(RFAILED);
173     }
174     if(SsRngInfoTbl[id].rngState < SS_RNG_CREATED)
175     {
176 #if (ERRCLASS & ERRCLS_DEBUG)
177       SSLOGERROR(ERRCLS_DEBUG, ESSXXX, id, 
178             "Attach Request in Invalid Ring ID");
179 #endif
180 #ifndef ALIGN_64BIT
181        printf("Attach Request in Invalid Ring State %ld id%ld \n",
182          SsRngInfoTbl[id].rngState,id);
183 #else
184        printf("Attach Request in Invalid Ring State %d id%d \n",
185          SsRngInfoTbl[id].rngState,id);
186 #endif
187        RETVALUE(RFAILED);
188     }
189     if(txRx == SS_RNG_TX)
190     {
191         SsRngInfoTbl[id].txEnt = ent;
192         SsRngInfoTbl[id].rngState = SS_RNG_TX_ATTACHED;
193     }
194     else if(txRx == SS_RNG_RX)
195     {
196         SsRngInfoTbl[id].rxEnt = ent;
197         SsRngInfoTbl[id].rngState = SS_RNG_RX_ATTACHED;
198     }
199     RETVALUE(ROK);
200 }
201 /* 
202 Func: SConnectSRngBuf
203 Desc: Establish a pipe between producer and consumer
204
205 */
206 #ifdef ANSI
207 PUBLIC S16 SConnectSRngBuf
208 (
209 U32 id,  
210 U32 rxEnt
211 )
212 #else
213 PUBLIC S16 SConnectSRngBuf (id, rxEnt)
214 U32 id;
215 U32 rxEnt;
216 #endif
217 {
218    /* Send to Reciever ENT*/ 
219    RETVALUE(ROK); 
220 }
221
222 /*
223 Func: IsFull
224 Desc: Checks if Ring is full
225 */
226 inline static S16 IsFull(SsRngBuf* rBuf)
227 {
228 #if 1
229    if((rBuf->write+1) == rBuf->read)
230    {
231      return 1;
232    }
233    if((rBuf->write+1) == (rBuf->read + rBuf->size))
234    {
235      return 1;
236    }
237    if((rBuf->write + 1) > rBuf->size )
238    {
239      return 1;
240    }
241    return 0;
242 #endif
243
244 /*
245 Func: IsEmpty
246 Desc: Checks if ring is empty
247 */
248 inline static S16 IsEmpty(SsRngBuf* rBuf)
249 {
250    /* write == read implies Buffer is empty*/
251    return (rBuf->write == rBuf->read); 
252 }
253
254 PUBLIC S16 isRngEmpty(U32 id)
255 {
256    return (IsEmpty(SsRngInfoTbl[id].r_addr));
257 }
258 /*
259 Func: SEnqSRngBuf
260 Desc: Perform Queue operation on Ring bufer
261 */
262 #ifdef ANSI
263 PUBLIC S16 SEnqSRngBuf 
264 (
265 U32 id, 
266 Void* elem
267 )
268 #else
269 PUBLIC S16 SEnqSRngBuf(id,elem) 
270 U32 id;
271 Void* elem;
272 #endif
273 {
274    U8* w_ptr;
275    U8 i=0;
276    U8 *element = (U8 *)elem;
277    U32 wrIndex;
278    /* TBD To replace id with ring addr when SAttachSRngBuf is used*/
279    /* Retrive Buffer from Id */
280    SsRngBuf* ring = SsRngInfoTbl[id].r_addr;
281    if (IsFull(ring))
282    {
283         SsRngInfoTbl[id].nWriteFail++;
284         RETVALUE(RFAILED);
285    }
286    /* TBD Avoid multiplication for optimisation */
287    w_ptr = (U8*)ring->elem + (ring->write * ring->type);
288    /* TBD Avoid for loop - use memcpy */
289    for( i=0; i < ring->type; i++)
290    {
291       *(U8*)w_ptr = *(U8*)element;
292       w_ptr++;
293       (U8*)element++;
294    }
295    /* Increment write index */
296     wrIndex = ring->write + 1 ;
297     ring->write = (wrIndex == ring->size)?0: wrIndex;
298    /* Update Statistics */
299    SsRngInfoTbl[id].n_write++;
300    RETVALUE(ROK);
301 }
302
303 #ifdef ANSI
304 PUBLIC S16 SGetNumElemInRng
305 (
306 U32 id
307 )
308 #else
309 PUBLIC S16 SGetNumElemInRng (id)
310 U32 id;
311 #endif
312 {
313
314    S16 freeDist = (SsRngInfoTbl[id].n_write- SsRngInfoTbl[id].n_read);
315
316         RETVALUE(freeDist);
317 }
318 /*
319 Func: SDeqSRngBuf
320 Desc: Perform DeQueue operation on Ring bufer
321 */
322 #ifdef ANSI
323 PUBLIC S16 SDeqSRngBuf
324 (
325 U32 id,
326 Void *elem
327 )
328 #else
329 PUBLIC S16 SDeqSRngBuf (id,elem)
330 U8 id;
331 Void *elem;
332 #endif
333 {
334    U8* r_ptr;
335    U8 i=0;
336    U8 *element = (U8 *)elem;
337    U32 rdIndex;
338    /* Retrive Buffer from Id*/
339    SsRngBuf* ring  = SsRngInfoTbl[id].r_addr;
340    if(IsEmpty(ring))
341    {  
342        SsRngInfoTbl[id].nReadFail++;
343        RETVALUE(RFAILED);
344    }
345    r_ptr = (U8*)ring->elem + (ring->read * ring->type);
346    for(i=0; i<ring->type; i++)
347    {
348       *(U8*)element = *r_ptr;
349       (U8*)element++;
350       r_ptr++;
351    }
352    // Avoiding % operation for wrap around
353    rdIndex= ring->read + 1;
354    ring->read = (rdIndex == ring->size)?0:rdIndex;
355    SsRngInfoTbl[id].n_read++;
356    RETVALUE(ROK);
357 }
358
359 #ifdef ANSI
360 PUBLIC S16 SDestroySRngBuf 
361 (
362 U32 id,
363 Region region,
364 Pool pool
365 )
366 #else
367 PUBLIC S16 SDestroySRngBuf(id, region, pool)
368 U32 id;
369 Region region;
370 Pool pool;
371 #endif
372 {
373    /* Retrive Buffer from Id */
374    SsRngBuf* ring = SsRngInfoTbl[id].r_addr;
375    if(ring)
376    {   
377       //SPutSBuf(region, pool, (Data *)ring->elem, (ring->size * ring->type));
378       //SPutSBuf(region, pool, (Data *)ring, sizeof(SsRngBuf));
379       
380       free(ring->elem); /* OK if null */ 
381       free(ring); /* OK if null */ 
382
383       /* Update Global Info  table */
384       SsRngInfoTbl[id].rngState = SS_RNG_DESTROYED;
385       SsRngInfoTbl[id].r_addr = 0;
386    }
387    RETVALUE(ROK);
388 }
389
390 #ifdef ANSI
391 PUBLIC S16 SPrintSRngStats
392 (
393 Void
394 )
395 #else
396 PUBLIC S16 SPrintSRngStats ()
397 Void;
398 #endif
399 {
400 U32 i; 
401
402    Txt   prntBuf[100];
403
404 #ifdef RGL_SPECIFIC_CHANGES
405    RETVALUE(ROK);
406 #endif
407    for(i=0; i< SS_RNG_BUF_MAX;i++)
408    {
409       if(SsRngInfoTbl[i].r_addr != 0 )
410       {
411 #ifndef ALIGN_64BIT
412          sprintf(prntBuf,"\n=======Ring %ld Stats========\n",i);
413          SDisplay(0, prntBuf);
414          sprintf(prntBuf,"r_addr      = %lx\n", (PTR)SsRngInfoTbl[i].r_addr);
415          SDisplay(0, prntBuf);
416          sprintf(prntBuf,"txEnt       = %lx\n", (PTR)SsRngInfoTbl[i].txEnt);
417          SDisplay(0, prntBuf);
418          sprintf(prntBuf,"rxEnt       = %lx\n", (PTR)SsRngInfoTbl[i].rxEnt);
419          SDisplay(0, prntBuf);
420          sprintf(prntBuf,"n_write     = %lu\n", SsRngInfoTbl[i].n_write);
421          SDisplay(0, prntBuf);
422          sprintf(prntBuf,"n_read      = %lu\n", SsRngInfoTbl[i].n_read);
423          SDisplay(0, prntBuf);
424          sprintf(prntBuf,"nWriteFail  = %lu\n", SsRngInfoTbl[i].nWriteFail);
425          SDisplay(0, prntBuf);
426          sprintf(prntBuf,"nReadFail   = %lu\n", SsRngInfoTbl[i].nReadFail);
427          SDisplay(0, prntBuf);
428          sprintf(prntBuf,"pktDrop     = %lu\n", SsRngInfoTbl[i].pktDrop);
429          SDisplay(0, prntBuf);
430          sprintf(prntBuf,"State       = %lu\n\n", SsRngInfoTbl[i].rngState);
431          SDisplay(0, prntBuf);
432          sprintf(prntBuf,"nPktProc    = %lu\n\n", SsRngInfoTbl[i].nPktProc);
433          SDisplay(0, prntBuf);
434 #else
435          sprintf(prntBuf,"\n=======Ring %d Stats========\n",i);
436          SDisplay(0, prntBuf);
437          sprintf(prntBuf,"r_addr      = %lx\n", (PTR)SsRngInfoTbl[i].r_addr);
438          SDisplay(0, prntBuf);
439          sprintf(prntBuf,"txEnt       = %lx\n", (PTR)SsRngInfoTbl[i].txEnt);
440          SDisplay(0, prntBuf);
441          sprintf(prntBuf,"rxEnt       = %lx\n", (PTR)SsRngInfoTbl[i].rxEnt);
442          SDisplay(0, prntBuf);
443          sprintf(prntBuf,"n_write     = %u\n", SsRngInfoTbl[i].n_write);
444          SDisplay(0, prntBuf);
445          sprintf(prntBuf,"n_read      = %u\n", SsRngInfoTbl[i].n_read);
446          SDisplay(0, prntBuf);
447          sprintf(prntBuf,"nWriteFail  = %u\n", SsRngInfoTbl[i].nWriteFail);
448          SDisplay(0, prntBuf);
449          sprintf(prntBuf,"nReadFail   = %u\n", SsRngInfoTbl[i].nReadFail);
450          SDisplay(0, prntBuf);
451          sprintf(prntBuf,"pktDrop     = %u\n", SsRngInfoTbl[i].pktDrop);
452          SDisplay(0, prntBuf);
453          sprintf(prntBuf,"State       = %u\n\n", SsRngInfoTbl[i].rngState);
454          SDisplay(0, prntBuf);
455          sprintf(prntBuf,"nPktProc    = %u\n\n", SsRngInfoTbl[i].nPktProc);
456          SDisplay(0, prntBuf);
457
458 #endif
459       }
460    }
461    RETVALUE(ROK); 
462 }
463
464 #ifdef ANSI
465 PUBLIC Void* SRngGetWIndx
466 (
467 U32 rngId
468 )
469 #else
470 PUBLIC Void* SRngGetWIndx (rngId)
471 U32 rngId;
472 #endif
473 {
474    /* Retrive Buffer from Id*/
475    SsRngBuf* ring  = SsRngInfoTbl[rngId].r_addr;
476    if (IsFull(ring))
477    {
478       SsRngInfoTbl[rngId].nWriteFail++;
479       RETVALUE(NULLP);
480    }
481    else
482    {
483       RETVALUE(((U8 *)ring->elem) + (ring->type * ring->write));
484    }
485 }
486
487 #ifdef ANSI
488 PUBLIC Void* SRngGetRIndx
489 (
490 U32 rngId
491 )
492 #else
493 PUBLIC Void* SRngGetRIndx (rngId)
494 U32 rngId;
495 #endif
496 {
497    /* Retrive Buffer from Id*/
498    SsRngBuf* ring  = SsRngInfoTbl[rngId].r_addr;
499    if(IsEmpty(ring))
500    {
501       SsRngInfoTbl[rngId].nReadFail++;
502       RETVALUE(NULLP);
503    }
504    else
505    {
506       RETVALUE(((U8 *)ring->elem) + (ring->type * ring->read));
507    }
508 }
509
510 #ifdef ANSI
511 PUBLIC Void SRngIncrWIndx
512 (
513 U32 rngId
514 )
515 #else
516 PUBLIC Void SRngIncrWIndx (rngId)
517 U32 rngId;
518 #endif
519 {
520    U32 wrIndex;
521    /* Retrive Buffer from Id*/
522    SsRngBuf* ring  = SsRngInfoTbl[rngId].r_addr;
523    wrIndex = ring->write + 1;
524    ring->write = (wrIndex == ring->size)?0:wrIndex;
525    /* Update Statistics */
526    SsRngInfoTbl[rngId].n_write++;
527 }
528
529 #ifdef ANSI
530 PUBLIC Void SRngIncrRIndx
531 (
532 U32 rngId
533 )
534 #else
535 PUBLIC Void SRngIncrRIndx (rngId)
536 U32 rngId;
537 #endif
538 {
539    U32 rdIndex;
540    /* Retrive Buffer from Id*/
541    SsRngBuf* ring  = SsRngInfoTbl[rngId].r_addr;
542    rdIndex = ring->read + 1;
543    ring->read = (rdIndex == ring->size)?0:rdIndex;
544    /* Update Statistics */
545    SsRngInfoTbl[rngId].n_read++;
546 }
547 #ifdef XEON_SPECIFIC_CHANGES
548 #if (defined (MAC_FREE_RING_BUF) || defined (RLC_FREE_RING_BUF))
549 S16 mtAddBufToRing(SsRngBufId ringId,void *bufPtr,U8 freeType)
550 {
551    S16 ret1 = ROK;
552    
553    Void *elem = NULLP;
554
555    RgKwFreeInfo *bufFreeInfo = NULLP;
556    elem = SRngGetWIndx(ringId);
557
558    if (NULLP != elem)
559    {
560       bufFreeInfo = (RgKwFreeInfo *) elem;
561
562       bufFreeInfo->bufToFree = bufPtr;
563       bufFreeInfo->freeType  = freeType;
564
565       SRngIncrWIndx(ringId);
566
567       SsRngInfoTbl[ringId].pktRate++;
568    }   
569    else
570    {
571       printf("Free Ring FULL id %d!!! \n",ringId);
572       SsRngInfoTbl[ringId].pktDrop++;
573       ret1 = RFAILED;
574    }
575    RETVALUE(ret1);
576 }
577 #endif
578 #endif
579
580
581
582 /**********************************************************************
583          End of file
584 **********************************************************************/