sys/dev/pms/RefTisa/tisa/sassata/common/tdesgl.c

   1 /*******************************************************************************
   2 *Copyright (c) 2014 PMC-Sierra, Inc.  All rights reserved.
   3 *
   4 *Redistribution and use in source and binary forms, with or without modification, are permitted provided
   5 *that the following conditions are met:
   6 *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
   7 *following disclaimer.
   8 *2. Redistributions in binary form must reproduce the above copyright notice,
   9 *this list of conditions and the following disclaimer in the documentation and/or other materials provided
  10 *with the distribution.
  11 *
  12 *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED
  13 *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  14 *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  15 *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  16 *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  17 *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  18 *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  19 *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
  20
  21 **
  22 ********************************************************************************/
  23 /*******************************************************************************/
  24 /** \file
  25  *
  26  *
  27  * This file contains ESGL realted functions
  28  *
  29  */
  30 #include <sys/cdefs.h>
  31 __FBSDID("$FreeBSD$");
  32 #include <dev/pms/config.h>
  33
  34 #include <dev/pms/freebsd/driver/common/osenv.h>
  35 #include <dev/pms/freebsd/driver/common/ostypes.h>
  36 #include <dev/pms/freebsd/driver/common/osdebug.h>
  37
  38 #include <dev/pms/RefTisa/sallsdk/api/sa.h>
  39 #include <dev/pms/RefTisa/sallsdk/api/saapi.h>
  40 #include <dev/pms/RefTisa/sallsdk/api/saosapi.h>
  41
  42 #include <dev/pms/RefTisa/tisa/api/titypes.h>
  43 #include <dev/pms/RefTisa/tisa/api/ostiapi.h>
  44 #include <dev/pms/RefTisa/tisa/api/tiapi.h>
  45 #include <dev/pms/RefTisa/tisa/api/tiglobal.h>
  46
  47 #ifdef FDS_SM
  48 #include <dev/pms/RefTisa/sat/api/sm.h>
  49 #include <dev/pms/RefTisa/sat/api/smapi.h>
  50 #include <dev/pms/RefTisa/sat/api/tdsmapi.h>
  51 #endif
  52
  53 #ifdef FDS_DM
  54 #include <dev/pms/RefTisa/discovery/api/dm.h>
  55 #include <dev/pms/RefTisa/discovery/api/dmapi.h>
  56 #include <dev/pms/RefTisa/discovery/api/tddmapi.h>
  57 #endif
  58
  59 #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h>
  60 #include <dev/pms/freebsd/driver/common/osstring.h>
  61 #include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h>
  62
  63 #ifdef INITIATOR_DRIVER
  64 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h>
  65 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h>
  66 #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h>
  67 #endif
  68
  69 #ifdef TARGET_DRIVER
  70 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h>
  71 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h>
  72 #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h>
  73 #endif
  74
  75 #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h>
  76 #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h>
  77
  78 /* no more esgl related functions */
  79 #ifdef REMOVED
  80 /*****************************************************************************
  81 *! \brief  tdsaEsglInit
  82 *
  83 *  Purpose: This function initializes the linked list of ESGL pool
  84 *
  85 *  \param  tiRoot:  Pointer to root data structure.
  86 *
  87 *  \return: None
  88 *
  89 *  \note
  90 *
  91 *****************************************************************************/
  92 osGLOBAL void
  93 tdsaEsglInit(
  94              tiRoot_t *tiRoot
  95              )
  96 {
  97   tdsaRoot_t               *tdsaRoot    = (tdsaRoot_t *)tiRoot->tdData;
  98   tdsaContext_t            *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
  99   tdsaEsglAllInfo_t        *pEsglAllInfo = (tdsaEsglAllInfo_t *)&(tdsaAllShared->EsglAllInfo);
 100   tdsaEsglPagePool_t       *pEsglPagePool;
 101
 102   bit32 pageno;
 103   bit32 PagePhysAddrUpper;
 104   bit32 PagePhysAddrLower;
 105   bit32 prev_PagePhysAddrLower;
 106   tdsaEsglPageInfo_t *pEsglPageInfo;
 107   void *PageVirtAddr;
 108   bit32 PageSizeInBytes;
 109
 110   /* for memory index requirement */
 111   agsaRoot_t          agRoot;
 112   bit32               maxSALocks = 0;
 113   bit32               usecsPerTick = 0;
 114   agsaSwConfig_t      SwConfig;
 115   agsaMemoryRequirement_t memRequirement;
 116   agsaQueueConfig_t   *QueueConfig;
 117   bit32                i;
 118
 119   TI_DBG6(("tdsaEsglInit: start\n"));
 120
 121   tdsaGetSwConfigParams(tiRoot);
 122   QueueConfig = &tdsaAllShared->QueueConfig;
 123
 124   for(i=0;i<QueueConfig->numInboundQueues;i++)
 125   {
 126     QueueConfig->inboundQueues[i].elementCount = tdsaAllShared->InboundQueueSize;
 127     QueueConfig->inboundQueues[i].elementSize = tdsaAllShared->InboundQueueEleSize;
 128     QueueConfig->inboundQueues[i].priority = tdsaAllShared->InboundQueuePriority[i];
 129     QueueConfig->inboundQueues[i].reserved = 0;
 130   }
 131   for(i=0;i<QueueConfig->numOutboundQueues;i++)
 132   {
 133     QueueConfig->outboundQueues[i].elementCount = tdsaAllShared->OutboundQueueSize;
 134     QueueConfig->outboundQueues[i].elementSize = tdsaAllShared->OutboundQueueEleSize;
 135     QueueConfig->outboundQueues[i].interruptDelay = tdsaAllShared->OutboundQueueInterruptDelay[i]; /* default 0; no interrupt delay */
 136     QueueConfig->outboundQueues[i].interruptCount = tdsaAllShared->OutboundQueueInterruptCount[i]; /* default 1*/
 137     QueueConfig->outboundQueues[i].interruptVectorIndex = 0;
 138   }
 139
 140   /*
 141     hardcoded Queue numbers
 142   */
 143   QueueConfig->sasHwEventQueue = 0;
 144   QueueConfig->sataNCQErrorEventQueue = 0;
 145   SwConfig.sizefEventLog1 = HOST_EVENT_LOG_SIZE;
 146   SwConfig.sizefEventLog2 = HOST_EVENT_LOG_SIZE;
 147   SwConfig.eventLog1Option = 0;
 148   SwConfig.eventLog2Option = 0;
 149   SwConfig.fatalErrorInterrtuptEnable = 1;
 150   SwConfig.fatalErrorInterruptVector = 1;
 151   SwConfig.reserved = 0;
 152
 153
 154   SwConfig.param3 = (void *)&(tdsaAllShared->QueueConfig);
 155   /* to find out memRequirement */
 156   saGetRequirements(&agRoot, &SwConfig, &memRequirement, &usecsPerTick, &maxSALocks);
 157
 158   /* initializes tdsaEsglAllInfo_t */
 159   pEsglAllInfo->physAddrUpper = tdsaAllShared->loResource.loLevelMem.mem[memRequirement.count].physAddrUpper;
 160   pEsglAllInfo->physAddrLower = tdsaAllShared->loResource.loLevelMem.mem[memRequirement.count].physAddrLower;
 161   pEsglAllInfo->virtPtr       = tdsaAllShared->loResource.loLevelMem.mem[memRequirement.count].virtPtr;
 162   pEsglAllInfo->NumEsglPages  = tdsaAllShared->loResource.loLevelMem.mem[memRequirement.count].numElements; /*   NUM_ESGL_PAGES;  number of esgl pages; configurable */
 163   pEsglAllInfo->EsglPageSize  = tdsaAllShared->loResource.loLevelMem.mem[memRequirement.count].singleElementLength; /* sizeof(agsaEsgl_t) */
 164   pEsglAllInfo->NumFreeEsglPages = pEsglAllInfo->NumEsglPages;
 165   pEsglPagePool = pEsglAllInfo->EsglPagePool;
 166
 167   TI_DBG6(("tdsaEsglInit: pEsglPagePool %p\n", pEsglPagePool));
 168   TI_DBG6(("tdsaEsglInit: tdsaAllShared->loResource.loLevelMem.mem[18].singleElementLength %d\n", tdsaAllShared->loResource.loLevelMem.mem[18].singleElementLength));
 169   TI_DBG6(("tdsaEsglInit: NumEsglPage %d EsglPageSize %d\n", pEsglAllInfo->NumEsglPages, pEsglAllInfo->EsglPageSize)); /* ?, 128 */
 170   TI_DBG6(("tdsaEsglInit: NumFreeEsglPages %d\n", pEsglAllInfo->NumFreeEsglPages));
 171   /* initialize the linked lists */
 172   TDLIST_INIT_HDR(&pEsglAllInfo->freelist);
 173
 174
 175   PageVirtAddr      = pEsglAllInfo->virtPtr;
 176   PagePhysAddrUpper = pEsglAllInfo->physAddrUpper;
 177   PagePhysAddrLower = pEsglAllInfo->physAddrLower;
 178   PageSizeInBytes   = pEsglAllInfo->EsglPageSize;
 179
 180   TI_DBG6(("tdsaEsglInit:  PageSizeInBytes 0x%x\n",  PageSizeInBytes));
 181   for (pageno = 0 ; pageno < pEsglAllInfo->NumEsglPages ; pageno++)
 182   {
 183     pEsglPageInfo = &(pEsglPagePool->EsglPages[pageno]);
 184     OSSA_WRITE_LE_32(agRoot, pEsglPageInfo, OSSA_OFFSET_OF(pEsglPageInfo, physAddressUpper), PagePhysAddrUpper);
 185     OSSA_WRITE_LE_32(agRoot, pEsglPageInfo, OSSA_OFFSET_OF(pEsglPageInfo, physAddressLower), PagePhysAddrLower);
 186     pEsglPageInfo->len = PageSizeInBytes;
 187     /* for debugging onlye*/
 188     pEsglPageInfo->id = pageno+123;
 189     pEsglPageInfo->agEsgl = (agsaEsgl_t *)PageVirtAddr;
 190
 191     /* for debugging only */
 192     TI_DBG6(("tdsaEsglInit: index %d upper 0x%8x lower 0x%8x PageVirtAddr %p\n", pageno, PagePhysAddrUpper, PagePhysAddrLower, PageVirtAddr));
 193
 194
 195     /* updates addresses */
 196     prev_PagePhysAddrLower = PagePhysAddrLower;
 197     PagePhysAddrLower += pEsglAllInfo->EsglPageSize;
 198     /* if lower wraps around, increment upper */
 199     if (PagePhysAddrLower <= prev_PagePhysAddrLower)
 200     {
 201       PagePhysAddrUpper++;
 202     }
 203
 204     if (pageno == pEsglAllInfo->NumEsglPages - 1) /* last page */
 205     {
 206       pEsglPageInfo->agEsgl->descriptor[MAX_ESGL_ENTRIES-1].len = 0;
 207       /* set bit31 to zero */
 208       CLEAR_ESGL_EXTEND(pEsglPageInfo->agEsgl->descriptor[MAX_ESGL_ENTRIES-1].extReserved);
 209     }
 210     else
 211     {
 212       /* first and so on */
 213       pEsglPageInfo->agEsgl->descriptor[MAX_ESGL_ENTRIES-1].sgLower = PagePhysAddrLower;
 214       pEsglPageInfo->agEsgl->descriptor[MAX_ESGL_ENTRIES-1].sgUpper = PagePhysAddrUpper;
 215       pEsglPageInfo->agEsgl->descriptor[MAX_ESGL_ENTRIES-1].len = PageSizeInBytes; /* sizeof (agsaEsgl_t)*/
 216       /* set bit31 to one */
 217       SET_ESGL_EXTEND(pEsglPageInfo->agEsgl->descriptor[MAX_ESGL_ENTRIES-1].extReserved);
 218     }
 219
 220     TDLIST_INIT_ELEMENT(&pEsglPageInfo->tdlist);
 221     tdsaSingleThreadedEnter(tiRoot, TD_ESGL_LOCK);
 222     TDLIST_ENQUEUE_AT_TAIL(&pEsglPageInfo->tdlist, &pEsglAllInfo->freelist);
 223     tdsaSingleThreadedLeave(tiRoot, TD_ESGL_LOCK);
 224
 225     PageVirtAddr = (bit8 *)PageVirtAddr + PageSizeInBytes;
 226   } /* end for */
 227
 228
 229
 230 #ifdef TD_INTERNAL_DEBUG /* for debugging only, for keep now */
 231   for (pageno = 0 ; pageno < pEsglAllInfo->NumEsglPages ; pageno++)
 232   {
 233     TI_DBG6(("tdsaEsglInit: index %d EsglPages %p\n", pageno, &pEsglPagePool->EsglPages[pageno]));
 234     TI_DBG6(("tdsaEsglInit: nextupper 0x%8x nextlower 0x%8x\n", pEsglPagePool->EsglPages[pageno].agEsgl->nextPageUpper, pEsglPagePool->EsglPages[pageno].agEsgl->nextPageLower));
 235   }
 236   TI_DBG6(("tdsaEsglInit:  tdsaEsglPageInfo_t size %d 0x%x\n", sizeof(tdsaEsglPageInfo_t), sizeof(tdsaEsglPageInfo_t)));
 237   TI_DBG6(("tdsaEsglInit: sizeof(SASG_DESCRIPTOR) %d 0x%x\n", sizeof(SASG_DESCRIPTOR), sizeof(SASG_DESCRIPTOR)));
 238 #endif
 239
 240   return;
 241 }
 242
 243
 244 /*****************************************************************************
 245 *! \brief  tdsaGetEsglPages
 246 *
 247 *  Purpose: This function prepares linked list of ESGL pages from
 248 *           the given scatter-gather list.
 249 *
 250 *  \param tiRoot:       Pointer to root data structure.
 251 *  \param EsglListHdr:  pointer to list header where the list needs to be stored.
 252 *  \param ptiSgl:       Pointer to scatter-gather list.
 253 *  \param virtSgl:      virtual pointer to scatter-gather list.
 254 *
 255 *  \return None
 256 *
 257 *  \note -
 258 *       1. If we are out of ESGL pages, then no pages will be added to the list
 259 *          pointed to by EsglListHdr. The list should be empty before calling
 260 *          this function, so that after returning from this function, the
 261 *          function can check for the emptyness of the list and find out if
 262 *          any pages were added or not.
 263 *
 264 *****************************************************************************/
 265 osGLOBAL void
 266 tdsaGetEsglPages(
 267                  tiRoot_t *tiRoot,
 268                  tdList_t *EsglListHdr,
 269                  tiSgl_t  *ptiSgl,
 270                  tiSgl_t  *virtSgl
 271                  )
 272 {
 273   tdsaRoot_t        *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
 274   tdsaContext_t     *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
 275
 276   tdsaEsglAllInfo_t *pEsglAllInfo = &(tdsaAllShared->EsglAllInfo);
 277   bit32 numSgElements = ptiSgl->len;
 278   bit32 numEntriesPerPage = MAX_ESGL_ENTRIES;
 279   bit32 numPagesRequired = ((numSgElements - 1) / numEntriesPerPage) + 1;
 280   bit32 i, j;
 281   tdList_t *tdlist_to_fill;
 282   tdsaEsglPageInfo_t *page_to_fill;
 283   tiSgl_t *tmp_tiSgl = (tiSgl_t *)virtSgl;
 284   agsaSgl_t *pDesc;
 285   agsaEsgl_t *agEsgl, *PrevagEsgl = agNULL;
 286
 287   TI_DBG6(("tdsaGetEsglPages: start\n"));
 288   TI_DBG6(("tdsaGetEsglPages: pEsglPagePool %p\n", pEsglAllInfo->EsglPagePool));
 289   TI_DBG6(("tdsaGetEsglPages: &(pEsglAllInfo->freelist) %p\n", &pEsglAllInfo->freelist));
 290   TI_DBG6(("tdsaGetEsglPages: numSgElements %d numEntriesPerPage %d\n", numSgElements, numEntriesPerPage)); /* ?,  10 */
 291   TI_DBG6(("tdsaGetEsglPages: numPagesRequired %d NumFreeEsglPages %d\n", numPagesRequired, pEsglAllInfo->NumFreeEsglPages)); /* 1, 2 */
 292   TI_DBG6(("tdsaGetEsglPages: free Pages %d\n", pEsglAllInfo->NumFreeEsglPages));
 293
 294   if (numPagesRequired > pEsglAllInfo->NumFreeEsglPages)
 295   {
 296     TI_DBG1(("tdsaGetEsglPages:don't have enough freepages. required %d free %d\n", numPagesRequired, pEsglAllInfo->NumFreeEsglPages));
 297     return;
 298   }
 299   tdsaSingleThreadedEnter(tiRoot, TD_ESGL_LOCK);
 300   pEsglAllInfo->NumFreeEsglPages -= numPagesRequired;
 301   tdsaSingleThreadedLeave(tiRoot, TD_ESGL_LOCK);
 302
 303
 304
 305 #ifdef TD_INTERNAL_DEBUG  /* for debugging only */
 306   for (i=0; i < 2; i++)
 307   {
 308     /* remove one page from freelist */
 309     tdsaSingleThreadedEnter(tiRoot, TD_ESGL_LOCK);
 310     TDLIST_DEQUEUE_FROM_HEAD(&tdlist_to_fill, &pEsglAllInfo->freelist);
 311     tdsaSingleThreadedLeave(tiRoot, TD_ESGL_LOCK);
 312
 313     /* get the pointer to the page from list pointer */
 314     page_to_fill = TDLIST_OBJECT_BASE(tdsaEsglPageInfo_t, tdlist, tdlist_to_fill);
 315     /* for debugging */
 316     TI_DBG6(("tdsaGetEsglPages:page ID %d\n", page_to_fill->id));
 317     agEsgl = page_to_fill->agEsgl;
 318
 319     pDesc = (SASG_DESCRIPTOR *)agEsgl;
 320
 321     for (j=0; j <numEntriesPerPage; j++)
 322     {
 323       TI_DBG6(("tdsaGetEsglPages: lower %d  upper %d\n", pDesc->sgLower, pDesc->sgUpper));
 324       TI_DBG6(("tdsaGetEsglPages: len %d\n", pDesc->len));
 325       pDesc++;
 326     }
 327     TI_DBG6(("tdsaGetEsglPages: next lower %d next upper %d\n", agEsgl->nextPageLower, agEsgl->nextPageUpper));
 328
 329   }
 330 #endif /* for debugging only  */
 331
 332   for (i = 0 ; i < numPagesRequired; i++)
 333   {
 334     /* remove one page from freelist */
 335     tdsaSingleThreadedEnter(tiRoot, TD_ESGL_LOCK);
 336     TDLIST_DEQUEUE_FROM_HEAD(&tdlist_to_fill, &pEsglAllInfo->freelist);
 337     tdsaSingleThreadedLeave(tiRoot, TD_ESGL_LOCK);
 338
 339     /* get the pointer to the page from list pointer */
 340     page_to_fill = TDLIST_OBJECT_BASE(tdsaEsglPageInfo_t, tdlist, tdlist_to_fill);
 341     /* for debugging */
 342     TI_DBG6(("tdsaGetEsglPages:page ID %d\n", page_to_fill->id));
 343
 344     agEsgl = page_to_fill->agEsgl;
 345     pDesc = (agsaSgl_t *)agEsgl;
 346
 347     /*
 348       adjust next page's address in the followings so that
 349       the last entry must be (0,0,0)
 350     */
 351     if (i == numPagesRequired - 1) /* only one page of last page */
 352     {
 353       for (j=0; j < numSgElements; j++)
 354       {
 355         OSSA_WRITE_LE_32(agRoot, pDesc, OSSA_OFFSET_OF(pDesc, sgLower), tmp_tiSgl->lower);
 356         OSSA_WRITE_LE_32(agRoot, pDesc, OSSA_OFFSET_OF(pDesc, sgUpper), tmp_tiSgl->upper);
 357         OSSA_WRITE_LE_32(agRoot, pDesc, OSSA_OFFSET_OF(pDesc, len), tmp_tiSgl->len);
 358         CLEAR_ESGL_EXTEND(pDesc->extReserved);
 359         pDesc++;
 360         tmp_tiSgl++;
 361       }
 362       for (j=numSgElements; j < numEntriesPerPage; j++)
 363       {
 364         /* left over(unused) in the page */
 365         pDesc->sgLower = 0x0;
 366         pDesc->sgUpper = 0x0;
 367         pDesc->len = 0x0;
 368         CLEAR_ESGL_EXTEND(pDesc->extReserved);
 369         pDesc++;
 370       }
 371     }
 372     else
 373     {
 374       /* in case of muliple pages, first and later, except one page only or last page */
 375       for (j=0; j <numEntriesPerPage - 1; j++) /* else */
 376       {
 377         /* do this till (last - 1) */
 378         OSSA_WRITE_LE_32(agRoot, pDesc, OSSA_OFFSET_OF(pDesc, sgLower), tmp_tiSgl->lower);
 379         OSSA_WRITE_LE_32(agRoot, pDesc, OSSA_OFFSET_OF(pDesc, sgUpper), tmp_tiSgl->upper);
 380         OSSA_WRITE_LE_32(agRoot, pDesc, OSSA_OFFSET_OF(pDesc, len), tmp_tiSgl->len);
 381         CLEAR_ESGL_EXTEND(pDesc->extReserved);
 382         pDesc++;
 383         tmp_tiSgl++;
 384       }
 385       numSgElements -= (numEntriesPerPage - 1);
 386     }
 387     if (PrevagEsgl != agNULL)
 388     {
 389       /* subsequent pages (second or later pages) */
 390       PrevagEsgl->descriptor[MAX_ESGL_ENTRIES-1].sgLower = page_to_fill->physAddressLower;
 391       PrevagEsgl->descriptor[MAX_ESGL_ENTRIES-1].sgUpper = page_to_fill->physAddressUpper;
 392       PrevagEsgl->descriptor[MAX_ESGL_ENTRIES-1].len = numSgElements;
 393       /* set bit31 to one */
 394       SET_ESGL_EXTEND(PrevagEsgl->descriptor[MAX_ESGL_ENTRIES-1].extReserved);
 395     }
 396     PrevagEsgl = agEsgl;
 397     /* put ESGL onto the EsglListHdr */
 398     tdsaSingleThreadedEnter(tiRoot, TD_ESGL_LOCK);
 399     TDLIST_ENQUEUE_AT_TAIL(tdlist_to_fill, EsglListHdr);
 400     tdsaSingleThreadedLeave(tiRoot, TD_ESGL_LOCK);
 401
 402
 403   } /* end for */
 404   return;
 405 }
 406
 407
 408 /*****************************************************************************
 409 *! \brief  tdsaFreeEsglPages
 410 *
 411 *  Purpose: This function frees the ESGL pages pointed to by EsglListHdr
 412 *           and puts them back onto the free list.
 413 *
 414 *  \param  tiRoot:       Pointer to root data structure.
 415 *  \param  EsglListHdr:  pointer to list header where the pages to be freed
 416 *                        are stored.
 417 *
 418 *  \return:     None
 419 *
 420 *  \note -
 421 *   1. This function removes all the pages from the list until the list
 422 *      empty and chains them at the end of the free list.
 423 *****************************************************************************/
 424 osGLOBAL void
 425 tdsaFreeEsglPages(
 426                   tiRoot_t *tiRoot,
 427                   tdList_t *EsglListHdr
 428                   )
 429 {
 430   tdsaRoot_t         *tdsaRoot        = (tdsaRoot_t *) tiRoot->tdData;
 431   tdsaContext_t      *tdsaAllShared = (tdsaContext_t *)&tdsaRoot->tdsaAllShared;
 432   tdsaEsglAllInfo_t  *pEsglAllInfo = (tdsaEsglAllInfo_t *)&(tdsaAllShared->EsglAllInfo);
 433   tdList_t           *tdlist_to_free;
 434
 435   TI_DBG6(("tdsaFreeEsglPages: start\n"));
 436   if (tiRoot == agNULL)
 437   {
 438     TI_DBG1(("tdsaFreeEsglPages: tiRoot is NULL\n"));
 439     return;
 440   }
 441
 442   if (EsglListHdr == agNULL)
 443   {
 444     TI_DBG1(("tdsaFreeEsglPages: EsglListHdr is NULL\n"));
 445     return;
 446   }
 447
 448   TI_DBG6(("tdsaFreeEsglPages: EsglListHdr %p\n", EsglListHdr));
 449   tdsaSingleThreadedEnter(tiRoot, TD_ESGL_LOCK);
 450   while (TDLIST_NOT_EMPTY(EsglListHdr))
 451   {
 452     TDLIST_DEQUEUE_FROM_HEAD(&tdlist_to_free, EsglListHdr);
 453     TDLIST_ENQUEUE_AT_TAIL(tdlist_to_free, &pEsglAllInfo->freelist);
 454     pEsglAllInfo->NumFreeEsglPages++;
 455   }
 456   tdsaSingleThreadedLeave(tiRoot, TD_ESGL_LOCK);
 457   TI_DBG6(("tdsaFreeEsglPages: NumFreeEsglPages  %d\n", pEsglAllInfo->NumFreeEsglPages));
 458   return;
 459 }
 460
 461
 462 /*****************************************************************************
 463 *! \brief  tdsaGetEsglPagesInfo
 464 *
 465 *  Purpose: This function gets the information about the size of ESGL pages
 466 *           and number pages to be configured.
 467 *
 468 *  \param tiRoot:     Pointer to root data structure.
 469 *  \param pPageSize:  pointer to bit32 where pagesize information is to be
 470 *                     stored
 471 *  \param pNumPages:  Pointer to bit32 where number of pages information is
 472 *                     to be stored
 473 *
 474 *  \return:     None
 475 *
 476 *  \note -
 477 *
 478 *****************************************************************************/
 479 osGLOBAL void
 480 tdsaGetEsglPagesInfo(
 481                      tiRoot_t *tiRoot,
 482                      bit32    *pPageSize,
 483                      bit32    *pNumPages
 484                      )
 485 {
 486   char    *buffer;
 487   bit32   buffLen;
 488   bit32   lenRecv = 0;
 489   char    *pLastUsedChar = agNULL;
 490   char    globalStr[]     = "Global";
 491   char    SwParmsStr[]   = "ESGLParms";
 492   char    tmpBuffer[DEFAULT_KEY_BUFFER_SIZE];
 493   /* default value, defined in tdsatypes.h */
 494   bit32   NumEsglPages = NUM_ESGL_PAGES;
 495   TI_DBG6(("tdsaGetEsglPagesInfo: start \n"));
 496
 497   /*
 498     calls ostiGetTransportParam which parses the configuration file to get
 499     parameters.
 500   */
 501
 502   buffer = tmpBuffer;
 503   buffLen = sizeof(tmpBuffer);
 504
 505   osti_memset(buffer, 0, buffLen);
 506
 507
 508   if ((ostiGetTransportParam(
 509                              tiRoot,
 510                              globalStr,   /* key */
 511                              SwParmsStr,  /* subkey1 */
 512                              agNULL,      /* subkey2 */
 513                              agNULL,
 514                              agNULL,
 515                              agNULL,      /* subkey5 */
 516                              "NumESGLPg", /* valueName */
 517                              buffer,
 518                              buffLen,
 519                              &lenRecv
 520                              ) == tiSuccess) && (lenRecv != 0))
 521   {
 522
 523     NumEsglPages = osti_strtoul(buffer, &pLastUsedChar, 10);
 524   }
 525
 526   osti_memset(buffer, 0, buffLen);
 527   lenRecv = 0;
 528
 529   TI_DBG6(("tdsaGetEsglPagesInfo: esgl page number %d\n",NumEsglPages));
 530   *pPageSize = ESGL_PAGES_SIZE;/* sizeof(agsaEsgl_t); defined in tdsatypes.h */
 531   *pNumPages = NumEsglPages;
 532
 533   return;
 534 }
 535 #endif
 536
 537
 538
 539
 540
 541
 542
 543