system.c

来自「针对Intel Xscale PXA255的WinCE boot loader源」· C语言 代码 · 共 640 行 · 第 1/2 页

//
// I/O Control function - responds to info, read and write control codes.
// The read and write take a scatter/gather list in pInBuf
//

//Modified for write protect issue
BOOL
DSK_IOControl(
    DWORD Handle,
    DWORD dwIoControlCode,
    PBYTE pInBuf,
    DWORD nInBufSize,
    PBYTE pOutBuf,
    DWORD nOutBufSize,
    PDWORD pBytesReturned
    )
{
    PDISK pDisk = (PDISK)Handle;
    PSG_REQ pSG;

	DEBUGMSG(ZONE_FUNCTION, (TEXT("DSK_IOControl()\r\n")));
	RETAILMSG(IOTRACE, (TEXT("----------dwIoControlCode:%d---------\r\n"),dwIoControlCode));

    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_WRITE:
    		RETAILMSG(IOTRACE, (TEXT("----------DISK_IOCTL_WRITE---------\r\n")));

    	case IOCTL_DISK_WRITE:
		RETAILMSG(IOTRACE, (TEXT("----------IOCTL_DISK_WRITE---------\r\n")));
    		    if(pInBuf == NULL)
				{
    		        SetLastError(ERROR_INVALID_PARAMETER);
    		        return FALSE;
    		    }
				if(bWriteProtect)
				{
					SetLastError(ERROR_WRITE_PROTECT);
					pSG = (PSG_REQ)pInBuf;
					pSG->sr_status = ERROR_WRITE_PROTECT;
					return FALSE;
				}
    		    break;
    	case DISK_IOCTL_READ:
    		RETAILMSG(IOTRACE, (TEXT("----------DISK_IOCTL_READ---------\r\n")));
    	case DISK_IOCTL_GETINFO:
    	case DISK_IOCTL_SETINFO:
    	case DISK_IOCTL_INITIALIZED:

    	case IOCTL_DISK_READ:
    		RETAILMSG(IOTRACE, (TEXT("----------IOCTL_DISK_READ---------\r\n")));
    	case IOCTL_DISK_GETINFO:
    	case IOCTL_DISK_SETINFO:
    	case IOCTL_DISK_INITIALIZED:

		RETAILMSG(IOTRACE, (TEXT("----------IOCTL_DISK_INITIALIZED---------\r\n")));
    		    if(pInBuf == NULL)
				{
    		        SetLastError(ERROR_INVALID_PARAMETER);
    		        return FALSE;
    		    }
    		    break;

    	case IOCTL_DISK_GET_STORAGEID:
    		RETAILMSG(IOTRACE, (TEXT("----------IOCTL_DISK_GET_STORAGEID---------\r\n")));
    		    if(pOutBuf == NULL)
				{
    		        SetLastError(ERROR_INVALID_PARAMETER);
    		        return FALSE;
    		    }
    		    break;

    	case IOCTL_DISK_DEVICE_INFO:
         	 //   if ((nInBufSize== 0) || (pInBuf== NULL))
         	 	RETAILMSG(IOTRACE, (TEXT("----------IOCTL_DISK_DEVICE_INFO---------\r\n")));
         	    if ((nInBufSize!= sizeof(STORAGEDEVICEINFO)) || (pInBuf== NULL))
        	    {
            		SetLastError(ERROR_INVALID_PARAMETER);
            		return FALSE;
        	    }
        	    break;
	    case DISK_IOCTL_GETNAME:
	    		RETAILMSG(IOTRACE, (TEXT("----------DISK_IOCTL_GETNAME---------\r\n")));
				if(pOutBuf == NULL)
				{
					SetLastError(ERROR_INVALID_PARAMETER);
					return FALSE;
				}
				break;

	    case DISK_IOCTL_FORMAT_MEDIA:
	        	SetLastError(ERROR_SUCCESS);
	        	return TRUE;
    
	    default:
	        	SetLastError(ERROR_INVALID_PARAMETER);
	        	return FALSE;
	}

    switch (dwIoControlCode)
	{
    	case DISK_IOCTL_READ:

		case IOCTL_DISK_READ:
				RETAILMSG(IOTRACE, (TEXT("----------IOCTL_DISK_READ==2==---------\r\n")));
				DEBUGMSG(ZONE_FUNCTION, (TEXT("DISK_IOControl() DISK_IOCTL_READ;\r\n")));
				pSG = (PSG_REQ)pInBuf;
				DoDiskIO(pDisk, dwIoControlCode, pSG);
				DEBUGMSG(ZONE_FUNCTION, (TEXT("DISK_IOControl() DISK_IOCTL_READ DoDiskIO OUT;\r\n")));
				if (pSG->sr_status)
				{
	    			SetLastError(pSG->sr_status);
	    			DEBUGMSG(ZONE_ERROR, (TEXT("DISK_IOControl() DISK_IOCTL_READ or DISK_IOCTL_WRITE status=0x%08x;\r\n"),pSG->sr_status));
				    return FALSE;
				}
				return TRUE;

    	case DISK_IOCTL_WRITE:
    		RETAILMSG(IOTRACE, (TEXT("----------DISK_IOCTL_WRITE==2==---------\r\n")));

		case IOCTL_DISK_WRITE:
				DEBUGMSG(ZONE_FUNCTION, (TEXT("DISK_IOControl() DISK_IOCTL_WRITE;\r\n")));
				pSG = (PSG_REQ)pInBuf;
				RETAILMSG(IOTRACE, (TEXT("----------IOCTL_DISK_WRITE==2==||||TEST01||||---------\r\n")));
			    if (PSLGetCallerTrust()!= OEM_CERTIFY_TRUST) {
			        PSG_REQ pSgReq=pSG;
			        if  (pSgReq && nInBufSize >= (sizeof(SG_REQ) + sizeof(SG_BUF) * (pSgReq->sr_num_sg - 1))) {
			            DWORD dwIndex;
			            for (dwIndex=0; dwIndex < pSgReq -> sr_num_sg; dwIndex++) {
			                pSgReq->sr_sglist[dwIndex].sb_buf =
			                    (PUCHAR)MapCallerPtr((LPVOID)pSgReq->sr_sglist[dwIndex].sb_buf,pSgReq->sr_sglist[dwIndex].sb_len);
			            }
			        }
			        else {// Parameter Wrong.
			            SetLastError(ERROR_INVALID_PARAMETER);
			            return FALSE;
			        };
			    }
				
				DoDiskIO(pDisk, dwIoControlCode, pSG);
				if (pSG->sr_status)
				{
	    			SetLastError(pSG->sr_status);
	    			DEBUGMSG(ZONE_ERROR, (TEXT("DISK_IOControl() DISK_IOCTL_READ or DISK_IOCTL_WRITE status=0x%08x;\r\n"),pSG->sr_status));
				    return FALSE;
				}
				return TRUE;

    	case DISK_IOCTL_GETINFO:
    				RETAILMSG(IOTRACE, (TEXT("----------DISK_IOCTL_GETINFO==2==---------\r\n")));
				DEBUGMSG(ZONE_FUNCTION, (TEXT("DISK_IOControl() DISK_IOCTL_GETINFO;\r\n")));
				SetLastError(GetDiskInfo(pDisk, (PDISK_INFO)pInBuf));
				return TRUE;

    	case DISK_IOCTL_SETINFO:
    				RETAILMSG(IOTRACE, (TEXT("----------DISK_IOCTL_SETINFO==2==---------\r\n")));
				DEBUGMSG(ZONE_FUNCTION, (TEXT("DISK_IOControl() DISK_IOCTL_SETINFO;\r\n")));
		  		SetLastError(SetDiskInfo(pDisk, (PDISK_INFO)pInBuf));
				return TRUE;



    	case DISK_IOCTL_FORMAT_MEDIA:
				DEBUGMSG(ZONE_FUNCTION, (TEXT("DISK_IOControl() DISK_IOCTL_FORMAT_MEDIA;\r\n")));
				SetLastError(ERROR_SUCCESS);
				return TRUE;

    	case DISK_IOCTL_GETNAME:
    				RETAILMSG(IOTRACE, (TEXT("----------DISK_IOCTL_GETNAME==2==---------\r\n")));
				DEBUGMSG(ZONE_FUNCTION, (TEXT("DISK_IOControl() DISK_IOCTL_GETNAME;\r\n")));
        		return GetFolderName(pDisk, (LPWSTR)pOutBuf, nOutBufSize, pBytesReturned);

    	case IOCTL_DISK_DEVICE_INFO:
    	{
    		
        		PSTORAGEDEVICEINFO psdi = (PSTORAGEDEVICEINFO)pInBuf;
        		RETAILMSG(IOTRACE, (TEXT("----------IOCTL_DISK_DEVICE_INFO==2==---------\r\n")));
			DEBUGMSG(ZONE_FUNCTION, (TEXT("DISK_IOControl() IOCTL_DISK_DEVICE_INFO\r\n")));

        		if (nInBufSize == sizeof(STORAGEDEVICEINFO)) {
           		 	wcscpy( psdi->szProfile, L"SDMMC");
            			psdi->dwDeviceClass = STORAGE_DEVICE_CLASS_BLOCK;
            			psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_REMOVABLE_MEDIA;
            			psdi->dwDeviceType |= STORAGE_DEVICE_TYPE_UNKNOWN;
            			psdi->dwDeviceFlags |= STORAGE_DEVICE_FLAG_READWRITE;
            			if (pBytesReturned)
                			*pBytesReturned = sizeof(STORAGEDEVICEINFO);
                                DEBUGMSG(1, (TEXT("RETURN TRUE\r\n")));
            			return TRUE;
        		}
			else
			{
            			SetLastError( ERROR_INVALID_PARAMETER);
    				DEBUGMSG(ZONE_ERROR, (TEXT("RETURN FALSE\r\n")));
            			return FALSE;
        		}
    	}
		case IOCTL_DISK_GET_STORAGEID:  // TBD later
			RETAILMSG(IOTRACE, (TEXT("----------IOCTL_DISK_GET_STORAGEID==2==---------\r\n")));
			return GetStorageID(pDisk,
						(PSTORAGE_IDENTIFICATION)pOutBuf,
						nOutBufSize,
						pBytesReturned);
//#endif	
    	default:
				DEBUGMSG(ZONE_ERROR, (TEXT("DISK_IOControl() default;\r\n")));
				SetLastError(ERROR_INVALID_PARAMETER);
				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)
{
	hw_powerup();
}
void DSK_PowerDown(void) 
{
	hw_powerdown();
}


//
// Returns TRUE if the MMC card is inserted
//
bool
IsCardInserted(
    PDISK pDisk
    )
{
    INT16 logical_drive;

    logical_drive = (0xFFFF & (INT16)pDisk->d_DrvNo); 


    // Check for MMC card presenting and working
    if (is_device_changed (logical_drive))
    return FALSE;

    return TRUE;

}   // IsCardInserted


//
// mmcinit:
//
// ActivePath is the registry path to our device's active key under
// HKEY_LOCAL_MACHINE\Drivers\Active
// Allocate storage to hold a copy of this and point pDisk->d_ActivePath
// to it. This will be used in getfoldername call.
//
// Return pointer to new disk structure or NULL.
//
PDISK
mmcinit(
    LPTSTR ActiveKey
    )
{
    DWORD status;
    PDISK pDisk;
    HKEY hKey;

    pDisk = CreateDiskObject();
    if (pDisk == NULL) {
    RETAILMSG(INIT, (TEXT("MmcDisk LocalAlloc(PDISK) failed %d\r\n"), GetLastError()));
    return NULL;
    }
    if (pDisk->d_ActivePath = LocalAlloc(LPTR, wcslen(ActiveKey)*sizeof(WCHAR)+sizeof(WCHAR))) {
    wcscpy(pDisk->d_ActivePath, ActiveKey);
    }


	hKey = OpenDriverKey( ActiveKey);
	RegCloseKey( hKey);
    //
    // InitDisk 
    //
    status = InitDisk(pDisk);
    if (status) {
    goto ci_fail;
    }



    if (pDisk->d_DiskCardState == STATE_INITING) {
    pDisk->d_DiskCardState = STATE_CLOSED;
    return pDisk;
    }


ci_fail:
/*    pDisk->d_pDataReg = NULL;*/


    CloseDisk(pDisk);
    return NULL;
}   // mmcinit