system_original.c

三星2410的BSP开发包

    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


#ifdef DEBUG
typedef struct _EVENT_NAME_TBL {
    CARD_EVENT EventCode;
    LPTSTR    pEventName;
} EVENT_NAME_TBL, *PEVENT_NAME_TBL;

#define LAST_EVENT_CODE ((CARD_EVENT) -1)

//
// Table of callback event codes and their names.
// NOTE: The names with ! at the end are not expected.
//
EVENT_NAME_TBL v_EventNames[] = {
    { CE_BATTERY_DEAD,          TEXT("CE_BATTERY_DEAD") },
    { CE_BATTERY_LOW,           TEXT("CE_BATTERY_LOW") },
    { CE_CARD_LOCK,             TEXT("CE_CARD_LOCK") },
    { CE_CARD_READY,            TEXT("CE_CARD_READY") },
    { CE_CARD_REMOVAL,          TEXT("CE_CARD_REMOVAL") },
    { CE_CARD_UNLOCK,           TEXT("CE_CARD_UNLOCK") },
    { CE_EJECTION_COMPLETE,     TEXT("CE_EJECTION_COMPLETE!") },
    { CE_EJECTION_REQUEST,      TEXT("CE_EJECTION_REQUEST!") },
    { CE_INSERTION_COMPLETE,    TEXT("CE_INSERTION_COMPLETE!") },
    { CE_INSERTION_REQUEST,     TEXT("CE_INSERTION_REQUEST!") },
    { CE_PM_RESUME,             TEXT("CE_PM_RESUME!") },
    { CE_PM_SUSPEND,            TEXT("CE_PM_SUSPEND!") },
    { CE_EXCLUSIVE_COMPLETE,    TEXT("CE_EXCLUSIVE_COMPLETE") },
    { CE_EXCLUSIVE_REQUEST,     TEXT("CE_EXCLUSIVE_REQUEST") },
    { CE_RESET_PHYSICAL,        TEXT("CE_RESET_PHYSICAL") },
    { CE_RESET_REQUEST,         TEXT("CE_RESET_REQUEST") },
    { CE_CARD_RESET,            TEXT("CE_CARD_RESET") },
    { CE_MTD_REQUEST,           TEXT("CE_MTD_REQUEST!") },
    { CE_CLIENT_INFO,           TEXT("CE_CLIENT_INFO!") },
    { CE_TIMER_EXPIRED,         TEXT("CE_TIMER_EXPIRED!") },
    { CE_SS_UPDATED,            TEXT("CE_SS_UPDATED!") },
    { CE_WRITE_PROTECT,         TEXT("CE_WRITE_PROTECT") },
    { CE_CARD_INSERTION,        TEXT("CE_CARD_INSERTION") },
    { CE_RESET_COMPLETE,        TEXT("CE_RESET_COMPLETE") },
    { CE_ERASE_COMPLETE,        TEXT("CE_ERASE_COMPLETE!") },
    { CE_REGISTRATION_COMPLETE, TEXT("CE_REGISTRATION_COMPLETE") },
    { LAST_EVENT_CODE,          TEXT("Unknown Event!") },
};

LPTSTR
FindEventName(
    CARD_EVENT EventCode
    )
{
    PEVENT_NAME_TBL pEvent = v_EventNames;

    while (pEvent->EventCode != LAST_EVENT_CODE) {
        if (pEvent->EventCode == EventCode) {
            return pEvent->pEventName;
        }
        pEvent++;
    }
    return pEvent->pEventName;
}
#endif // DEBUG


//
// This is the PCMCIA callback function specified in CardRegisterClient.
// PCMCIA indicates card insertions and removals by calling this function.
//
STATUS PcmciaCallBack(
    CARD_EVENT EventCode,
    CARD_SOCKET_HANDLE hSock,
    PCARD_EVENT_PARMS pParms
    )
{
    PDISK pDisk;

    DEBUGMSG(ZONE_PCMCIA,
        (TEXT("ATADISK: PcmciaCallBack(%s)\r\n"), FindEventName(EventCode)));

    pDisk = DiskFromSocket(hSock);

    switch (EventCode) {
    case CE_EXCLUSIVE_REQUEST:
        if (pDisk != NULL) {
            return CERR_IN_USE;    
        }

    case CE_CARD_REMOVAL:
        //
        // If this is not an artificial removal notice, then indicate that in the
        // disk's global state.
        //
        if (pDisk != NULL) {
            if (IsCardInserted(hSock) == FALSE) {
                EnterCriticalSection(&(pDisk->d_DiskCardCrit));
                if (pDisk->d_DiskCardState != STATE_DEAD) {
                    pDisk->d_DiskCardState = STATE_REMOVED;
                }
                LeaveCriticalSection(&(pDisk->d_DiskCardCrit));
                SetEvent(pDisk->d_IRQEvent);
            }
        }
        break;

    default:
        break;
    }
    return CERR_SUCCESS;
}   // PcmciaCallBack


static BOOL isVoltageNear (USHORT supply, USHORT demand)
{
    // Some cards don't report any power usage! They probably mean to be 5V.
    if (demand == 0)
        demand = 50;
    
    // True iff demand is in [0.9*supply, supply]
    // We need this because some cards ask for a nominal voltage of 3.0 V
    // rather than 3.3 V, and then don't specify min and peak values.
    // The 0.9 constant is arbitrary but sufficient for the 3.0/3.3 comparison
    // without matching the 5 V entries.
    return (demand <= supply && demand >= 9*supply/10);
}

//
// GetATAWindows return codes:
//
#define GAW_SUCCESS           0
#define GAW_PRIMARY_FAIL      1
#define GAW_SECONDARY_FAIL    2
#define GAW_MEMORY_FAIL       3
#define GAW_TRY_MEMORY_CFG    4

//
// I/O access capabilities (wtype)
//
#define ACCESS_MEMORY_ONLY 0
#define ACCESS_IO_8BIT     1
#define ACCESS_IO_16BIT    2
#define ACCESS_IO_ANY      3

//
// 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
GetATAWindows(
    PDISK pDisk,
    DWORD wtype,
    DWORD reg_base,
    DWORD modifier
    )
{
    CARD_WINDOW_PARMS WndParms;
    DWORD alt_base;
    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 = pDisk->d_hSock;

    switch (reg_base) {
    case 0: // memory configuration
        alt_base = ATA_ALT_MEM_REG_BASE;
        break;

    case ATA_IO_REG_BASE:
        alt_base = ATA_ALT_IO_REG_BASE;
        break;

    case ATA_IO_REG_BASE_SECONDARY:
        alt_base = ATA_ALT_IO_REG_BASE_SECONDARY;
        break;

    default:
        return GAW_MEMORY_FAIL;
    }

    switch (wtype) {
    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 (pDisk->d_Flags & 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)v_pfnCardRequestWindow(pDisk->d_hPcmcia, &WndParms);

    if (!(pDisk->d_Flags & ATADISK_FLAG_TRY8BIT)) {
        if (hATAReg == NULL) {
            //
            // The host may not have 16 bit I/O. Since the device allows 8 bit, try it.
            //
            if (wtype == ACCESS_IO_ANY) {
                wtype = ACCESS_IO_8BIT;
                WndParms.fAttributes  = WIN_ATTR_IO_SPACE;
                hATAReg = (CARD_WINDOW_HANDLE)v_pfnCardRequestWindow(pDisk->d_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_SECONDARY_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.
    //
    DEBUGMSG( 1, (L"Address ATADISK is going to map is at %08X Modifer=%08X\r\n", reg_base+modifier, modifier));
    pATAReg = (PVOID)v_pfnCardMapWindow(
                                    hATAReg,
                                    reg_base + modifier,
                                    ATA_REG_LENGTH,
                                    &v_MemGran);
    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));
        if (status == CERR_IN_USE) {
            if (reg_base == ATA_IO_REG_BASE) {
                 status = GAW_PRIMARY_FAIL;
                 goto gaw_error;
            }
        }
        status = (wtype == ACCESS_MEMORY_ONLY) ?
                                 GAW_MEMORY_FAIL : GAW_SECONDARY_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)v_pfnCardRequestWindow(pDisk->d_hPcmcia, &WndParms);
    if (hATARegAlt == NULL) {
        DEBUGMSG(ZONE_PCMCIA|ZONE_INIT|ZONE_ERROR,
            (TEXT("ATADISK: CardRequestWindow(hATARegAlt) failed %d\r\n"),
            GetLastError()));
        status = (wtype == ACCESS_MEMORY_ONLY) ?
                                 GAW_MEMORY_FAIL : GAW_SECONDARY_FAIL;
        goto gaw_error;
    }

    pATARegAlt = (PVOID)v_pfnCardMapWindow(
                                hATARegAlt,
                                alt_base + modifier,
                                ATA_ALT_REG_LENGTH,
                                &v_MemGran);
    if (pATARegAlt == NULL) {
        DEBUGMSG(ZONE_PCMCIA|ZONE_INIT|ZONE_ERROR,
            (TEXT("ATADISK: CardMapWindow(pATARegAlt) failed %d\r\n"),
            GetLastError()));
        status = (wtype == ACCESS_MEMORY_ONLY) ?
                                 GAW_MEMORY_FAIL : GAW_SECONDARY_FAIL;
        goto gaw_error;
    }

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

    pDisk->d_hATAReg = hATAReg;
    pDisk->d_pATAReg = pATAReg;
    pDisk->d_hATARegAlt = hATARegAlt;
    pDisk->d_pATARegAlt = pATARegAlt;

    if ((wtype == ACCESS_IO_16BIT) || ((wtype == ACCESS_IO_ANY) && !(pDisk->d_Flags & ATADISK_FLAG_TRY8BIT))) {
        pDisk->d_f16Bit = TRUE;
        DEBUGMSG(ZONE_PCMCIA|ZONE_INIT, (TEXT("ATADISK: Using 16 bit I/O\r\n")));
    }
    return GAW_SUCCESS;

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

}   // GetATAWindows


//
// ATAConfig - get required PCMCIA resources
// 1. Ask for status notifications on the socket
// 2. Find which PCMCIA I/O card configuration to use.
// 3. Request and map an I/O window to the ATA registers.
// 4. Request the PCMCIA interrupt
// 5. Request the configuration
//
// Return: CERR_SUCCESS or one of the CERR_* return codes.
//
DWORD
ATAConfig(
    PDISK pDisk
    )
{
    CARD_CONFIG_INFO CfgInfo;
    PARSED_CFTABLE CfTable[10];
    DWORD i,j,k;
    DWORD nCfg;
    DWORD status;
    DWORD reg_base;
    UCHAR req_vcc;
    BOOL fPowerAC;
    HANDLE hEvent;

    //
    // 1. Ask for status notifications on the socket
    //
    status = v_pfnCardRequestSocketMask(
                pDisk->d_hPcmcia,
                pDisk->d_hSock,
                0xff);  // all events for now
    if (status != CERR_SUCCESS) {
        DEBUGMSG(ZONE_PCMCIA|ZONE_INIT|ZONE_ERROR,
            (TEXT("ATADISK: CardRequestSocketMask failed %d\r\n"), status));
        return status;
    }