system.c

2443 wince5.0 bsp, source code

            }
            
            ppc = (PPOWER_CAPABILITIES)pOutBuf;
            
            memset(ppc, 0, sizeof(POWER_CAPABILITIES));

            // support D0, D4
            ppc->DeviceDx = 0x11;

            // no wake
            // no inrush

            // Report our nominal power consumption in uAmps rather than mWatts.
            ppc->Flags = POWER_CAP_PREFIX_MICRO | POWER_CAP_UNIT_AMPS;

            // REVIEW: Do we enable all these for normal playback?
            // D0: SPI + I2S + CODEC (Playback) + Headphone= 
            //     0.5 mA + 0.5 mA + (23 mW, into BUGBUG ohms ) + (30 mW, into 32 ohms)
            //     500 uA + 500 uA + 23000 uA + 32000 uA
            ppc->Power[D0] = 56000;
            
            *pBytesReturned = sizeof(POWER_CAPABILITIES);  
            ////RETAILMSG(RTL_MSG,(TEXT("SML_IOCONTROL: powerCapability")));
            return bRc;
        } break;

        case IOCTL_POWER_SET: 
        {
            CEDEVICE_POWER_STATE NewDx;
            HANDLE hDevice = NULL;
		RETAILMSG(1,(TEXT("#############################2 \r\n")));            
		bRc = TRUE;

            if ( !pBytesReturned || !pOutBuf || (nOutBufSize < sizeof(CEDEVICE_POWER_STATE)) ) {
                bRc = FALSE;
                dwErr = ERROR_INVALID_PARAMETER;
                break;
            }

            NewDx = *(PCEDEVICE_POWER_STATE)pOutBuf;

            if ( VALID_DX(NewDx) ) {
                // grab the CS since the normal Xxx_PowerXxx can not.
                switch ( NewDx ) {
                    case D0:
				if (m_Dx != D0) {
                    			RETAILMSG(1,(TEXT("### Being UP ### \r\n")));
					m_Dx = D0;
	              	}
                    		break;
                    default:
                        if (m_Dx != D4) {
				      	RETAILMSG(1,(TEXT("### Being DOWN ### \r\n")));
					//DSK_Deinit(g_dwContext);     // pointer to the per disk structure
					m_Dx = D4;		
                        	}
                        break;
                	} 
                // return our state
                *(PCEDEVICE_POWER_STATE)pOutBuf = m_Dx;
                
                //RETAILMSG(RTL_MSG, (TEXT("SML: IOCTL_POWER_SET: D%u => D%u \r\n"), NewDx, m_Dx));

                
                *pBytesReturned = sizeof(CEDEVICE_POWER_STATE);
            } else {
                bRc = FALSE;
                dwErr = ERROR_INVALID_PARAMETER;
            }
		return bRc;
            
        } break;

        case IOCTL_POWER_GET: 
		RETAILMSG(1,(TEXT("#############################3 \r\n")));			
		if ( !pBytesReturned || !pOutBuf || (nOutBufSize < sizeof(CEDEVICE_POWER_STATE)) ) {
			bRc = FALSE;
			dwErr = ERROR_INVALID_PARAMETER;
			break;
		}

		*(PCEDEVICE_POWER_STATE)pOutBuf = m_Dx;

		//RETAILMSG(RTL_MSG, (TEXT("SML: IOCTL_POWER_GET: D%u \r\n"), m_Dx));

            *pBytesReturned = sizeof(CEDEVICE_POWER_STATE);
		if ( !bRc ) 
		{
			RETAILMSG(1, (TEXT("### error occured")));
			SetLastError(dwErr);
		}			
		return bRc;
			
		break;
    	}
#endif


    //
    // Check parameters
    //
    switch (dwIoControlCode) 
    {
	    case DISK_IOCTL_WRITE:
	    case IOCTL_DISK_WRITE:
   		    if(pInBuf == NULL)
			{
   		        SetLastError(ERROR_INVALID_PARAMETER);
   		        return FALSE;
   		    }
#if 0
			if(dWriteProtect)
			{
				SetLastError(ERROR_WRITE_PROTECT);
				pSG = (PSG_REQ)pInBuf;
				pSG->sr_status = ERROR_WRITE_PROTECT;
				return FALSE;
			}
#endif			
   		    break;

	    case DISK_IOCTL_READ:
	    case IOCTL_DISK_READ:
   	case DISK_IOCTL_GETINFO:
    	case IOCTL_DISK_GETINFO:
    	case DISK_IOCTL_SETINFO:
    	case IOCTL_DISK_SETINFO:
    	case DISK_IOCTL_INITIALIZED:
    	case IOCTL_DISK_INITIALIZED:
    	case IOCTL_DISK_DEVICE_INFO:
	    	if (pInBuf == NULL) 
    		{
	        	SetLastError(ERROR_INVALID_PARAMETER);
        		return FALSE;
	    	}
		    break;

    	case DISK_IOCTL_GETNAME:
    	//case DISK_IOCTL_IDENTIFY:
    	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;
    
    	default:
	    	SetLastError(ERROR_INVALID_PARAMETER);
    		return FALSE;
    }


    switch (dwIoControlCode)
    {
    case DISK_IOCTL_READ:
    case DISK_IOCTL_WRITE:
    case IOCTL_DISK_READ:
    case IOCTL_DISK_WRITE:
		pSG = (PSG_REQ)pInBuf;
    	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);
       	 	return FALSE;
	    	}
    	return TRUE;

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

    case DISK_IOCTL_SETINFO:
	//RETAILMSG(RTL_MSG,(TEXT("+++ IOCTL_DISK_SET_INFO\r\n")));		
        SetLastError(SetDiskInfo(pDisk, (PDISK_INFO)pInBuf));
    	return TRUE;

    case DISK_IOCTL_FORMAT_MEDIA:
    	SetLastError(ERROR_SUCCESS);
    	return TRUE;
  
    case DISK_IOCTL_GETNAME:
    	return GetFolderName(pDisk, (LPWSTR)pOutBuf, nOutBufSize, pBytesReturned);


    case IOCTL_DISK_DEVICE_INFO:
    {

	PSTORAGEDEVICEINFO psdi = (PSTORAGEDEVICEINFO)pInBuf;
	 
        if (nInBufSize == sizeof(STORAGEDEVICEINFO)) 
        {
	       //RETAILMSG(RTL_MSG,(TEXT("+++ INSIDE of IOCTL_DISK_DEVICE_INFO\r\n")));
            wcscpy( psdi->szProfile, TEXT("2443_CF"));
            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);
            return TRUE;
        } 
        else 
        {
            SetLastError( ERROR_INVALID_PARAMETER);
            return FALSE;
        }

    }    
    

    case IOCTL_DISK_GET_STORAGEID:
	//RETAILMSG(RTL_MSG,(TEXT("+++ ATAPI: GetStorageID()... not completed yet\r\n")));
/*
	GetStorageID(pDisk,
                (PSTORAGE_IDENTIFICATION)pOutBuf,
                nOutBufSize,
                pBytesReturned); */
      		 ((PSTORAGE_IDENTIFICATION)pOutBuf)->dwSize = 0;//sizeof(STORAGE_IDENTIFICATION);
		 ((PSTORAGE_IDENTIFICATION)pOutBuf)->dwFlags = SERIALNUM_INVALID;
		 ((PSTORAGE_IDENTIFICATION)pOutBuf)->dwFlags |= MANUFACTUREID_INVALID;
		 ((PSTORAGE_IDENTIFICATION)pOutBuf)->dwManufactureIDOffset=0;
		 ((PSTORAGE_IDENTIFICATION)pOutBuf)->dwSerialNumOffset=0;
	return 1;


    default:
    	SetLastError(ERROR_INVALID_PARAMETER);
    	return FALSE;
    }
#endif	
	
}   // DSK_IOControl


DWORD DSK_Read(DWORD Handle, LPVOID pBuffer, DWORD dwNumBytes){return 1;}
DWORD DSK_Write(DWORD Handle, LPCVOID pBuffer, DWORD dwNumBytes){return 1;}
DWORD DSK_Seek(DWORD Handle, long lDistance, DWORD dwMoveMethod){return 1;}
void DSK_PowerUp(void)
{
}
void DSK_PowerDown(void) 
{
//	CloseHandle(g_hDMAInterrupt);
 //   VirtualFree((PVOID)g_vDmaBuffer, 0, MEM_RELEASE); 
//    InterruptDisable(SYSINTR_DMA0);
}


//
// Returns TRUE if the MMC card is inserted
//
int
IsCardInserted(
    PDISK pDisk
    )
{
#if 0
	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;
#endif
    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
AtapiInit(
    LPTSTR ActiveKey
    )
{
    DWORD status;
    PDISK pDisk;
    HKEY hKey = NULL;

	//RETAILMSG(RTL_MSG, (TEXT("+++ ATAPI_CF : Before Entering CreateDiskObject()\r\n")));
    pDisk = CreateDiskObject();
    if (pDisk == NULL) {
    DEBUGMSG(ZONE_INIT|ZONE_ERROR, (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);
    }

	//RETAILMSG(RTL_MSG, (TEXT("+++ ATAPI_CF : Before Entering OpenDriveKey()\r\n")));
    hKey = OpenDriverKey( ActiveKey);
    if (hKey) {
        RegCloseKey( hKey);
    }    
    //
    // InitDisk 
    //
	//RETAILMSG(RTL_MSG, (TEXT("+++ ATAPI_CF : Before Entering InitDisk()\r\n")));    
    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;*/

	RETAILMSG(1, (TEXT("+++ ATAPI_CF : AtapiInit Fail.!!!!\r\n")));    

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

void FreeVirtualMemory(void)
{

	if ( g_vDmaBuffer )
	{
		VirtualFree((PVOID)g_vDmaBuffer, 0, MEM_RELEASE); 
		g_vDmaBuffer = NULL;
	}

	if ( g_vEBIRegs)
	{
		VirtualFree((PVOID)g_vEBIRegs, 0, MEM_RELEASE); 
		g_vEBIRegs= NULL;
	}

	if ( g_vIOPORTRegs)
	{
		VirtualFree((PVOID)g_vIOPORTRegs, 0, MEM_RELEASE); 
		g_vIOPORTRegs= NULL;
	}
    

	if ( g_vATAPIRegs)
	{
		VirtualFree((PVOID)g_vATAPIRegs, 0, MEM_RELEASE); 
		g_vATAPIRegs= NULL;
	}

        DeleteCriticalSection(&g_ControllerCriticalSection);    
}