FreeBSD/Linux Kernel Cross Reference
sys/dev/pms/RefTisa/sallsdk/spc/saphy.c

     /*******************************************************************************
     *Copyright (c) 2014 PMC-Sierra, Inc.  All rights reserved. 
     *
     *Redistribution and use in source and binary forms, with or without modification, are permitted provided 
     *that the following conditions are met: 
     *1. Redistributions of source code must retain the above copyright notice, this list of conditions and the
     *following disclaimer. 
     *2. Redistributions in binary form must reproduce the above copyright notice, 
     *this list of conditions and the following disclaimer in the documentation and/or other materials provided
    *with the distribution. 
    *
    *THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED 
    *WARRANTIES,INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
    *FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
    *FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
    *NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR 
    *BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
    *LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
    *SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE
    
    ********************************************************************************/
    /*******************************************************************************/
    /*! \file saphy.c
     *  \brief The file implements the functions to Start, Stop a phy
     *
     *
     */
    /******************************************************************************/
    #include <sys/cdefs.h>
    __FBSDID("$FreeBSD$");
    #include <dev/pms/config.h>
    
    #include <dev/pms/RefTisa/sallsdk/spc/saglobal.h>
    #ifdef SA_ENABLE_TRACE_FUNCTIONS
    #ifdef siTraceFileID
    #undef siTraceFileID
    #endif
    #define siTraceFileID 'K'
    #endif
    
    
    extern bit32 gFPGA_TEST;
    /******************************************************************************/
    /*! \brief Start a Phy
     *
     *  Start a Phy
     *
     *  \param agRoot handles for this instance of SAS/SATA hardware
     *  \param agContext
     *  \param phyId the phy id of the link will be started
     *  \param agPhyConfig the phy configuration
     *  \param agSASIdentify the SAS identify frame will be sent by the phy
     *
     *  \return If phy is started successfully
     *          - \e AGSA_RC_SUCCESS phy is started successfully
     *          - \e AGSA_RC_BUSY phy is already started or starting
     *          - \e AGSA_RC_FAILURE phy is not started successfully
     */
    /*******************************************************************************/
    GLOBAL bit32 saPhyStart(
      agsaRoot_t         *agRoot,
      agsaContext_t      *agContext,
      bit32              queueNum,
      bit32              phyId,
      agsaPhyConfig_t    *agPhyConfig,
      agsaSASIdentify_t  *agSASIdentify
      )
    {
      agsaLLRoot_t        *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
      agsaIORequestDesc_t *pRequest;
      bit32               ret = AGSA_RC_SUCCESS;
      bit32               using_reserved = agFALSE;
    
      smTraceFuncEnter(hpDBG_VERY_LOUD, "7a");
    
      /* sanity check */
      SA_ASSERT((agNULL != agRoot), "");
      SA_ASSERT((agNULL != agSASIdentify), "");
    
      SA_DBG3(("saPhyStart: phy%d started with ID %08X:%08X\n",
        phyId,
        SA_IDFRM_GET_SAS_ADDRESSHI(agSASIdentify),
        SA_IDFRM_GET_SAS_ADDRESSLO(agSASIdentify)));
    
      /* If phyId is invalid, return failure */
      if ( phyId >= saRoot->phyCount )
      {
        ret = AGSA_RC_FAILURE;
      }
      /* If phyId is valid */
      else
      {
        /* Get request from free IORequests */
        ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
        pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests)); /* */
        /* If no LL Control request entry available */
        if ( agNULL == pRequest )
        {
          pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeReservedRequests));
         /* If no LL Control request entry available */
         if(agNULL != pRequest)
         {
           using_reserved = agTRUE;
           SA_DBG1(("saPhyStart, using saRoot->freeReservedRequests\n"));
         }
         else
         {
           ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
           SA_DBG1(("saPhyStart, No request from free list Not using saRoot->freeReservedRequests\n"));
           smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "7a");
           return AGSA_RC_BUSY;
         }
       }
       SA_ASSERT((!pRequest->valid), "The pRequest is in use");
       pRequest->valid = agTRUE;
       /* If LL Control request entry avaliable */
       if( using_reserved )
       {
         saLlistIORemove(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
       }
       else
       {
         /* Remove the request from free list */
         saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
       }
       ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
   
       saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
       saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
       saRoot->IOMap[pRequest->HTag].agContext = agContext;
       pRequest->valid = agTRUE;
   
       /* Build the Phy Start IOMB command and send to SPC */
   
       smTrace(hpDBG_VERY_LOUD,"P2", phyId);
       /* TP:P2 phyId */
   
       ret = mpiPhyStartCmd(agRoot, pRequest->HTag, phyId, agPhyConfig, agSASIdentify, queueNum);
       if (AGSA_RC_SUCCESS != ret)
       {
         /* remove the request from IOMap */
         saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
         saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
         saRoot->IOMap[pRequest->HTag].agContext = agNULL;
         pRequest->valid = agFALSE;
   
         ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
         /* return the request to free pool */
         if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
         {
           SA_DBG1(("saPhyStart: saving pRequest (%p) for later use\n", pRequest));
           saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
         }
         else
         {
           /* return the request to free pool */
           saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
         }
         ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
         SA_DBG1(("saPhyStart, sending IOMB failed\n" ));
       }
     }
   
     smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "7a");
   
     return ret;
   }
   
   /******************************************************************************/
   /*! \brief Stop a Phy
    *
    *  Stop a Phy
    *
    *  \param agRoot handles for this instance of SAS/SATA hardware
    *  \param agContext the context of this API
    *  \param phyId the phy id of the link will be stopped
    *
    *  \return If phy is stopped successfully
    *          - \e AGSA_RC_SUCCESS phy is stopped successfully
    *          - \e AGSA_RC_FAILURE phy is not stopped successfully
    */
   /*******************************************************************************/
   GLOBAL bit32 saPhyStop(
     agsaRoot_t      *agRoot,
     agsaContext_t   *agContext,
     bit32           queueNum,
     bit32           phyId
     )
   {
     agsaLLRoot_t        *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
     agsaIORequestDesc_t *pRequest;
     bit32               ret = AGSA_RC_SUCCESS;
     bit32               using_reserved = agFALSE;
   
     smTraceFuncEnter(hpDBG_VERY_LOUD,"7b");
   
     /* sanity check */
     SA_ASSERT((agNULL != agRoot), "");
   
     SA_DBG2(("saPhyStop: phy%d stop\n", phyId));
   
     if(1)
     {
       mpiOCQueue_t         *circularQ;
       int i;
       SA_DBG4(("saPhyStop:\n"));
       for ( i = 0; i < saRoot->QueueConfig.numOutboundQueues; i++ )
       {
         circularQ = &saRoot->outboundQueue[i];
         OSSA_READ_LE_32(circularQ->agRoot, &circularQ->producerIdx, circularQ->piPointer, 0);
         if(circularQ->producerIdx != circularQ->consumerIdx)
         {
           SA_DBG1(("saPhyStop: PI 0x%03x CI 0x%03x\n",circularQ->producerIdx, circularQ->consumerIdx ));
         }
       }
     }
   
     if(smIS_SPC(agRoot))
     { 
       phyId &= 0xF;
     }
     /* If phyId is invalid, return failure */
     if ( (phyId & 0xF) >= saRoot->phyCount )
     {
       ret = AGSA_RC_FAILURE;
       SA_DBG1(("saPhyStop: phy%d - failure with phyId\n", phyId));
     }
     else
     {
       /* If phyId is valid */
       /* Get request from free IORequests */
       ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
       pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests)); /**/
       /* If no LL Control request entry available */
       if ( agNULL == pRequest )
       {
         pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeReservedRequests));
         /* If no LL Control request entry available */
         if(agNULL != pRequest)
         {
           using_reserved = agTRUE;
           SA_DBG1(("saPhyStop: using saRoot->freeReservedRequests\n"));
         }
         else
         {
           ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
           SA_DBG1(("saPhyStop, No request from free list Not using saRoot->freeReservedRequests\n"));
           smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "7b");
           return AGSA_RC_BUSY;
         }
       }
       /* Remove the request from free list */
       if( using_reserved )
       {
         saLlistIORemove(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
       }
       else
       {
         saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
       }
       ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
       SA_ASSERT((!pRequest->valid), "The pRequest is in use");
       saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
       saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
       saRoot->IOMap[pRequest->HTag].agContext = agContext;
       pRequest->valid = agTRUE;
   
       /* build IOMB command and send to SPC */
       ret = mpiPhyStopCmd(agRoot, pRequest->HTag, phyId, queueNum);
       if (AGSA_RC_SUCCESS != ret)
       {
         /* remove the request from IOMap */
         saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
         saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
         saRoot->IOMap[pRequest->HTag].agContext = agNULL;
   
         ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
         /* return the request to free pool */
         if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
         {
           SA_DBG2(("saPhyStop: saving pRequest (%p) for later use\n", pRequest));
           saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
         }
         else
         {
           /* return the request to free pool */
           saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
         }
         ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
         SA_DBG1(("saPhyStop, sending IOMB failed\n" ));
       }
     }
   
     smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "7b");
   
     return ret;
   }
   
   /******************************************************************************/
   /*! \brief CallBack Routine to stop a Phy
    *
    *  CallBack for Stop a Phy
    *
    *  \param agRoot handles for this instance of SAS/SATA hardware
    *  \param phyId the phy id of the link will be stopped
    *  \param status the status of the phy
    *  \param agContext the context of the saPhyStop
    *
    *  \return If phy is stopped successfully
    *          - \e AGSA_RC_SUCCESS phy is stopped successfully
    *          - \e AGSA_RC_FAILURE phy is not stopped successfully
    */
   /*******************************************************************************/
   GLOBAL bit32 siPhyStopCB(
     agsaRoot_t    *agRoot,
     bit32         phyId,
     bit32         status,
     agsaContext_t *agContext,
     bit32         portId,
     bit32         npipps
     )
   {
     agsaLLRoot_t            *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
     agsaPhy_t               *pPhy;
     agsaPort_t              *pPort;
     bit32                   ret = AGSA_RC_SUCCESS;
     bit32                   iomb_status = status;
   
     smTraceFuncEnter(hpDBG_VERY_LOUD,"7c");
   
     /* sanity check */
     SA_ASSERT((agNULL != agRoot), "");
   
     /* If phyId is invalid, return failure */
     if ( phyId >= saRoot->phyCount )
     {
       ret = AGSA_RC_FAILURE;
       SA_DBG1(("siPhyStopCB: phy%d - failure with phyId\n", phyId));
       /* makeup for CB */
       status = (status << SHIFT8) | phyId;
       status |= ((npipps & PORT_STATE_MASK) << SHIFT16);
       ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_PHY_STOP_STATUS, status, agContext, agNULL);
     }
     /* If phyId is valid */
     else
     {
       pPhy = &(saRoot->phys[phyId]);
   
       /* get the port of the phy */
       pPort = pPhy->pPort;
   
       /* makeup for CB */
       status = (status << SHIFT8) | phyId;
       status |= ((npipps & PORT_STATE_MASK) << SHIFT16);
       /* Callback to stop phy */
       if ( agNULL != pPort )
       {
         if ( iomb_status == OSSA_SUCCESS && (OSSA_PORT_INVALID == (npipps & PORT_STATE_MASK) ))
         {
           SA_DBG1(("siPhyStopCB: phy%d invalidating port\n", phyId));
           /* invalid port state, remove the port */
           pPort->status |= PORT_INVALIDATING;
           saRoot->PortMap[portId].PortStatus  |= PORT_INVALIDATING;
           /* invalid the port */
           siPortInvalid(agRoot, pPort);
           /* map out the portmap */
           saRoot->PortMap[pPort->portId].PortContext = agNULL;
           saRoot->PortMap[pPort->portId].PortID = PORT_MARK_OFF;
           saRoot->PortMap[pPort->portId].PortStatus  |= PORT_INVALIDATING;
         }
         ossaHwCB(agRoot, &(pPort->portContext), OSSA_HW_EVENT_PHY_STOP_STATUS, status, agContext, agNULL);
       }
       else
       {
         SA_DBG1(("siPhyStopCB: phy%d - Port is not established\n", phyId));
         ossaHwCB(agRoot, agNULL, OSSA_HW_EVENT_PHY_STOP_STATUS, status, agContext, agNULL);
       }
   
       /* set PHY_STOPPED status */
       PHY_STATUS_SET(pPhy, PHY_STOPPED);
   
       /* Exclude the phy from a port */
       if ( agNULL != pPort )
       {
         /* Acquire port list lock */
         ossaSingleThreadedEnter(agRoot, LL_PORT_LOCK);
   
         /* Delete the phy from the port */
         pPort->phyMap[phyId] = agFALSE;
         saRoot->phys[phyId].pPort = agNULL;
   
         /* Release port list lock */
         ossaSingleThreadedLeave(agRoot, LL_PORT_LOCK);
       }
     }
   
     smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "7c");
   
     /* return */
     return ret;
   }
   
   /******************************************************************************/
   /*! \brief Initiate a Local PHY control command
    *
    *  This function is called to initiate a PHY control command to the local PHY.
    *  The completion of this function is reported in ossaLocalPhyControlCB()
   
    *
    *  \param agRoot handles for this instance of SAS/SATA hardware
    *  \param agContext the context of this API
    *  \param phyId  phy number
    *  \param phyOperation
    *    one of AGSA_PHY_LINK_RESET, AGSA_PHY_HARD_RESET, AGSA_PHY_ENABLE_SPINUP
    *
    *  \return
    *          - none
    */
   /*******************************************************************************/
   GLOBAL bit32 saLocalPhyControl(
     agsaRoot_t             *agRoot,
     agsaContext_t          *agContext,
     bit32                   queueNum,
     bit32                   phyId,
     bit32                   phyOperation,
     ossaLocalPhyControlCB_t agCB
     )
   {
     agsaLLRoot_t         *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
     agsaIORequestDesc_t  *pRequest;
     agsaPhyErrCounters_t errorParam;
     bit32                ret = AGSA_RC_SUCCESS;
     bit32                value, value1, value2, copyPhyId;
     bit32                count = 100;
     bit32                using_reserved = agFALSE;
   
   
     /* sanity check */
     SA_ASSERT((agNULL != saRoot), "");
     if(saRoot == agNULL)
     {
       SA_DBG1(("saLocalPhyControl: saRoot == agNULL\n"));
       return(AGSA_RC_FAILURE);
     }
     smTraceFuncEnter(hpDBG_VERY_LOUD,"7d");
   
     si_memset(&errorParam,0,sizeof(agsaPhyErrCounters_t));
     SA_DBG2(("saLocalPhyControl: phy%d operation %08X\n", phyId, phyOperation));
   
     switch(phyOperation)
     {
       case AGSA_PHY_LINK_RESET:
       case AGSA_PHY_HARD_RESET:
       case AGSA_PHY_NOTIFY_ENABLE_SPINUP:
       case AGSA_PHY_BROADCAST_ASYNCH_EVENT:
       case AGSA_PHY_COMINIT_OOB:
       {
         /* Get request from free IORequests */
         ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
         pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests)); /**/
   
         /* If no LL Control request entry available */
         if ( agNULL == pRequest )
         {
           pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeReservedRequests));
           /* If no LL Control request entry available */
           if(agNULL != pRequest)
           {
             using_reserved = agTRUE;
             SA_DBG1(("saLocalPhyControl, using saRoot->freeReservedRequests\n"));
           }
           else
           {
             ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
             SA_DBG1(("saLocalPhyControl, No request from free list Not using saRoot->freeReservedRequests\n"));
             smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "7d");
             return AGSA_RC_BUSY;
           }
         }
         if( using_reserved )
         {
           saLlistIORemove(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
         }
         else
         {
           saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
         }
         /* Remove the request from free list */
         SA_ASSERT((!pRequest->valid), "The pRequest is in use");
         pRequest->completionCB = (void*)agCB;
         //  pRequest->abortCompletionCB = agCB;
         saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
         saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
         saRoot->IOMap[pRequest->HTag].agContext = agContext;
         pRequest->valid = agTRUE;
         ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
   
         /* Build the local phy control IOMB command and send to SPC */
         ret = mpiLocalPhyControlCmd(agRoot, pRequest->HTag, phyId, phyOperation, queueNum);
         if (AGSA_RC_SUCCESS != ret)
         {
           /* remove the request from IOMap */
           saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
           saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
           saRoot->IOMap[pRequest->HTag].agContext = agNULL;
           pRequest->valid = agFALSE;
   
           ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
           /* return the request to free pool */
           if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
           {
             SA_DBG1(("saLocalPhyControl: saving pRequest (%p) for later use\n", pRequest));
             saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
           }
           else
           {
             /* return the request to free pool */
             saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
           }
           SA_DBG1(("saLocalPhyControl, sending IOMB failed\n" ));
           ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
           return ret;
         }
       }
       break;
       case AGSA_PHY_GET_ERROR_COUNTS:
       {
         if(smIS_SPCV(agRoot))
         {
   
           SA_ASSERT((smIS_SPC(agRoot)), "SPC only");
           SA_DBG1(("saLocalPhyControl: V AGSA_PHY_GET_ERROR_COUNTS\n" ));
           smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "7d");
           return AGSA_RC_FAILURE;
         }
         /* If phyId is invalid, return failure */
         if ( phyId >= saRoot->phyCount )
         {
           ret = AGSA_RC_FAILURE;
           si_memset(&errorParam, 0, sizeof(agsaPhyErrCounters_t));
           SA_DBG1(("saLocalPhyControl: phy%d - failure with phyId\n", phyId));
           /* call back with the status */
   
           if( agCB == agNULL )
           {
             ossaLocalPhyControlCB(agRoot, agContext, phyId, phyOperation, OSSA_FAILURE, (void *)&errorParam);
           }
           else
           {
             agCB(agRoot, agContext, phyId, phyOperation, OSSA_FAILURE, (void *)&errorParam);
           }
           smTraceFuncExit(hpDBG_VERY_LOUD, 'c', "7d");
           return ret;
         }
         /* save phyId */
         copyPhyId = phyId;
         /* map 0x030000 or 0x040000 based on phyId to BAR4(0x20), BAT2(win) to access the register  */
         if (phyId < 4)
         {
           /* for phyId = 0, 1, 2, 3 */
           value = 0x030000;
         }
         else
         {
           /* for phyId = 4, 5, 6, 7 */
           phyId = phyId - 4;
           value = 0x040000;
         }
   
         /* Need to make sure DEVICE_LCLK_GENERATION register bit 6 is 0 */
         value1 = ossaHwRegReadExt(agRoot, PCIBAR2, SPC_REG_DEVICE_LCLK);
   
         SA_DBG3(("saLocalPhyControl: TOP DEVICE LCLK Register value = %08X\n", value1));
         /* If LCLK_CLEAR bit set then disable it */
         if (value1 & DEVICE_LCLK_CLEAR)
         {
           ossaHwRegWriteExt(agRoot, PCIBAR2, SPC_REG_DEVICE_LCLK, (value1 & 0xFFFFFFBF) );
           SA_DBG3(("saLocalPhyControl: TOP DEVICE LCLK value = %08X\n", (value1 & 0xFFFFFFBF)));
         }
   
         if (AGSA_RC_FAILURE == siBar4Shift(agRoot, value))
         {
           SA_DBG1(("saLocalPhyControl:Shift Bar4 to 0x%x failed\n", value));
           phyId = copyPhyId;
           /* call back with the status */
   
           if( agCB == agNULL )
           {
             ossaLocalPhyControlCB(agRoot, agContext, phyId, phyOperation, OSSA_FAILURE, (void *)&errorParam);
           }
           else
           {
             agCB(agRoot, agContext, phyId, phyOperation, OSSA_FAILURE, (void *)&errorParam);
           }
   
           smTraceFuncExit(hpDBG_VERY_LOUD, 'd', "7d");
           return AGSA_RC_FAILURE;
         }
   
         /* set LCLK = 1 and LCLK_CLEAR = 0 */
         SPC_WRITE_COUNTER_CNTL(phyId, LCLK);
   
         /* LCLK bit should be low to be able to read error registers */
         while((value = SPC_READ_COUNTER_CNTL(phyId)) & LCLK)
         {
           if(--count == 0)
           {
             SA_DBG1(("saLocalPhyControl: Timeout,SPC_COUNTER_CNTL value = %08X\n", value));
             ret = AGSA_RC_FAILURE;
             break;
           }
         } /* while */
   
         value = SPC_READ_COUNTER_CNTL(phyId);
         SA_DBG3(("saLocalPhyControl: SPC_COUNTER_CNTL value = %08X\n", value));
   
         /* invalidDword */
         errorParam.invalidDword = SPC_READ_INV_DW_COUNT(phyId);
         /* runningDisparityError */
         errorParam.runningDisparityError = SPC_READ_DISP_ERR_COUNT(phyId);
         /* lossOfDwordSynch */
         errorParam.lossOfDwordSynch = SPC_READ_LOSS_DW_COUNT(phyId);
         /* phyResetProblem */
         errorParam.phyResetProblem = SPC_READ_PHY_RESET_COUNT(phyId);
         /* codeViolation */
         errorParam.codeViolation = SPC_READ_CODE_VIO_COUNT(phyId);
         /* never occurred in SPC8x6G */
         errorParam.elasticityBufferOverflow = 0;
         errorParam.receivedErrorPrimitive = 0;
         errorParam.inboundCRCError = 0;
   
         SA_DBG3(("saLocalPhyControl:INV_DW_COUNT         0x%x\n", SPC_READ_INV_DW_COUNT(phyId)));
         SA_DBG3(("saLocalPhyControl:DISP_ERR_COUNT       0x%x\n", SPC_READ_DISP_ERR_COUNT(phyId)));
         SA_DBG3(("saLocalPhyControl:LOSS_DW_COUNT        0x%x\n", SPC_READ_LOSS_DW_COUNT(phyId)));
         SA_DBG3(("saLocalPhyControl:PHY_RESET_COUNT      0x%x\n", SPC_READ_PHY_RESET_COUNT(phyId)));
         SA_DBG3(("saLocalPhyControl:CODE_VIOLATION_COUNT 0x%x\n", SPC_READ_CODE_VIO_COUNT(phyId)));
   
         /* Shift back to BAR4 original address */
         if (AGSA_RC_FAILURE == siBar4Shift(agRoot, 0x0))
         {
           SA_DBG1(("saLocalPhyControl:Shift Bar4 to 0x%x failed\n", 0x0));
           ret = AGSA_RC_FAILURE;
         }
   
         /* restore back the Top Device LCLK generation register value */
         ossaHwRegWriteExt(agRoot, PCIBAR2, SPC_REG_DEVICE_LCLK, value1);
   
         /* restore phyId */
         phyId = copyPhyId;
         /* call back with the status */
   
         if (AGSA_RC_SUCCESS == ret)
         {
           if( agCB == agNULL )
           {
             ossaLocalPhyControlCB(agRoot, agContext, copyPhyId, phyOperation, OSSA_SUCCESS, (void *)&errorParam);
           }
           else
           {
             agCB(agRoot, agContext, copyPhyId, phyOperation, OSSA_SUCCESS, (void *)&errorParam);
           }
         }
         else
         {
           if( agCB == agNULL )
           {
             ossaLocalPhyControlCB(agRoot, agContext, phyId, phyOperation, OSSA_FAILURE, (void *)&errorParam);
           }
           else
           {
             agCB(agRoot, agContext, phyId, phyOperation, OSSA_FAILURE, (void *)&errorParam);
           }
         }
         break;
       }
       case AGSA_PHY_CLEAR_ERROR_COUNTS:
       {
         if(smIS_SPCV(agRoot))
         {
   
           SA_ASSERT((smIS_SPC(agRoot)), "SPC only");
           SA_DBG1(("saLocalPhyControl: V AGSA_PHY_CLEAR_ERROR_COUNTS\n" ));
           smTraceFuncExit(hpDBG_VERY_LOUD, 'e', "7d");
           return AGSA_RC_FAILURE;
         }
         /* If phyId is invalid, return failure */
         if ( phyId >= saRoot->phyCount )
         {
           si_memset(&errorParam, 0, sizeof(agsaPhyErrCountersPage_t));
           SA_DBG3(("saLocalPhyControl(CLEAR): phy%d - failure with phyId\n", phyId));
           /* call back with the status */
           if( agCB == agNULL )
           {
             ossaLocalPhyControlCB(agRoot, agContext, phyId, phyOperation, OSSA_FAILURE, (void *)&errorParam);
           }
           else
           {
             agCB(agRoot, agContext, phyId, phyOperation, OSSA_FAILURE, (void *)&errorParam);
           }
           smTraceFuncExit(hpDBG_VERY_LOUD, 'f', "7d");
           return AGSA_RC_FAILURE;
         }
         /* save phyId */
         copyPhyId = phyId;
         /* map 0x030000 or 0x040000 based on phyId to BAR4(0x20), BAT2(win) to access the register  */
         if (phyId < 4)
         {
           /* for phyId = 0, 1, 2, 3 */
           value = 0x030000;
         }
         else
         {
           /* for phyId = 4, 5, 6, 7 */
           phyId = phyId - 4;
           value = 0x040000;
         }
         /* Need to make sure DEVICE_LCLK_GENERATION register bit 6 is 1 */
         value2 = ossaHwRegReadExt(agRoot, PCIBAR2, SPC_REG_DEVICE_LCLK);
   
         SA_DBG3(("saLocalPhyControl: TOP DEVICE LCLK Register value = %08X\n", value2));
         /* If LCLK_CLEAR bit not set then set it */
         if ((value2 & DEVICE_LCLK_CLEAR) == 0)
         {
           ossaHwRegWriteExt(agRoot, PCIBAR2, SPC_REG_DEVICE_LCLK, (value2 | DEVICE_LCLK_CLEAR) );
           SA_DBG3(("saLocalPhyControl: TOP DEVICE LCLK value = %08X\n", (value2 & 0xFFFFFFBF)));
         }
   
         if (AGSA_RC_FAILURE == siBar4Shift(agRoot, value))
         {
           SA_DBG1(("saLocalPhyControl(CLEAR):Shift Bar4 to 0x%x failed\n", value));
           phyId = copyPhyId;
           /* call back with the status */
           if( agCB == agNULL )
           {
             ossaLocalPhyControlCB(agRoot, agContext, phyId, phyOperation, OSSA_FAILURE, (void *)&errorParam);
           }
           else
           {
             agCB(agRoot, agContext, phyId, phyOperation, OSSA_FAILURE, (void *)&errorParam);
           }
           smTraceFuncExit(hpDBG_VERY_LOUD, 'g', "7d");
           return AGSA_RC_FAILURE;
         }
   
         /* read Counter Control register */
         value1 = SPC_READ_COUNTER_CNTL(phyId);
         SA_DBG3(("saLocalPhyControl(CLEAR): SPC_COUNTER_CNTL value = %08X\n", value1));
         /* set LCLK and LCLK_CLEAR */
         SPC_WRITE_COUNTER_CNTL(phyId, (LCLK_CLEAR | LCLK));
         /* read back the value of register */
         /* poll LCLK bit = 0 */
         while((value = SPC_READ_COUNTER_CNTL(phyId)) & LCLK)
         {
           if(--count == 0)
           {
             SA_DBG1(("saLocalPhyControl: Timeout,SPC_COUNTER_CNTL value = %08X\n", value));
             ret = AGSA_RC_FAILURE;
             break;
           }
         } /* while */
   
         value = SPC_READ_COUNTER_CNTL(phyId);
         SA_DBG3(("saLocalPhyControl(CLEAR): SPC_COUNTER_CNTL value = %08X\n", value));
   
         /* restore the value */
         SPC_WRITE_COUNTER_CNTL(phyId, value1);
   
         /* Shift back to BAR4 original address */
         if (AGSA_RC_FAILURE == siBar4Shift(agRoot, 0x0))
         {
           SA_DBG1(("saLocalPhyControl:Shift Bar4 to 0x%x failed\n", 0x0));
           ret = AGSA_RC_FAILURE;
         }
   
         /* restore back the Top Device LCLK generation register value */
         ossaHwRegWriteExt(agRoot, PCIBAR2, SPC_REG_DEVICE_LCLK, value2);
   
         /* restore phyId */
         phyId = copyPhyId;
         /* call back with the status */
         if (AGSA_RC_SUCCESS == ret)
         {
           if( agCB == agNULL )
           {
             ossaLocalPhyControlCB(agRoot, agContext, phyId, phyOperation, OSSA_SUCCESS, agNULL);
           }
           else
           {
             agCB(agRoot, agContext, phyId, phyOperation, OSSA_SUCCESS, agNULL);
           }
         }
         else
         {
           if( agCB == agNULL )
           {
             ossaLocalPhyControlCB(agRoot, agContext, phyId, phyOperation, OSSA_FAILURE, (void *)&errorParam);
           }
           else
           {
             agCB(agRoot, agContext, phyId, phyOperation, OSSA_FAILURE, (void *)&errorParam);
           }
         }
         break;
       }
       case AGSA_PHY_GET_BW_COUNTS:
       {
         SA_ASSERT((smIS_SPC(agRoot)), "SPCv only");
         SA_DBG1(("saLocalPhyControl: AGSA_PHY_GET_BW_COUNTS\n" ));
         break;
       }
   
       default:
         ret = AGSA_RC_FAILURE;
         SA_ASSERT(agFALSE, "(saLocalPhyControl) Unknown operation");
         break;
     }
   
     smTraceFuncExit(hpDBG_VERY_LOUD, 'h', "7d");
     return ret;
   }
   
   
   GLOBAL bit32 saGetPhyProfile(
                         agsaRoot_t    *agRoot,
                         agsaContext_t *agContext,
                         bit32         queueNum,
                         bit32         ppc,
                         bit32         phyId
                         )
   {
     bit32 ret = AGSA_RC_SUCCESS;
   
     agsaLLRoot_t            *saRoot = agNULL;
     agsaPhyErrCountersPage_t errorParam;
   
     ossaLocalPhyControlCB_t agCB = ossaGetPhyProfileCB;
   
     /* sanity check */
     SA_ASSERT((agNULL != agRoot), "");
     saRoot = (agsaLLRoot_t *) (agRoot->sdkData);
     SA_ASSERT((agNULL != saRoot), "");
      
     if(saRoot == agNULL)
     {
       SA_DBG3(("saGetPhyProfile : saRoot is NULL"));
       return AGSA_RC_FAILURE;
     }
     
     SA_DBG1(("saGetPhyProfile: ppc 0x%x phyID %d\n", ppc,phyId));
   
     switch(ppc)
     {
       case AGSA_SAS_PHY_ERR_COUNTERS_PAGE:
       {
         if(smIS_SPCV(agRoot))
         {
   
           SA_DBG1(("saGetPhyProfile: V AGSA_SAS_PHY_ERR_COUNTERS_PAGE\n" ));
   
           ret = mpiGetPhyProfileCmd( agRoot,agContext,ppc ,phyId,agCB);
           smTraceFuncExit(hpDBG_VERY_LOUD, 'i', "7d");
           return ret;
         }
       }
       case AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE:
       {
         /* If phyId is invalid, return failure */
         if ( phyId >= saRoot->phyCount )
         {
           si_memset(&errorParam, 0, sizeof(agsaPhyErrCountersPage_t));
           SA_DBG3(("saGetPhyProfile(CLEAR): phy%d - failure with phyId\n", phyId));
           /* call back with the status */
           ossaGetPhyProfileCB(agRoot, agContext, phyId, ppc, OSSA_FAILURE, (void *)&errorParam);
           smTraceFuncExit(hpDBG_VERY_LOUD, 'j', "7d");
           return AGSA_RC_FAILURE;
         }
         if(smIS_SPCV(agRoot))
         {
           SA_DBG1(("saGetPhyProfile: V AGSA_SAS_PHY_ERR_COUNTERS_CLR_PAGE\n" ));
   
           ret = mpiGetPhyProfileCmd( agRoot,agContext, ppc,phyId,agCB);
           smTraceFuncExit(hpDBG_VERY_LOUD, 'k', "7d");
           return ret;
         }
   
       }
       case AGSA_SAS_PHY_BW_COUNTERS_PAGE:
       {
         SA_DBG1(("saGetPhyProfile: AGSA_SAS_PHY_BW_COUNTERS_PAGE\n" ));
         ret = mpiGetPhyProfileCmd( agRoot,agContext,ppc ,phyId,agCB);
         break;
       }
       case AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE:
       {
         SA_DBG1(("saGetPhyProfile: AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE\n" ));
         ret = mpiGetPhyProfileCmd( agRoot,agContext,ppc ,phyId,agCB);
         break;
       }
   
       case AGSA_SAS_PHY_GENERAL_STATUS_PAGE:
       {
         SA_DBG1(("saGetPhyProfile: AGSA_SAS_PHY_GENERAL_STATUS_PAGE\n" ));
         ret = mpiGetPhyProfileCmd( agRoot,agContext,ppc ,phyId,agCB);
         break;
       }
       case AGSA_PHY_SNW3_PAGE:
       {
         SA_DBG1(("saGetPhyProfile: AGSA_PHY_SNW3_PAGE\n" ));
         ret = mpiGetPhyProfileCmd( agRoot,agContext,ppc ,phyId,agCB);
         break;
       }
       case AGSA_PHY_RATE_CONTROL_PAGE:
       {
         SA_DBG1(("saGetPhyProfile: AGSA_PHY_RATE_CONTROL_PAGE\n" ));
         ret = mpiGetPhyProfileCmd( agRoot,agContext,ppc ,phyId,agCB);
         break;
       }
       case AGSA_SAS_PHY_OPEN_REJECT_RETRY_BACKOFF_THRESHOLD_PAGE:
       {
         SA_DBG1(("saGetPhyProfile: AGSA_SAS_PHY_OPEN_REJECT_RETRY_BACKOFF_THRESHOLD_PAGE\n" ));
         ret = mpiGetPhyProfileCmd( agRoot,agContext,ppc ,phyId,agCB);
         break;
       }
   
       default:
         SA_DBG1(("saGetPhyProfile: Unknown operation 0x%X\n",ppc ));
         SA_ASSERT(agFALSE, "saGetPhyProfile Unknown operation " );
         break;
   
     }
     return ret;
   
   }
   
   
   GLOBAL bit32 saSetPhyProfile (
                         agsaRoot_t    *agRoot,
                         agsaContext_t *agContext,
                         bit32         queueNum,
                         bit32         ppc,
                         bit32         length,
                         void          *buffer,
                         bit32         phyID
                         )
   {
     bit32 ret = AGSA_RC_SUCCESS;
   
     SA_DBG1(("saSetPhyProfile: ppc 0x%x length 0x%x phyID %d\n", ppc,length,phyID));
   
     switch(ppc)
     {
       case AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE:
       {
         SA_DBG1(("saSetPhyProfile: AGSA_SAS_PHY_ANALOG_SETTINGS_PAGE\n" ));
         ret = mpiSetPhyProfileCmd( agRoot,agContext,ppc ,phyID,length,buffer);
         break;
       }
       case AGSA_PHY_SNW3_PAGE:
       {
         SA_DBG1(("saSetPhyProfile: AGSA_PHY_SNW3_PAGE\n" ));
         ret = mpiSetPhyProfileCmd( agRoot,agContext,ppc ,phyID,length,buffer);
         break;
       }
       case AGSA_PHY_RATE_CONTROL_PAGE:
       {
         SA_DBG1(("saSetPhyProfile: AGSA_PHY_RATE_CONTROL_PAGE\n" ));
         ret = mpiSetPhyProfileCmd( agRoot,agContext,ppc ,phyID,length,buffer);
         break;
       }
       case AGSA_SAS_PHY_MISC_PAGE:
       {
         SA_DBG1(("saSetPhyProfile: AGSA_SAS_PHY_MISC_PAGE\n"));
         ret = mpiSetPhyProfileCmd( agRoot,agContext,ppc ,phyID,length,buffer);
         break;
       }
   
       default:
         SA_DBG1(("saSetPhyProfile: Unknown operation 0x%X\n",ppc ));
         SA_ASSERT(agFALSE, "saSetPhyProfile Unknown operation " );
         ret = AGSA_RC_FAILURE;
         break;
     }
     return ret;
   }
   
   
   /******************************************************************************/
   /*! \brief Initiate a HW Event Ack command
    *
    *  This function is called to initiate a HW Event Ack command to the SPC.
    *  The completion of this function is reported in ossaHwEventAckCB().
    *
    *  \param agRoot      handles for this instance of SAS/SATA hardware
    *  \param agContext   the context of this API
    *  \param queueNum    queue number
    *  \param eventSource point to the event source structure
    *  \param param0
    *  \param param1
    *
   *  \return
   *          - none
   */
  /*******************************************************************************/
  GLOBAL bit32 saHwEventAck(
                        agsaRoot_t        *agRoot,
                        agsaContext_t     *agContext,
                        bit32             queueNum,
                        agsaEventSource_t *eventSource,
                        bit32             param0,
                        bit32             param1
                        )
  {
    agsaLLRoot_t           *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
    agsaIORequestDesc_t    *pRequest;
    agsaPortContext_t      *agPortContext;
    agsaPort_t             *pPort = agNULL;
    agsaSASHwEventAckCmd_t payload;
    bit32                  phyportid;
    bit32                  ret = AGSA_RC_SUCCESS;
    bit32                  using_reserved = agFALSE;
  
    smTraceFuncEnter(hpDBG_VERY_LOUD,"7e");
  
    /* sanity check */
    SA_ASSERT((agNULL != saRoot), "");
    if(saRoot == agNULL)
    {
      SA_DBG1(("saHwEventAck: saRoot == agNULL\n"));
      return(AGSA_RC_FAILURE);
    }
  
    SA_DBG2(("saHwEventAck: agContext %p eventSource %p\n", agContext, eventSource));
    SA_DBG1(("saHwEventAck: event 0x%x param0 0x%x param1 0x%x\n", eventSource->event, param0, param1));
  
    agPortContext = eventSource->agPortContext;
  
    /* Get request from free IORequests */
    ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
    pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests)); /**/
  
    /* If no LL Control request entry available */
    if ( agNULL == pRequest )
    {
      pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeReservedRequests)); /**/
      if(agNULL != pRequest)
      {
        using_reserved = agTRUE;
        SA_DBG1(("saHwEventAck, using saRoot->freeReservedRequests\n"));
      }
      else
      {
        ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
        /* If no LL Control request entry available */
        SA_DBG1(("saHwEventAck, No request from free list Not using saRoot->freeReservedRequests\n"));
        smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "7e");
        return AGSA_RC_BUSY;
      }
    }
    if( using_reserved )
    {
      saLlistIORemove(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
    }
    else
    {
      /* Remove the request from free list */
      saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
    }
    ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
    SA_ASSERT((!pRequest->valid), "The pRequest is in use");
  
    SA_DBG2(("saHwEventAck: queueNum 0x%x HTag 0x%x\n",queueNum ,pRequest->HTag));
  
    saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
    saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
    saRoot->IOMap[pRequest->HTag].agContext = agContext;
    pRequest->valid = agTRUE;
  
    /* build IOMB command and send to SPC */
    /* set payload to zeros */
    si_memset(&payload, 0, sizeof(agsaSASHwEventAckCmd_t));
  
    /* find port id */
    if (agPortContext)
    {
      pPort = (agsaPort_t *) (agPortContext->sdkData);
      if (pPort)
      {
        if(eventSource->event == OSSA_HW_EVENT_PHY_DOWN)
        {
          pPort->tobedeleted = agTRUE;
        }
        SA_DBG3(("saHwEventAck,pPort->portId %X\n",pPort->portId));
  
        if(smIS_SPC(agRoot))
        {
          /* fillup PORT_ID field */
          phyportid = pPort->portId & 0xF;
        }
        else
        {
          /* fillup PORT_ID field */
          phyportid = pPort->portId & 0xFF;
  
        }
      }
      else
      {
        /*  pPort is NULL - set PORT_ID to not intialized  */
        if(smIS_SPC(agRoot))
        {
          phyportid = 0xF;
        }
        else
        {
          phyportid = 0xFF;
        }
      }
    }
    else
    {
      /* agPortContext is NULL - set PORT_ID to not intialized  */
      if(smIS_SPC(agRoot))
      {
        phyportid = 0xF;
      }
      else
      {
        phyportid = 0xFF;
      }
    }
  
    pRequest->pPort = pPort;
  
    SA_DBG3(("saHwEventAck,eventSource->param 0x%X\n",eventSource->param));
    SA_DBG3(("saHwEventAck,eventSource->event 0x%X\n",eventSource->event));
  
    if(smIS_SPC(agRoot))
    {
      /* fillup up PHY_ID */
      phyportid |= ((eventSource->param & 0x0000000F) << 4);
      /* fillup SEA field */
      phyportid |= (eventSource->event & 0x0000FFFF) << 8;
      SA_DBG3(("saHwEventAck: portId 0x%x phyId 0x%x SEA 0x%x\n", phyportid & 0xF,
        eventSource->param & 0x0000000F, eventSource->event & 0x0000FFFF));
    }
    else
    {
      /* fillup up PHY_ID */
      phyportid |= ((eventSource->param & 0x000000FF) << SHIFT24);
      /* fillup SEA field */
      phyportid |= (eventSource->event & 0x00FFFFFF) << SHIFT8;
      SA_DBG3(("saHwEventAck: portId 0x%x phyId 0x%x SEA 0x%x\n", phyportid & 0xFF,
        eventSource->param & 0x0000000F, eventSource->event & 0x0000FFFF));
    }
  
    pRequest->HwAckType =  (bit16)phyportid;
  
    SA_DBG1(("saHwEventAck,phyportid 0x%X HwAckType 0x%X\n",phyportid,pRequest->HwAckType));
    /* set tag */
    OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASHwEventAckCmd_t, tag), pRequest->HTag);
    OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASHwEventAckCmd_t, sEaPhyIdPortId), phyportid);
    OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASHwEventAckCmd_t, Param0), param0);
    OSSA_WRITE_LE_32(agRoot, &payload, OSSA_OFFSET_OF(agsaSASHwEventAckCmd_t, Param1), param1);
  
    /* build IOMB command and send to SPC */
  
    if(smIS_SPC(agRoot))
    {
      ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_SPC_SAS_HW_EVENT_ACK, IOMB_SIZE64, queueNum);
    }
    else
    {
      ret = mpiBuildCmd(agRoot, (bit32 *)&payload, MPI_CATEGORY_SAS_SATA, OPC_INB_SAS_HW_EVENT_ACK, IOMB_SIZE64, queueNum);
    }
  
    if (AGSA_RC_SUCCESS != ret)
    {
      /* remove the request from IOMap */
      saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
      saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
      saRoot->IOMap[pRequest->HTag].agContext = agNULL;
      pRequest->valid = agFALSE;
  
      ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
      /* return the request to free pool */
      if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
      {
        SA_DBG1(("saHwEventAck: saving pRequest (%p) for later use\n", pRequest));
        saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
      }
      else
      {
        /* return the request to free pool */
        saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
      }
      ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
      SA_DBG1(("saHwEventAck, sending IOMB failed\n" ));
    }
    smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "7e");
  
    return ret;
  }
  
  
  GLOBAL bit32 saVhistCapture(
                            agsaRoot_t    *agRoot,
                            agsaContext_t *agContext,
                            bit32         queueNum,
                            bit32         Channel,
                            bit32         NumBitLo,
                            bit32         NumBitHi,
                            bit32         PcieAddrLo,
                            bit32         PcieAddrHi,
                            bit32         ByteCount )
  {
  
    agsaLLRoot_t        *saRoot = (agsaLLRoot_t *)(agRoot->sdkData);
    agsaIORequestDesc_t *pRequest;
    bit32               ret = AGSA_RC_SUCCESS;
    bit32               using_reserved = agFALSE;
  
    smTraceFuncEnter(hpDBG_VERY_LOUD,"3N");
  
    /* sanity check */
    SA_ASSERT((agNULL != agRoot), "");
  
    SA_DBG1(("saVhistCapture:Channel 0x%08X 0x%08X%08X 0x%08X%08X  count 0x%X\n",Channel, NumBitHi, NumBitLo ,PcieAddrHi,PcieAddrLo,ByteCount));
  
    {
      /* Get request from free IORequests */
      ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
      pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeIORequests)); /* */
      /* If no LL Control request entry available */
      if ( agNULL == pRequest )
      {
        pRequest = (agsaIORequestDesc_t *)saLlistIOGetHead(&(saRoot->freeReservedRequests));
        /* If no LL Control request entry available */
        if(agNULL != pRequest)
        {
          using_reserved = agTRUE;
          SA_DBG1((", using saRoot->freeReservedRequests\n"));
        }
        else
        {
          ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
          SA_DBG1(("saVhistCapture: No request from free list Not using saRoot->freeReservedRequests\n"));
          smTraceFuncExit(hpDBG_VERY_LOUD, 'a', "3N");
          return AGSA_RC_BUSY;
        }
      }
      SA_ASSERT((!pRequest->valid), "The pRequest is in use");
      pRequest->valid = agTRUE;
      /* If LL Control request entry avaliable */
      if( using_reserved )
      {
        saLlistIORemove(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
      }
      else
      {
        /* Remove the request from free list */
        saLlistIORemove(&(saRoot->freeIORequests), &(pRequest->linkNode));
      }
      ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
  
      saRoot->IOMap[pRequest->HTag].Tag = pRequest->HTag;
      saRoot->IOMap[pRequest->HTag].IORequest = (void *)pRequest;
      saRoot->IOMap[pRequest->HTag].agContext = agContext;
      pRequest->valid = agTRUE;
  
      /* Build the VhisCapture IOMB command and send to SPCv */
  
      ret = mpiVHistCapCmd(agRoot,agContext, queueNum, Channel, NumBitLo, NumBitHi ,PcieAddrLo, PcieAddrHi, ByteCount);
      if (AGSA_RC_SUCCESS != ret)
      {
        /* remove the request from IOMap */
        saRoot->IOMap[pRequest->HTag].Tag = MARK_OFF;
        saRoot->IOMap[pRequest->HTag].IORequest = agNULL;
        saRoot->IOMap[pRequest->HTag].agContext = agNULL;
        pRequest->valid = agFALSE;
  
        ossaSingleThreadedEnter(agRoot, LL_IOREQ_LOCKEQ_LOCK);
        /* return the request to free pool */
        if(saLlistIOGetCount(&(saRoot->freeReservedRequests)) < SA_RESERVED_REQUEST_COUNT)
        {
          SA_DBG1(("saPhyStart: saving pRequest (%p) for later use\n", pRequest));
          saLlistIOAdd(&(saRoot->freeReservedRequests), &(pRequest->linkNode));
        }
        else
        {
          /* return the request to free pool */
          saLlistIOAdd(&(saRoot->freeIORequests), &(pRequest->linkNode));
        }
        ossaSingleThreadedLeave(agRoot, LL_IOREQ_LOCKEQ_LOCK);
        SA_DBG1(("saVhistCapture: sending IOMB failed\n" ));
      }
    }
  
    smTraceFuncExit(hpDBG_VERY_LOUD, 'b', "3N");
  
    return ret;
  }
  

Cache object: e5c44520fb23e2f918847e1174e98ff8