1 /**************************************************************************** 2 **+-----------------------------------------------------------------------+** 3 **| |** 4 **| Copyright(c) 1998 - 2008 Texas Instruments. All rights reserved. |** 5 **| All rights reserved. |** 6 **| |** 7 **| Redistribution and use in source and binary forms, with or without |** 8 **| modification, are permitted provided that the following conditions |** 9 **| are met: |** 10 **| |** 11 **| * Redistributions of source code must retain the above copyright |** 12 **| notice, this list of conditions and the following disclaimer. |** 13 **| * Redistributions in binary form must reproduce the above copyright |** 14 **| notice, this list of conditions and the following disclaimer in |** 15 **| the documentation and/or other materials provided with the |** 16 **| distribution. |** 17 **| * Neither the name Texas Instruments nor the names of its |** 18 **| contributors may be used to endorse or promote products derived |** 19 **| from this software without specific prior written permission. |** 20 **| |** 21 **| THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |** 22 **| "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |** 23 **| LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |** 24 **| A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |** 25 **| OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |** 26 **| SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |** 27 **| LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |** 28 **| DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |** 29 **| THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |** 30 **| (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |** 31 **| OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |** 32 **| |** 33 **+-----------------------------------------------------------------------+** 34 ****************************************************************************/ 35 36 /**************************************************************************/ 37 /* */ 38 /* MODULE: memMngr.c */ 39 /* PURPOSE: manage the SDRAM buffers for MSDU Data Buffers allocations */ 40 /* */ 41 /**************************************************************************/ 42 43 #include "memMngrEx.h" 44 #include "osApi.h" 45 #include "report.h" 46 47 48 /************************************************************************* 49 * wlan_memMngrInit * 50 ************************************************************************** 51 * DESCRIPTION: Init of the Memory Manager module. This function allocated 52 * all memroy resources needed for the MemMngr. It tallocate 53 * a pool of Msdu structure, pool of Bd structure, and 54 * number of pools of data buffers. 55 * 56 * INPUT: hOs - handle to Os abstraction layer 57 * 58 * OUTPUT: 59 * 60 * RETURN: Handle to the allocated MemMngr control block 61 **************************************************************************/ 62 TI_HANDLE wlan_memMngrInit(TI_HANDLE hOs) 63 { 64 memMngr_t *pMemMngr; 65 UINT32 count,i; 66 memMngrInit_t pMemMngrInit; 67 68 if( hOs == NULL ) 69 { 70 WLAN_OS_REPORT(("wlan_memMngrInit() : FATAL ERROR: OS handle Error - Aborting\n")); 71 return NULL; 72 } 73 74 /* structures for initialization of Memory manager */ 75 pMemMngrInit.numOfPools = DEF_NUMBER_OF_BUF_POOLS; 76 pMemMngrInit.bufPoolInit[0].buffersSize = DEF_BUFFER_LENGTH_POOL_1; 77 pMemMngrInit.bufPoolInit[0].numOfbuffers = DEF_NUMBER_OF_BUFFERS_IN_POOL_1; 78 pMemMngrInit.bufPoolInit[1].buffersSize = DEF_BUFFER_LENGTH_POOL_2; 79 pMemMngrInit.bufPoolInit[1].numOfbuffers = DEF_NUMBER_OF_BUFFERS_IN_POOL_2; 80 pMemMngrInit.bufPoolInit[2].buffersSize = DEF_BUFFER_LENGTH_POOL_3; 81 pMemMngrInit.bufPoolInit[2].numOfbuffers = DEF_NUMBER_OF_BUFFERS_IN_POOL_3; 82 83 for( count = 0 ; count < pMemMngrInit.numOfPools ; count++ ) 84 { 85 if( pMemMngrInit.bufPoolInit[count].buffersSize > MAX_BUFFER_LENGTH || 86 pMemMngrInit.bufPoolInit[count].buffersSize < MIN_BUFFER_LENGTH) 87 { 88 WLAN_OS_REPORT(("wlan_memMngrInit() : FATAL ERROR: Buffer length out of range - Aborting\n")); 89 return NULL; 90 } 91 if( count != 0 ) 92 { 93 if(pMemMngrInit.bufPoolInit[count].buffersSize < pMemMngrInit.bufPoolInit[count-1].buffersSize ) 94 { 95 WLAN_OS_REPORT(("wlan_memMngrInit() : FATAL ERROR: Buffer length's out of order - Aborting\n")); 96 return NULL; 97 } 98 } 99 } 100 101 /* alocate MemMngr module control block */ 102 pMemMngr = os_memoryAlloc(hOs, (sizeof(memMngr_t))); 103 if(!pMemMngr) { 104 WLAN_OS_REPORT(("FATAL ERROR: Could not allocate pMemMngr - Aborting\n")); 105 return NULL; 106 } 107 108 os_memoryZero(hOs, pMemMngr, sizeof(memMngr_t)); 109 110 pMemMngr->hOs = hOs; 111 112 pMemMngr->msduMaxNumber = DEF_NUMBER_OF_MSDUS; 113 pMemMngr->bdMaxNumber = DEF_NUMBER_OF_BDS; 114 pMemMngr->numFreeMSDU = pMemMngr->msduMaxNumber; 115 pMemMngr->numFreeBD = pMemMngr->bdMaxNumber; 116 117 pMemMngr->msduPool = (mem_MSDU_T*)os_memoryCAlloc(hOs, pMemMngr->msduMaxNumber, sizeof(mem_MSDU_T)); 118 os_profile (hOs, 8, pMemMngr->msduMaxNumber * sizeof(mem_MSDU_T)); 119 120 if (pMemMngr->msduPool == NULL) 121 { 122 wlan_memMngrDestroy(pMemMngr); 123 WLAN_OS_REPORT(("FATAL ERROR: Could not allocate memory for MEM MNGR - Aborting\n")); 124 return NULL; 125 } 126 127 pMemMngr->bdPool = (mem_BD_T*)os_memoryCAlloc(hOs, pMemMngr->bdMaxNumber, sizeof(mem_BD_T)); 128 os_profile (hOs, 8, pMemMngr->bdMaxNumber * sizeof(mem_BD_T)); 129 130 if (pMemMngr->bdPool == NULL) 131 { 132 wlan_memMngrDestroy(pMemMngr); 133 WLAN_OS_REPORT(("FATAL ERROR: Could not allocate memory for MEM MNGR - Aborting\n")); 134 return NULL; 135 } 136 137 /* initialize buffer pools objects */ 138 pMemMngr->currentNumberOfPools = pMemMngrInit.numOfPools; 139 for( count = 0 ; count < pMemMngr->currentNumberOfPools ; count++ ) 140 { 141 pMemMngr->buffersPool[count].buffersSize = pMemMngrInit.bufPoolInit[count].buffersSize; 142 143 pMemMngr->buffersPool[count].numFreeDataBuf = pMemMngrInit.bufPoolInit[count].numOfbuffers; 144 145 pMemMngr->buffersPool[count].dataBufMaxNumber = pMemMngrInit.bufPoolInit[count].numOfbuffers; 146 147 if((pMemMngr->buffersPool[count].dataBufPool = (mem_DataBuf_T*)os_memoryCAlloc(hOs, 148 pMemMngr->buffersPool[count].dataBufMaxNumber, sizeof(mem_DataBuf_T))) == NULL) 149 { 150 wlan_memMngrDestroy(pMemMngr); 151 WLAN_OS_REPORT(("FATAL ERROR: Could not allocate buffer pools for MEM MNGR - Aborting\n")); 152 return NULL; 153 } 154 os_profile (hOs, 8, pMemMngr->buffersPool[count].dataBufMaxNumber * sizeof(mem_DataBuf_T)); 155 156 pMemMngr->buffersPool[count].firstFreeDataBuf = pMemMngr->buffersPool[count].dataBufPool; 157 158 os_memoryZero(hOs, pMemMngr->buffersPool[count].dataBufPool, 159 (pMemMngr->buffersPool[count].numFreeDataBuf * sizeof(mem_DataBuf_T))); 160 161 #ifdef TNETW_MASTER_MODE 162 if((pMemMngr->buffersPool[count].dataBufPoolPtr = (UINT8 *)os_memorySharedAlloc(hOs, 163 pMemMngr->buffersPool[count].buffersSize * pMemMngr->buffersPool[count].dataBufMaxNumber, 164 (void *)&pMemMngr->buffersPool[count].physicalDataBufPoolPtr)) == NULL) 165 { 166 wlan_memMngrDestroy(pMemMngr); 167 WLAN_OS_REPORT(("FATAL ERROR: Could not allocate buffers for MEM MNGR (count=%d / %d, size=%d) - Aborting\n", 168 count, pMemMngr->currentNumberOfPools, 169 pMemMngr->buffersPool[count].buffersSize * pMemMngr->buffersPool[count].dataBufMaxNumber)); 170 return NULL; 171 } 172 #else 173 if((pMemMngr->buffersPool[count].dataBufPoolPtr = (UINT8 *)os_memoryPreAlloc(hOs, count, 174 pMemMngr->buffersPool[count].buffersSize * pMemMngr->buffersPool[count].dataBufMaxNumber)) == NULL) 175 { 176 wlan_memMngrDestroy(pMemMngr); 177 WLAN_OS_REPORT(("FATAL ERROR: Could not allocate buffers for MEM MNGR - Aborting\n")); 178 return NULL; 179 } 180 #endif 181 os_profile (hOs, 8, pMemMngr->buffersPool[count].buffersSize * pMemMngr->buffersPool[count].dataBufMaxNumber); 182 183 /* alocate the buffers */ 184 for (i = 0; i < pMemMngr->buffersPool[count].dataBufMaxNumber; ++i) 185 { 186 #ifdef TNETW_MASTER_MODE 187 pMemMngr->buffersPool[count].dataBufPool[i].data = (UINT8 *) 188 (pMemMngr->buffersPool[count].dataBufPoolPtr 189 + i*pMemMngr->buffersPool[count].buffersSize); 190 191 pMemMngr->buffersPool[count].dataBufPool[i].data_physical.u.LowPart = (ULONG) 192 (pMemMngr->buffersPool[count].physicalDataBufPoolPtr.u.LowPart + i*pMemMngr->buffersPool[count].buffersSize); 193 #else 194 195 pMemMngr->buffersPool[count].dataBufPool[i].data = (UINT8 *) 196 (pMemMngr->buffersPool[count].dataBufPoolPtr 197 + i*pMemMngr->buffersPool[count].buffersSize); 198 199 #endif 200 201 pMemMngr->buffersPool[count].dataBufPool[i].poolIndex = count; 202 } 203 } 204 205 /* chain the items in each list */ 206 for (count = 0; count < pMemMngr->msduMaxNumber; ++count) { 207 pMemMngr->msduPool[count].handle = count; 208 if (count < pMemMngr->msduMaxNumber-1) /* update next pointer except of the last one */ 209 pMemMngr->msduPool[count].nextFreeMSDU = &(pMemMngr->msduPool[count+1]); 210 } 211 for (count = 0; count < pMemMngr->bdMaxNumber; ++count) { 212 pMemMngr->bdPool[count].handle = count; 213 if (count < pMemMngr->bdMaxNumber-1) /* update next pointer except of the last one */ 214 pMemMngr->bdPool[count].nextBDPtr = &(pMemMngr->bdPool[count+1]); 215 } 216 for (i = 0; i < pMemMngr->currentNumberOfPools; ++i) { 217 for (count = 0; count < pMemMngr->buffersPool[i].dataBufMaxNumber; ++count) { 218 pMemMngr->buffersPool[i].dataBufPool[count].handle = count; 219 if (count < pMemMngr->buffersPool[i].dataBufMaxNumber-1) /* update next pointer except of the last one */ 220 pMemMngr->buffersPool[i].dataBufPool[count].nextDataBuf = &(pMemMngr->buffersPool[i].dataBufPool[count+1]); 221 } 222 } 223 224 /* assign a pointer for the start of each list */ 225 pMemMngr->firstFreeMSDU = pMemMngr->msduPool; 226 pMemMngr->firstFreeBD = pMemMngr->bdPool; 227 228 for(count=0 ; count < MAX_NUMBER_OF_MODULE; count++) 229 pMemMngr->moduleAllocCount[count] = 0; 230 231 if(( pMemMngr->hCriticalSectionProtect = os_protectCreate(hOs)) == NULL) 232 { 233 wlan_memMngrDestroy(pMemMngr); 234 WLAN_OS_REPORT(("FATAL ERROR: Could not Create Critical Section Protection for MEM MNGR - Aborting\n")); 235 return NULL; 236 } 237 238 return pMemMngr; 239 } 240 /*************************************************************************** 241 * wlan_memMngrConfigure * 242 **************************************************************************** 243 * DESCRIPTION: This function configures MemMngr module 244 * 245 * INPUTS: hMemMngr - The object 246 * hOs - Handle to the Os Abstraction Layer 247 * hReport - Handle to the Report object 248 * OUTPUT: 249 * 250 * RETURNS: OK - Configuration succesfull 251 * NOK - Configuration unsuccesfull 252 ***************************************************************************/ 253 TI_STATUS wlan_memMngrConfigure(TI_HANDLE hMemMngr, TI_HANDLE hOs, TI_HANDLE hReport) 254 { 255 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 256 257 pMemMngr->hReport = hReport; 258 259 WLAN_REPORT_INIT(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 260 (".....MemMngr configured successfully\n")); 261 262 return OK; 263 } 264 /*************************************************************************** 265 * wlan_memMngrDestroy * 266 **************************************************************************** 267 * DESCRIPTION: This function unload the tMemMngr module. It first free 268 * the msdu pool, bd pool, data buffers pools and 269 * then free the tMemMngr control block 270 * 271 * INPUTS: hMemMngr - the object 272 * 273 * OUTPUT: 274 * 275 * RETURNS: OK - Unload succesfull 276 * NOK - Unload unsuccesfull 277 ***************************************************************************/ 278 279 TI_STATUS wlan_memMngrDestroy(TI_HANDLE hMemMngr) 280 { 281 UINT32 count; 282 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 283 284 /* Free Msdu pool */ 285 if(pMemMngr->msduPool) 286 { 287 os_memoryFree(pMemMngr->hOs, pMemMngr->msduPool, 288 sizeof(mem_MSDU_T)*pMemMngr->msduMaxNumber); 289 } 290 /* Free Bd pool */ 291 if(pMemMngr->bdPool) 292 { 293 os_memoryFree(pMemMngr->hOs, pMemMngr->bdPool, 294 sizeof(mem_BD_T)*pMemMngr->bdMaxNumber); 295 } 296 297 /* free data buf pools according to the number of pools */ 298 for( count = 0 ; count < pMemMngr->currentNumberOfPools ; count++ ) 299 { 300 #ifdef TNETW_MASTER_MODE 301 if(pMemMngr->buffersPool[count].dataBufPoolPtr) 302 { 303 os_memorySharedFree(pMemMngr->hOs,pMemMngr->buffersPool[count].dataBufPoolPtr, 304 pMemMngr->buffersPool[count].buffersSize*pMemMngr->buffersPool[count].dataBufMaxNumber, 305 pMemMngr->buffersPool[count].physicalDataBufPoolPtr); 306 } 307 #else 308 if(pMemMngr->buffersPool[count].dataBufPoolPtr) 309 { 310 os_memoryFree(pMemMngr->hOs,pMemMngr->buffersPool[count].dataBufPoolPtr, 311 pMemMngr->buffersPool[count].buffersSize*pMemMngr->buffersPool[count].dataBufMaxNumber); 312 } 313 #endif 314 315 if(pMemMngr->buffersPool[count].dataBufPool) 316 { 317 os_memoryFree(pMemMngr->hOs, pMemMngr->buffersPool[count].dataBufPool, 318 sizeof(mem_DataBuf_T)*pMemMngr->buffersPool[count].dataBufMaxNumber); 319 } 320 } 321 322 /* free os_protect resources */ 323 if(pMemMngr->hCriticalSectionProtect) 324 os_protectDestroy(pMemMngr->hOs,pMemMngr->hCriticalSectionProtect); 325 326 /* free the MemMngr control block */ 327 os_memoryFree(pMemMngr->hOs, pMemMngr,sizeof(memMngr_t)); 328 329 return OK; 330 } 331 332 /************************************************************************* 333 * wlan_memMngrAllocDataBuf * 334 ************************************************************************** 335 * DESCRIPTION: This function allocates BDs and Data Buffers according 336 * to the required length. The memory manager will allocate 337 * the Data Buffers, update the buffer pointer in the BD 338 * structure and link the BDs when more than one Data 339 * Buffer is required. The Buffer length is selected that 340 * minimum beffer len will allocted. 341 * 342 * INPUT: hMemMngr - the object 343 * len - the length of the required data buffer 344 * 345 * OUTPUT: BDPtr - a pointer in which this function will return 346 * to the allocated BD 347 * 348 *RETURN: OK/NOK 349 **************************************************************************/ 350 TI_STATUS wlan_memMngrAllocDataBuf(TI_HANDLE hMemMngr, mem_BD_T** bdPtr, UINT32 len) 351 { 352 UINT32 poolIndex,count,dataBufNum; 353 mem_BD_T* allocBdTmp; /* pointer to the current allocated BD in the new list */ 354 mem_DataBuf_T* allocDataBufTmp; /* pointer to the current allocated Data Buf */ 355 buffersPool_t* tempBuffersPool; 356 357 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 358 359 /* calculate the length and the number of Data Buffers we need allocate */ 360 for (poolIndex = 0; poolIndex < pMemMngr->currentNumberOfPools-1; poolIndex++) 361 { 362 if(len < pMemMngr->buffersPool[poolIndex].buffersSize) 363 break; 364 } 365 366 /* the selected buffer pool */ 367 tempBuffersPool = &pMemMngr->buffersPool[poolIndex]; 368 369 /* calculate the number of buffers needed */ 370 dataBufNum = (len / tempBuffersPool->buffersSize) + 1; 371 372 os_protectLock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* START OF CRITICAL SECTION */ 373 374 allocBdTmp = pMemMngr->firstFreeBD; 375 *bdPtr = pMemMngr->firstFreeBD; 376 377 allocDataBufTmp = tempBuffersPool->firstFreeDataBuf; 378 379 /* check if we have enough memory - Data buffers (in the selected pool) and Bds */ 380 if ((pMemMngr->numFreeBD < dataBufNum) || (tempBuffersPool->numFreeDataBuf < dataBufNum)) 381 { 382 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* END OF CRITICAL SECTION */ 383 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 384 ("DB: mem_allocDataBuf: not enough memory numFreeBD=%d numFreeDataBuf=%d in Pool number=%d req DataBufs=%d\n", 385 pMemMngr->numFreeBD, tempBuffersPool->numFreeDataBuf,poolIndex, dataBufNum)); 386 *bdPtr = NULL; 387 return NOK; 388 } 389 390 /* update the pointers to the head of the list */ 391 for (count = 0 ; count < dataBufNum ; ++count) 392 { 393 allocBdTmp->refCount = 1; 394 allocBdTmp->dataBuf = allocDataBufTmp; 395 allocBdTmp->data = (char*)(allocDataBufTmp->data); 396 #ifdef TNETW_MASTER_MODE 397 allocBdTmp->data_physical_low = os_memoryGetPhysicalLow(allocDataBufTmp->data_physical); 398 #endif 399 allocDataBufTmp->refCount = 1; 400 allocBdTmp->length = tempBuffersPool->buffersSize; 401 if (count == (dataBufNum-1)) 402 { 403 /* the last BD in the allocated list */ 404 pMemMngr->firstFreeBD = allocBdTmp->nextBDPtr; 405 tempBuffersPool->firstFreeDataBuf = allocDataBufTmp->nextDataBuf; 406 allocBdTmp->nextBDPtr = NULL; 407 allocDataBufTmp->nextDataBuf = NULL; 408 } 409 else 410 { 411 allocBdTmp = allocBdTmp->nextBDPtr; 412 allocDataBufTmp = allocDataBufTmp->nextDataBuf; 413 } 414 } 415 416 /* update counter of free Bds and Data buffers */ 417 pMemMngr->numFreeBD -= dataBufNum; 418 tempBuffersPool->numFreeDataBuf -= dataBufNum; 419 420 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* END OF CRITICAL SECTION */ 421 422 return OK; 423 } 424 425 426 /************************************************************************* 427 * wlan_memMngrAllocBDs * 428 ************************************************************************** 429 * DESCRIPTION: This function allocates and returns a pointer to a link 430 * list of BDs. This function allocates only Bds structure 431 * and does not allocate any memory buffers. 432 * 433 * INPUT: hMemMngr - The object 434 * bdNumber - number of required BDs 435 * 436 * OUTPUT: bdPtr - a pointer in which this function will return 437 * to the first Bd in the allocated list 438 * 439 * RETURN: OK/NOK 440 **************************************************************************/ 441 TI_STATUS wlan_memMngrAllocBDs(TI_HANDLE hMemMngr, UINT32 bdNumber, mem_BD_T** bdPtr) 442 { 443 UINT32 count; 444 mem_BD_T* allocBdTmp; /* pointer to the current allocated BD in the new list */ 445 446 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 447 448 if (bdNumber == 0) 449 { 450 *bdPtr = NULL; 451 return NOK; 452 } 453 454 os_protectLock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* START OF CRITICAL SECTION */ 455 allocBdTmp = pMemMngr->firstFreeBD; 456 *bdPtr = pMemMngr->firstFreeBD; 457 458 /* check if we have enough Bds */ 459 if (pMemMngr->numFreeBD < bdNumber) 460 { 461 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* END OF CRITICAL SECTION */ 462 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 463 ("DB: wlan_memMngrAllocBDs: not enough memory\n")); 464 *bdPtr = NULL; 465 return NOK; 466 } 467 468 /* update the pointers to the head of the list */ 469 for (count = 0 ; count < bdNumber ; ++count) 470 { 471 allocBdTmp->refCount = 1; 472 if (count == (bdNumber-1)) 473 { 474 /* the last bd in the allocated list */ 475 pMemMngr->firstFreeBD = allocBdTmp->nextBDPtr; 476 allocBdTmp->nextBDPtr = NULL; 477 } 478 else 479 { 480 allocBdTmp = allocBdTmp->nextBDPtr; 481 } 482 } 483 484 /* update counter of free Bds */ 485 pMemMngr->numFreeBD -= bdNumber; 486 487 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* END OF CRITICAL SECTION */ 488 489 return OK; 490 } 491 492 493 /************************************************************************* 494 * wlan_memMngrAllocMSDU * 495 ************************************************************************** 496 * DESCRIPTION: This function allocates MSDU structure with a number of 497 * BDs and Data Buffers as required by 'len'. 498 * 499 * INPUT: hMemMngr - The object 500 * len - the length of the required data buffer 501 * if len=0, than only MSDU buffer will be allocated 502 * module - the module that allocate this Msdu 503 * 504 * OUTPUT: MSDUPtr - a pointer in which this function will 505 * return to the allocated MSDU structure 506 * 507 * RETURN: OK/NOK 508 **************************************************************************/ 509 TI_STATUS wlan_memMngrAllocMSDU (TI_HANDLE hMemMngr, mem_MSDU_T** MSDUPtr, 510 UINT32 len, allocatingModule_e module) 511 { 512 UINT32 rc; 513 mem_BD_T* bdTmp; 514 515 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 516 517 if (pMemMngr->msduPool == NULL) 518 { 519 /* object not initiated yet (!!!) */ 520 *MSDUPtr = NULL; 521 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 522 ("wlan_memMngrAllocMSDU: failed!\n")); 523 memMngrPrint(hMemMngr); 524 return NOK; 525 } 526 527 if (len > 0) 528 { 529 /* we need to allocate BD and Data Buffers */ 530 rc = wlan_memMngrAllocDataBuf(hMemMngr,&bdTmp, len); 531 if (rc == NOK) 532 { 533 *MSDUPtr = NULL; 534 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 535 ("wlan_memMngrAllocMSDU: failed! no data bufs\n")); 536 memMngrPrint(hMemMngr); 537 return NOK; 538 } 539 } 540 else 541 { 542 /* len = 0 - need to allocate msdu structure only */ 543 rc = wlan_memMngrAllocMSDUBufferOnly(hMemMngr, MSDUPtr, module); 544 if (rc == NOK) 545 { 546 *MSDUPtr = NULL; 547 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 548 ("wlan_memMngrAllocMSDU: failed to alloc buffer only!\n")); 549 memMngrPrint(hMemMngr); 550 return NOK; 551 } 552 return OK; 553 554 } 555 556 os_protectLock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* START OF CRITICAL SECTION */ 557 558 /* check if we have enough free Msdu's */ 559 if (pMemMngr->firstFreeMSDU == NULL) 560 { 561 /* no free MSDU buffers */ 562 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 563 ("wlan_memMngrAllocMSDU no free MSDU in MemMngr !!!\n")); 564 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* END OF CRITICAL SECTION */ 565 memMngrPrint(hMemMngr); 566 567 /* In case we dont have free msdu - free the allocated Bds */ 568 wlan_memMngrFreeBD(hMemMngr,bdTmp->handle); 569 *MSDUPtr = NULL; 570 return NOK; 571 } 572 573 *MSDUPtr = pMemMngr->firstFreeMSDU; 574 pMemMngr->firstFreeMSDU = pMemMngr->firstFreeMSDU->nextFreeMSDU; 575 pMemMngr->moduleAllocCount[module]++; 576 577 /* update counter of free msdu's */ 578 pMemMngr->numFreeMSDU--; 579 580 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* END OF CRITICAL SECTION */ 581 582 (*MSDUPtr)->nextFreeMSDU = NULL; 583 (*MSDUPtr)->freeFunc = NULL; 584 (*MSDUPtr)->firstBDPtr = bdTmp; 585 (*MSDUPtr)->lastBDPtr = bdTmp; 586 (*MSDUPtr)->dataLen = len; 587 (*MSDUPtr)->nextMSDUinList = NULL; 588 (*MSDUPtr)->prevMSDUinList = NULL; 589 (*MSDUPtr)->txFlags = 0; 590 (*MSDUPtr)->txCompleteFlags = 0; 591 (*MSDUPtr)->module = module; 592 #ifdef TI_DBG 593 (*MSDUPtr)->timeStampNum = 0; 594 #endif 595 596 return OK; 597 } 598 599 /************************************************************************* 600 * wlan_memMngrAllocMSDUBufferOnly * 601 ************************************************************************** 602 * DESCRIPTION: This function allocates MSDU structure - without 603 * Bds and Data Buffers 604 * 605 * INPUT: hMemMngr - The object 606 * 607 * OUTPUT: MSDUPtr - a pointer in which this function will return 608 * to the allocated MSDU structure 609 * module - the module that allocate this Msdu 610 * 611 * RETURN: OK/NOK 612 **************************************************************************/ 613 TI_STATUS wlan_memMngrAllocMSDUBufferOnly(TI_HANDLE hMemMngr, mem_MSDU_T** MSDUPtr, allocatingModule_e module) 614 { 615 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 616 617 os_protectLock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* START OF CRITICAL SECTION */ 618 619 if (pMemMngr->firstFreeMSDU == NULL) 620 { 621 /* no free MSDU buffers */ 622 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 623 ("wlan_memMngrAllocMSDUBufferOnly no free MSDU in MemMngr !!!\n")); 624 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* END OF CRITICAL SECTION */ 625 *MSDUPtr = NULL; 626 return NOK; 627 } 628 629 *MSDUPtr = pMemMngr->firstFreeMSDU; 630 pMemMngr->firstFreeMSDU = pMemMngr->firstFreeMSDU->nextFreeMSDU; 631 pMemMngr->moduleAllocCount[module]++; 632 633 /* update counter of free msdu's */ 634 pMemMngr->numFreeMSDU--; 635 636 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* END OF CRITICAL SECTION */ 637 638 (*MSDUPtr)->nextFreeMSDU = NULL; 639 (*MSDUPtr)->freeFunc = NULL; 640 (*MSDUPtr)->firstBDPtr = NULL; 641 (*MSDUPtr)->lastBDPtr = NULL; 642 (*MSDUPtr)->dataLen = 0; 643 (*MSDUPtr)->nextMSDUinList = NULL; 644 (*MSDUPtr)->prevMSDUinList = NULL; 645 (*MSDUPtr)->txFlags = 0; 646 (*MSDUPtr)->txCompleteFlags = 0; 647 (*MSDUPtr)->module = module; 648 #ifdef TI_DBG 649 (*MSDUPtr)->timeStampNum = 0; 650 #endif 651 652 return OK; 653 } 654 655 /************************************************************************* 656 * wlan_memMngrFreeListOfMSDU * 657 ************************************************************************** 658 * DESCRIPTION: Free list of MSDUs structure. This function will run 659 * over the MSDU list (if exist) and free all MSDU's with 660 * all BDs and Data Buffers that are bind to this MSDU. 661 * 662 * INPUT: hMemMngr - The object 663 * handle - handle to the first MSDU in the list 664 * 665 * OUTPUT: 666 * 667 * RETURN: OK/NOK 668 **************************************************************************/ 669 TI_STATUS wlan_memMngrFreeListOfMSDU(TI_HANDLE hMemMngr, UINT32 handle) 670 { 671 mem_MSDU_T *msduTmp,*nextTmpMsdu; 672 673 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 674 675 msduTmp = &(pMemMngr->msduPool[handle]); 676 677 while (msduTmp != NULL) 678 { 679 nextTmpMsdu = msduTmp->nextMSDUinList; 680 if(wlan_memMngrFreeMSDU(hMemMngr,memMgr_MsduHandle(msduTmp)) != OK) 681 { 682 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 683 ("wlan_memMngrFreeListOfMSDU This MSDU is already free\n")); 684 //os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* END OF CRITICAL SECTION */ 685 return NOK; 686 } 687 msduTmp = nextTmpMsdu; 688 } 689 690 return OK; 691 } 692 693 /************************************************************************* 694 * wlan_memMngrFreeMSDU * 695 ************************************************************************** 696 * DESCRIPTION: Free ONE MSDU structure. This function will free all 697 * BDs and Data Buffers that are bind to this MSDU. 698 * 699 * INPUT: hMemMngr - The object 700 * handle - handle of the MSDU 701 * 702 * OUTPUT: 703 * 704 * RETURN: OK/NOK 705 **************************************************************************/ 706 TI_STATUS wlan_memMngrFreeMSDU(TI_HANDLE hMemMngr, UINT32 handle) 707 { 708 UINT32 freeFlag; 709 ap_FreeMemFunc freeFunc = NULL; /* pointer to the Data Buffer free function */ 710 UINT32 freeArgs[NUM_OF_FREE_ARGS]; /* arguments to be send with the free function */ 711 int i; 712 713 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 714 715 if( handle == WLAN_DRV_NULL_MEM_HANDLE ) 716 return OK; 717 718 /* check if the msdu is already free */ 719 if(pMemMngr->msduPool[handle].module == MODULE_FREE_MSDU) 720 { 721 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 722 ("wlan_memMngrFreeMSDU This MSDU is already free\n")); 723 return NOK; 724 725 } 726 727 if (pMemMngr->msduPool[handle].firstBDPtr != NULL) 728 { 729 /* free all BDs and Data Buffers */ 730 freeFlag = wlan_memMngrFreeBD(hMemMngr, pMemMngr->msduPool[handle].firstBDPtr->handle); 731 732 if ((freeFlag == TRUE) && (pMemMngr->msduPool[handle].freeFunc != NULL)) 733 { 734 /* save the free parameters to do it at the end of the function */ 735 freeFunc = pMemMngr->msduPool[handle].freeFunc; 736 for (i=0; i<NUM_OF_FREE_ARGS; i++) 737 freeArgs[i] = pMemMngr->msduPool[handle].freeArgs[i]; 738 } 739 } 740 741 os_protectLock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* START OF CRITICAL SECTION */ 742 743 /* reset the fields of the MSDU buffer */ 744 pMemMngr->msduPool[handle].firstBDPtr = NULL; 745 pMemMngr->msduPool[handle].freeFunc = NULL; 746 pMemMngr->msduPool[handle].freeArgs[0] = 0; 747 pMemMngr->msduPool[handle].freeArgs[1] = 0; 748 pMemMngr->msduPool[handle].freeArgs[2] = 0; 749 pMemMngr->msduPool[handle].dataLen = 0; 750 pMemMngr->msduPool[handle].headerLen = 0; 751 pMemMngr->msduPool[handle].txFlags = 0; 752 pMemMngr->msduPool[handle].txCompleteFlags = 0; 753 pMemMngr->msduPool[handle].nextMSDUinList = 0; 754 pMemMngr->msduPool[handle].prevMSDUinList = 0; 755 pMemMngr->numFreeMSDU++; 756 757 pMemMngr->moduleAllocCount[pMemMngr->msduPool[handle].module]--; 758 759 pMemMngr->msduPool[handle].module = MODULE_FREE_MSDU; 760 761 /* add the MSDU to the free MSDU list */ 762 pMemMngr->msduPool[handle].nextFreeMSDU = pMemMngr->firstFreeMSDU; 763 pMemMngr->firstFreeMSDU = &(pMemMngr->msduPool[handle]); 764 765 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* END OF CRITICAL SECTION */ 766 767 /* !!!!!!!! The free should be only after os_protectUnlock !!!!!!!! */ 768 if (freeFunc != NULL) 769 { 770 /* call free function */ 771 freeFunc((TI_HANDLE)(freeArgs[0]), 772 (TI_HANDLE)(freeArgs[1]), 773 (TI_STATUS)(freeArgs[2])); 774 } 775 776 return OK; 777 } 778 779 780 /************************************************************************* 781 * allocDataBuf * 782 ************************************************************************** 783 * DESCRIPTION: Allocate Data Buffer 784 * 785 * INPUT: hMemMngr - The object 786 * dataBuf - pointer to the new allocated Data Buffer 787 * poolIndex - The index of the pool to allocate from 788 * 789 * OUTPUT: 790 * 791 * RETURN: OK/NOK 792 **************************************************************************/ 793 #if 0 794 static TI_STATUS allocDataBuf(TI_HANDLE hMemMngr, mem_DataBuf_T* dataBuf, UINT32 poolIndex) 795 { 796 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 797 798 os_protectLock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* START OF CRITICAL SECTION */ 799 if (pMemMngr->buffersPool[poolIndex].firstFreeDataBuf == NULL) { 800 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect);/* END OF CRITICAL SECTION */ 801 return NOK; 802 } 803 dataBuf = pMemMngr->buffersPool[poolIndex].firstFreeDataBuf; 804 pMemMngr->buffersPool[poolIndex].firstFreeDataBuf = pMemMngr->buffersPool[poolIndex].firstFreeDataBuf->nextDataBuf; 805 pMemMngr->buffersPool[poolIndex].numFreeDataBuf--; 806 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect);/* END OF CRITICAL SECTION */ 807 808 return OK; 809 } 810 #endif 811 812 813 /************************************************************************* 814 * freeDataBuf * 815 ************************************************************************** 816 * DESCRIPTION: Free Data Buffer. 817 * 818 * INPUT: hMemMngr - The object 819 * dataBuf - pointer to the Data Buffer 820 * 821 * OUTPUT: 822 * 823 * RETURN: OK/NOK 824 **************************************************************************/ 825 static TI_STATUS freeDataBuf(TI_HANDLE hMemMngr, mem_DataBuf_T* dataBuf) 826 { 827 buffersPool_t *tempBuffersPool; 828 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 829 830 if (dataBuf->refCount == 0) { 831 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 832 ("DB: freeDataBuf FATAL ERROR: dataBuf->refCount < 0\n")); 833 return NOK; 834 } 835 836 if (--(dataBuf->refCount) == 0) { 837 tempBuffersPool = &pMemMngr->buffersPool[dataBuf->poolIndex]; 838 /* add this Data Buffer to the free list of the correct pool*/ 839 dataBuf->nextDataBuf = tempBuffersPool->firstFreeDataBuf; 840 tempBuffersPool->firstFreeDataBuf = dataBuf; 841 tempBuffersPool->numFreeDataBuf++; 842 } 843 844 return OK; 845 } 846 847 848 /************************************************************************* 849 * wlan_memMngrFreeBD * 850 ************************************************************************** 851 * DESCRIPTION: Free BD structure. This function will free a list of BD 852 * structures and the Data Buffer that is being pointed by 853 * these BD if any. 854 * 855 * INPUT: hMemMngr - The object 856 * handle - handle of this BD 857 * OUTPUT: 858 * RETURN: freeFlag - return TRUE if this BD list was freed 859 * return FALSE if this BD list was not freed (refCount>0) 860 **************************************************************************/ 861 UINT32 wlan_memMngrFreeBD(TI_HANDLE hMemMngr, UINT32 handle) 862 { 863 UINT32 rc = FALSE; 864 mem_DataBuf_T* dataBuf; 865 mem_BD_T* bdTmp; /* pointer to the current BD we need to free */ 866 mem_BD_T* nextBdTmp; /* pointer to the next BD we need to free */ 867 868 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 869 870 bdTmp = &(pMemMngr->bdPool[handle]); 871 872 os_protectLock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* START OF CRITICAL SECTION */ 873 874 while (bdTmp != NULL) 875 { 876 dataBuf = bdTmp->dataBuf; 877 nextBdTmp = bdTmp->nextBDPtr; 878 if (bdTmp->refCount == 0) 879 { 880 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 881 ("DB: wlan_memMngrFreeBD FATAL ERROR: bdTmp->refCount < 0\n")); 882 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect);/* END OF CRITICAL SECTION */ 883 return FALSE; 884 } 885 if (dataBuf != NULL) 886 { 887 freeDataBuf(hMemMngr, dataBuf); 888 } 889 890 #ifdef TNETW_MASTER_MODE 891 if( bdTmp->freeFunc != NULL) 892 { 893 bdTmp->freeFunc( bdTmp->freeArgs[0], bdTmp->freeArgs[1], bdTmp->freeArgs[2], 894 bdTmp->freeArgs[3], bdTmp->freeArgs[4]); 895 } 896 #endif 897 898 if (--(bdTmp->refCount) == 0) 899 { 900 bdTmp->dataBuf = NULL; 901 bdTmp->data = NULL; 902 903 #ifdef TNETW_MASTER_MODE 904 bdTmp->data_physical_low = 0; 905 bdTmp->freeFunc = NULL; 906 os_memoryZero(pMemMngr->hOs, bdTmp->freeArgs, sizeof(UINT32)*NUM_OF_FREE_ARGS); 907 #endif 908 bdTmp->dataOffset = 0; 909 bdTmp->length = 0; 910 /* adding the free BD to the free BD list */ 911 bdTmp->nextBDPtr = pMemMngr->firstFreeBD; 912 pMemMngr->firstFreeBD = bdTmp; 913 pMemMngr->numFreeBD++; 914 } 915 if (nextBdTmp == NULL) 916 { 917 if (bdTmp->refCount <= 0) 918 { 919 rc = TRUE; 920 } 921 } 922 bdTmp = nextBdTmp; 923 } 924 925 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* END OF CRITICAL SECTION */ 926 return rc; 927 } 928 929 930 /************************************************************************* 931 * wlan_memMngrFreeAllOsAlocatesBuffer * 932 ************************************************************************** 933 * DESCRIPTION: This function run over the all msdus in the MemMngr 934 * and call the free function of the os allocated buffers 935 * 936 * INPUT: hMemMngr - The object 937 * 938 * OUTPUT: 939 * 940 * RETURN: OK 941 **************************************************************************/ 942 943 TI_STATUS wlan_memMngrFreeAllOsAlocatesBuffer(TI_HANDLE hMemMngr) 944 { 945 UINT32 count; 946 947 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 948 949 os_protectLock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect);/* START OF CRITICAL SECTION */ 950 951 for(count = 0 ; count < pMemMngr->msduMaxNumber ; count++) 952 { 953 if (pMemMngr->msduPool[count].freeFunc) 954 { 955 WLAN_OS_REPORT(("wlan_memMngrFreeAllOsAlocatesBuffer() - Call Os free func */*/*/**/*/*/*/*/*/*/*/*/*/*/*/*/*/*/*/ :\n")); 956 #ifndef TNETW_MASTER_MODE 957 pMemMngr->msduPool[count].freeArgs[2] = NOK; 958 #endif 959 /* call free function */ 960 pMemMngr->msduPool[count].freeFunc((TI_HANDLE)(pMemMngr->msduPool[count].freeArgs[0]), 961 (TI_HANDLE)(pMemMngr->msduPool[count].freeArgs[1]), 962 (TI_STATUS)(pMemMngr->msduPool[count].freeArgs[2])); 963 964 pMemMngr->msduPool[count].freeFunc = NULL; 965 pMemMngr->msduPool[count].freeArgs[0] = 0; 966 pMemMngr->msduPool[count].freeArgs[1] = 0; 967 pMemMngr->msduPool[count].freeArgs[2] = 0; 968 } 969 } 970 971 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect);/* END OF CRITICAL SECTION */ 972 973 return OK; 974 } 975 976 /************************************************************************* 977 * wlan_memMngrCopyMsduFreeFunc * 978 ************************************************************************** 979 * DESCRIPTION: Copy The free function and the free arguments from on 980 * Msdu to another 981 * 982 * INPUT: hMemMngr - The object 983 * destMsduHandle - the handle of the destination msdu 984 * sourceMsduHandle - the handle of the source msdu 985 * 986 * OUTPUT: 987 * 988 * RETURN: OK 989 **************************************************************************/ 990 991 TI_STATUS wlan_memMngrCopyMsduFreeFunc(TI_HANDLE hMemMngr, UINT32 destMsduHandle, UINT32 sourceMsduHandle) 992 { 993 mem_MSDU_T* sourceMsdu; 994 mem_MSDU_T* destMsdu; 995 996 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 997 998 if( destMsduHandle == WLAN_DRV_NULL_MEM_HANDLE || sourceMsduHandle == WLAN_DRV_NULL_MEM_HANDLE ) 999 return NOK; 1000 1001 os_protectLock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* START OF CRITICAL SECTION */ 1002 1003 sourceMsdu = &(pMemMngr->msduPool[sourceMsduHandle]); 1004 destMsdu = &(pMemMngr->msduPool[destMsduHandle]); 1005 1006 destMsdu->freeFunc = sourceMsdu->freeFunc; 1007 1008 os_memoryCopy(pMemMngr->hOs, (void *)destMsdu->freeArgs, (void *)sourceMsdu->freeArgs,(NUM_OF_FREE_ARGS*sizeof(UINT32))); 1009 1010 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect);/* END OF CRITICAL SECTION */ 1011 1012 return OK; 1013 } 1014 1015 /************************************************************************* 1016 * wlan_memMngrChangeMsduOwner * 1017 ************************************************************************** 1018 * DESCRIPTION: the function changes the msdu module owner. 1019 * 1020 * INPUT: hMemMngr - The object 1021 * newModule - msdu new module owner 1022 * pMsdu - the msdu to be changed 1023 * 1024 * OUTPUT: 1025 * 1026 * RETURN: OK 1027 **************************************************************************/ 1028 1029 TI_STATUS wlan_memMngrChangeMsduOwner(TI_HANDLE hMemMngr,allocatingModule_e newModule,mem_MSDU_T *pMsdu) 1030 { 1031 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 1032 allocatingModule_e oldModule; 1033 1034 if(pMsdu == NULL) 1035 { 1036 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 1037 ("wlan_memMngrChangeMsduOwner: pMsdu == NULL\n")); 1038 return NOK; 1039 1040 } 1041 1042 oldModule = pMsdu->module; 1043 1044 if(pMemMngr->moduleAllocCount[oldModule] > 0) 1045 { 1046 pMemMngr->moduleAllocCount[oldModule]--; 1047 } 1048 else 1049 { 1050 WLAN_REPORT_ERROR(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 1051 ("wlan_memMngrChangeMsduOwner: oldModule %d AllocCount < 0 ,newModule %d\n", oldModule,newModule)); 1052 return NOK; 1053 } 1054 1055 1056 pMemMngr->moduleAllocCount[newModule]++; 1057 1058 pMsdu->module = newModule; 1059 1060 WLAN_REPORT_INFORMATION(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 1061 ("wlan_memMngrChangeMsduOwner: oldModule: %d , newModule: %d\n", oldModule, newModule)); 1062 1063 1064 return OK; 1065 1066 1067 1068 1069 1070 1071 } 1072 1073 1074 /************************************************************************* 1075 * wlan_memMngrSwapMsdu * 1076 ************************************************************************** 1077 * DESCRIPTION: Swap two Msdu, only the MSDU descriptor and not all fields 1078 * 1079 * INPUT: 1080 * 1081 * OUTPUT: 1082 * 1083 * RETURN: OK 1084 **************************************************************************/ 1085 TI_STATUS wlan_memMngrSwapMsdu(TI_HANDLE hMemMngr, mem_MSDU_T *pMsdu_1, mem_MSDU_T *pMsdu_2) 1086 { 1087 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 1088 mem_MSDU_T Msdu_tmp; 1089 1090 os_protectLock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect); /* START OF CRITICAL SECTION */ 1091 1092 /* copy msdu 1 to Temporary msdu */ 1093 Msdu_tmp.freeFunc = pMsdu_1->freeFunc; 1094 os_memoryCopy(pMemMngr->hOs, (void *)Msdu_tmp.freeArgs, (void *)pMsdu_1->freeArgs,(NUM_OF_FREE_ARGS*sizeof(UINT32))); 1095 Msdu_tmp.dataLen = pMsdu_1->dataLen; 1096 Msdu_tmp.headerLen = pMsdu_1->headerLen; 1097 Msdu_tmp.firstBDPtr = pMsdu_1->firstBDPtr; 1098 Msdu_tmp.lastBDPtr = pMsdu_1->lastBDPtr; 1099 1100 /* copy msdu 2 to msdu 1 */ 1101 pMsdu_1->freeFunc = pMsdu_2->freeFunc; 1102 os_memoryCopy(pMemMngr->hOs, (void *)pMsdu_1->freeArgs, (void *)pMsdu_2->freeArgs,(NUM_OF_FREE_ARGS*sizeof(UINT32))); 1103 pMsdu_1->dataLen = pMsdu_2->dataLen; 1104 pMsdu_1->headerLen = pMsdu_2->headerLen; 1105 pMsdu_1->firstBDPtr = pMsdu_2->firstBDPtr; 1106 pMsdu_1->lastBDPtr = pMsdu_2->lastBDPtr; 1107 1108 /* copy Temporary msdu to msdu 2 */ 1109 pMsdu_2->freeFunc = Msdu_tmp.freeFunc; 1110 os_memoryCopy(pMemMngr->hOs, (void *)pMsdu_2->freeArgs, (void *)Msdu_tmp.freeArgs,(NUM_OF_FREE_ARGS*sizeof(UINT32))); 1111 pMsdu_2->dataLen = Msdu_tmp.dataLen; 1112 pMsdu_2->headerLen = Msdu_tmp.headerLen; 1113 pMsdu_2->firstBDPtr = Msdu_tmp.firstBDPtr; 1114 pMsdu_2->lastBDPtr = Msdu_tmp.lastBDPtr; 1115 1116 os_protectUnlock(pMemMngr->hOs, pMemMngr->hCriticalSectionProtect);/* END OF CRITICAL SECTION */ 1117 1118 return OK; 1119 } 1120 1121 TI_STATUS wlan_memMngrGetMemMgrResources(TI_HANDLE hMemMngr, memMgrResources_t* memMgrResources) 1122 { 1123 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 1124 1125 memMgrResources->numOfFreeBDs = pMemMngr->numFreeBD; 1126 memMgrResources->numOfFreeMsdu = pMemMngr->numFreeMSDU; 1127 memMgrResources->numOfFreeBufPool1 = pMemMngr->buffersPool[0].numFreeDataBuf; 1128 memMgrResources->numOfFreeBufPool2 = pMemMngr->buffersPool[1].numFreeDataBuf; 1129 memMgrResources->numOfFreeBufPool3 = pMemMngr->buffersPool[2].numFreeDataBuf; 1130 1131 return OK; 1132 } 1133 1134 1135 TI_STATUS wlan_memMngrAddTimeStamp (TI_HANDLE hMemMngr, mem_MSDU_T *pMsdu) 1136 { 1137 #ifdef TI_DBG 1138 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 1139 1140 if (pMsdu->timeStampNum < MAX_NUM_OF_TIME_STAMPS) 1141 pMsdu->timeStamp[pMsdu->timeStampNum ++] = 1142 os_timeStampUs (pMemMngr->hOs); 1143 #endif 1144 1145 return OK; 1146 } 1147 1148 1149 /************************************************************************* 1150 ************************************************************************** 1151 * * 1152 * TEST FUNCTIONS * 1153 * * 1154 ************************************************************************** 1155 **************************************************************************/ 1156 1157 void memMngrPrintMSDU(mem_MSDU_T* pMsdu ) 1158 { 1159 WLAN_OS_REPORT(("\nPrinting MSDU :\n")); 1160 WLAN_OS_REPORT(("handle = %X\n",pMsdu->handle)); 1161 WLAN_OS_REPORT(("nextFreeMSDU = %X\n",pMsdu->nextFreeMSDU)); 1162 WLAN_OS_REPORT(("headerLen = %d\n",pMsdu->headerLen)); 1163 WLAN_OS_REPORT(("firstBDPtr = %X\n",pMsdu->firstBDPtr)); 1164 WLAN_OS_REPORT(("lastBDPtr = %X\n",pMsdu->lastBDPtr)); 1165 WLAN_OS_REPORT(("freeFunc = %X\n",pMsdu->freeFunc)); 1166 WLAN_OS_REPORT(("freeArgs[0] = %X\n",pMsdu->freeArgs[0])); 1167 WLAN_OS_REPORT(("freeArgs[1] = %X\n",pMsdu->freeArgs[1])); 1168 WLAN_OS_REPORT(("freeArgs[2] = %X\n",pMsdu->freeArgs[2])); 1169 WLAN_OS_REPORT(("freeArgs[3] = %X\n",pMsdu->freeArgs[3])); 1170 WLAN_OS_REPORT(("freeArgs[4] = %X\n",pMsdu->freeArgs[4])); 1171 WLAN_OS_REPORT(("dataLen = %d\n",pMsdu->dataLen)); 1172 WLAN_OS_REPORT(("module = %d\n",pMsdu->module)); 1173 WLAN_OS_REPORT(("nextMSDUinList = %X\n",pMsdu->nextMSDUinList)); 1174 WLAN_OS_REPORT(("prevMSDUinList = %X\n",pMsdu->prevMSDUinList)); 1175 WLAN_OS_REPORT(("txFlags = %X\n",pMsdu->txFlags)); 1176 WLAN_OS_REPORT(("txCompleteFlags = %X\n",pMsdu->txCompleteFlags)); 1177 1178 } 1179 1180 void memMngrPrintBD(mem_BD_T * pBd ) 1181 { 1182 WLAN_OS_REPORT(("\nPrinting BD \n")); 1183 WLAN_OS_REPORT(("handle = %X\n",pBd->handle)); 1184 WLAN_OS_REPORT(("refCount = %d\n",pBd->refCount)); 1185 WLAN_OS_REPORT(("dataBuf = %X\n",pBd->dataBuf)); 1186 WLAN_OS_REPORT(("data = %X\n",pBd->data)); 1187 WLAN_OS_REPORT(("dataOffset = %d\n",pBd->dataOffset)); 1188 WLAN_OS_REPORT(("length = %d\n",pBd->length)); 1189 WLAN_OS_REPORT(("nextBDPtr = %X\n",pBd->nextBDPtr)); 1190 #ifdef TNETW_MASTER_MODE 1191 WLAN_OS_REPORT(("data_physical_low = %X\n",pBd->data_physical_low)); 1192 #endif 1193 } 1194 1195 void memMngrPrintDataBuf(mem_DataBuf_T* pDataBuf ) 1196 { 1197 WLAN_OS_REPORT(("\nPrinting DataBuf \n")); 1198 WLAN_OS_REPORT(("handle = %X\n",pDataBuf->handle)); 1199 WLAN_OS_REPORT(("nextDataBuf = %X\n",pDataBuf->nextDataBuf)); 1200 WLAN_OS_REPORT(("refCount = %d\n",pDataBuf->refCount)); 1201 WLAN_OS_REPORT(("poolIndex = %X\n",pDataBuf->poolIndex)); 1202 WLAN_OS_REPORT(("data = %d\n",pDataBuf->data)); 1203 } 1204 1205 void memMngrPrintMSDUWithItsBds(mem_MSDU_T* pMsdu ) 1206 { 1207 mem_BD_T *bdTmp = pMsdu->firstBDPtr; 1208 1209 memMngrPrintMSDU(pMsdu); 1210 1211 while(bdTmp != NULL) 1212 { 1213 memMngrPrintBD(bdTmp); 1214 bdTmp = bdTmp->nextBDPtr; 1215 } 1216 } 1217 1218 void memMngrPrintHandle(TI_HANDLE hMemMngr, UINT32 handle) 1219 { 1220 mem_BD_T* tmpBD; 1221 1222 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 1223 1224 WLAN_REPORT_INFORMATION(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 1225 ("MSDU handle = %d firstBDPtr=%X length=%d\n", handle, 1226 pMemMngr->msduPool[handle].firstBDPtr, 1227 pMemMngr->msduPool[handle].dataLen)); 1228 1229 tmpBD = pMemMngr->msduPool[handle].firstBDPtr; 1230 while (tmpBD != NULL) { 1231 WLAN_REPORT_INFORMATION(pMemMngr->hReport, MEM_MGR_MODULE_LOG, 1232 ("MSDU BD=%X handle=%d refCount=%d\n", tmpBD, tmpBD->handle, tmpBD->refCount)); 1233 tmpBD = tmpBD->nextBDPtr; 1234 } 1235 1236 } 1237 1238 void memMngrFullPrint(TI_HANDLE hMemMngr) 1239 { 1240 mem_MSDU_T* tmpMSDU; 1241 mem_BD_T* tmpBD; 1242 mem_DataBuf_T* tmpDataBuf; 1243 UINT32 j,i=0; 1244 1245 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 1246 1247 WLAN_OS_REPORT(("memMngrPrint\n")); 1248 WLAN_OS_REPORT(("numFreeMSDU %d numFreeBD %d \n", pMemMngr->numFreeMSDU, pMemMngr->numFreeBD)); 1249 for(j = 0 ;j < pMemMngr->currentNumberOfPools; j++) 1250 WLAN_OS_REPORT(("Pool Num %d buffer length %d numFreeDataBuf %d \n", 1251 j, pMemMngr->buffersPool[j].buffersSize, pMemMngr->buffersPool[j].numFreeDataBuf)); 1252 1253 WLAN_OS_REPORT(("\nAllocated by modules : MLME=%d, OS_ABS=%d, RSN=%d, HAL_RX=%d\n", 1254 pMemMngr->moduleAllocCount[MLME_MODULE],pMemMngr->moduleAllocCount[OS_ABS_TX_MODULE], 1255 pMemMngr->moduleAllocCount[RSN_MODULE],pMemMngr->moduleAllocCount[HAL_RX_MODULE])); 1256 1257 1258 WLAN_OS_REPORT(("\nfirstFreeMSDU=%X\n",pMemMngr->firstFreeMSDU)); 1259 tmpMSDU = pMemMngr->firstFreeMSDU; 1260 while (++i, tmpMSDU != NULL) { 1261 WLAN_OS_REPORT(("tmpMSDU %d = %X handle=%d tmpMSDU->nextMSDU=%X\n", 1262 i, tmpMSDU, tmpMSDU->handle, tmpMSDU->nextFreeMSDU)); 1263 tmpMSDU = tmpMSDU->nextFreeMSDU; 1264 } 1265 1266 WLAN_OS_REPORT(("\nfirstFreeBD=%X\n",pMemMngr->firstFreeBD)); 1267 i = 0; 1268 tmpBD = pMemMngr->firstFreeBD; 1269 while (++i, tmpBD != NULL) { 1270 WLAN_OS_REPORT(("tmpBD %d = %X handle=%d tmpBD->nextBDPtr=%X\n", 1271 i, tmpBD, tmpBD->handle, tmpBD->nextBDPtr)); 1272 tmpBD = tmpBD->nextBDPtr; 1273 } 1274 WLAN_OS_REPORT(("\n")); 1275 1276 for(j = 0 ;j < pMemMngr->currentNumberOfPools; j++) { 1277 i = 0; 1278 tmpDataBuf = pMemMngr->buffersPool[j].firstFreeDataBuf; 1279 WLAN_OS_REPORT(("\npoolIndex=%d firstFreeDataBuf=%X\n",j,pMemMngr->buffersPool[j].firstFreeDataBuf)); 1280 while (++i, tmpDataBuf != NULL) { 1281 WLAN_OS_REPORT(("Buf %d = %X handle=%d next=%X poolIndex=%d pData=%X\n", i, tmpDataBuf, 1282 tmpDataBuf->handle,tmpDataBuf->nextDataBuf, tmpDataBuf->poolIndex, tmpDataBuf->data)); 1283 tmpDataBuf = tmpDataBuf->nextDataBuf; 1284 } 1285 WLAN_OS_REPORT(("\n")); 1286 } 1287 WLAN_OS_REPORT(("\n")); 1288 } 1289 1290 1291 void memMngrPrint(TI_HANDLE hMemMngr) 1292 { 1293 #if 0 1294 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 1295 1296 WLAN_OS_REPORT(("memMngrPrint\n")); 1297 WLAN_OS_REPORT(("numFreeMSDU %d numFreeBD %d \n", pMemMngr->numFreeMSDU, pMemMngr->numFreeBD)); 1298 for(j = 0 ;j < pMemMngr->currentNumberOfPools; j++) 1299 WLAN_OS_REPORT(("Pool Num %d buffer length %d numFreeDataBuf %d \n", j, 1300 pMemMngr->buffersPool[j].buffersSize, pMemMngr->buffersPool[j].numFreeDataBuf)); 1301 1302 WLAN_OS_REPORT(("\nAllocated by modules on Tx\n")); 1303 1304 1305 WLAN_OS_REPORT(("\nAllocated by modules : MLME=%d, OS_ABS=%d, RSN=%d \n", 1306 pMemMngr->moduleAllocCount[MLME_MODULE], 1307 pMemMngr->moduleAllocCount[OS_ABS_TX_MODULE], 1308 pMemMngr->moduleAllocCount[RSN_MODULE])); 1309 1310 WLAN_OS_REPORT(("\nAllocated by modules : HAL_TX=%d, CONCAT=%d, DE_CONCAT=%d, TX=%d\n", 1311 pMemMngr->moduleAllocCount[HAL_TX_MODULE], 1312 pMemMngr->moduleAllocCount[CONCAT_MODULE], 1313 pMemMngr->moduleAllocCount[DE_CONCAT_MODULE], 1314 pMemMngr->moduleAllocCount[TX_MODULE])); 1315 1316 WLAN_OS_REPORT(("\nAllocated by modules : ACK_EMUL=%d, MEASUREMENT=%d, SITE_MGR=%d, EXC_MANAGER=%d\n", 1317 pMemMngr->moduleAllocCount[ACK_EMUL_MODULE], 1318 pMemMngr->moduleAllocCount[MEASUREMENT_MODULE], 1319 pMemMngr->moduleAllocCount[SITE_MGR_MODULE], 1320 pMemMngr->moduleAllocCount[EXC_MANAGER_MODULE])); 1321 1322 WLAN_OS_REPORT(("\nAllocated by modules on Rx\n")); 1323 1324 WLAN_OS_REPORT(("\nAllocated by modules : HAL_RX=%d, CORE_RX=%d, MLME_RX=%d, OS_ABS_RX=%d\n", 1325 pMemMngr->moduleAllocCount[HAL_RX_MODULE], 1326 pMemMngr->moduleAllocCount[CORE_RX_MODULE], 1327 pMemMngr->moduleAllocCount[MLME_RX_MODULE], 1328 pMemMngr->moduleAllocCount[OS_ABS_RX_MODULE])); 1329 1330 WLAN_OS_REPORT(("\nAllocated by modules : RSN_RX=%d, MEASUREMENT_RX=%d, SITE_MGR_RX=%d, EXC_MANAGER_RX=%d\n", 1331 pMemMngr->moduleAllocCount[RSN_RX_MODULE], 1332 pMemMngr->moduleAllocCount[MEASUREMENT_RX_MODULE], 1333 pMemMngr->moduleAllocCount[SITE_MGR_RX_MODULE], 1334 pMemMngr->moduleAllocCount[EXC_MANAGER_RX_MODULE])); 1335 1336 1337 1338 WLAN_OS_REPORT(("\nAllocated by modules : HAL_WEP1_RX=%d, HAL_WEP2_RX=%d, HAL_DEFRAG_RX=%d, HAL_DUPLICA_RX=%d\n", 1339 pMemMngr->moduleAllocCount[HAL_WEP1_RX], 1340 pMemMngr->moduleAllocCount[HAL_WEP2_RX], 1341 pMemMngr->moduleAllocCount[HAL_DEFRAG_RX], 1342 pMemMngr->moduleAllocCount[HAL_DUPLICA_RX])); 1343 1344 1345 1346 1347 WLAN_OS_REPORT(("\nAllocated by modules : FREE_MSDU=%d\n", 1348 pMemMngr->moduleAllocCount[MODULE_FREE_MSDU])); 1349 1350 #endif 1351 } 1352 1353 void print_MsduDataHeader(TI_HANDLE hMemMngr, mem_MSDU_T *pMsdu) 1354 { 1355 mem_BD_T *pBd; 1356 UINT8 tempBuffer[40],*pTempBuffer; 1357 UINT32 lengthToPrint = 40; 1358 UINT32 i; 1359 1360 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 1361 1362 pTempBuffer = tempBuffer; 1363 pBd = pMsdu->firstBDPtr; 1364 1365 while (lengthToPrint != 0) 1366 { 1367 if (pBd->length < lengthToPrint) 1368 { 1369 os_memoryCopy(pMemMngr->hOs, (void *)pTempBuffer, (void *)pBd->data, pBd->length); 1370 lengthToPrint -= pBd->length; 1371 pTempBuffer += pBd->length; 1372 pBd = pBd->nextBDPtr; 1373 } 1374 else /* enough place in current BD*/ 1375 { 1376 os_memoryCopy(pMemMngr->hOs, (void *)pTempBuffer, (void *)pBd->data, lengthToPrint); 1377 lengthToPrint = 0; 1378 } 1379 } 1380 WLAN_OS_REPORT(("\n")); 1381 for(i = 0 ; i < 60 ; i++) 1382 { 1383 WLAN_OS_REPORT(("%02X ",tempBuffer[i])); 1384 } 1385 WLAN_OS_REPORT(("\n\n")); 1386 } 1387 /*void DumpMemory(char* data, int size) 1388 { 1389 char NumStr[60], CharStr[20], ResStr[81]; 1390 int bank, i, space; 1391 1392 bank = 0; 1393 1394 for(i=0; i<size; i++) { 1395 1396 sprintf(&NumStr[bank*3], "%02X ", (UCHAR)data[i]); 1397 CharStr[bank] = (data[i]>=0x20 && data[i]<=0x7E) ? data[i] : '.'; 1398 1399 if(++bank == 16) { 1400 CharStr[bank] = 0; 1401 sprintf(ResStr, "%s %s", NumStr, CharStr); 1402 printf("%s\n",ResStr); 1403 bank = 0; 1404 } 1405 1406 } 1407 1408 if(bank) { 1409 CharStr[bank] = 0; 1410 printf("%s", NumStr); 1411 if(size < 16) 1412 space = 6; 1413 else 1414 space = 56-strlen(NumStr); 1415 for(i=0; i<space; i++) 1416 printf(" "); 1417 printf("%s\n",CharStr); 1418 } 1419 1420 } 1421 */ 1422 1423 TI_STATUS txDataSTUB_txSendMsdu(TI_HANDLE hMemMngr, mem_MSDU_T *pMsdu) 1424 { 1425 TI_STATUS status; 1426 memMngr_t *pMemMngr = (memMngr_t *)hMemMngr; 1427 1428 status = wlan_memMngrFreeMSDU(pMemMngr, memMgr_MsduHandle(pMsdu)); 1429 if(status != OK) 1430 return NOK; 1431 1432 return OK; 1433 } 1434 1435
