diskio.c

intel xscale pxa270的完整wince4.2 BSP包

/*++     
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.
Copyright (c) 1995, 1996, 1997  Microsoft Corporation

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 <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include "diskio.h"
#include "sddisk.h"
#include "sdmmc.h"
#include "plx9054.h"
#include <bvd1.h>
#include <blrbits.h>
#include "bcr.h"
#include <oalintr.h>
#include <nkintr.h>
#include <bvd1bd.h>
#include "xllp_mmc.h"
#include "xllp_common.h"
#include "cken.h"
#include "drive.h"

UINT32      total;

#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;
	unsigned short num_of_sector;
	// DWORD read_out;
    PSG_BUF pSg;
    UCHAR *pBuf16;
   // PUSHORT pTmp16;
    DWORD sectno;
    DWORD endsect;
    DWORD error;
   

//	RETAILMSG(1, (TEXT("Enter the MMCREAD\r\n")));
    num_sg = pSgr->sr_num_sg;
//	NKDbgPrintfW(TEXT("MMCREAD --num_sg = %d \r\n"),num_sg);
    pSg = &(pSgr->sr_sglist[0]);
    bytes_this_sg = pSg->sb_len;
//	NKDbgPrintfW(TEXT("new MMCREAD --bytes_this_sg = %d \r\n"),bytes_this_sg);
    pBuf16 = (UCHAR *)  MapPtrToProcess((LPVOID)pSg->sb_buf, GetCallerProcess());
    
    sectno = pSgr->sr_start;
//	NKDbgPrintfW(TEXT("MMCREAD --sectno = %d \r\n"),sectno);
    endsect = sectno + pSgr->sr_num_sec;
//	NKDbgPrintfW(TEXT("MMCREAD --endsect = %d \r\n"),endsect);
	num_of_sector = (unsigned short) pSgr->sr_num_sec;
    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);
          error = ERROR_SUCCESS;
    if ( error == ERROR_SUCCESS)


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

#else
		     
       //     WorkBuf = (BYTE *)malloc(512 * pSgr->sr_num_sec);
			//if(WorkBuf == NULL)
			//	NKDbgPrintfW(TEXT("there is not enough room in the memory\r\n"));
             if (mmc_read(0, sectno, pBuf16, num_of_sector) == 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


 
 
 
    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;
	UINT32  starttime=0, endtime=0, diff=0;
  //  PUSHORT pBuf16;
	PUCHAR pBuf16;
    DWORD sectno;
    DWORD endsect;
    DWORD error;

    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 = (PUCHAR) MapPtrToProcess((LPVOID)pSg->sb_buf, GetCallerProcess());

    sectno = pSgr->sr_start;
    endsect = sectno + pSgr->sr_num_sec;
    error = ERROR_SUCCESS;
   // NKDbgPrintfW(TEXT("number of segments is %d\r\n"),pSgr->sr_num_sec);
//	NKDbgPrintfW(TEXT("start segment num is %d\r\n"), sectno);
    //
    // This loop writes data from multiple scatter/gather buffers to multiple
    // sectors.
    //
//    while (num_sg) {

    try {
        //error = CheckMedia(pDisk);
        error = ERROR_SUCCESS;
    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 , pSgr->sr_num_sec) == 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 error;
    }

    
    

 

      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;
    }

    if (!IsCardInserted(pDisk)) {
     RETAILMSG(1, (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;
    }

   // RETAILMSG(1, 
//    (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 = MMCREAD(pDisk, pSgr);
    } else {
    status = MMCWRITE(pDisk, pSgr);
    }


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--;