diskio.c

2443 wince5.0 bsp, source code

        free(pTempBuf);

    }
    return 0;    
}   // MMCWRITE


#endif
#if 1
//
// DoDiskIO - fulfill I/O requests
//
DWORD
DoDiskIO(
    PDISK pDisk,
    DWORD Opcode,
    PSG_REQ pSgr
    )
{
    DWORD status;
    
    //RETAILMSG(RTL_MSG, (TEXT("### ATAPI:DoDiskIO entered with Code : 0x%x\r\n"),Opcode));
    pSgr->sr_status = ERROR_IO_PENDING;

    if (pSgr->sr_num_sg > MAX_SG_BUF) {
    status = ERROR_INVALID_PARAMETER;
    goto ddi_exit;
    }

    if (pDisk->d_DiskCardState != STATE_OPENED) {
    status = GetDiskStateError(pDisk->d_DiskCardState);
    goto ddi_exit;
    }


    EnterCriticalSection(&(pDisk->d_DiskCardCrit));

    if (pDisk->d_DiskCardState != STATE_OPENED) {
    status = GetDiskStateError(pDisk->d_DiskCardState);
    goto ddi_leave;
    }

    if (!IsCardInserted(pDisk)) {
    DEBUGMSG(ZONE_WARNING|ZONE_ERROR|ZONE_IO, 
        (TEXT("MMCDISK:DoDiskIO - CF Card no longer present!\r\n")));
    if (pDisk->d_DiskCardState != STATE_DEAD) {
        pDisk->d_DiskCardState = STATE_REMOVED;
    }
    status = DISK_REMOVED_ERROR;
    goto ddi_leave;
    }
    DEBUGMSG(ZONE_IO,  (TEXT("MMCDISK:DoDiskIO - working on request @ 0x%x from sector %d to %d\r\n"), pSgr, pSgr->sr_start, pSgr->sr_start + pSgr->sr_num_sec - 1));
    if ((Opcode == DISK_IOCTL_READ) || (Opcode == IOCTL_DISK_READ))
    {
    	status = ATAREAD(pDisk, pSgr);
    } 
    else 
    {
    	
    	status = ATAWRITE(pDisk, pSgr);
    }
#ifdef DEBUG
    if (status != ERROR_SUCCESS) {
        DWORD  i;
        DEBUGMSG( ZONE_ERROR, (L"SDMMC Failed with error code = %08X start sector=%ld sgcount=%ld\r\n", status, pSgr->sr_start, pSgr->sr_num_sg));
        for(i = 0; i < pSgr->sr_num_sg;i++) {
            DEBUGMSG( ZONE_ERROR,(L"     Buffer = %08X Size=%ld\r\n", pSgr->sr_sglist[i].sb_buf, pSgr->sr_sglist[i].sb_len));
        }
    }
#endif

ddi_leave:
    LeaveCriticalSection(&(pDisk->d_DiskCardCrit));

ddi_exit:
    DEBUGMSG(ZONE_IO, (TEXT("MMCDISK:DoDiskIO done\r\n")));
    pSgr->sr_status = status;
    return status;
}   // DoDiskIO


//#ifdef DEBUG
VOID
FormatSBCS(
    PUCHAR p,
    LPTSTR pT,
    DWORD len
    )
{
    while (len) {
    if ((*p > 0x20) && (*p < 0x7F)) {
        *pT = (TCHAR)*p;
    } else {
        *pT = (TCHAR)'.';
    }
    pT++;
    p++;
    len--;
    }
    *pT = 0;    // Terminate the string
}   // FormatSBCS
//#endif // DEBUG


//
// GetDiskInfo - return disk info in response to DISK_IOCTL_GETINFO
//
DWORD
GetDiskInfo(
    PDISK pDisk,
    PDISK_INFO pInfo
    )
{
    *pInfo = pDisk->d_DiskInfo;
    pInfo->di_flags |= DISK_INFO_FLAG_PAGEABLE;
    pInfo->di_flags &= ~DISK_INFO_FLAG_UNFORMATTED;
    return ERROR_SUCCESS;
}   // GetDiskInfo


//
// SetDiskInfo - store disk info in response to DISK_IOCTL_SETINFO
//
DWORD
SetDiskInfo(
    PDISK pDisk,
    PDISK_INFO pInfo
    )
{
    DWORD sectsize;


    sectsize = pDisk->d_DiskInfo.di_bytes_per_sect;
    pDisk->d_DiskInfo   = *pInfo;

    return ERROR_SUCCESS;
}   // SetDiskInfo

#ifdef DEBUG
void DumpRegKey( DWORD dwZone, PTSTR szKey, HKEY hKey)
{
    DWORD dwIndex=0;
    WCHAR szValueName[MAX_PATH];
    DWORD dwValueNameSize = MAX_PATH;
    BYTE pValueData[256];
    DWORD dwType;
    DWORD dwValueDataSize = sizeof(pValueData);
    DEBUGMSG( dwZone, (TEXT("Dumping registry for key %s \r\n"), szKey));
    while(ERROR_SUCCESS == RegEnumValue( hKey, dwIndex, szValueName, &dwValueNameSize, NULL, &dwType, pValueData, &dwValueDataSize)) {
        if (REG_SZ == dwType) {
            DEBUGMSG( dwZone, (TEXT("\t\t%s = %s\r\n"), szValueName, (LPWSTR)pValueData));
        } else
        if (REG_DWORD == dwType) {
            DEBUGMSG( dwZone, (TEXT("\t\t%s = %08X\r\n"), szValueName, *(PDWORD)pValueData));
        }
        dwIndex++;
        dwValueDataSize = sizeof(pValueData);
        dwValueNameSize = MAX_PATH;
    }
}

#define DUMPREGKEY(dwZone, szKey, hKey) DumpRegKey(dwZone, szKey, hKey)
#else
#define DUMPREGKEY(dwZone, szKey, hKey)
#endif

//
// Function to open the driver key specified by the active key
//
// The caller is responsible for closing the returned HKEY
//
#endif

HKEY
OpenDriverKey(
    LPTSTR ActiveKey
    )
{
    TCHAR DevKey[256];
    HKEY hDevKey;
    HKEY hActive;
    DWORD ValType;
    DWORD ValLen;
    DWORD status;

    //
    // Get the device key from active device registry key
    //
    status = RegOpenKeyEx(
        HKEY_LOCAL_MACHINE,
        ActiveKey,
        0,
        0,
        &hActive);

    
    if (status) {
    DEBUGMSG(ZONE_INIT|ZONE_ERROR, (TEXT("MMCDISK:OpenDriverKey RegOpenKeyEx(HLM\\%s) returned %d!!!\r\n"), ActiveKey, status));
    return NULL;
    }
#ifdef DEBUG
//    DUMPREGKEY( ZONE_INIT, ActiveKey, hActive);
#endif

    hDevKey = NULL;

    ValLen = sizeof(DevKey);
    status = RegQueryValueEx(
        hActive,
        DEVLOAD_DEVKEY_VALNAME,
        NULL,
        &ValType,
        (PUCHAR)DevKey,
        &ValLen);
    if (status != ERROR_SUCCESS) {
    DEBUGMSG(ZONE_INIT|ZONE_ERROR, (TEXT("MMCDISK:OpenDriverKey - RegQueryValueEx(%s) returned %d\r\n"), DEVLOAD_DEVKEY_VALNAME, status));
    goto odk_fail;
    }

    //
    // Get the geometry values from the device key
    //
    status = RegOpenKeyEx(
        HKEY_LOCAL_MACHINE,
        DevKey,
        0,
        0,
        &hDevKey);
    if (status) {
    hDevKey = NULL;
    DEBUGMSG(ZONE_INIT|ZONE_ERROR, (TEXT("MMCDISK:OpenDriverKey RegOpenKeyEx(HLM\\%s) returned %d!!!\r\n"), DevKey, status));
    }
//    DUMPREGKEY( ZONE_INIT, DevKey, hDevKey);

odk_fail:
    RegCloseKey(hActive);
    return hDevKey;
}   // OpenDriverKey

//
// Function to retrieve the folder name value from the driver key. The folder name is
// used by FATFS to name this disk volume.
//

int
GetFolderName(
    PDISK pDisk,
    LPWSTR FolderName,
    DWORD cBytes,
    DWORD * pcBytes
    )
{
    HKEY DriverKey;
    DWORD ValType;
    DWORD status;

    DriverKey = OpenDriverKey(pDisk->d_ActivePath);
    if (DriverKey) {
    *pcBytes = cBytes;
    status = RegQueryValueEx(
            DriverKey,
            TEXT("Folder"),
            NULL,
            &ValType,
            (PUCHAR)FolderName,
            pcBytes);
    if (status != ERROR_SUCCESS) {
        //RETAILMSG(RTL_MSG, (TEXT("ATAPI:GetFolderName - RegQueryValueEx(Folder) returned %d\r\n"), status));
        *pcBytes = 0;
    } else {
        //RETAILMSG(RTL_MSG, (TEXT("ATAPI:GetFolderName - FolderName = %s, length = %d\r\n"), FolderName, *pcBytes));
       *pcBytes += sizeof(WCHAR); // account for terminating 0.
    }
    RegCloseKey(DriverKey);
    if (status || (*pcBytes == 0)) {
        SetLastError( ERROR_NOT_FOUND);
        return FALSE;
    }
    return TRUE;
    }
    return FALSE;
}   // GetFolderName

#if 1

int
GetStorageID(
    PDISK pDisk,
    PSTORAGE_IDENTIFICATION psid,
    DWORD cBytes,
    DWORD * pcBytes
    )
{
    DRV_GEOMETRY_DESC * pmy_geom_desc;
    DRV_GEOMETRY_DESC my_geom_desc;
    PCHAR pDstOffset;
    WORD str_length;
    
    if (cBytes < sizeof(*psid)) {
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
    }
    __try {
    psid->dwSize = sizeof(*psid);
    psid->dwFlags = 0;  // can be or of {MANUFACTUREID,SERIALNUM}_INVALID
    psid->dwManufactureIDOffset = 0;
        pDstOffset = (PCHAR)(psid + 1);
        psid->dwSerialNumOffset = pDstOffset - (PCHAR) psid;
    } __except (EXCEPTION_EXECUTE_HANDLER) {
    SetLastError(ERROR_INVALID_PARAMETER);
    return FALSE;
    }

    pmy_geom_desc=&my_geom_desc;

/*

if (mmc_read_serial(0, pmy_geom_desc) == FALSE) {   //go get the serial number
    return FALSE;
    }

*/
    psid->dwFlags = MANUFACTUREID_INVALID;
/*
    str_length=strlen(&my_geom_desc.serialNum[0]);

    if ((sizeof(*psid)+str_length+1) > cBytes) {
    	SetLastError(ERROR_INSUFFICIENT_BUFFER);
    } else {
	    memcpy(pDstOffset, &my_geom_desc.serialNum[0], str_length + 1);
	}
    pDstOffset += (str_length + 1);

    psid->dwSize = pDstOffset - (PCHAR)psid;    // required size

    *pcBytes = min(psid->dwSize, cBytes);       // bytes written
*/
    return (GetLastError() == ERROR_SUCCESS);
}

#endif

//
// InitDisk
//
DWORD InitDisk(
    PDISK pDisk
    )
{
	//RETAILMSG(RTL_MSG, (TEXT("+++ ATAPI_CF : Before Entering AtapiDeviceInit()\r\n")));
    if (!(AtapiDeviceInit())) {    //init MMC
   	 return TRUE;
    }

    pDisk->d_fLBAMode = TRUE;

    pDisk->d_DiskInfo.di_bytes_per_sect = BYTES_PER_SECTOR; // Start with 512, then go with SetInfo changes
    pDisk->d_DiskInfo.di_cylinders = g_pcPC->drive->num_cylinders;
    pDisk->d_DiskInfo.di_heads = g_pcPC->drive->num_heads;
    pDisk->d_DiskInfo.di_sectors = g_pcPC->drive->sec_p_track;
    pDisk->d_DiskInfo.di_total_sectors = g_pcPC->drive->total_lba;
    pDisk->d_DiskInfo.di_flags = DISK_INFO_FLAG_MBR;

    return 0;
}   // Initdisk