FreeBSD/Linux Kernel Cross Reference
sys/dev/pms/RefTisa/tisa/sassata/common/tdint.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
     *
     *
     * This file contains interrupt related functions in the SAS/SATA TD layer
     *
     */
    #include <sys/cdefs.h>
    __FBSDID("$FreeBSD$");
    #include <dev/pms/config.h>
    
    #include <dev/pms/freebsd/driver/common/osenv.h>
    #include <dev/pms/freebsd/driver/common/ostypes.h>
    #include <dev/pms/freebsd/driver/common/osdebug.h>
    
    #include <dev/pms/RefTisa/sallsdk/api/sa.h>
    #include <dev/pms/RefTisa/sallsdk/api/saapi.h>
    #include <dev/pms/RefTisa/sallsdk/api/saosapi.h>
    
    #include <dev/pms/RefTisa/tisa/api/titypes.h>
    #include <dev/pms/RefTisa/tisa/api/ostiapi.h>
    #include <dev/pms/RefTisa/tisa/api/tiapi.h>
    #include <dev/pms/RefTisa/tisa/api/tiglobal.h>
    
    #ifdef FDS_SM
    #include <dev/pms/RefTisa/sat/api/sm.h>
    #include <dev/pms/RefTisa/sat/api/smapi.h>
    #include <dev/pms/RefTisa/sat/api/tdsmapi.h>
    #endif
    
    #ifdef FDS_DM
    #include <dev/pms/RefTisa/discovery/api/dm.h>
    #include <dev/pms/RefTisa/discovery/api/dmapi.h>
    #include <dev/pms/RefTisa/discovery/api/tddmapi.h>
    #endif
    
    #include <dev/pms/RefTisa/tisa/sassata/sas/common/tdtypes.h>
    #include <dev/pms/freebsd/driver/common/osstring.h>
    #include <dev/pms/RefTisa/tisa/sassata/common/tdutil.h>
    
    #ifdef INITIATOR_DRIVER
    #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdtypes.h>
    #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itddefs.h>
    #include <dev/pms/RefTisa/tisa/sassata/sas/ini/itdglobl.h>
    #endif
    
    #ifdef TARGET_DRIVER
    #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdglobl.h>
    #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdxchg.h>
    #include <dev/pms/RefTisa/tisa/sassata/sas/tgt/ttdtypes.h>
    #endif
    
    #include <dev/pms/RefTisa/tisa/sassata/common/tdsatypes.h>
    #include <dev/pms/RefTisa/tisa/sassata/common/tdproto.h>
    
    /*****************************************************************************
    *! \biref  tiCOMInterruptHandler
    *
    *  Purpose: This function is called to service the hardware interrupt of the
    *           hardware.
    *
    *  \param tiRoot:   Pointer to initiator specific root data structure  for this
    *                   instance of the driver.
    *
    *  \param channelNum: The zero-base channel number of the controller.
    *                     0xFFFFFFFF indicates that the OS-App Specific layer does 
    *                     not provide the channel number. The TD/LL Layer needs to 
    *                     discover of any of its own channels that are causing the 
    *                     interrupt.
    *
    *  \return None
    *
    *  \note - The only thing that this API will do is to acknowledge and mask
    *          the necessary hardware interrupt register. The actual processing
    *          of the interrupt handler is done in tiCOMDelayedInterruptHandler().
    *
    *****************************************************************************/
    FORCEINLINE bit32 
   tiCOMInterruptHandler(
                         tiRoot_t * tiRoot,
                         bit32      channelNum)
   {
     tdsaRoot_t      *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
     tdsaContext_t   *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
     agsaRoot_t      *agRoot = &(tdsaAllShared->agRootNonInt);
     bit32           interruptPending = agFALSE;
   
     interruptPending = saInterruptHandler(agRoot, channelNum);
     
     return interruptPending;
     
   } /* tiCOMInterruptHandler() */
   
   
   /*****************************************************************************
   *! \brief tiCOMDelayedInterruptHandler
   *
   *  Purpose: This function is called to process the task associated with the
   *           interrupt handler. The task that this handler needs to do includes:
   *           completion of I/O, login event, error event, etc
   *
   *  \param tiRoot:     Pointer to initiator specific root data structure for
   *                     this instance of the driver.
   *  \param channelNum: The zero-base channel number of the controller.
   *                     0xFFFFFFFF indicates that the OS-App Specific layer does 
   *                     not provide the channel number. The TD/LL Layer needs to 
   *                     discover of any of its own channels that are causing the 
   *                     interrupt.
   *  \param count:      Count on how many items (such as IO completion) need to
   *                     be processed in this context.
   *  \param interruptContext: The thread/process context within which this 
   *                           function is called.
   *
   *             tiInterruptContext:     this function is called within an
   *                                     interrupt context.
   *             tiNonInterruptContext:  this function is called outside an
   *                                     interrupt context.
   *  \return None
   *
   *****************************************************************************/
   FORCEINLINE 
   bit32 
   tiCOMDelayedInterruptHandler(
                                tiRoot_t  *tiRoot,
                                bit32     channelNum,
                                bit32     count, 
                                bit32     context
                                )
   {
     tdsaRoot_t      *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
     tdsaContext_t   *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
     agsaRoot_t      *agRoot = agNULL;
     bit32            completed = 0;
   
     TDSA_OUT_ENTER(tiRoot);
   
     if(context == tiInterruptContext)
     {
       agRoot = &(tdsaAllShared->agRootInt);
     }
     else
     {
       agRoot = &(tdsaAllShared->agRootNonInt);
     }
   
     completed = saDelayedInterruptHandler(agRoot, channelNum, count);
   
     if(completed == 0)
     {
       TI_DBG3(("tiCOMDelayedInterruptHandler: processedMsgCount zero\n"));
     }
   
     
     TDSA_OUT_LEAVE(tiRoot);
   
     return(completed);
   } /* tiCOMDelayedInterruptHandler() */
   
   
   /*****************************************************************************
   *! \brief tiCOMSystemInterruptsActive
   *
   *  Purpose: This function is called to indicate whether interrupts are 
   *           active or not from this point in time.
   *
   *  \param tiRoot:        Pointer to initiator specific root data structure for
   *                        this instance of the driver.
   *  \param sysIntsActive: Boolean value either true or false
   *
   *  \return None
   *
   *****************************************************************************/
   osGLOBAL void
   tiCOMSystemInterruptsActive(
                               tiRoot_t * tiRoot, 
                               bit32 sysIntsActive
                               )
   {
   
     tdsaRoot_t     *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
     tdsaContext_t  *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
     agsaRoot_t     *agRoot;
     agRoot = &(tdsaAllShared->agRootNonInt);
   
   #ifdef SPC_POLLINGMODE
     if(sysIntsActive)  return;
   #endif /* SPC_POLLINGMODE */
   
     tdsaAllShared->flags.sysIntsActive = sysIntsActive;
   
     TI_DBG6(("tiCOMSystemInterruptsActive: start\n"));
     /* enable low level interrupts */
     if(agRoot->sdkData != agNULL)
     {
       saSystemInterruptsActive(
                                agRoot, 
                                (agBOOLEAN) tdsaAllShared->flags.sysIntsActive
                                );
     }
     
     TI_DBG6(("tiCOMSystemInterruptsActive: end\n"));
   } /* tiCOMSystemInterruptsActive */
   
   
   osGLOBAL void
   tiComCountActiveIORequests(
                               tiRoot_t * tiRoot 
                             )
   {
     tdsaRoot_t     *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
     tdsaContext_t  *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
     agsaRoot_t     *agRoot;
     agRoot = &(tdsaAllShared->agRootNonInt);
     saCountActiveIORequests(agRoot );
   }
   
   /*****************************************************************************
   *! \brief tiCOMInterruptEnable
   *
   *  Purpose: This function is called to enable an interrupts on the specified channel 
   *           active or not from this point in time.
   *
   *  \param tiRoot:        Pointer to initiator specific root data structure for
   *                        this instance of the driver.
   *  \param : channelNum   vector number for MSIX  Zero for legacy interrupt 
   *
   *  \return None
   *
   *****************************************************************************/
   osGLOBAL FORCEINLINE 
   void
   tiCOMInterruptEnable(
                         tiRoot_t * tiRoot,
                         bit32      channelNum)
   {
     tdsaRoot_t     *tdsaRoot = (tdsaRoot_t *) tiRoot->tdData;
     tdsaContext_t  *tdsaAllShared = (tdsaContext_t *)&(tdsaRoot->tdsaAllShared);
     agsaRoot_t     *agRoot;
     agRoot = &(tdsaAllShared->agRootNonInt);
   
     saSystemInterruptsEnable(agRoot, channelNum);
   }

Cache object: 357302cb0ade03e83a38a2c9413efd42