The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/pms/RefTisa/tisa/sassata/common/tdesgl.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10  
    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

Cache object: 5dfee5f8909bb107139cd3d6db8e1e11

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.