|
|
|
@ -15,7 +15,24 @@ |
|
|
|
#include <../src/hwif/h/vxbus/vxbAccess.h> |
|
|
|
#include <hwif/vxbus/vxbSpiLib.h> |
|
|
|
#include "vxbFtSpi.h" |
|
|
|
|
|
|
|
#include "ft2000-4.h" |
|
|
|
|
|
|
|
#define CTRLR0 0x0 |
|
|
|
#define CTRLR1 0x4 |
|
|
|
#define SSIENR 0x8 |
|
|
|
#define MWCR 0xc |
|
|
|
#define SER 0x10 |
|
|
|
#define BAUDR 0x14 |
|
|
|
#define TXFTLR 0x18 |
|
|
|
#define RXFTLR 0x1c |
|
|
|
#define TXFLR 0x20 |
|
|
|
#define RXFLR 0x24 |
|
|
|
#define SR 0x28 |
|
|
|
#define IMR 0x2c |
|
|
|
#define ISR 0x30 |
|
|
|
#define DMACR 0x4c |
|
|
|
#define DR 0x60 |
|
|
|
#define RX_SAMPLE_DLY 0xfc |
|
|
|
/* debug macro */ |
|
|
|
#undef SPI_DBG_ON |
|
|
|
#ifdef SPI_DBG_ON |
|
|
|
@ -49,6 +66,30 @@ IMPORT FUNCPTR _func_logMsg; |
|
|
|
# define SPI_REG_HANDLE_SWAP(x) (x) |
|
|
|
#endif /* _BYTE_ORDER == _BIG_ENDIAN */ |
|
|
|
|
|
|
|
/* read write macros */ |
|
|
|
#define VXB_FT_SPI_REG(pChan, reg) \ |
|
|
|
(UINT32 *)((UINT32) ((pChan)->regBase) + (reg)) |
|
|
|
|
|
|
|
#define VXB_FT_SPI_REG16(pChan, reg) \ |
|
|
|
(UINT16 *)((UINT32) ((pChan)->regBase) + (reg)) |
|
|
|
|
|
|
|
#define VXB_FT_SPI_REG8(pChan, reg) \ |
|
|
|
(UINT8 *)((UINT32) ((pChan)->regBase) + (reg)) |
|
|
|
|
|
|
|
#define VXB_FT_SPI_REG_READ(pChan, reg, result) \ |
|
|
|
(result) = vxbRead32 ((pChan)->regHandle, VXB_FT_SPI_REG(pChan, reg)) |
|
|
|
|
|
|
|
#define VXB_FT_SPI_REG_WRITE(pChan, reg, data) \ |
|
|
|
vxbWrite32 ((pChan)->regHandle, VXB_FT_SPI_REG(pChan, reg), (data)) |
|
|
|
|
|
|
|
#define VXB_FT_SPI_REG_BIT_SET(pChan, reg, data) \ |
|
|
|
VXB_FT_SPI_REG_WRITE (pChan, reg, \ |
|
|
|
vxbRead32 ((pChan)->regHandle, VXB_FT_SPI_REG(pChan, reg)) | (data)) |
|
|
|
|
|
|
|
#define VXB_FT_SPI_REG_BIT_CLR(pChan, reg, data) \ |
|
|
|
VXB_FT_SPI_REG_WRITE (pChan, reg, \ |
|
|
|
vxbRead32 ((pChan)->regHandle, VXB_FT_SPI_REG(pChan, reg)) & (~(data))) |
|
|
|
|
|
|
|
/* VxBus methods */ |
|
|
|
LOCAL void vxbFtSpiInstInit (VXB_DEVICE_ID pDev); |
|
|
|
LOCAL void vxbFtSpiInstInit2 (VXB_DEVICE_ID pDev); |
|
|
|
@ -58,6 +99,8 @@ LOCAL void vxbFtSpiShow (VXB_DEVICE_ID, int); |
|
|
|
LOCAL STATUS vxbFtSpiInstUnlink (VXB_DEVICE_ID pDev, void * unused); |
|
|
|
|
|
|
|
/* forward declarations */ |
|
|
|
LOCAL void vxbFtSpiCtrlInit (VXB_DEVICE_ID pDev); |
|
|
|
|
|
|
|
LOCAL STATUS vxbFtSpiTransfer (VXB_DEVICE_ID pDev, SPI_HARDWARE * pSpiDev, |
|
|
|
SPI_TRANSFER * pPkg); |
|
|
|
/* locals */ |
|
|
|
@ -89,7 +132,6 @@ LOCAL struct vxbPlbRegister vxbFtSpiDevRegistration = { |
|
|
|
}; |
|
|
|
|
|
|
|
/*
|
|
|
|
* |
|
|
|
* vxbFtSpiRegister - register with the VxBus subsystem |
|
|
|
* |
|
|
|
* This routine registers the SPI driver with VxBus Systems. |
|
|
|
@ -104,7 +146,6 @@ void vxbFtSpiRegister (void) |
|
|
|
} |
|
|
|
|
|
|
|
/*
|
|
|
|
* |
|
|
|
* vxbFtSpiInstInit - initialize SPI controller |
|
|
|
* |
|
|
|
* This function implements the VxBus instInit handler for a SPI controller |
|
|
|
@ -161,13 +202,28 @@ LOCAL void vxbFtSpiInstInit(VXB_DEVICE_ID pDev) |
|
|
|
return; |
|
|
|
} |
|
|
|
|
|
|
|
if (devResourceGet (pHcf, "clkDiv", HCF_RES_INT,(void *) &pDrvCtrl->clkDiv) != OK) { |
|
|
|
pDrvCtrl->clkDiv = 2; |
|
|
|
if (devResourceGet (pHcf, "clkFreq", HCF_RES_INT,(void *) &pDrvCtrl->clkFreq) != OK) { |
|
|
|
pDrvCtrl->clkFreq = FT2000_SPI_CLK; |
|
|
|
} |
|
|
|
|
|
|
|
if (devResourceGet (pHcf, "speed", HCF_RES_INT,(void *) &pDrvCtrl->speed) != OK) { |
|
|
|
pDrvCtrl->speed = 1000000; |
|
|
|
} |
|
|
|
|
|
|
|
if (devResourceGet (pHcf, "mode", HCF_RES_INT,(void *) &pDrvCtrl->mode) != OK) { |
|
|
|
pDrvCtrl->mode = 0; |
|
|
|
} |
|
|
|
|
|
|
|
if (devResourceGet (pHcf, "dataWidth", HCF_RES_INT,(void *) &pDrvCtrl->dataWidth) != OK) { |
|
|
|
pDrvCtrl->dataWidth = 8; |
|
|
|
} |
|
|
|
|
|
|
|
if (devResourceGet (pHcf, "spiDevNum", HCF_RES_INT, (void *) &pDrvCtrl->spiDevNum) != OK) { |
|
|
|
pDrvCtrl->spiDevNum = 0; |
|
|
|
} |
|
|
|
pDrvCtrl->cs = 0; |
|
|
|
|
|
|
|
vxbFtSpiCtrlInit(pDev); |
|
|
|
|
|
|
|
pDrvCtrl->vxbSpiCtrl.spiTransfer = (void *)vxbFtSpiTransfer; |
|
|
|
|
|
|
|
@ -181,7 +237,6 @@ LOCAL void vxbFtSpiInstInit(VXB_DEVICE_ID pDev) |
|
|
|
} |
|
|
|
|
|
|
|
/*
|
|
|
|
* |
|
|
|
* vxbFtSpiInstInit2 - second level initialization routine of SPI controller |
|
|
|
* |
|
|
|
* This routine performs the second level initialization of the SPI controller. |
|
|
|
@ -213,7 +268,6 @@ LOCAL void vxbFtSpiInstInit2(VXB_DEVICE_ID pDev) |
|
|
|
} |
|
|
|
|
|
|
|
/*
|
|
|
|
* |
|
|
|
* vxbFtSpiInstConnect - third level initialization |
|
|
|
* |
|
|
|
* This routine performs the third level initialization of the QSPI controller |
|
|
|
@ -232,7 +286,6 @@ LOCAL void vxbFtSpiInstConnect(VXB_DEVICE_ID pDev) |
|
|
|
} |
|
|
|
|
|
|
|
/*
|
|
|
|
* |
|
|
|
* vxbFtSpiCtrlGet - get the SPI controller struct |
|
|
|
* |
|
|
|
* This routine returns the QSPI controller struct pointer (VXB_SPI_BUS_CTRL *) |
|
|
|
@ -260,7 +313,89 @@ LOCAL VXB_SPI_BUS_CTRL * vxbFtSpiCtrlGet(VXB_DEVICE_ID pDev) |
|
|
|
} |
|
|
|
|
|
|
|
/*
|
|
|
|
* vxbFtSpiCtrlInit - SPI controller initialization |
|
|
|
* |
|
|
|
* This routine performs the SPI controller initialization. |
|
|
|
* |
|
|
|
* RETURNS: N/A |
|
|
|
* |
|
|
|
* ERRNO: N/A |
|
|
|
*/ |
|
|
|
LOCAL void vxbFtSpiCtrlInit(VXB_DEVICE_ID pDev) |
|
|
|
{ |
|
|
|
FT_SPI_CTRL *pDrvCtrl; |
|
|
|
UINT32 regval, clkDiv; |
|
|
|
|
|
|
|
pDrvCtrl = (FT_SPI_CTRL *) pDev->pDrvCtrl; |
|
|
|
|
|
|
|
/* disable the controller */ |
|
|
|
VXB_FT_SPI_REG_WRITE(pDrvCtrl, SSIENR, 0x0); |
|
|
|
|
|
|
|
/* CTRLR0 */ |
|
|
|
VXB_FT_SPI_REG_READ(pDrvCtrl, CTRLR0, regval); |
|
|
|
|
|
|
|
/* normal mode */ |
|
|
|
regval &= ~(1 << 11); |
|
|
|
|
|
|
|
/* data width */ |
|
|
|
regval &= ~(0xf); |
|
|
|
regval |= (pDrvCtrl->dataWidth - 1) & 0xf; |
|
|
|
|
|
|
|
/*
|
|
|
|
* spi mode mapping: |
|
|
|
* |
|
|
|
* CPOL CPHA |
|
|
|
* 0 0 mode 0 |
|
|
|
* 0 1 mode 1 |
|
|
|
* 1 0 mode 2 |
|
|
|
* 1 1 mode 3 |
|
|
|
*/ |
|
|
|
if (pDrvCtrl->mode & 0x1) { |
|
|
|
regval |= (1 << 6); /* CPHA */ |
|
|
|
} else { |
|
|
|
regval &= ~(1 << 6); |
|
|
|
} |
|
|
|
if (pDrvCtrl->mode & 0x2) { |
|
|
|
regval |= (1 << 7); |
|
|
|
} else { |
|
|
|
regval &= ~(1 << 7); |
|
|
|
} |
|
|
|
/* rx & tx */ |
|
|
|
regval &= ~(0x3 << 8); |
|
|
|
|
|
|
|
/* slv_oe = 1 (slave disable) */ |
|
|
|
regval &= ~(1 << 10); |
|
|
|
|
|
|
|
VXB_FT_SPI_REG_WRITE(pDrvCtrl, CTRLR0, regval); |
|
|
|
|
|
|
|
VXB_FT_SPI_REG_WRITE(pDrvCtrl, CTRLR1, 0); |
|
|
|
|
|
|
|
/* disable DMA */ |
|
|
|
VXB_FT_SPI_REG_WRITE(pDrvCtrl, DMACR, 0); |
|
|
|
|
|
|
|
/* baudrate */ |
|
|
|
clkDiv = pDrvCtrl->clkFreq / pDrvCtrl->speed; |
|
|
|
if (clkDiv < 2) { |
|
|
|
clkDiv = 2; |
|
|
|
} |
|
|
|
|
|
|
|
if (clkDiv > 65534) { |
|
|
|
clkDiv = 65534; |
|
|
|
} |
|
|
|
|
|
|
|
VXB_FT_SPI_REG_WRITE(pDrvCtrl, BAUDR, clkDiv); |
|
|
|
|
|
|
|
VXB_FT_SPI_REG_WRITE(pDrvCtrl, RX_SAMPLE_DLY, 0); |
|
|
|
|
|
|
|
VXB_FT_SPI_REG_WRITE(pDrvCtrl, RXFTLR, 0); |
|
|
|
VXB_FT_SPI_REG_WRITE(pDrvCtrl, TXFTLR, 0); |
|
|
|
|
|
|
|
VXB_FT_SPI_REG_BIT_CLR(pDrvCtrl, IMR, 0x1f); /* disable all interrupts */ |
|
|
|
regval = (1 << pDrvCtrl->cs); |
|
|
|
VXB_FT_SPI_REG_BIT_SET(pDrvCtrl, SER, regval); |
|
|
|
} |
|
|
|
|
|
|
|
/*
|
|
|
|
* vxbFtSpiTransfer - SPI transfer routine |
|
|
|
* |
|
|
|
* This routine is used to perform one transmission. It is the interface which |
|
|
|
@ -278,9 +413,11 @@ LOCAL STATUS vxbFtSpiTransfer( |
|
|
|
) |
|
|
|
{ |
|
|
|
STATUS sts = OK; |
|
|
|
UINT32 cmd; |
|
|
|
UINT32 alignSize; |
|
|
|
FT_SPI_CTRL * pDrvCtrl; |
|
|
|
int i, len; |
|
|
|
UINT8 dummy8; |
|
|
|
UINT16 dummy16, *dptr; |
|
|
|
/* check if the pointers are valid */ |
|
|
|
|
|
|
|
if (pDev == NULL || pSpiDev == NULL || pPkg == NULL || pSpiDev->devInfo == NULL) { |
|
|
|
@ -340,8 +477,7 @@ LOCAL STATUS vxbFtSpiTransfer( |
|
|
|
return ERROR; |
|
|
|
} |
|
|
|
|
|
|
|
pDrvCtrl->channel = pSpiDev->devInfo->chipSelect; |
|
|
|
if (pDrvCtrl->channel >= SPI_MAX_CS_NUM) { |
|
|
|
if ( pSpiDev->devInfo->chipSelect >= SPI_MAX_CS_NUM) { |
|
|
|
SPI_DBG (SPI_DBG_ERR, |
|
|
|
"vxbFtQspiTransfer invalid channel[%x] \n", |
|
|
|
pDrvCtrl->channel, 2, 3, 4, 5, 6); |
|
|
|
@ -358,57 +494,55 @@ LOCAL STATUS vxbFtSpiTransfer( |
|
|
|
(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; |
|
|
|
if ((pSpiDev->devInfo->devFreq != pDrvCtrl->speed) || (pSpiDev->devInfo->bitWidth != pDrvCtrl->dataWidth) |
|
|
|
|| (pSpiDev->devInfo->mode != pDrvCtrl->mode) || (pSpiDev->devInfo->chipSelect != pDrvCtrl->cs)) { |
|
|
|
pDrvCtrl->mode = pSpiDev->devInfo->mode; |
|
|
|
pDrvCtrl->speed = pSpiDev->devInfo->devFreq; |
|
|
|
pDrvCtrl->dataWidth = pSpiDev->devInfo->bitWidth; |
|
|
|
pDrvCtrl->cs = pSpiDev->devInfo->chipSelect; |
|
|
|
vxbFtSpiCtrlInit(pDev); |
|
|
|
} |
|
|
|
vxbFtQspiFlashRegSetWithAddr(pDev); |
|
|
|
break; |
|
|
|
case QSPI_FLASH_CMD_PP: |
|
|
|
if(pDrvCtrl->addrMode == QSPI_ADDR_SEL_4) |
|
|
|
{ |
|
|
|
pDrvCtrl->txBuf[0] = QSPI_FLASH_CMD_4PP; |
|
|
|
|
|
|
|
VXB_FT_SPI_REG_WRITE(pDrvCtrl, SSIENR, 0x1); |
|
|
|
if (pPkg->txLen > 0) { |
|
|
|
if (alignSize == 1) { |
|
|
|
for (i = 0;i < pPkg->txLen; ++i) { |
|
|
|
vxbWrite8(pDrvCtrl->regHandle, VXB_FT_SPI_REG8(pDrvCtrl, DR), pPkg->txBuf[i]); |
|
|
|
dummy8 = vxbRead8(pDrvCtrl->regHandle, VXB_FT_SPI_REG8(pDrvCtrl, DR)); |
|
|
|
(void)dummy8; |
|
|
|
} |
|
|
|
} else { |
|
|
|
dptr = (UINT16 *)(pPkg->txBuf); |
|
|
|
len = pPkg->txLen >> 1; |
|
|
|
for (i = 0; i < len; ++i) { |
|
|
|
vxbWrite16(pDrvCtrl->regHandle, VXB_FT_SPI_REG16(pDrvCtrl, DR), dptr[i]); |
|
|
|
dummy16 = vxbRead16(pDrvCtrl->regHandle, VXB_FT_SPI_REG16(pDrvCtrl, DR)); |
|
|
|
(void)dummy16; |
|
|
|
} |
|
|
|
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->rxLen > 0) { |
|
|
|
if (alignSize == 1) { |
|
|
|
dummy8 = 0x0; |
|
|
|
for (i = 0;i < pPkg->rxLen; ++i) { |
|
|
|
vxbWrite8(pDrvCtrl->regHandle, VXB_FT_SPI_REG8(pDrvCtrl, DR), dummy8); |
|
|
|
pPkg->rxBuf[i] = vxbRead8(pDrvCtrl->regHandle, VXB_FT_SPI_REG8(pDrvCtrl, DR)); |
|
|
|
} |
|
|
|
} else { |
|
|
|
dummy16 = 0; |
|
|
|
dptr = (UINT16 *)(pPkg->rxBuf); |
|
|
|
len = pPkg->rxLen >> 1; |
|
|
|
for (i = 0; i < len; ++i) { |
|
|
|
vxbWrite16(pDrvCtrl->regHandle, VXB_FT_SPI_REG16(pDrvCtrl, DR), dummy16); |
|
|
|
dptr[i] = vxbRead16(pDrvCtrl->regHandle, VXB_FT_SPI_REG16(pDrvCtrl, DR)); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
VXB_FT_SPI_REG_WRITE(pDrvCtrl, SSIENR, 0x0); |
|
|
|
|
|
|
|
printf(" xfer : tx %d bytes, rx %d bytes\n",pPkg->txLen, pPkg->rxLen); |
|
|
|
|
|
|
|
if (pPkg->usDelay > 0) { |
|
|
|
vxbUsDelay(pPkg->usDelay); |
|
|
|
@ -421,7 +555,6 @@ LOCAL STATUS vxbFtSpiTransfer( |
|
|
|
} |
|
|
|
|
|
|
|
/*
|
|
|
|
* |
|
|
|
* vxbFtSpiShow - show the controller info |
|
|
|
* |
|
|
|
* This function shows the SPI controller's info. |
|
|
|
@ -450,13 +583,15 @@ LOCAL void vxbFtSpiShow(VXB_DEVICE_ID pDev,int verbose) |
|
|
|
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 (" clkFreq : %u\n", pDrvCtrl->clkFreq); |
|
|
|
printf (" speed : %u\n", pDrvCtrl->speed); |
|
|
|
printf (" bitWidth : %u\n", pDrvCtrl->dataWidth); |
|
|
|
printf (" mode : %u\n", pDrvCtrl->mode); |
|
|
|
printf (" spiDevNum : %u\n", pDrvCtrl->spiDevNum); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/*
|
|
|
|
* |
|
|
|
* vxbFtSpiInstUnlink - VxBus unlink handler |
|
|
|
* |
|
|
|
* This function shuts down a SPI controller instance in response to an |
|
|
|
|
surenyi
3 weeks ago