ft2004_km02_vxworks/vxbFtSpi.c

#include <vxWorks.h>
#include <vsbConfig.h>
#include <intLib.h>
#include <stdlib.h>
#include <string.h>
#include <semLib.h>
#include <taskLib.h>
#include <stdio.h>
#include <vxbTimerLib.h>
#include <cacheLib.h>
#include <hwif/util/hwMemLib.h>
#include <hwif/util/vxbParamSys.h>
#include <hwif/vxbus/vxBus.h>
#include <hwif/vxbus/vxbPlbLib.h>
#include <../src/hwif/h/vxbus/vxbAccess.h>
#include <hwif/vxbus/vxbSpiLib.h>
#include "vxbFtSpi.h"

/* debug macro */
#undef  SPI_DBG_ON
#ifdef  SPI_DBG_ON

#undef  LOCAL
#define LOCAL

#define SPI_DBG_OFF            0x00000000
#define SPI_DBG_ISR            0x00000001
#define SPI_DBG_RW             0x00000002
#define SPI_DBG_ERR            0x00000004
#define SPI_DBG_RTN            0x00000008
#define SPI_DBG_INFO           0x00000010
#define SPI_DBG_ALL            0xffffffff

LOCAL UINT32 spiDbgMask =  SPI_DBG_ALL;
IMPORT FUNCPTR _func_logMsg;

#define SPI_DBG(mask, string, X1, X2, X3, X4, X5, X6)           \
    if ((spiDbgMask & mask) || (mask == SPI_DBG_ALL))           \
        if (_func_logMsg != NULL)                               \
            (* _func_logMsg)(string, (int)X1, (int)X2, (int)X3, \
                             (int)X4, (int)X5, (int)X6)
#else
#define SPI_DBG(mask, string, X1, X2, X3, X4, X5, X6)
#endif  /* SPI_DBG_ON */

#if _BYTE_ORDER == _BIG_ENDIAN
#    define SPI_REG_HANDLE_SWAP(x) VXB_HANDLE_SWAP(x)
#else
#    define SPI_REG_HANDLE_SWAP(x) (x)
#endif /* _BYTE_ORDER == _BIG_ENDIAN */

/* VxBus methods */
LOCAL void vxbFtSpiInstInit (VXB_DEVICE_ID pDev);
LOCAL void vxbFtSpiInstInit2 (VXB_DEVICE_ID pDev);
LOCAL void vxbFtSpiInstConnect (VXB_DEVICE_ID pDev);
LOCAL VXB_SPI_BUS_CTRL * vxbFtSpiCtrlGet (VXB_DEVICE_ID pDev);
LOCAL void vxbFtSpiShow (VXB_DEVICE_ID, int);
LOCAL STATUS vxbFtSpiInstUnlink (VXB_DEVICE_ID pDev, void * unused);

/* forward declarations */
LOCAL STATUS vxbFtSpiTransfer (VXB_DEVICE_ID pDev, SPI_HARDWARE * pSpiDev,
                                  SPI_TRANSFER * pPkg);
/* locals */
LOCAL struct drvBusFuncs vxbFtSpiVxbFuncs = {
    vxbFtSpiInstInit,      /* devInstanceInit */ 
    vxbFtSpiInstInit2,     /* devInstanceInit2 */
    vxbFtSpiInstConnect    /* devConnect */
};

LOCAL device_method_t vxbFtSpiDeviceMethods[] = {
    DEVMETHOD (vxbSpiControlGet, vxbFtSpiCtrlGet),
    DEVMETHOD (busDevShow,       vxbFtSpiShow),
    DEVMETHOD (vxbDrvUnlink,     vxbFtSpiInstUnlink),
    DEVMETHOD_END
};

LOCAL struct vxbPlbRegister vxbFtSpiDevRegistration = {
    {
    NULL,                       /* pNext */
    VXB_DEVID_DEVICE,           /* devID */
    VXB_BUSID_PLB,              /* busID = PLB */
    VXB_VER_4_0_0,              /* vxbVersion */
    FT_SPI_NAME,                /* drvName */
    &vxbFtSpiVxbFuncs,          /* pDrvBusFuncs */
    &vxbFtSpiDeviceMethods[0],  /* pMethods */
    NULL,                       /* devProbe  */
    NULL,                       /* pParamDefaults */
    },
};

/*
 *
 * vxbFtSpiRegister - register with the VxBus subsystem
 *
 * This routine registers the SPI driver with VxBus Systems.
 *
 * RETURNS: N/A
 *
 * ERRNO: N/A
 */
void vxbFtSpiRegister (void)
{
    vxbDevRegister ((struct vxbDevRegInfo *) &vxbFtSpiDevRegistration);    
}

/*
 *
 * vxbFtSpiInstInit - initialize SPI controller
 *
 * This function implements the VxBus instInit handler for a SPI controller
 * device instance.
 *
 * Initialize the device by the following:
 *
 * - retrieve the resource from the hwconf
 * - per-device init
 * - announce SPI Bus and create device instance
 *
 * RETURNS: N/A
 *
 * ERRNO: N/A
 */
LOCAL void vxbFtSpiInstInit(VXB_DEVICE_ID pDev)
{
    FT_SPI_CTRL * pDrvCtrl;
    struct hcfDevice *pHcf;
    int i;
    
    /* check for valid parameter */
    VXB_ASSERT_NONNULL_V (pDev);
    
    /* create controller driver context structure for core */
    pDrvCtrl = (FT_SPI_CTRL *) hwMemAlloc (sizeof (FT_SPI_CTRL));
    if (pDrvCtrl == NULL) {
        return;
    }
    pDev->pDrvCtrl = pDrvCtrl;
    pDrvCtrl->pDev = pDev;
    
    for (i = 0; i < VXB_MAXBARS; i++) {
        if (pDev->regBaseFlags[i] == VXB_REG_MEM) {
            break;
        }
    }
    if (i == VXB_MAXBARS) {
#ifndef _VXBUS_BASIC_HWMEMLIB
        hwMemFree((char *)pDrvCtrl);
#endif
        pDev->pDrvCtrl = NULL;
        return;
    }
    pDrvCtrl->regBase = pDev->pRegBase[i];
    vxbRegMap(pDev, i, &pDrvCtrl->regHandle);
    pDrvCtrl->regHandle = (void *)SPI_REG_HANDLE_SWAP ((ULONG)pDrvCtrl->regHandle);
    pHcf = (struct hcfDevice *) hcfDeviceGet (pDev);
    if (pHcf == NULL) {
#ifndef _VXBUS_BASIC_HWMEMLIB
        hwMemFree((char *)pDrvCtrl);
#endif
        pDev->pDrvCtrl = NULL;
        return;
    }
    
    if (devResourceGet (pHcf, "clkDiv", HCF_RES_INT,(void *) &pDrvCtrl->clkDiv) != OK) {
        pDrvCtrl->clkDiv = 2;
    }
    
    if (devResourceGet (pHcf, "spiDevNum", HCF_RES_INT, (void *) &pDrvCtrl->spiDevNum) != OK) {
        pDrvCtrl->spiDevNum = 0;
    }
    
    pDrvCtrl->vxbSpiCtrl.spiTransfer = (void *)vxbFtSpiTransfer;
    
    /* announce that there's a SPI bus */
    (void) vxbBusAnnounce (pDev, VXB_BUSID_SPI);
 
    /* notify the bus subsystem of all devices on SPI */
    (void) spiBusAnnounceDevices (pDev); 
    
    pDrvCtrl->initPhase = 1;
}

/*
 *
 * vxbFtSpiInstInit2 - second level initialization routine of SPI controller
 *
 * This routine performs the second level initialization of the SPI controller.
 *
 * RETURNS: N/A
 *
 * ERRNO: N/A
 */
LOCAL void vxbFtSpiInstInit2(VXB_DEVICE_ID pDev)
{
    FT_SPI_CTRL * pDrvCtrl;

    /* check for valid parameter */

    VXB_ASSERT_NONNULL_V (pDev);

    pDrvCtrl = (FT_SPI_CTRL *) pDev->pDrvCtrl;

    /* used for mutex accessing of the controller */
    pDrvCtrl->muxSem = semMCreate (SEM_Q_PRIORITY);

    if (pDrvCtrl->muxSem == NULL) {
        SPI_DBG (SPI_DBG_ERR, "semMCreate failed for muxSem\n",
                 0, 0, 0, 0, 0, 0);
        return;
    }

    pDrvCtrl->initPhase = 2;
}

/*
 *
 * vxbFtSpiInstConnect - third level initialization
 *
 * This routine performs the third level initialization of the QSPI controller
 * driver.
 *
 * RETURNS: N/A
 *
 * ERRNO : N/A
 */
LOCAL void vxbFtSpiInstConnect(VXB_DEVICE_ID pDev)
{
    FT_SPI_CTRL * pDrvCtrl;

    pDrvCtrl = pDev->pDrvCtrl;
    pDrvCtrl->initPhase = 3;
}

/*
 *
 * vxbFtSpiCtrlGet - get the SPI controller struct
 *
 * This routine returns the QSPI controller struct pointer (VXB_SPI_BUS_CTRL *)
 * to caller (SPI Lib) by vxbSpiControlGet method. Currently, this struct
 * only contain the spiTransfer routine(eg: vxbFtQspiTransfer) for SPI Lib,
 * other parameters can be easily added in this struct.
 *
 * RETURNS: the pointer of SPI controller struct
 *
 * ERRNO: N/A
 */
LOCAL VXB_SPI_BUS_CTRL * vxbFtSpiCtrlGet(VXB_DEVICE_ID pDev)
{
    FT_SPI_CTRL * pDrvCtrl;

    /* check if the pDev pointer is valid */
    VXB_ASSERT (pDev != NULL, NULL)

    pDrvCtrl = (FT_SPI_CTRL *) pDev->pDrvCtrl;

    SPI_DBG (SPI_DBG_RTN, "vxbFtQspiCtrlGet(0x08%x) called\n",
            (_Vx_usr_arg_t)pDev, 2, 3, 4, 5, 6);

    return (&(pDrvCtrl->vxbSpiCtrl));
}

/*
 *
 * vxbFtSpiTransfer - SPI transfer routine
 *
 * This routine is used to perform one transmission. It is the interface which 
 * can be called by SPI device driver to send and receive data via the QSPI 
 * controller.
 *
 * RETURNS: OK or ERROR
 *
 * ERRNO: N/A
 */
LOCAL STATUS vxbFtSpiTransfer(
    VXB_DEVICE_ID       pDev,           /* controller pDev */
    SPI_HARDWARE *      pSpiDev,        /* device info */
    SPI_TRANSFER *      pPkg            /* transfer data info */
)
{
    STATUS              sts = OK;
    UINT32              cmd;
    UINT32              alignSize;
    FT_SPI_CTRL * pDrvCtrl;
    /* check if the pointers are valid */

    if (pDev == NULL || pSpiDev == NULL || pPkg == NULL || pSpiDev->devInfo == NULL) {
        SPI_DBG (SPI_DBG_ERR, "vxbFtQspiTransfer NULL pointer\n",
                 1, 2, 3, 4, 5, 6);
        return ERROR;
    }

    pDrvCtrl = (FT_SPI_CTRL *) pDev->pDrvCtrl;
    if (pDrvCtrl == NULL) {
        SPI_DBG (SPI_DBG_ERR, "vxbFtQspiTransfer pDrvCtrl is NULL\n",
                 1, 2, 3, 4, 5, 6);
        return ERROR;
    }

    SPI_DBG (SPI_DBG_RTN, "vxbFtQspiTransfer txLen[%d] rxLen[%d]\n",
             pPkg->txLen, pPkg->rxLen, 3, 4, 5, 6);

    if (pPkg->txLen == 0 && pPkg->rxLen == 0) {
        SPI_DBG (SPI_DBG_ERR, "vxbFtQspiTransfer tx and rx both are 0\n",
                 1, 2, 3, 4, 5, 6);
        return ERROR;
    }

    if ((pPkg->txLen != 0 && pPkg->txBuf == NULL ) || (pPkg->rxLen != 0 && pPkg->rxBuf == NULL)) {
        SPI_DBG (SPI_DBG_ERR,
                 "vxbFtQspiTransfer invalid parameters[%x %x %x %x] \n",
                  pPkg->txBuf, pPkg->txLen, pPkg->rxLen, pPkg->rxBuf, 5, 6);

        return ERROR;
    }

    if (pSpiDev->devInfo->bitWidth <= 8) {     /* 4 to 8 bits */
        alignSize = sizeof(char);
    } else if (pSpiDev->devInfo->bitWidth <= 16) { /* 9 to 16 bits */
        alignSize = sizeof(UINT16);
    } else {   /* 17 to 32 bits */
        SPI_DBG (SPI_DBG_ERR, 
                 "vxbFtQspiTransfer: data word length must between 2-16\n",
                 1, 2, 3, 4, 5, 6);
        return ERROR;
    }

    /* check to see if the address is aligned with SPI bit width */
    if ((pPkg->txLen != 0 && 
        (((UINT32)pPkg->txBuf & (alignSize - 1)) != 0 ||
         (pPkg->txLen & (alignSize - 1)) != 0)) ||
        (pPkg->rxLen != 0 && 
         (((UINT32)pPkg->rxBuf & (alignSize - 1)) != 0 ||
          (pPkg->rxLen & (alignSize - 1)) != 0))) {
        SPI_DBG (SPI_DBG_ERR,
                 "vxbFtQspiTransfer address or len is not aligned:"
                 "[tx:%x-%x rx:%x-%x] with %d \n",
                 pPkg->txBuf, pPkg->txLen, pPkg->rxBuf, pPkg->rxLen, 
                 alignSize, 6);

        return ERROR;
    }

    pDrvCtrl->channel = pSpiDev->devInfo->chipSelect;
    if (pDrvCtrl->channel >= SPI_MAX_CS_NUM) {
        SPI_DBG (SPI_DBG_ERR,
                 "vxbFtQspiTransfer invalid channel[%x] \n",
                 pDrvCtrl->channel, 2, 3, 4, 5, 6);

        return ERROR;
    }

    /*
     * The controller can not be used by multichannel at the same time.
     * If the initPhase < 2, there is no multi-task context. So, the
     * semTake is not needed.
     */
    if (pDrvCtrl->initPhase >= 2) {
        (void)semTake (pDrvCtrl->muxSem, WAIT_FOREVER);
    }

    pDrvCtrl->txBuf  = pPkg->txBuf;
    pDrvCtrl->txLen = pPkg->txLen;
    pDrvCtrl->rxBuf  = pPkg->rxBuf;
    pDrvCtrl->rxLen = pPkg->rxLen;
    cmd = pDrvCtrl->txBuf[0];
 #if 0   
    switch (cmd) {
        case QSPI_FLASH_CMD_RDID:
        case QSPI_FLASH_CMD_RDSR1:          
             vxbFtQspiFlashRegGet(pDev);            
            break;
        case QSPI_FLASH_CMD_4BAM:
            pDrvCtrl->addrMode = QSPI_ADDR_SEL_4;
            /*vxbFtQspiFlashRegSet(pDev);*/
            break;
        case QSPI_FLASH_CMD_4BEX:
            pDrvCtrl->addrMode = QSPI_ADDR_SEL_3;
            /*vxbFtQspiFlashRegSet(pDev);*/
            break;
        case QSPI_FLASH_CMD_WREN:
        case QSPI_FLASH_CMD_WRDI:
        case QSPI_FLASH_CMD_BE: 
        case QSPI_FLASH_CMD_WRR:
             vxbFtQspiFlashRegSet(pDev); 
            break;
        case QSPI_FLASH_CMD_SE:
             if(pDrvCtrl->addrMode == QSPI_ADDR_SEL_4)
             {
                 pDrvCtrl->txBuf[0] = QSPI_FLASH_CMD_4SE;
             }
             vxbFtQspiFlashRegSetWithAddr(pDev);
            break;
        case QSPI_FLASH_CMD_PP:
             if(pDrvCtrl->addrMode == QSPI_ADDR_SEL_4)
             {
                 pDrvCtrl->txBuf[0] = QSPI_FLASH_CMD_4PP;
             }
             vxbFtQspiFlashPageWrite(pDev);
            break;
        case QSPI_FLASH_CMD_READ:
             if(pDrvCtrl->addrMode == QSPI_ADDR_SEL_4)
             {
                 pDrvCtrl->txBuf[0] = QSPI_FLASH_CMD_4READ;
             }
             vxbFtQspiFlashRead(pDev);
            break;          
        default:
            break;
    }
#endif
    printf(" xfer :%x\n",cmd);
    
    if (pPkg->usDelay > 0) {
        vxbUsDelay(pPkg->usDelay);
    }

    if (pDrvCtrl->initPhase >= 2) {
        semGive (pDrvCtrl->muxSem);
    }
    return sts;
}

/*
 *
 * vxbFtSpiShow - show the controller info
 *
 * This function shows the SPI controller's info.
 *
 * RETURNS: N/A
 *
 * ERRNO: N/A
 */
LOCAL void vxbFtSpiShow(VXB_DEVICE_ID pDev,int verbose)
{
    FT_SPI_CTRL * pDrvCtrl;

    /* check for valid parameter */
    VXB_ASSERT_NONNULL_V (pDev);

    pDrvCtrl = (FT_SPI_CTRL *) pDev->pDrvCtrl;

    printf ("         %s unit %d on %s @ %p with busInfo %08p\n",
            pDev->pName,
            pDev->unitNumber,
            vxbBusTypeString (pDev->busID),
            pDev,
            pDev->u.pSubordinateBus);

    if (verbose > 0) {
        printf ("                BAR0 @ 0x%08x (memory mapped)\n",pDev->pRegBase[0]);
        printf ("            pDrvCtrl @ 0x%08x\n", pDev->pDrvCtrl);
        printf ("           initPhase : %u\n",  pDrvCtrl->initPhase);
        printf ("              clkDiv : %u\n",  pDrvCtrl->clkDiv);
        printf ("           spiDevNum : %u\n",  pDrvCtrl->spiDevNum);
    }
}

/*
 *
 * vxbFtSpiInstUnlink - VxBus unlink handler
 *
 * This function shuts down a SPI controller instance in response to an
 * an unlink event from VxBus. This may occur if our VxBus instance has
 * been terminated, or if the SPI driver has been unloaded.
 *
 * RETURNS: OK if device was successfully destroyed, otherwise ERROR
 *
 * ERRNO: N/A
 */
LOCAL STATUS vxbFtSpiInstUnlink(VXB_DEVICE_ID pDev, void * unused)
{
    FT_SPI_CTRL * pDrvCtrl;

    /* check if the pDev pointer is valid */
    VXB_ASSERT (pDev != NULL, ERROR)

    pDrvCtrl = (FT_SPI_CTRL *) pDev->pDrvCtrl;

    /*
     * The semaphore and interrupt resource are released here . The 
     * semaphore was created at phase 2 and interrupt was installed
     * at phase 3.
     */

    if (pDrvCtrl->initPhase >= 2) {
        (void)semTake (pDrvCtrl->muxSem, WAIT_FOREVER);

        (void) semDelete (pDrvCtrl->muxSem);
        pDrvCtrl->muxSem = NULL;
    }

#ifndef _VXBUS_BASIC_HWMEMLIB
    hwMemFree ((char *) pDrvCtrl);
#endif  /* _VXBUS_BASIC_HWMEMLIB */

    pDev->pDrvCtrl = NULL;
    pDrvCtrl->initPhase = 0;

    return (OK);
}