diskio.c

针对Intel Xscale PXA255的WinCE boot loader源代码包！极具参考价值！

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/*++     
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

Module Name:  

    diskio.c

Abstract:  

    WINCE driver for MultiMediaCard      

Functions:

Notes:


--*/
#include <windows.h>
#include <types.h>
#include <tchar.h>
#include <excpt.h>
#include <devload.h>
#include <pkfuncs.h>

#include "diskio.h"
#include "sddisk.h"
#include "sdmmc.h"
#include "plx9054.h"




#if (USE_MEMMODE)
    volatile PUCHAR virtreg;
#endif
SDGLOBAL ADAPTER myAdapters[N_CONTROLLERS];


//SDGLOBAL SDBOOL scan_PCI_config(SDVOID);



//
// This module contains the functions:
//  CloseDisk
//  CheckMedia
//  MMCREAD
//  MMCWRITE
//  DoDiskIO
//  GetDiskInfo
//  SetDiskInfo
//  InitDisk
//

bool IsCardInserted(PDISK pDisk);
HKEY OpenDriverKey(LPTSTR ActiveKey);
BOOL GetFolderName(PDISK pDisk, LPWSTR FolderName, DWORD cBytes, DWORD * pcBytes);
BOOL GetStorageID(PDISK pDisk, PSTORAGE_IDENTIFICATION pOutBuf, DWORD nOutBufSize, DWORD * pBytesReturned);

//
// CloseDisk - finish and free all outstanding requests and free other resources
// associated with the specified disk
//
VOID
CloseDisk(
    PDISK pDisk
    )
{
    PDISK pd;

    DEBUGMSG(ZONE_IO, (TEXT("MMCDISK:CloseDisk closing 0x%x\r\n"), pDisk));

    //
    // Remove it from the global list of disks
    //
    EnterCriticalSection(&v_DiskCrit);
    if (pDisk == v_DiskList) {
    v_DiskList = pDisk->d_next;
    } else {
    pd = v_DiskList;
    while (pd->d_next != NULL) {
        if (pd->d_next == pDisk) {
        pd->d_next = pDisk->d_next;
        break;
        }
        pd = pd->d_next;
    }
    }
    LeaveCriticalSection(&v_DiskCrit);

    DEBUGMSG(ZONE_IO, (TEXT("MMCDISK:CloseDisk - freeing resources\r\n")));

    DeleteCriticalSection(&(pDisk->d_DiskCardCrit));
    if (pDisk->d_AlignBuf) {
    LocalFree(pDisk->d_AlignBuf);
    }

    if (pDisk->d_ActivePath) {
    LocalFree(pDisk->d_ActivePath);
    }
        
    LocalFree(pDisk);

#if USE_MEM_MODE
    if (virtreg) {
    VirtualFree(virtreg, 0, MEM_RELEASE);
    }

#endif


    DEBUGMSG(ZONE_IO, (TEXT("MMCDISK:CloseDisk done with 0x%x\r\n"), pDisk));
}    // CloseDisk


//
// CheckMedia - Simply check to see if media is present
//       
//       
//
DWORD
CheckMedia(PDISK pDisk)
{

    if (!IsCardInserted(pDisk)) {
    DEBUGMSG(ZONE_WARNING|ZONE_ERROR|ZONE_IO, 
        (TEXT("MMCDISK:CheckMedia - Built-in CF Card no longer present!\r\n")));
    if (pDisk->d_DiskCardState != STATE_DEAD) {
        pDisk->d_DiskCardState = STATE_REMOVED;
    }
    return DISK_REMOVED_ERROR;
    }

    return ERROR_SUCCESS;
}    // CheckMedia


//
// MMCREAD - fulfill one scatter/gather read request
//
DWORD
MMCREAD(
    PDISK pDisk,
    PSG_REQ pSgr
    )
{
	
    DWORD i;
    DWORD num_sg;
    DWORD bytes_this_int;
    DWORD bytes_this_sg;
    PSG_BUF pSg;
    PUSHORT pBuf16;
    PUSHORT pTmp16;
    DWORD sectno;
    DWORD endsect;
    DWORD error;
    BYTE WorkBuf[512];   
    
 
    //For test
    PUCHAR  pBuf8;
    PUCHAR  pTmp8;  
    //<-- End

//	RETAILMSG(0, (TEXT("Enter the MMCREAD\r\n")));
    num_sg = pSgr->sr_num_sg;
//	RETAILMSG(0, (TEXT("MMCREAD --num_sg = %d \r\n"),num_sg));
    pSg = &(pSgr->sr_sglist[0]);
    bytes_this_sg = pSg->sb_len;
//	RETAILMSG(0, (TEXT("MMCREAD --bytes_this_sg = %d \r\n"),bytes_this_sg));
    pBuf16 = (PUSHORT)  MapPtrToProcess((LPVOID)pSg->sb_buf, GetCallerProcess());
    
    sectno = pSgr->sr_start;
//	RETAILMSG(0, (TEXT("MMCREAD --sectno = %d \r\n"),sectno));
    endsect = sectno + pSgr->sr_num_sec;
//	RETAILMSG(0, (TEXT("MMCREAD --endsect = %d \r\n"),endsect));
    error = ERROR_SUCCESS;
    //
    // This loop reads multiple sectors into multiple scatter/gather buffers.
    // The scatter/gather buffers may be bigger or smaller or same size as a
    // sector.
    //
    while (num_sg) {

#ifdef USE_INTERRUPT
    ResetEvent(pDisk->d_IRQEvent);
#endif

    try {
        error = CheckMedia(pDisk);

    if ( error == ERROR_SUCCESS)
    {


#if (USE_SPI || USE_SPI_EMULATION)
        if (spi_read(0, sectno, WorkBuf, 1) == 0)
                     error = ERROR_READ_FAULT;

#else
        if (mmc_read(0, sectno, WorkBuf, 1) == 0)
                     error = ERROR_READ_FAULT;

#endif
	}




        pTmp16 =(PUSHORT)  WorkBuf;

    } except (GetExceptionCode() == STATUS_ACCESS_VIOLATION ?
        EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        error = ERROR_READ_FAULT;
    }
    if (error != ERROR_SUCCESS) {
        return error;
    }

#ifdef USE_INTERRUPT
    if (pDisk->d_DiskCardState == STATE_OPENED) {
        WaitForSingleObject(pDisk->d_IRQEvent, DISK_IO_TIME_OUT);
    }
    if (pDisk->d_DiskCardState != STATE_OPENED) {
        return GetDiskStateError(pDisk->d_DiskCardState);
    }
#endif

    sectno++;
    bytes_this_int = pDisk->d_DiskInfo.di_bytes_per_sect;

ar_continue_sector:
    i = (bytes_this_sg < bytes_this_int) ? bytes_this_sg : bytes_this_int;
    bytes_this_sg -= i;
    bytes_this_int -= i;

    
	try
	{
		if(((DWORD)pBuf16) & 0x01L)
		{
			pBuf8 = (PUCHAR )pBuf16;
			pTmp8 = (PUCHAR )pTmp16;
			while(i)
			{
				*pBuf8 = *pTmp8;
		    		i--;
				++pBuf8;
				++pTmp8;
			}
			pBuf16 = (PUSHORT)pBuf8;
		}
		else
		{
		    	i = (i+1) / 2;
			while (i)
			{
				*pBuf16 = *pTmp16;
		    		i--;
		    		pBuf16++;
	    			pTmp16++;
		    	}
		}
    } except (GetExceptionCode() == STATUS_ACCESS_VIOLATION ?
        EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        error = GetDiskStateError(pDisk->d_DiskCardState);
    }
    if (error != ERROR_SUCCESS) {
        return error;
    }

    if (bytes_this_int == 0) {
        if (sectno < endsect) {
        continue;       // next sector
        }
    }

    //
    // Use the next scatter/gather buffer
    //
    num_sg--;
    if (num_sg == 0) {
        break;
    }
    pSg++;
    pBuf16 = (PUSHORT)  MapPtrToProcess((LPVOID)pSg->sb_buf, GetCallerProcess());
    bytes_this_sg = pSg->sb_len;
    if (bytes_this_int) {
        goto ar_continue_sector;
    }

    }   // while 
    return 0;
}    // MMCREAD


//
// MMCWRITE
//
DWORD
MMCWRITE(
    PDISK pDisk,
    PSG_REQ pSgr
    )
{
	
    DWORD i;
    DWORD num_sg;
    DWORD bytes_this_int;
    DWORD bytes_this_sg;
    PSG_BUF pSg;
    PUSHORT pBuf16;
    DWORD sectno;
    DWORD endsect;
    DWORD error;
    
//	RETAILMSG(0, (TEXT("Enter the MMCWRITE\r\n")));
    num_sg = pSgr->sr_num_sg;
    pSg = &(pSgr->sr_sglist[0]);
    bytes_this_sg = pSg->sb_len;
    bytes_this_int = pDisk->d_DiskInfo.di_bytes_per_sect;
    pBuf16 = (PUSHORT) MapPtrToProcess((LPVOID)pSg->sb_buf, GetCallerProcess());

    sectno = pSgr->sr_start;
    endsect = sectno + pSgr->sr_num_sec;
    error = ERROR_SUCCESS;

    //
    // This loop writes data from multiple scatter/gather buffers to multiple
    // sectors.
    //
    while (num_sg) {

    try {
        error = CheckMedia(pDisk);

    if ( error == ERROR_SUCCESS)

#if (USE_SPI || USE_SPI_EMULATION)

        if (spi_write(0, sectno, (UTINY *) pBuf16 , 1) == 0)
                     error = ERROR_WRITE_FAULT;

#else
        if (mmc_write(0, sectno, (UTINY *) pBuf16 , 1) == 0)
                     error = ERROR_WRITE_FAULT;
#endif

    } except (GetExceptionCode() == STATUS_ACCESS_VIOLATION ?
        EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        error = ERROR_WRITE_FAULT;
    }
    if (error != ERROR_SUCCESS) {
        return GetDiskStateError(pDisk->d_DiskCardState);
    }

    sectno++;
    bytes_this_int = pDisk->d_DiskInfo.di_bytes_per_sect;

aw_continue_sector:
    i = (bytes_this_sg < bytes_this_int) ? bytes_this_sg : bytes_this_int;
    bytes_this_sg -= i;
    bytes_this_int -= i;

    try {
        i = (i+1) / 2;

    if (i >= 256) i -=256;
    else
        i=0;

    pBuf16 += 256;

    } except (GetExceptionCode() == STATUS_ACCESS_VIOLATION ?
        EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH) {
        error = GetDiskStateError(pDisk->d_DiskCardState);
    }
    if (error != ERROR_SUCCESS) {
        return error;
    }

    if (bytes_this_int == 0) {
        if (pDisk->d_DiskCardState != STATE_OPENED) {
        return GetDiskStateError(pDisk->d_DiskCardState);
        }
        if (sectno < endsect) {
        continue;       // next sector
        }
    }

    //
    // Use the next scatter/gather buffer
    //
    num_sg--;
    if (num_sg == 0) {
        break;
    }
    pSg++;
    pBuf16 =  (PUSHORT) MapPtrToProcess((LPVOID)pSg->sb_buf, GetCallerProcess());
    bytes_this_sg = pSg->sb_len;
    if (bytes_this_int) {
        goto aw_continue_sector;
    }
    }   // while

    return 0;
}   // MMCWRITE



//
// DoDiskIO - fulfill I/O requests
//
DWORD
DoDiskIO(
    PDISK pDisk,
    DWORD Opcode,
    PSG_REQ pSgr
    )
{
    DWORD status;

    DEBUGMSG(ZONE_IO, (TEXT("MMCDISK:DoDiskIO entered\r\n")));

    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;