📄 spi.cpp
字号:
default:
SET_ERR(ERROR_INVALID_PARAMETER);
break;
#ifdef GPS_GPIO_RESET_EXISTS // { 4
case GPS_GPIO_RESET:
GL_PRINT((MSG("SPI_IOControl(RESET 0x%x) %d\n\r"),
GPS_GPIO_RESET_EXISTS, gpioIn->value));
if (gpioIn->value)
{
v_pGPIORegs->GPSR_RESET = GPS_GPIO_RESET_EXISTS;
v_pGPIORegs->GPDR_RESET |= GPS_GPIO_RESET_EXISTS;
}
else
{
v_pGPIORegs->GPCR_RESET = GPS_GPIO_RESET_EXISTS;
v_pGPIORegs->GPDR_RESET |= GPS_GPIO_RESET_EXISTS;
}
break;
#endif // } GPS_GPIO_RESET_EXISTS
#ifdef GPS_GPIO_POWER_EXISTS // { 5
case GPS_GPIO_POWER:
GL_PRINT((MSG("SPI_IOControl(POWER 0x%x) %d\n\r"),
GPS_GPIO_POWER_EXISTS, gpioIn->value));
if (gpioIn->value)
{
v_pGPIORegs->GPSR_POWER = GPS_GPIO_POWER_EXISTS;
v_pGPIORegs->GPDR_POWER |= GPS_GPIO_POWER_EXISTS;
}
else
{
v_pGPIORegs->GPCR_POWER = GPS_GPIO_POWER_EXISTS;
v_pGPIORegs->GPDR_POWER |= GPS_GPIO_POWER_EXISTS;
}
break;
#endif // } GPS_GPIO_POWER_EXISTS
#ifdef GPS_GPIO_STANDBY_EXISTS // { 6
case GPS_GPIO_STANDBY:
GL_PRINT((MSG("SPI_IOControl(nSTANDBY 0x%x) %d\n\r"),
GPS_GPIO_STANDBY_EXISTS, gpioIn->value));
if (gpioIn->value)
{
v_pGPIORegs->GPSR_STANDBY = GPS_GPIO_STANDBY_EXISTS;
v_pGPIORegs->GPDR_STANDBY |= GPS_GPIO_STANDBY_EXISTS;
}
else
{
v_pGPIORegs->GPCR_STANDBY = GPS_GPIO_STANDBY_EXISTS;
v_pGPIORegs->GPDR_STANDBY |= GPS_GPIO_STANDBY_EXISTS;
}
break;
#endif // } GPS_GPIO_STANDBY_EXISTS
}
//----------------------------------------------------------------------
// [required] Get the GPIO.
//----------------------------------------------------------------------
if (pBufOut) switch(gpioOut->id)
{
case GPS_NONE:
break;
default:
SET_ERR(ERROR_INVALID_PARAMETER);
break;
#ifdef GPS_GPIO_RESET_EXISTS // { 4
case GPS_GPIO_RESET:
if (v_pGPIORegs->GPLR_RESET & GPS_GPIO_RESET_EXISTS)
{
gpioOut->value = 1;
}
break;
#endif // } GPS_GPIO_RESET_EXISTS
#ifdef GPS_GPIO_STANDBY_EXISTS // { 5
case GPS_GPIO_STANDBY:
if (v_pGPIORegs->GPLR_STANDBY & GPS_GPIO_STANDBY_EXISTS)
{
gpioOut->value = 1;
}
break;
#endif // } GPS_GPIO_STANDBY_EXISTS
#ifdef GPS_GPIO_POWER_EXISTS // { 6
case GPS_GPIO_POWER:
if (v_pGPIORegs->GPLR_POWER & GPS_GPIO_POWER_EXISTS)
{
gpioOut->value = 1;
}
break;
#endif // } GPS_GPIO_POWER_EXISTS
}
break;
}
//----------------------------------------------------------------------
// [optional] Get the Cell Info.
//----------------------------------------------------------------------
CASE(GET_CELL_INFO);
{
GLL_CID* cid = (GLL_CID *)pBufOut;
CHECK_OUT(cid);
structureOutName = _T("GLL_CID");
if (Customer_getCellInfo(cid))
{
*pdwActualOut = sizeof(*cid);
}
else
{
*pdwActualOut = 0;
SET_ERR(ERROR_NOT_FOUND);
}
break;
}
//----------------------------------------------------------------------
// [optional] Get the Mobile Station ID.
//----------------------------------------------------------------------
CASE(GET_MSISDN);
{
GlSuplSetID* msisdn = (GlSuplSetID *)pBufOut;
CHECK_OUT(msisdn);
structureOutName = _T("GlSuplSetID");
//----------------------------------------------------------------------
// Sample code to showing how to fill in the MSISDN.
// This case uses BCD, but IMSI or any of the other
// 7 styles of MSISDN are OK.
//----------------------------------------------------------------------
msisdn->eType = GL_SUPLID_MSISDN_BCD;
if (Customer_getMsisdnBcd(msisdn->u.msisdn_bcd))
{
*pdwActualOut = sizeof(msisdn->u.msisdn_bcd);
}
else
{
*pdwActualOut = 0;
SET_ERR(ERROR_NOT_FOUND);
}
break;
}
//----------------------------------------------------------------------
// [optional] Set the power-down data.
// TODO: change the GPSCT to make POWER_DOWN_DATA obsolete.
// Otherwise, save the data into an internal buffer
// and spew it when shutting down.
//----------------------------------------------------------------------
CASE(POWER_DOWN_DATA);
{
if (!pBufIn)
{
SET_ERR(ERROR_INVALID_DATA);
break;
}
if (dwLenIn > sizeof(pSpi->mShutDownData))
{
SET_ERR(ERROR_BAD_LENGTH);
break;
}
memcpy(pSpi->mShutDownData, pBufIn, dwLenIn);
pSpi->mShutDownCount = dwLenIn;
break;
}
CASE(SECONDS);
{
DWORD* time = (DWORD *)pBufOut;
CHECK_OUT(time);
#if 0 // { TODO - decide how to keep GPS time
structureOutName = "DWORD time";
*time = Customer_reallyGoodTime();
#else
// SET_ERR(ERROR_NOT_SUPPORTED);
*time = rb_TestRead();
#endif // }
break;
}
CASE(TRACE);
{
if (pBufIn && dwLenIn)
{
traceParamSet(pBufIn, dwLenIn);
}
*pdwActualOut = traceCopy(pBufOut, dwLenOut, GPS_SPI_VERSION_MAJOR,
GPS_SPI_VERSION_MINOR);
if (!*pdwActualOut)
{
SET_ERR(ERROR_NOT_SUPPORTED);
}
break;
}
CASE(INTERRUPT_ACKNOWLEDGE);
{
static int intackTimer = 0;
if (++intackTimer > 25)
{
STATS_INT_ACK(0);
GL_ERROR((TEXT("*** spiGps/%d: Intack timeout\n\r"), __LINE__));
pSpi->intackNeeded = true;
}
if (pSpi->intackNeeded)
{
pSpi->intackNeeded = false;
intackTimer = 0;
STATS_INT_ACK(*pGpsTimer - pSpi->interruptTime_);
InterruptDone(SYSINTR_GPS);
rb__InterruptEnable();
}
else
{
STATS_INT_ACK(0);
}
break;
}
CASE(RADIO_CLOCK);
{
traceDump(false);
// To eliminate this API, please gate CNTIN so that it is forced to
// zero whenever the GSM phone is not locked to the network.
SET_ERR(ERROR_NOT_SUPPORTED);
// Otherwise, implement this protocol:
// TBD
break;
}
#if 0 // { Windows CE stuff
case IOCTL_PSL_NOTIFY:
DEVICE_PSL_NOTIFYO* pPSL = pBufIn;
#endif // }
#if 0 // { Power capabilities
case IOCTL_POWER_CAPABILITIES:
// This IOCTL queries to determine device-specific capabilities.
case IOCTL_POWER_GET:
// This IOCTL gets the current device power state.
case IOCTL_POWER_SET:
// This IOCTL requests a change from one device power state to another.
case IOCTL_REGISTER_POWER_RELATIONSHIP:
// This IOCTL notifies the parent device so the parent device can
// register all devices it controls.
// case IOCTL_POWER_QUERY:
// This IOCTL queries to determine whether changing power state
// is feasible. This IOCTL has been deprecated and is not called
// by the Power Manager.
#endif // }
}
if (err)
{
if (printError)
{
GL_ERROR((TEXT("SPI_IOControl(%d %x \"%s\") err %d %d\r\n"),
code, dwCode, ioctlName, err, errLine));
}
else // set/get unknown GPIO bits not forcefully printed.
{
GL_PRINT(( MSG("SPI_IOControl(%d %x \"%s\") err %d %d\r\n"),
code, dwCode, ioctlName, err, errLine));
}
}
if (pBufIn)
{
GL_DEBUG_PACKET(structureInName,(const void*) pBufIn,dwLenIn);
}
if (pBufOut)
{
GL_DEBUG_PACKET(structureOutName, (const void*) pBufOut,*pdwActualOut);
}
//--------------------------------------------------------------------------
// Report status & exit
//--------------------------------------------------------------------------
SetLastError(err);
if (err)
{
return FALSE;
}
return TRUE;
}
/*******************************************************************************
********************************************************************************
**
** Internal Subroutines
**
********************************************************************************
*******************************************************************************/
//-----------------------------------------------------------------------------
//
// AllocSPIReg()
//
//-----------------------------------------------------------------------------
static BOOL SPI_AllocReg(SPI_DEVICE_CONTEXT* pDev)
{
if (pDev->v_pGPIORegs == NULL)
{
//PHYSICAL_ADDRESS gpio = {BULVERDE_BASE_REG_PA_GPIO,0};
//PVOID pvGpio = MmMapIoSpace(gpio, sizeof(BULVERDE_GPIO_REG), FALSE);
//pDev->v_pGPIORegs = (BULVERDE_GPIO_REG *)pvGpio;
pDev->v_pGPIORegs = v_pGPIORegs;
}
if (pDev->v_pSPIRegs == NULL)
{
//PHYSICAL_ADDRESS ssp3 = {BULVERDE_BASE_REG_PA_SSP3,0};
//PVOID pvSsp3 = MmMapIoSpace(ssp3, sizeof(XLLP_SSP_REGS), FALSE);
//pDev->v_pSPIRegs = (XLLP_SSP_REGS *)pvSsp3;
//v_pSPIRegs = pDev->v_pSPIRegs;
}
if (pDev->v_pClockRegs == NULL)
{
//PHYSICAL_ADDRESS clock = {BULVERDE_CLOCK_EN_REG,0};
//PVOID pvClock = MmMapIoSpace(clock, sizeof(BULVERDE_CLOCK_CONTROL), FALSE);
pDev->v_pClockRegs = v_pClockRegs;
//v_pClockRegs = pDev->v_pClockRegs;
}
if (pDev->v_pGPIORegs == NULL ||
pDev->v_pSPIRegs == NULL ||
pDev->v_pClockRegs == NULL)
{
return false;
}
return true;
}
//-----------------------------------------------------------------------------
//
// sample kernel code
//
//-----------------------------------------------------------------------------
#if 0 // {
// Add this code...
typedef void (*Type_pGpsTraceFunc)(int val);
void gpsTrace(int val)
{
}
Type_pGpsTraceFunc pFuncGpsTrace = gpsTrace;
kernel_interrupt_code(int interrupt_number)
{
// Add this code...
if (interrupt_number == GPS_INTERRUPT)
{
// NKdebugW(_T("GPS.........Interrupt Occurred"));
pFuncGpsTrace(8); // same as above.
}
}
// Add this code...
// public export ....
void kernel_install_gps_trace(Type_pGpsTraceFunc p)
{
pFuncGpsTrace = p;
}
#endif // }
//-----------------------------------------------------------------------------
//
// SPI_Isr()
//
//-----------------------------------------------------------------------------
static DWORD
SPI_Isr(PVOID pArg)
{
GL_PRINT((MSG("SPI_Isr()/%d 0x%x\n\r"),__LINE__, pArg));
SPI_DEVICE_CONTEXT* pDev = (SPI_DEVICE_CONTEXT *)pArg;
UINT messageCount = 0;
// add this code when the kernel is ready!
// kernel_install_gps_trace(traceIsr);
CeSetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_SPI_IST);
pDev->mhIntr = CreateEvent(NULL, FALSE, FALSE, NULL);
if (!pDev->mhIntr)
{
GL_ERROR((TEXT("SPI_Isr()/%d no interrupt handle\n\r"),__LINE__));
return 0;
}
if (!InterruptInitialize(SYSINTR_GPS, pDev->mhIntr, 0, 0))
{
GL_ERROR((TEXT("SPI_Isr()/%d interrupt %d\n\r"),__LINE__, SYSINTR_GPS));
return 0;
}
pDev->mhGpsEvent = CreateEvent(NULL, FALSE, FALSE, _T("GpsEvent"));
GL_PRINT((MSG("SPI_Isr()/%d event 0x%x\n\r"),__LINE__, pDev->mhGpsEvent));
while(true)
{
DWORD e = WaitForSingleObject(pDev->mhIntr, INFINITE);
pDev->interruptTime_ = *pGpsTimer;
if (e == WAIT_OBJECT_0)
{
GL_PRINT((MSG("SPI_Isr()/%d\n\r"),__LINE__));
TRACE_ISR(1, pDev->interruptTime_);
}
else
{
GL_ERROR((TEXT("SPI_Isr()/%d wait error 0x%x\n\r"),__LINE__, e));
TRACE_ISR(2, pDev->interruptTime_);
}
pDev->intackNeeded = true;
SetEvent(pDev->mhGpsEvent);
}
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -