system.c

三星2410的BSP开发包

        if ((status != ERROR_SUCCESS) || (dwSize > sizeof(psdi->szProfile))){
            DEBUGMSG(ZONE_INIT|ZONE_ERROR,
                (TEXT("ATADISK:GetFolderName - RegQueryValueEx(Profile) returned %d\r\n"),
                      status));
            wcscpy( psdi->szProfile, L"Default");
        } else {
            DEBUGMSG(ZONE_INIT|ZONE_ERROR,
                (TEXT("ATADISK:GetProfileName - Profile = %s, length = %d\r\n"),
                 psdi->szProfile, dwSize));
        }
        RegCloseKey(DriverKey);
    }

    
    psdi->dwDeviceClass = STORAGE_DEVICE_CLASS_BLOCK;
    psdi->dwDeviceType = STORAGE_DEVICE_TYPE_PCCARD;
    psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_ATA;
    psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_REMOVABLE_DRIVE;
    psdi->dwDeviceFlags = STORAGE_DEVICE_FLAG_READWRITE;
    return TRUE;
}
//
// File system device entrypoints (DSK_????)
//

//
// Returns context data (PDISK) for this Init instance or 0 for failure.
//
// Arguments:
//      dwContext - registry path for this device's active key
//
DWORD
DSK_Init(
    DWORD dwContext
    )
{
    DWORD ret;
    CARD_SOCKET_HANDLE hSock;
    LPTSTR ActiveKey = (LPTSTR)dwContext;

    DEBUGMSG(ZONE_INIT,
        (TEXT("ATADISK: DSK_Init\r\n")));

    //
    // Get the socket number from the device's active key.
    //
    ret = ATAGetSocket(ActiveKey, &hSock);
    if (ret) {
        DEBUGMSG(ZONE_INIT,
            (TEXT("ATADISK:DSK_Init ATAGetSocket failed %d\r\n"),
            ret));
        return 0;
    }

    if (ATADetect(hSock) == TRUE) {
        return (DWORD)ATAInit(hSock, ActiveKey);
    } else {
        DEBUGMSG(ZONE_INIT,
            (TEXT("ATADISK:DSK_Init Non-ATA device inserted\r\n")));
        return 0;
    }
}   // DSK_Init


BOOL
DSK_Close(
    DWORD Handle
    )
{
    BOOL bClose = TRUE;
    PDISK pDisk = (PDISK)Handle;

    DEBUGMSG(ZONE_IO, (TEXT("ATADISK: DSK_Close\r\n")));

    if (!IsValidDisk(pDisk)) {
        return FALSE;
    }

    if (pDisk->d_DiskCardState == STATE_OPENED) {
        EnterCriticalSection(&(pDisk->d_DiskCardCrit));
        pDisk->d_OpenCount--;
        if (pDisk->d_OpenCount == 0) {
            pDisk->d_DiskCardState = STATE_CLOSED;
        } else {
            bClose = FALSE;
        }
        LeaveCriticalSection(&(pDisk->d_DiskCardCrit));
    }
    if (bClose == TRUE) {
        SetEvent(pDisk->d_IRQEvent);
    }
    return TRUE;
}   // DSK_Close


//
// Device deinit - devices are expected to close down.
// The device manager does not check the return code.
//
BOOL
DSK_Deinit(
    DWORD dwContext     // pointer to the per disk structure
    )
{
    PDISK pDisk = (PDISK)dwContext;

    DEBUGMSG(ZONE_INIT, (TEXT("ATADISK: DSK_Deinit\r\n")));

    DSK_Close(dwContext);
    CloseDisk(pDisk);
    return TRUE;
}   // DSK_Deinit

//
// Returns handle value for the open instance.
//
DWORD
DSK_Open(
    DWORD dwData,
    DWORD dwAccess,
    DWORD dwShareMode
    )
{
    PDISK pDisk = (PDISK)dwData;
    DWORD ret = 0;


    DEBUGMSG(ZONE_IO, (TEXT("ATADISK: DSK_Open(0x%x)\r\n"),dwData));

    if (IsValidDisk(pDisk) == FALSE) {
        DEBUGMSG(ZONE_IO, (TEXT("ATADISK: DSK_Open - Passed invalid disk handle\r\n")));
        return ret;
    }

    if ((pDisk->d_DiskCardState != STATE_CLOSED) &&
        (pDisk->d_DiskCardState != STATE_OPENED)) {
        SetLastError(GetDiskStateError(pDisk->d_DiskCardState));
        return ret;
    }

    EnterCriticalSection(&(pDisk->d_DiskCardCrit));
    if (pDisk->d_DiskCardState == STATE_CLOSED) {
        pDisk->d_DiskCardState = STATE_OPENED;
    }
    ret = (DWORD)pDisk;
    pDisk->d_OpenCount++;
    LeaveCriticalSection(&(pDisk->d_DiskCardCrit));

    return ret;
}   // DSK_Open


//
// I/O Control function - responds to info, read and write control codes.
// The read and write take a scatter/gather list in pInBuf
//
BOOL
DSK_IOControl(
    DWORD Handle,
    DWORD dwIoControlCode,
    PBYTE pInBuf,
    DWORD nInBufSize,
    PBYTE pOutBuf,
    DWORD nOutBufSize,
    PDWORD pBytesReturned
    )
{
    PDISK pDisk = (PDISK)Handle;
    PSG_REQ pSG;

    if (IsValidDisk(pDisk) == FALSE) {
        SetLastError(ERROR_INVALID_HANDLE);
        return FALSE;
    }

    if (pDisk->d_DiskCardState != STATE_OPENED) {
        SetLastError(GetDiskStateError(pDisk->d_DiskCardState));
        return FALSE;
    }

    //
    // Check parameters
    //
    switch (dwIoControlCode) {
    case DISK_IOCTL_READ:
    case DISK_IOCTL_WRITE:
    case DISK_IOCTL_GETINFO:
    case DISK_IOCTL_SETINFO:
    case DISK_IOCTL_INITIALIZED:
        if (pInBuf == NULL) {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
        break;
    case IOCTL_DISK_DEVICE_INFO:
        if ((nInBufSize== 0) || (pInBuf== NULL))
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
        break;             
                

    case DISK_IOCTL_GETNAME:
    case IOCTL_DISK_GET_STORAGEID:  // this is a new op, so use new codes //
        if (pOutBuf == NULL) {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
        break;

    case DISK_IOCTL_FORMAT_MEDIA:
        SetLastError(ERROR_SUCCESS);
        return TRUE;

    case IOCTL_POWER_CAPABILITIES: 
        if (!pOutBuf || nOutBufSize < sizeof(POWER_CAPABILITIES) || !pBytesReturned) {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
        break;

    case IOCTL_POWER_SET:
    case IOCTL_POWER_QUERY:
        if (!pOutBuf || nOutBufSize < sizeof(CEDEVICE_POWER_STATE) || !pBytesReturned) {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
        break;

    default:
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    //
    // Execute dwIoControlCode
    //
    switch (dwIoControlCode) {
    case DISK_IOCTL_READ:
    case DISK_IOCTL_WRITE:
        pSG = (PSG_REQ)pInBuf;
        DoDiskIO(pDisk, dwIoControlCode, pSG);
        if (pSG->sr_status) {
            SetLastError(pSG->sr_status);
            return FALSE;
        }
        return TRUE;

    case DISK_IOCTL_GETINFO:
        SetLastError(GetDiskInfo(pDisk, (PDISK_INFO)pInBuf));
        return TRUE;

    case DISK_IOCTL_SETINFO:
        SetLastError(SetDiskInfo(pDisk, (PDISK_INFO)pInBuf));
        return TRUE;

    case DISK_IOCTL_INITIALIZED:
        //
        // Load and initialize the associated file system driver
        //
        if (InitFSD((PPOST_INIT_BUF)pInBuf)) {
            DEBUGMSG(ZONE_INIT, (TEXT("ATADISK: InitFSD succeeded\r\n")));
        } else {
            DEBUGMSG(ZONE_INIT, (TEXT("ATADISK: InitFSD failed\r\n")));
        }
        return TRUE;
        
    case IOCTL_DISK_DEVICE_INFO:
        if (pBytesReturned)
            *(pBytesReturned) = sizeof(STORAGEDEVICEINFO);
        return GetDeviceInfo(pDisk, (STORAGEDEVICEINFO *)pInBuf);             

    case DISK_IOCTL_GETNAME:
        return GetFolderName(pDisk, (LPWSTR)pOutBuf, nOutBufSize, pBytesReturned);

    case IOCTL_DISK_GET_STORAGEID:
        return GetStorageID(pDisk,
                            (PSTORAGE_IDENTIFICATION)pOutBuf,
                            nOutBufSize,
                            pBytesReturned);

    case IOCTL_POWER_CAPABILITIES: 
    {
        PPOWER_CAPABILITIES ppc = (PPOWER_CAPABILITIES)pOutBuf;
        
        memset(ppc, 0, sizeof(POWER_CAPABILITIES));
        
        // TODO: get these from the device
        // Fake it for now...
        ppc->DeviceDx = 0x11;   // supports D0 & D4

        // supported power & latency info
        ppc->Power[D0] = PwrDeviceUnspecified;     // mW
        ppc->Power[D4] = PwrDeviceUnspecified;     
        ppc->Latency[D0] = 0;   // mSec
        ppc->Latency[D4] = 0;
        
        ppc->WakeFromDx = 0;    // no device wake
        ppc->InrushDx = 0;      // no inrush
        
        ppc->Flags = POWER_DRIVER;

        *pBytesReturned = sizeof(POWER_CAPABILITIES);
        return TRUE;
    } break;

    case IOCTL_POWER_QUERY: {
        CEDEVICE_POWER_STATE Dx = *(PCEDEVICE_POWER_STATE)pOutBuf;
        DEBUGMSG(1, (TEXT("ATADISK: IOCTL_POWER_QUERY: D%d\r\n"), Dx));
        // return PwrDeviceUnspecified if the device needs to reject the query
        *pBytesReturned = sizeof(Dx);
        return TRUE;
    } break;

    case IOCTL_POWER_SET: 
    {
        CEDEVICE_POWER_STATE Dx = *(PCEDEVICE_POWER_STATE)pOutBuf;
        
        DEBUGMSG(1, (TEXT("ATADISK: IOCTL_POWER_SET: D%d\r\n"), Dx));

        // TODO: set Dx on the device
        if (Dx != D0) {
            // return the actual value set on the device
            // since we currently do not set Dx then return D0
            *(PCEDEVICE_POWER_STATE)pOutBuf = D0;
        }
        
        *pBytesReturned = sizeof(Dx);
        return TRUE;
    }

    }
    return FALSE;
}   // DSK_IOControl


DWORD DSK_Read(DWORD Handle, LPVOID pBuffer, DWORD dwNumBytes){return 0;}
DWORD DSK_Write(DWORD Handle, LPCVOID pBuffer, DWORD dwNumBytes){return 0;}
DWORD DSK_Seek(DWORD Handle, long lDistance, DWORD dwMoveMethod){return 0;}
void DSK_PowerUp(void){}

//
// Mark all disks on power down to avoid race between DCD wakeup activity
// and forced PCMCIA card removal due to power up.
//
void
DSK_PowerDown(void)
{
    PDISK pd;

    pd = v_DiskList;
    while (pd) {
        pd->d_DiskCardState = STATE_DEAD;
        pd = pd->d_next;
    }
}


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

    CardStatus.hSocket = hSock;
    status = v_pfnCardGetStatus(&CardStatus);
    if (status == CERR_SUCCESS) {
        if (CardStatus.fCardState & EVENT_MASK_CARD_DETECT) {
            return TRUE;
        }