qcibus.cpp

wince 6.0 摄像头(ov7670)驱动,已在ce6测试通过

                DEBUGMSG(ZONE_ENUM,(TEXT("QciBus: Activate Child add %s to %s ActivePath\r\n"),m_lpInitParamArray[dwIndex],pCurDevice->GetRegPath()));                
            }
        }
        pCurDevice =(SensorFolder *) pCurDevice->GetNextDeviceFolder();
    }

    // Activate Device 
    DWORD dwCurOrder = 0;
    while (dwCurOrder != MAXDWORD) {
        DEBUGMSG(ZONE_ENUM,(TEXT("QciBus: Activate Child LoaderDriver at order %d \r\n"),dwCurOrder));
        DWORD dwNextOrder = MAXDWORD;
        pCurDevice = (SensorFolder *)GetDeviceList ();
        while (pCurDevice) {
            DWORD dwDeviceLoadOrder = pCurDevice->GetLoadOrder();
            if ( dwDeviceLoadOrder == dwCurOrder)
            {
                SetLastError(0);
                BOOL rv = pCurDevice->LoadDevice();
            }
            else 
            if (dwDeviceLoadOrder> dwCurOrder  && dwDeviceLoadOrder < dwNextOrder)
                dwNextOrder = dwDeviceLoadOrder;
            pCurDevice = (SensorFolder *)pCurDevice->GetNextDeviceFolder();
        }
        dwCurOrder = dwNextOrder;
    }
    LeaveReadLock();
    return TRUE;
}

BOOL QciBus::FastIOControl(DWORD dwCode, PBYTE pBufIn, DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut,
                           PDWORD pdwActualOut,DeviceFolder **ppDeviceFolder )
{
    BOOL  rc   = TRUE;
    
    switch (dwCode)
    {
    case IOCTL_QCI_SET_INTERFACE:
        if (pBufIn == NULL || dwLenIn < sizeof(qci_interface_t))
            goto err;

        __try
        {
            //qci_set_interface((qci_interface_t*)pBufIn);
            QCISetInterface((qci_interface_t*)pBufIn);
        }
        __except( EXCEPTION_EXECUTE_HANDLER )
        {
            goto err;
        }

        break;
    case IOCTL_QCI_CLOCK_ENABLE:
    {        
        if (pBufIn == NULL || dwLenIn < sizeof(BOOL))
            goto err;

        __try
        {            
            QCIClockEnable(*(BOOL*)pBufIn);
        }
        __except( EXCEPTION_EXECUTE_HANDLER )
        {
            goto err;
        }

        break;
    }
    case IOCTL_QCI_ENABLE:
        QCIEnable();
        break;
    case IOCTL_QCI_SET_MASTER_TIMING:
        if (pBufIn == NULL || dwLenIn < sizeof(qci_master_timing_t))
            goto err;

        __try
        {
            QCISetMasterTiming((qci_master_timing_t*)pBufIn);
        }
        __except( EXCEPTION_EXECUTE_HANDLER )
        {
            goto err;
        }

        break;
    case IOCTL_QCI_SET_IMAGE_FORMAT:
        {
            if (pBufIn == NULL || dwLenIn < sizeof(int) * 2)
                goto err;

            int* in_format = (int*)pBufIn;
            int* out_format = in_format + 1;

            __try
            {
                QCISetImageFormat(*in_format, *out_format);
            }        
            __except( EXCEPTION_EXECUTE_HANDLER )
            {
                goto err;
            }
        }
        break;
    case IOCTL_QCI_START_CAPTURE:
        {
            int still_skips;

            __try
            {
                still_skips = *(int*)pBufIn;
            }        
            __except( EXCEPTION_EXECUTE_HANDLER )
            {
                goto err;
            }

            QCICaptureStart(still_skips);
            break;
        }

    case IOCTL_QCI_STOP_CAPTURE:
        QCICaptureStop();
        break;

    case IOCTL_QCI_SET_CAPTURE_CALLBACK:
        {
            if (pBufIn == NULL || dwLenIn < sizeof(callback_data_t))
                goto err;
            callback_data_t* callback_data = (callback_data_t*)pBufIn;

            __try
            {                
                QCIAddCallBack(callback_data);
            }
            __except( EXCEPTION_EXECUTE_HANDLER )
            {
                goto err;
            }
        }
        break;
    case IOCTL_QCI_NOTIFY_FORMAT:
        {
            if (pBufIn == NULL || dwLenIn < sizeof(format_t))
                goto err;
            format_t* format = (format_t*) pBufIn;            
            QCIDMAPrepareFormat(format);
        }

    case IOCTL_QCI_SET_FRAME_FORMAT:
        {
            if (pBufIn == NULL || dwLenIn < sizeof(format_t))
                goto err;
            format_t* format = (format_t*) pBufIn;            
            QCIDMASetFrameFormat(format);
        }
        
        break;
    case IOCTL_QCI_SET_IMAGE_PROC_CFG:
        __try
        {
            QCIImageProcCfg((qci_image_proc_cfg_t*)pBufIn);
        }
        __except( EXCEPTION_EXECUTE_HANDLER )
        {
            goto err;
        }
        break;
    default:
        return DefaultBusDriver::FastIOControl(dwCode, pBufIn, dwLenIn, 
            pBufOut, dwLenOut, pdwActualOut, ppDeviceFolder);
        break;
    }

    return rc;
err:
    DEBUGMSG(ZONE_IOCTL,(L"QciBus: IOCTL 0x%x failed for invalid parameter\r\n",dwCode));

    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
}


extern "C" void
QCI_Deinit (DWORD dwData)
{
    DefaultBusDriver * pBusDriver = (DefaultBusDriver*) dwData;
    if (pBusDriver != NULL) 
        delete pBusDriver;
}

extern "C" BOOL 
QCI_PowerUp(DWORD dwData)
{

    //power_on();
    QCIPowerOn();
    return TRUE;
}

extern "C" BOOL 
QCI_PowerDown(DWORD dwData)
{
    return TRUE;
}

#define FASTBUSACCESS_TAG 0xDEFBa51e
typedef struct __FASTBUSACCESSHANDLE {
    DWORD dwHandleTag;
    DefaultBusDriver * pBusDriver;
    DeviceFolder     * pDeviceFolder;    
} FASTBUSACCESSHANDLE, *PFASTBUSACCESSHANDLE ;

extern "C" HANDLE
QCI_Open(
        HANDLE  pHead,          // @parm Handle returned by COM_Init.
        DWORD   AccessCode,     // @parm access code.
        DWORD   ShareMode       // @parm share mode - Not used in this driver.
        )
{
    DefaultBusDriver * pBusDriver = (DefaultBusDriver * )pHead;
    if (pBusDriver && pBusDriver->Open(AccessCode,ShareMode)) {
        PFASTBUSACCESSHANDLE pFastAccessHandle = new FASTBUSACCESSHANDLE;
        if (pFastAccessHandle) {
            pFastAccessHandle->dwHandleTag = FASTBUSACCESS_TAG;
            pFastAccessHandle->pBusDriver = pBusDriver;
            pFastAccessHandle->pDeviceFolder = NULL ; 
            return (HANDLE)pFastAccessHandle;
        }
        else 
            pBusDriver->Close();
    }
    return NULL;
}

extern "C" BOOL
QCI_Close(HANDLE pOpenHead)
{
    PFASTBUSACCESSHANDLE pFastAccessHandle = (PFASTBUSACCESSHANDLE) pOpenHead ;
    if (pFastAccessHandle && pFastAccessHandle->dwHandleTag ==FASTBUSACCESS_TAG ) {
        pFastAccessHandle->pBusDriver->Close();
        delete pFastAccessHandle ;
    }
    return FALSE;
}

extern "C" BOOL
QCI_IOControl(HANDLE pOpenHead,
              DWORD dwCode, PBYTE pBufIn,
              DWORD dwLenIn, PBYTE pBufOut, DWORD dwLenOut,
              PDWORD pdwActualOut)
{
    PFASTBUSACCESSHANDLE pFastAccessHandle = (PFASTBUSACCESSHANDLE) pOpenHead ;

    if (pFastAccessHandle && pFastAccessHandle->dwHandleTag ==FASTBUSACCESS_TAG )
        return pFastAccessHandle->pBusDriver->FastIOControl(dwCode,pBufIn,dwLenIn,pBufOut,dwLenOut,pdwActualOut,
            &(pFastAccessHandle->pDeviceFolder));
    return FALSE;
}

//
// driver entry point.
//
extern "C" DWORD
QCI_Init(DWORD key)
{
    QciBus * pQCI = new QciBus((LPCTSTR)key);
    if (pQCI) 
    {
        if (pQCI->Init())
            return  (DWORD)pQCI;
        else
            delete  pQCI;
    }
    return NULL;
}

extern "C" BOOL WINAPI
DllEntry(HINSTANCE DllInstance, INT Reason, LPVOID Reserved)
{
    switch(Reason) 
    {
    case DLL_PROCESS_ATTACH:
        DEBUGREGISTER(DllInstance);
        DEBUGMSG(ZONE_INIT,(TEXT("QciBus.DLL DLL_PROCESS_ATTACH\r\n")));
        DisableThreadLibraryCalls((HMODULE) DllInstance);
        break;
    case DLL_PROCESS_DETACH:
        DEBUGMSG(ZONE_INIT,(TEXT("QciBus.DLL DLL_PROCESS_DETACH\r\n")));
        break;
    };
    return TRUE;
}