You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
805 lines
21 KiB
805 lines
21 KiB
/* vxbFtGpioCtrl.c - Driver for GPIO controller */
|
|
|
|
/*
|
|
*
|
|
* This program is OPEN SOURCE software: you can redistribute it and/or modify it;
|
|
* This program is distributed in the hope that it will be useful,but WITHOUT ANY WARRANTY;
|
|
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
|
|
*
|
|
*/
|
|
|
|
/* includes */
|
|
|
|
#include <vxWorks.h>
|
|
#include <vsbConfig.h>
|
|
#include <intLib.h>
|
|
#include <errnoLib.h>
|
|
#include <errno.h>
|
|
#include <sioLib.h>
|
|
#include <ioLib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <logLib.h>
|
|
#include <hwif/util/hwMemLib.h>
|
|
#include <hwif/util/vxbParamSys.h>
|
|
#include <hwif/vxbus/vxbIntrCtlr.h>
|
|
#include <hwif/vxbus/vxBus.h>
|
|
#include <vxbFtGpio.h>
|
|
|
|
#define GPIO_DBG_ON
|
|
#ifdef GPIO_DBG_ON
|
|
#define GPIO_DBG_IRQ 0x00000001
|
|
#define GPIO_DBG_RW 0x00000002
|
|
#define GPIO_DBG_ERR 0x00000004
|
|
#define GPIO_DBG_ALL 0xffffffff
|
|
#define GPIO_DBG_OFF 0x00000000
|
|
LOCAL UINT32 gpioDbgMask = GPIO_DBG_ALL;
|
|
IMPORT FUNCPTR _func_logMsg;
|
|
|
|
#define GPIO_DBG(mask, string, a, b, c, d, e, f) \
|
|
if ((gpioDbgMask & mask) || (mask == GPIO_DBG_ALL)) \
|
|
if (_func_logMsg != NULL) \
|
|
(* _func_logMsg)(string, a, b, c, d, e, f)
|
|
#else
|
|
#define GPIO_DBG(mask, string, a, b, c, d, e, f)
|
|
#endif /* GPIO_DBG_ON */
|
|
|
|
LOCAL void vxbFtGpioInstInit(VXB_DEVICE_ID pInst);
|
|
LOCAL void vxbFtGpioInstInit2(VXB_DEVICE_ID pInst);
|
|
LOCAL void vxbFtGpioInstConnect(VXB_DEVICE_ID pInst);
|
|
LOCAL void vxbFtGpioShow (VXB_DEVICE_ID pDev, int verbose);
|
|
|
|
LOCAL STATUS vxbFtGpioPinModeSet (VXB_DEVICE_ID pDev, UINT32 port, UINT32 pin,UINT32 mode);
|
|
LOCAL UINT32 vxbFtGpioPinInput (VXB_DEVICE_ID pDev, UINT32 port, UINT32 pin);
|
|
LOCAL STATUS vxbFtGpioPinOuput (VXB_DEVICE_ID pDev, UINT32 port, UINT32 pin,
|
|
UINT32 value);
|
|
LOCAL STATUS vxbFtGpioISRSet (VXB_DEVICE_ID pDev, UINT32 pin,
|
|
VOIDFUNCPTR pIsr, void * pArg);
|
|
LOCAL void vxbFtGpioISR (FT_GPIO_DRVCTRL * pDrvCtrl);
|
|
|
|
LOCAL struct drvBusFuncs vxbFtGpioDrvFuncs =
|
|
{
|
|
vxbFtGpioInstInit, /* devInstanceInit */
|
|
vxbFtGpioInstInit2, /* devInstanceInit2 */
|
|
vxbFtGpioInstConnect /* devConnect */
|
|
};
|
|
|
|
LOCAL device_method_t vxbFtGpioDrv_methods[] =
|
|
{
|
|
DEVMETHOD (busDevShow, vxbFtGpioShow),
|
|
DEVMETHOD_END
|
|
};
|
|
|
|
/* FT2000/4 GPIO VxBus registration info */
|
|
|
|
LOCAL struct vxbDevRegInfo vxbFtGpioDrvRegistration =
|
|
{
|
|
NULL, /* pNext */
|
|
VXB_DEVID_DEVICE, /* devID */
|
|
VXB_BUSID_PLB, /* busID = PLB */
|
|
VXB_VER_4_0_0, /* busVer */
|
|
"ftGpio", /* drvName */
|
|
&vxbFtGpioDrvFuncs, /* pDrvBusFuncs */
|
|
&vxbFtGpioDrv_methods[0], /* pMethods */
|
|
NULL /* devProbe */
|
|
};
|
|
|
|
/******************************************************************************
|
|
*
|
|
* vxbFtGpioDrvRegister - register FT2000/4 GPIO driver
|
|
*
|
|
* This routine registers the FT2000/4 GPIO driver with the vxBus subsystem.
|
|
*
|
|
* RETURNS: N/A
|
|
*
|
|
* ERRNO: N/A
|
|
*/
|
|
|
|
void vxbFtGpioDrvRegister (void)
|
|
{
|
|
/* call the vxBus routine to register the GPIO driver */
|
|
|
|
vxbDevRegister (&vxbFtGpioDrvRegistration);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* vxbFtGpioInstInit - first level initialization routine of GPIO modules
|
|
*
|
|
* This is the function called to perform the first level initialization of
|
|
* the six FT2000/4 GPIO modules.
|
|
*
|
|
* NOTE:
|
|
*
|
|
* This routine is called early during system initialization, and
|
|
* *MUST NOT* make calls to OS facilities such as memory allocation
|
|
* and I/O.
|
|
*
|
|
* RETURNS: N/A
|
|
*
|
|
* ERRNO: N/A
|
|
*
|
|
* \NOMANUAL
|
|
*
|
|
*/
|
|
|
|
LOCAL void vxbFtGpioInstInit
|
|
(
|
|
VXB_DEVICE_ID pInst
|
|
)
|
|
{
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* vxbFtGpioInstInit2 - second level initialization routine of GPIO modules
|
|
*
|
|
* This routine performs the second level initialization of the GPIO modules.
|
|
*
|
|
* This routine is called later during system initialization. OS features
|
|
* such as memory allocation are available at this time.
|
|
*
|
|
* RETURNS: N/A
|
|
*
|
|
* ERRNO: N/A
|
|
*
|
|
* \NOMANUAL
|
|
*
|
|
*/
|
|
|
|
LOCAL void vxbFtGpioInstInit2
|
|
(
|
|
VXB_DEVICE_ID pInst
|
|
)
|
|
{
|
|
STATUS st[GPIO_PORT_MUM];
|
|
FT_GPIO_DRVCTRL * pDrvCtrl;
|
|
UINT32 port = 0, pin = 0;
|
|
HCF_DEVICE * pHcf;
|
|
UINT8 ** ppPortModeTable[GPIO_PORT_MUM];
|
|
UINT8 *pPortModeTable[GPIO_PORT_MUM];
|
|
|
|
pDrvCtrl = (FT_GPIO_DRVCTRL *)hwMemAlloc(sizeof (FT_GPIO_DRVCTRL));
|
|
|
|
if (pDrvCtrl == NULL)
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "vxbFtGpioInstInit: pDrvCtrl alloc failed\r\n.",1,2,3,4,5,6);
|
|
return;
|
|
}
|
|
|
|
pInst->pDrvCtrl = pDrvCtrl;
|
|
pDrvCtrl->pInst = pInst;
|
|
|
|
/* map register base */
|
|
|
|
if (vxbRegMap(pInst, 0, &pDrvCtrl->gpioHandle) == ERROR)
|
|
{
|
|
GPIO_DBG (GPIO_DBG_ERR, "vxbFtGpioInstInit: vxbRegMap GPIO ERROR\n", 1, 2, 3, 4, 5, 6);
|
|
#ifndef _VXBUS_BASIC_HWMEMLIB
|
|
hwMemFree ((char *)pDrvCtrl);
|
|
#endif /* _VXBUS_BASIC_HWMEMLIB */
|
|
|
|
pInst->pDrvCtrl = NULL;
|
|
return;
|
|
}
|
|
|
|
pDrvCtrl->gpioModeSet = vxbFtGpioPinModeSet;
|
|
pDrvCtrl->gpioInput = vxbFtGpioPinInput;
|
|
pDrvCtrl->gpioOutput = vxbFtGpioPinOuput;
|
|
pDrvCtrl->gpioISRSet = vxbFtGpioISRSet;
|
|
pDrvCtrl->intEnabled = FALSE;
|
|
|
|
/* clear all interrupt */
|
|
GPIO_WRITE_4 (pDrvCtrl, GPIO_INTEN_A, 0);
|
|
|
|
ppPortModeTable[0] = &pPortModeTable[0];
|
|
ppPortModeTable[1] = &pPortModeTable[1];
|
|
|
|
pHcf = (struct hcfDevice *) hcfDeviceGet (pInst);
|
|
|
|
if (pHcf == NULL)
|
|
{
|
|
#ifndef _VXBUS_BASIC_HWMEMLIB
|
|
hwMemFree ((char *)pDrvCtrl);
|
|
#endif /* _VXBUS_BASIC_HWMEMLIB */
|
|
|
|
pInst->pDrvCtrl = NULL;
|
|
return;
|
|
}
|
|
|
|
if (devResourceGet (pHcf, "trigger", HCF_RES_INT,(void *) &pDrvCtrl->triggerMode) != OK)
|
|
{
|
|
pDrvCtrl->triggerMode = 0;
|
|
}
|
|
|
|
st[0] = devResourceGet (pHcf, "portAModeTable", HCF_RES_ADDR, (void **)ppPortModeTable[0]);
|
|
st[1] = devResourceGet (pHcf, "portBModeTable", HCF_RES_ADDR, (void **)ppPortModeTable[1]);
|
|
|
|
for(port = 0; port < GPIO_PORT_MUM; port++)
|
|
{
|
|
for(pin = 0; pin < FT_GPIO_PORT_WIDTH; pin ++)
|
|
{
|
|
if(st[port] == OK)
|
|
vxbFtGpioPinModeSet(pInst, port, pin, *(pPortModeTable[port] + pin));
|
|
else
|
|
vxbFtGpioPinModeSet(pInst, port, pin, GPIO_MODE_NOT_USED);
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* vxbFtInstConnect - third level initialization routine of GPIO modules
|
|
*
|
|
* This is the function called to perform the third level initialization of
|
|
* the GPIO modules.
|
|
*
|
|
* RETURNS: N/A
|
|
*
|
|
* ERRNO: N/A
|
|
*
|
|
* \NOMANUAL
|
|
*
|
|
*/
|
|
|
|
LOCAL void vxbFtGpioInstConnect
|
|
(
|
|
VXB_DEVICE_ID pInst
|
|
)
|
|
{
|
|
/* nothing is done here */
|
|
|
|
}
|
|
|
|
LOCAL STATUS vxbFtGpioBitSet(FT_GPIO_DRVCTRL * pDrvCtrl, UINT32 reg, UINT32 pin, UINT32 bit)
|
|
{
|
|
UINT32 value=0;
|
|
|
|
if(pin >= FT_GPIO_PORT_WIDTH)
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "[reg 0x%x]Bad pin %d! Only support pin: 0~%d \r\n", reg, pin, FT_GPIO_PORT_WIDTH - 1,4,5,6);
|
|
return ERROR;
|
|
}
|
|
if((bit!=0)&&(bit!=1))
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "[reg 0x%x]Bad bit value %d! \r\n", reg, bit,3,4,5,6);
|
|
return ERROR;
|
|
}
|
|
|
|
value = GPIO_READ_4(pDrvCtrl, reg);
|
|
|
|
switch(bit)
|
|
{
|
|
case 0:
|
|
value &= ~(1<<pin);
|
|
break;
|
|
case 1:
|
|
value |= (1<<pin);
|
|
break;
|
|
|
|
default:
|
|
return ERROR;
|
|
}
|
|
|
|
GPIO_WRITE_4(pDrvCtrl, reg, value);
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* vxbFtGpioPinIntEnable - enable interrupt of a pin
|
|
*
|
|
* the function enable interrupt of a pin.
|
|
*
|
|
* RETURNS: OK or ERROR
|
|
*
|
|
* ERRNO: N/A
|
|
*
|
|
* \NOMANUAL
|
|
*
|
|
*/
|
|
LOCAL STATUS vxbFtGpioPinIntEnable
|
|
(
|
|
VXB_DEVICE_ID pDev,
|
|
UINT32 pin
|
|
)
|
|
{
|
|
FT_GPIO_DRVCTRL * pDrvCtrl = pDev->pDrvCtrl;
|
|
STATUS st = OK;
|
|
|
|
/*all pin of portA use a common interrupt number*/
|
|
if(pDrvCtrl->intEnabled == FALSE)
|
|
{
|
|
st |= vxbIntConnect(pDev, 0, vxbFtGpioISR, pDrvCtrl);
|
|
st |= vxbIntEnable(pDev, 0, vxbFtGpioISR, pDrvCtrl);
|
|
if (OK == st)
|
|
pDrvCtrl->intEnabled = TRUE;
|
|
else
|
|
GPIO_DBG(GPIO_DBG_ERR, "Failed to enable port 0 pin %d interrupt\r\n", pin, 2,3,4,5,6);
|
|
}
|
|
return st;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* vxbFtGpioPinIntDisable - disable interrupt of a pin
|
|
*
|
|
* the function disable interrupt of a pin.
|
|
*
|
|
* RETURNS: OK or ERROR
|
|
*
|
|
* ERRNO: N/A
|
|
*
|
|
* \NOMANUAL
|
|
*
|
|
*/
|
|
LOCAL STATUS vxbFtGpioPinIntDisable
|
|
(
|
|
VXB_DEVICE_ID pDev,
|
|
UINT32 pin
|
|
)
|
|
{
|
|
FT_GPIO_DRVCTRL * pDrvCtrl = pDev->pDrvCtrl;
|
|
STATUS st = OK;
|
|
STATUS disableFlag = TRUE;
|
|
UINT32 i;
|
|
|
|
/*all pin of a portA use a common interrupt number,
|
|
so only if all of pins of portA are not used as interrupt pin,
|
|
we need to disable the interrupt*/
|
|
if(pDrvCtrl->intEnabled == TRUE)
|
|
{
|
|
for(i = 0; i < FT_GPIO_PORT_WIDTH; i++)
|
|
{
|
|
if((pDrvCtrl->pinMode[0][i] == GPIO_MODE_INT) && (i != pin))
|
|
{
|
|
/*have another pin that used as interrupt pin, so don't need to disable interrupt */
|
|
disableFlag = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
if(disableFlag == TRUE)
|
|
{
|
|
st |= vxbIntDisable(pDev, 0, vxbFtGpioISR, pDrvCtrl);
|
|
st |= vxbIntDisconnect(pDev, 0, vxbFtGpioISR, pDrvCtrl);
|
|
if (OK == st)
|
|
pDrvCtrl->intEnabled = FALSE;
|
|
else
|
|
GPIO_DBG(GPIO_DBG_ERR, "Failed to disable port 0 pin %d interrupt\r\n", pin, 2,3,4,5,6);
|
|
}
|
|
}
|
|
return st;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* vxbFtGpioPinModeSet - set mode of a pin
|
|
*
|
|
* the function set mode of a pin.
|
|
*
|
|
* RETURNS: OK or ERROR
|
|
*
|
|
* ERRNO: N/A
|
|
*
|
|
* \NOMANUAL
|
|
*
|
|
*/
|
|
LOCAL STATUS vxbFtGpioPinModeSet
|
|
(
|
|
VXB_DEVICE_ID pDev,
|
|
UINT32 port,
|
|
UINT32 pin,
|
|
UINT32 mode
|
|
)
|
|
{
|
|
FT_GPIO_DRVCTRL * pDrvCtrl = pDev->pDrvCtrl;
|
|
STATUS st = OK;
|
|
UINT32 level = 0, polar = 0;
|
|
|
|
if ((port > GPIO_PORT_B) || (pin >= FT_GPIO_PORT_WIDTH) || (mode > GPIO_MODE_INT))
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "Parameter is out of range : GPIO port %d, pin %d, mode %d\r\n", port, pin, mode,4,5,6);
|
|
return ERROR;
|
|
}
|
|
|
|
/* only port A support interrupt */
|
|
if((mode == GPIO_MODE_INT) && (port != GPIO_PORT_A))
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "Only port A support interrupt \r\n", 1,2,3,4,5,6);
|
|
return ERROR;
|
|
}
|
|
|
|
switch(mode)
|
|
{
|
|
case GPIO_MODE_NOT_USED:
|
|
case GPIO_MODE_IN:
|
|
if (port == GPIO_PORT_A)
|
|
{
|
|
/* st |= */vxbFtGpioPinIntDisable(pDev, pin);
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_SW_DDR_A, pin, GPIO_DIR_IN);
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_INTMASK_A, pin, GPIO_INT_MASK);
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_INTEN_A, pin, GPIO_INT_DIS);
|
|
}
|
|
else
|
|
{
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_SW_DDR_B, pin, GPIO_DIR_IN);
|
|
}
|
|
break;
|
|
case GPIO_MODE_OUT:
|
|
if (port == GPIO_PORT_A)
|
|
{
|
|
/* st |= */vxbFtGpioPinIntDisable(pDev, pin);
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_SW_DDR_A, pin, GPIO_DIR_OUT);
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_INTMASK_A, pin, GPIO_INT_MASK);
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_INTEN_A, pin, GPIO_INT_DIS);
|
|
}
|
|
else
|
|
{
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_SW_DDR_B, pin, GPIO_DIR_OUT);
|
|
}
|
|
break;
|
|
case GPIO_MODE_INT:
|
|
if(port == GPIO_PORT_A)
|
|
{
|
|
switch(pDrvCtrl->triggerMode)
|
|
{
|
|
case VXB_INTR_TRIG_FALLING_EDGE:
|
|
level = GPIO_INT_TYPE_EDGE;
|
|
polar = GPIO_INT_POL_LOW_DOWN;
|
|
break;
|
|
case VXB_INTR_TRIG_RISING_EDGE:
|
|
level = GPIO_INT_TYPE_EDGE;
|
|
polar = GPIO_INT_POL_HIGH_UP;
|
|
break;
|
|
case VXB_INTR_TRIG_ACTIVE_LOW:
|
|
level = GPIO_INT_TYPE_LEVEL;
|
|
polar = GPIO_INT_POL_LOW_DOWN;
|
|
break;
|
|
case VXB_INTR_TRIG_ACTIVE_HIGH:
|
|
level = GPIO_INT_TYPE_LEVEL;
|
|
polar = GPIO_INT_POL_HIGH_UP;
|
|
break;
|
|
default:
|
|
pDrvCtrl->pinMode[port][pin] = GPIO_MODE_NOT_USED;
|
|
GPIO_DBG(GPIO_DBG_ERR, "Mode set error of port %d pin %d: trigger mode error \r\n", port, pin,3,4,5,6);
|
|
return ERROR;
|
|
}
|
|
/* st |= */vxbFtGpioPinIntEnable(pDev, pin);
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_SW_DDR_A, pin, GPIO_DIR_IN);
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_INTMASK_A, pin, GPIO_INT_NOT_MASK);
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_INTTYPE_LEVEL_A, pin, level);
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_INT_POLARITY_A, pin, polar);
|
|
st |= vxbFtGpioBitSet(pDrvCtrl, GPIO_INTEN_A, pin, GPIO_INT_ENA);
|
|
}
|
|
break;
|
|
default:
|
|
return ERROR;
|
|
}
|
|
if (OK != st)
|
|
{
|
|
pDrvCtrl->pinMode[port][pin] = GPIO_MODE_NOT_USED;
|
|
GPIO_DBG(GPIO_DBG_ERR, "Mode set error of port %d pin %d\r\n", port, pin,3,4,5,6);
|
|
return ERROR;
|
|
}
|
|
else
|
|
{
|
|
pDrvCtrl->pinMode[port][pin] = mode;
|
|
}
|
|
return OK;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* vxbFtGpioPinInput - gpio pin input value
|
|
*
|
|
* The function return value of specified intput pin.
|
|
*
|
|
* RETURNS: input value
|
|
*
|
|
* ERRNO: N/A
|
|
*
|
|
* \NOMANUAL
|
|
*
|
|
*/
|
|
LOCAL UINT32 vxbFtGpioPinInput
|
|
(
|
|
VXB_DEVICE_ID pDev,
|
|
UINT32 port,
|
|
UINT32 pin
|
|
)
|
|
{
|
|
FT_GPIO_DRVCTRL * pDrvCtrl = pDev->pDrvCtrl;
|
|
|
|
if ((port > GPIO_PORT_B) || (pin >= FT_GPIO_PORT_WIDTH))
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "Parameter is out of range :GPIO port %d, pin %d \r\n", port, pin,3,4,5,6);
|
|
return (UINT32)ERROR;
|
|
}
|
|
if (pDrvCtrl->pinMode[port][pin] != GPIO_MODE_IN)
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "port %d pin %d is not in input mode\r\n",port, pin,3,4,5,6);
|
|
return (UINT32)ERROR;
|
|
}
|
|
|
|
if ( port == GPIO_PORT_A)
|
|
return ((GPIO_READ_4(pDrvCtrl, GPIO_EXT_A) >> pin) & 1);
|
|
else
|
|
return ((GPIO_READ_4(pDrvCtrl, GPIO_EXT_B) >> pin) & 1);
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* vxbFtGpioPinOuput - output value to gpio pin
|
|
*
|
|
* Write value to the specified pin.
|
|
*
|
|
* RETURNS: OK or ERROR if the pin is invalid.
|
|
*
|
|
* ERRNO: N/A
|
|
*
|
|
* \NOMANUAL
|
|
*
|
|
*/
|
|
LOCAL STATUS vxbFtGpioPinOuput
|
|
(
|
|
VXB_DEVICE_ID pDev,
|
|
UINT32 port,
|
|
UINT32 pin,
|
|
UINT32 value
|
|
)
|
|
{
|
|
FT_GPIO_DRVCTRL * pDrvCtrl = pDev->pDrvCtrl;
|
|
|
|
if ((port > GPIO_PORT_B) || (pin >= FT_GPIO_PORT_WIDTH))
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "Parameter is out of range :GPIO port %d, pin %d \r\n", port, pin,3,4,5,6);
|
|
return ERROR;
|
|
}
|
|
if (pDrvCtrl->pinMode[port][pin] != GPIO_MODE_OUT)
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "port %d pin %d is not in output mode\r\n",port, pin,3,4,5,6);
|
|
return ERROR;
|
|
}
|
|
if((value!=0)&&(value!=1))
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "Bad pin value %d! Only support value: 0,1 \r\n", value,2,3,4,5,6);
|
|
return ERROR;
|
|
}
|
|
|
|
if (port == GPIO_PORT_A)
|
|
vxbFtGpioBitSet(pDrvCtrl, GPIO_SW_DR_A, pin, value);
|
|
else
|
|
vxbFtGpioBitSet(pDrvCtrl, GPIO_SW_DR_B, pin, value);
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* vxbFtGpioISRSet - set a function to be called on the gpio interrupt
|
|
*
|
|
* This function is called to set a function which can be called when
|
|
* the gpio interrupt occurs.
|
|
*
|
|
* RETURNS: OK or ERROR if the pin is invalid.
|
|
*
|
|
* ERRNO: N/A
|
|
*
|
|
* \NOMANUAL
|
|
*
|
|
*/
|
|
LOCAL STATUS vxbFtGpioISRSet
|
|
(
|
|
VXB_DEVICE_ID pDev,
|
|
UINT32 pin,
|
|
VOIDFUNCPTR pIsr, /* ISR */
|
|
void * pArg /* parameter */
|
|
)
|
|
{
|
|
FT_GPIO_DRVCTRL * pDrvCtrl = pDev->pDrvCtrl;
|
|
|
|
if (pin >= FT_GPIO_PORT_WIDTH)
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "Parameter is out of range :GPIO pin %d \r\n", pin, 2,3,4,5,6);
|
|
return ERROR;
|
|
}
|
|
if (pDrvCtrl->pinMode[0][pin] != GPIO_MODE_INT)
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "port 0 pin %d is not in interrupt mode\r\n",pin,2,3,4,5,6);
|
|
return ERROR;
|
|
}
|
|
|
|
pDrvCtrl->isrTable[pin].pIsr = pIsr;
|
|
pDrvCtrl->isrTable[pin].pArg = pArg;
|
|
|
|
return OK;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* vxbFtGpioISR - interrupt level processing for gpio module
|
|
*
|
|
* This routine handles gpio interrupts. It acknowledges the interrupt and
|
|
* calls the routine installed by vxbFtGpioISRSet().
|
|
*
|
|
* RETURNS: N/A
|
|
*
|
|
* ERRNO: N/A
|
|
*
|
|
* \NOMANUAL
|
|
*
|
|
*/
|
|
LOCAL void vxbFtGpioISR
|
|
(
|
|
FT_GPIO_DRVCTRL * pDrvCtrl
|
|
)
|
|
{
|
|
UINT32 val;
|
|
UINT32 ix;
|
|
|
|
/* read interrupt flags */
|
|
|
|
val = GPIO_READ_4 (pDrvCtrl, GPIO_INTSTATUS_A);
|
|
|
|
if (val == 0)
|
|
{
|
|
GPIO_DBG(GPIO_DBG_ERR, "vxFtGpioISR: it's not a gpio interrupt. \r\n.",
|
|
1,2,3,4,5,6);
|
|
goto exit;
|
|
}
|
|
|
|
for (ix = 0; ix < FT_GPIO_PORT_WIDTH; ix++)
|
|
{
|
|
UINT32 bit = 1 << ix;
|
|
if (val & bit)
|
|
{
|
|
if (pDrvCtrl->isrTable[ix].pIsr != NULL)
|
|
{
|
|
pDrvCtrl->isrTable[ix].pIsr(pDrvCtrl->isrTable[ix].pArg);
|
|
}
|
|
else
|
|
{
|
|
/* suspicious int */
|
|
|
|
GPIO_DBG(GPIO_DBG_ERR, "vxFtGpioISR: neet to set ISR for pin %d \r\n.",
|
|
ix,2,3,4,5,6);
|
|
goto exit;
|
|
}
|
|
}
|
|
}
|
|
|
|
exit:
|
|
/* clear interrupt flags */
|
|
|
|
GPIO_WRITE_4 (pDrvCtrl, GPIO_PORTA_EOI_A, val);
|
|
|
|
return;
|
|
}
|
|
|
|
LOCAL void vxbFtGpioShow (VXB_DEVICE_ID pDev, int verbose)
|
|
{
|
|
FT_GPIO_DRVCTRL * pDrvCtrl;
|
|
|
|
/* check for valid parameter */
|
|
VXB_ASSERT_NONNULL_V (pDev);
|
|
|
|
pDrvCtrl = (FT_GPIO_DRVCTRL *) 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) {
|
|
int i, j;
|
|
printf (" BAR0 @ 0x%08x (memory mapped)\n",pDev->pRegBase[0]);
|
|
for (i = 0; i < GPIO_PORT_MUM; ++i) {
|
|
printf(" port %c:", i == 0 ? 'A' : 'B');
|
|
for (j = 0; j < FT_GPIO_PORT_WIDTH; ++j) {
|
|
printf(" %d", pDrvCtrl->pinMode[i][j]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
#define FT_GPIO_DEBUD
|
|
#ifdef FT_GPIO_DEBUD
|
|
void gpioModeShow(UINT32 gpio)
|
|
{
|
|
int i,j;
|
|
VXB_DEVICE_ID pDev;
|
|
FT_GPIO_DRVCTRL * pCtrl;
|
|
|
|
pDev = vxbInstByNameFind("ftGpio", gpio);
|
|
if (pDev == NULL) {
|
|
return;
|
|
}
|
|
|
|
pCtrl = pDev->pDrvCtrl;
|
|
for(i = 0; i < GPIO_PORT_MUM; i++)
|
|
{
|
|
for(j = 0; j < FT_GPIO_PORT_WIDTH; j++)
|
|
printf("port %d pin %d mode %d\n", i, j, pCtrl->pinMode[i][j]);
|
|
}
|
|
|
|
printf("intEnabled %d\n", pCtrl->intEnabled);
|
|
printf("triggerMode %x\n", pCtrl->triggerMode);
|
|
}
|
|
|
|
void gpioModeSetTest (UINT32 gpio, UINT32 port, UINT32 pin, UINT32 mode)
|
|
{
|
|
VXB_DEVICE_ID pDev;
|
|
FT_GPIO_DRVCTRL * pCtrl;
|
|
|
|
pDev = vxbInstByNameFind("ftGpio", gpio);
|
|
if (pDev == NULL) {
|
|
return;
|
|
}
|
|
pCtrl = pDev->pDrvCtrl;
|
|
|
|
pCtrl->gpioModeSet(pDev, port, pin, mode);
|
|
|
|
}
|
|
|
|
void gpioOutTest (UINT32 gpio, UINT32 port, UINT32 pin, UINT32 val)
|
|
{
|
|
VXB_DEVICE_ID pDev;
|
|
FT_GPIO_DRVCTRL * pCtrl;
|
|
|
|
pDev = vxbInstByNameFind("ftGpio", gpio);
|
|
if (pDev == NULL) {
|
|
return;
|
|
}
|
|
|
|
pCtrl = pDev->pDrvCtrl;
|
|
|
|
pCtrl->gpioOutput(pDev, port, pin, val);
|
|
}
|
|
|
|
void gpioInTest (UINT32 gpio, UINT32 port, UINT32 pin)
|
|
{
|
|
VXB_DEVICE_ID pDev;
|
|
FT_GPIO_DRVCTRL * pCtrl;
|
|
|
|
pDev = vxbInstByNameFind("ftGpio", gpio);
|
|
if (pDev == NULL) {
|
|
return;
|
|
}
|
|
pCtrl = pDev->pDrvCtrl;
|
|
|
|
printf("input val %d\n", pCtrl->gpioInput(pDev, port, pin));
|
|
}
|
|
|
|
|
|
LOCAL void gpioIsrFunction(void * arg)
|
|
{
|
|
UINT32 * pin = (UINT32 *)arg;
|
|
logMsg("GPIO pin %d ISR \n",* pin,0,0,0,0,0);
|
|
}
|
|
|
|
LOCAL UINT32 isrArgTest = 0;
|
|
|
|
void gpioIsrSetTest (UINT32 gpio, UINT32 pin)
|
|
{
|
|
VXB_DEVICE_ID pDev;
|
|
FT_GPIO_DRVCTRL * pCtrl;
|
|
|
|
pDev = vxbInstByNameFind("ftGpio", gpio);
|
|
if (pDev == NULL) {
|
|
return;
|
|
}
|
|
pCtrl = pDev->pDrvCtrl;
|
|
|
|
isrArgTest = pin;
|
|
|
|
pCtrl->gpioISRSet(pDev, pin, gpioIsrFunction, &isrArgTest);
|
|
|
|
}
|
|
#endif
|
|
|