atapipcmcia.cpp

这是运行在windows ce 4.2 版本下的关于硬盘加载的驱动程序

                m_dwPCMCIAFlags |= ATADISK_FLAG_MEMORY_MAPPED;
                goto ac_address_ok;
            }
        }
    }

    DEBUGMSG(ZONE_PCMCIA|ZONE_INIT|ZONE_ERROR,
             (TEXT("ATADISK: Unable to find adequate configuration!\r\n")));
    return CERR_BAD_BASE;

ac_address_ok:
    //
    // 4. Request the PCMCIA interrupt
    //
    status = g_pfnCardRequestIRQ(
                m_hPcmcia,
                m_hSock,
                (CARD_ISR)PcmciaIntr,
                (DWORD)this);
    if (status != CERR_SUCCESS) {
        DEBUGMSG(ZONE_PCMCIA|ZONE_INIT|ZONE_ERROR,
            (TEXT("ATADISK: CardRequestIRQ failed %d\r\n"), status));
        if (hEvent) {
            CloseHandle( hEvent);
        }
        return status;
    }

    //
    // 5. Request the configuration (this will enable the interrupt)
    //
ac_req_config:
    CfgInfo.hSocket = m_hSock;
    CfgInfo.fAttributes = CFG_ATTR_IRQ_STEERING|CFG_ATTR_NO_IO_IS_8;
    CfgInfo.fInterfaceType = CFG_IFACE_MEMORY_IO;
    CfgInfo.uVcc = req_vcc;
    CfgInfo.uVpp1 = 0;
    CfgInfo.uVpp2 = 0;
    CfgInfo.fRegisters = CFG_REGISTER_CONFIG|CFG_REGISTER_STATUS;
    CfgInfo.uConfigReg = CfTable[i].ConfigIndex;
    CfgInfo.uStatusReg = 0;
    
    DEBUGMSG(ZONE_PCMCIA|ZONE_INIT,
             (TEXT("ATADISK: CardRequestConfiguration 0x%x at %d dV\r\n"),
              CfgInfo.uConfigReg, CfgInfo.uVcc));

    status = g_pfnCardRequestConfiguration(
                m_hPcmcia,
                &CfgInfo);
    if (status != CERR_SUCCESS) {
        DEBUGMSG(ZONE_PCMCIA|ZONE_INIT|ZONE_ERROR,
            (TEXT("ATADISK: CardRequestConfiguration failed %d\r\n"), status));

        if (status == CERR_BAD_VCC && (fPowerAC ? 50 : 33) == req_vcc) {
            req_vcc = fPowerAC ? 33 : 50;  // try the other known Vcc
            goto ac_req_config;
        }
    }

    return (status == CERR_SUCCESS);
}   


//
// GetATAWindows - Function to request and map memory or I/O windows
// required for the ATA interface.
//
// wtype is the I/O access capabilities for the card configuration.
//
// Return: one of the GAW_* codes defined above.
//
DWORD CPCMCIADisk::GetATAWindows(DWORD dwType, DWORD dwRegBase, DWORD dwAltBase, DWORD dwModifier)
{
    CARD_WINDOW_PARMS WndParms;
    DWORD status;
    CARD_WINDOW_HANDLE hATAReg;   // Handle to ATA register window
    PUCHAR pATAReg;
    CARD_WINDOW_HANDLE hATARegAlt;// Handle to ATA alternate reg window
    PUCHAR pATARegAlt;

    hATARegAlt = NULL;

    //
    // Get a window handle for the ATA card's registers
    //
    WndParms.hSocket = m_hSock;

    if (dwType == ACCESS_MEMORY_ONLY) dwAltBase = ATA_ALT_MEM_REG_BASE;

    switch (dwType) {
    case ACCESS_MEMORY_ONLY: // memory configuration
        WndParms.fAttributes  = 0;  // Common memory 8bit window 
        break;

    case ACCESS_IO_8BIT:
        WndParms.fAttributes  = WIN_ATTR_IO_SPACE;
        break;

    case ACCESS_IO_16BIT:
        WndParms.fAttributes  = WIN_ATTR_IO_SPACE|WIN_ATTR_16BIT;
        break;

    case ACCESS_IO_ANY:
        if (m_dwPCMCIAFlags & ATADISK_FLAG_TRY8BIT) {
            WndParms.fAttributes  = WIN_ATTR_IO_SPACE;
        } else {
            WndParms.fAttributes  = WIN_ATTR_IO_SPACE|WIN_ATTR_16BIT;
        }
        break;
        

    default:
        return GAW_MEMORY_FAIL;
    }

    WndParms.uWindowSize  = ATA_REG_LENGTH;
    WndParms.fAccessSpeed = WIN_SPEED_USE_WAIT;

    hATAReg = (CARD_WINDOW_HANDLE)g_pfnCardRequestWindow(m_hPcmcia, &WndParms);

    if (!(m_dwPCMCIAFlags & ATADISK_FLAG_TRY8BIT)) {
        if (hATAReg == NULL) {
            //
            // The host may not have 16 bit I/O. Since the device allows 8 bit, try it.
            //
            if (dwType == ACCESS_IO_ANY) {
                dwType = ACCESS_IO_8BIT;
                WndParms.fAttributes  = WIN_ATTR_IO_SPACE;
                hATAReg = (CARD_WINDOW_HANDLE)g_pfnCardRequestWindow(m_hPcmcia, &WndParms);
            }
        }
    }    

    if (hATAReg == NULL) {
        //
        // Device may not support I/O access - try to get a memory config
        //
        DEBUGMSG(ZONE_PCMCIA|ZONE_INIT|ZONE_ERROR,
            (TEXT("ATADISK: CardRequestWindow(hATAReg) failed %d, looking for memory configuration\r\n"),
            GetLastError()));
        status = GAW_PRIMARY_FAIL;
        goto gaw_error;
    }

    //
    // Map the command window now. If this fails we can tell the caller to try
    // the secondary ATA I/O port range.
    //
    pATAReg = (PBYTE)g_pfnCardMapWindow(
                                    hATAReg,
                                    dwRegBase + dwModifier,
                                    ATA_REG_LENGTH,
                                    &m_dwMemGran);
    if (pATAReg == NULL) {
        //
        // There may be another ATA device in the system. Tell the caller to
        // use the secondary ATA I/O range.
        //
        status = GetLastError();
        DEBUGMSG(ZONE_PCMCIA|ZONE_INIT|ZONE_ERROR,
            (TEXT("ATADISK: CardMapWindow(pATAReg) failed %d\r\n"),
            status));
        status = (dwType == ACCESS_MEMORY_ONLY) ?
                                 GAW_MEMORY_FAIL : GAW_PRIMARY_FAIL;
        goto gaw_error;
    }
    DEBUGMSG(ZONE_PCMCIA|ZONE_INIT,
        (TEXT("ATADISK: pATAReg = 0x%x\r\n"), pATAReg));

    WndParms.uWindowSize  = ATA_ALT_REG_LENGTH;
    hATARegAlt = (CARD_WINDOW_HANDLE)g_pfnCardRequestWindow(m_hPcmcia, &WndParms);
    if (hATARegAlt == NULL) {
        DEBUGMSG(ZONE_PCMCIA|ZONE_INIT|ZONE_ERROR,
            (TEXT("ATADISK: CardRequestWindow(hATARegAlt) failed %d\r\n"),
            GetLastError()));
        status = (dwType == ACCESS_MEMORY_ONLY) ?
                                 GAW_MEMORY_FAIL : GAW_SECONDARY_FAIL;
        goto gaw_error;
    }

    pATARegAlt = (PBYTE)g_pfnCardMapWindow(
                                hATARegAlt,
                                dwAltBase + dwModifier,
                                ATA_ALT_REG_LENGTH,
                                &m_dwMemGran);
    if (pATARegAlt == NULL) {
        DEBUGMSG(ZONE_PCMCIA|ZONE_INIT|ZONE_ERROR,
            (TEXT("ATADISK: CardMapWindow(pATARegAlt) failed %d\r\n"),
            GetLastError()));
        status = (dwType == ACCESS_MEMORY_ONLY) ?
                                 GAW_MEMORY_FAIL : GAW_SECONDARY_FAIL;
        goto gaw_error;
    }

    DEBUGMSG(ZONE_PCMCIA|ZONE_INIT,
        (TEXT("ATADISK: pATARegAlt = 0x%x. m_dwMemGran = %d\r\n"),
        pATARegAlt, m_dwMemGran));

    m_hATAReg = hATAReg;
    m_pATAReg = pATAReg;
    m_hATARegAlt = hATARegAlt;
    m_pATARegAlt = pATARegAlt;

    if ((dwType == ACCESS_IO_16BIT) || ((dwType == ACCESS_IO_ANY) && !(m_dwPCMCIAFlags & ATADISK_FLAG_TRY8BIT))) {
        m_f16Bit = TRUE;
        DEBUGMSG(ZONE_PCMCIA|ZONE_INIT, (TEXT("ATADISK: Using 16 bit I/O\r\n")));
    }
    return GAW_SUCCESS;

gaw_error:
    if (hATAReg) {
        g_pfnCardReleaseWindow(hATAReg);
    }
    if (hATARegAlt) {
        g_pfnCardReleaseWindow(hATARegAlt);
    }
    return status;

}   // GetATAWindows


//
// Returns TRUE if there is a card inserted in the specified socket
//
BOOL CPCMCIADisk::IsCardInserted(CARD_SOCKET_HANDLE hSock)
{
    STATUS status;
    CARD_STATUS CardStatus;

    CardStatus.hSocket = hSock;
    status = g_pfnCardGetStatus(&CardStatus);
    if (status == CERR_SUCCESS) {
        if (CardStatus.fCardState & EVENT_MASK_CARD_DETECT) {
            return TRUE;
        }
    } else {
        DEBUGMSG(ZONE_PCMCIA|ZONE_ERROR,
            (TEXT("ATADISK: CardGetStatus returned %d\r\n"), status));
    }
    return FALSE;
}   // IsCardInserted

void CPCMCIADisk::RemoveCardEvent(CARD_SOCKET_HANDLE hSock)
{
     if (IsCardInserted(hSock) == FALSE) {
 //       TakeCS();
        if (m_bState != STATE_DEAD) {
            m_bState = STATE_REMOVED;
        }
 //       ReleaseCS();
        SetEvent();
    }
}

/*------------------------------------------------------------------------------------------*/
DWORD CPCMCIADisk::GetDeviceInfo(PIOREQ pIOReq)
{
    PSTORAGEDEVICEINFO psdi = (PSTORAGEDEVICEINFO)pIOReq->pInBuf;
    HKEY hKey;
    if ((pIOReq->dwInBufSize== 0) ||
         (pIOReq->pInBuf== NULL))
    {
        return ERROR_INVALID_PARAMETER; 
    }
    
    if (pIOReq->pBytesReturned)
        *(pIOReq->pBytesReturned) = sizeof(STORAGEDEVICEINFO);

    if (ERROR_SUCCESS != RegOpenKeyEx( HKEY_LOCAL_MACHINE, m_szDeviceKey, 0, 0, &hKey)) {
        hKey = NULL;
    }   
    psdi->dwDeviceClass = STORAGE_DEVICE_CLASS_BLOCK;
    psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_REMOVABLE_DRIVE;
    psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_ATA;
    psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_PCCARD;
    psdi->dwDeviceFlags |= STORAGE_DEVICE_FLAG_READWRITE;
    if (!hKey || !AtaGetRegistryString( hKey, REG_VALUE_CDPROFILE, (PTSTR *)&psdi->szProfile, sizeof(psdi->szProfile))) {
        wcscpy( psdi->szProfile, REG_VALUE_PCMCIAPROFILE);
    }
    return ERROR_SUCCESS;
}
#else
EXTERN_C PTSTR PCMCIADetectATA(CARD_SOCKET_HANDLE hSock, UCHAR ucDevType, PTSTR szDevKey, DWORD  dwKeyLen)
{
    return NULL;
}    
#endif