gpio.cpp

一个基于windows mobile 的GPS 接受IC 驱动程序。

    DWORD result = 0;
    GL_PRINT((MSG("} GCO_Read()/%d %d\n\r"),__LINE__, result));
    return result;
}

//-----------------------------------------------------------------------------
//
//                  GCO_Write()
//
//  Write data into the queue.
//  If we had a power-down/up - ignore the write quietly.
//
//-----------------------------------------------------------------------------

GPIO_EXPORT DWORD
GCO_Write(DWORD hOpenContext, LPCVOID pBuf, DWORD Count)
{
    GL_PRINT((MSG("GCO_Write(%d)/%d {\n\r"), Count, __LINE__));

    GPIO_DEVICE_CONTEXT* pGpio = getGpioDeviceContext(hOpenContext);
    SetLastError(0);
    if (pGpio->mbClosed)
    {
        GL_PRINT((MSG("GCO_Write()/%d\n\r"),__LINE__));
    }
    return Count;           // Quietly ignore all writes.
}

//-----------------------------------------------------------------------------
//
//                  GCO_Seek()
//
//-----------------------------------------------------------------------------

GPIO_EXPORT DWORD
GCO_Seek(DWORD hOpenContext, long Amount, WORD Type)
{
    GL_PRINT((MSG("GCO_Seek()/%d\n\r"),__LINE__));
    GPIO_DEVICE_CONTEXT* pGpio = getGpioDeviceContext(hOpenContext);
    SetLastError(0);
	return Amount;
}

//------------------------------------------------------------------------------
//
//      Handy Macros for commonly repeated code.
//
//  CASE(name)      --> case IOCTL_SERIAL_name: ioctlName = "name"
//  CHECK_IN(item)  --> make sure pBufIn and lenIn are OK compared to
//                      sizeof(item)
//  CHECK_OUT(item) --> make sure pBufIn, lenIn, and actualOut are OK
//                      compared to sizeof(item)
//  COPY_IN(item)   --> copy the pBufIn to item.
//  COPY_OUT(item)  --> copy the item to pBufIn.
//
//------------------------------------------------------------------------------

#define SET_ERR(e)    err = (e); errLine = __LINE__

#define CASE(name)    \
        case GPS_IOCTL_##name: \
            ioctlName = _T(#name)

#define CHECK_IN(item)   \
            if (sizeof(*item) != dwLenIn) \
            { \
                GL_ERROR((TEXT("GCO_IOCTL(%d)/%d inLength. expect %d\n\r"), \
                                        dwLenIn, __LINE__, sizeof(*item))); \
                SET_ERR(ERROR_BAD_LENGTH); \
                break; \
            }

#define CHECK_OUT(item)     \
            if (dwLenOut < sizeof(*item)) \
            { \
                GL_ERROR((TEXT("GCO_IOCTL(%d)/%d outLength. expect %d\n\r"), \
                                        dwLenOut, __LINE__, sizeof(*item))); \
                SET_ERR(ERROR_BAD_LENGTH); \
                break; \
            } \
            *pdwActualOut = sizeof(*item)

//-----------------------------------------------------------------------------
//
//                  GCO_IOControl()
//
//  REQUIRED - Set or get GPIO read/write.
//
//-----------------------------------------------------------------------------

GPIO_EXPORT BOOL
GCO_IOControl(DWORD  hOpenContext, DWORD dwCode,
              PBYTE  pBufIn,   DWORD dwLenIn,
              PBYTE  pBufOut,  DWORD dwLenOut, 
              PDWORD pdwActualOut)
{
    bool printError = true;
    int code = (dwCode - GPS_IOCTL_ZERO) >> 2;
    if (code <= GPS_INDEX_ZERO || code >= GPS_INDEX_MAX)
    {
        GL_PRINT((MSG("GCO_IOControl(0x%x,%%x,%d,%%x,%d,%%x)/%d Bad code %d err %d\n 0x%x\r"),
                dwCode,
                /* pBufIn, */  dwLenIn,
                /* pBufOut, */ dwLenOut,
                /* pdwActualOut, */
                __LINE__,
                code, ERROR_INVALID_PARAMETER, GPS_IOCTL_ZERO));
        SetLastError(ERROR_INVALID_PARAMETER);
        GL_ERROR((TEXT("GCO_IOControl(%x[%d])/%d bad IO code\n\r"),
                                                    dwCode, code, __LINE__));
        return FALSE;
    }

    if (pBufIn && dwLenIn)
    {
        if (IsBadReadPtr(pBufIn, dwLenIn))
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            GL_ERROR((TEXT("GCO_IOControl(%x[%d])/%d bad pBufIn\n\r"),
                                                pBufIn, dwLenIn, __LINE__));
            return -1;
        }
    }

    if (pBufOut && dwLenOut && pdwActualOut)
    {
        if (IsBadWritePtr(pBufOut, dwLenOut))
        {
            GL_ERROR((TEXT("GCO_IOControl(%x[%d])/%d bad pBufOut\n\r"),
                                                pBufOut, dwLenOut, __LINE__));
            SetLastError(ERROR_INVALID_PARAMETER);
            return -1;
        }
        if (IsBadWritePtr(pdwActualOut, sizeof(DWORD)))
        {
            GL_ERROR((TEXT("GCO_IOControl(%x[%d])/%d bad pdwActualOut\n\r"),
                                                pdwActualOut, __LINE__));
            SetLastError(ERROR_INVALID_PARAMETER);
            return -1;
        }
    }
    else if (pBufOut || dwLenOut || pdwActualOut)
    {
        GL_ERROR((TEXT("GCO_IOControl(%x,%d,%x)/%d missing param\n\r"),
                                pBufOut, dwLenOut, pdwActualOut, __LINE__));
        SetLastError(ERROR_INVALID_PARAMETER);
        return -1;
    }

    GPIO_DEVICE_CONTEXT* pGpio      = getGpioDeviceContext(hOpenContext);
    const TCHAR* ioctlName        = _T("unknown");
    const TCHAR* structureInName  = (pBufIn ) ? _T("unknown") : _T("<null>");
    const TCHAR* structureOutName = (pBufOut) ? _T("unknown") : _T("<null>");

    DWORD err     = 0;
    int   errLine = 0;

    switch(dwCode)
	{
	case GPS_IOCTL_CHIPSET_CONTROL:
    {
        const GPS_GPIO_CONTROL* gpioIn = (const GPS_GPIO_CONTROL *)pBufIn;
        GPS_GPIO_CONTROL* gpioOut = (GPS_GPIO_CONTROL *)pBufOut;
        if (pBufIn)
        {
            CHECK_IN(gpioIn);
            structureInName = _T("GPS_GPIO_CONTROL<in>");
        }
        if (pBufOut)
        {
            CHECK_OUT(gpioOut);
            structureOutName = _T("GPS_GPIO_CONTROL<out>");
        }

        printError = false;

        //----------------------------------------------------------------------
        //      [required] Set the GPIO.
        //----------------------------------------------------------------------
        if (pBufIn) switch(gpioIn->id)
        {
        case GPS_NONE:
        	break;
        default:
            SET_ERR(ERROR_INVALID_PARAMETER);
            break;

#ifdef  GPS_GPIO_RESET_EXISTS         // {    4
        case GPS_GPIO_RESET:
            GL_PRINT((MSG("GCO_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("GCO_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("GCO_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;
    }
	}

    if (err)
    {
        if (printError)
        {
            GL_ERROR((TEXT("GCO_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("GCO_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
**
********************************************************************************
*******************************************************************************/

//-----------------------------------------------------------------------------
//
//                  AllocGPIOReg()
//
//-----------------------------------------------------------------------------

static BOOL GCO_AllocReg(GPIO_DEVICE_CONTEXT* pDev)
{
	if (pDev->v_pGPIORegs == NULL)
	{
		pDev->v_pGPIORegs = v_pGPIORegs;			
	}

	if (pDev->v_pGPIORegs == NULL)
    {
		return false;
    }
		
	return true;
}