system.c

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

							0,
							(LPTHREAD_START_ROUTINE)ATAPIIsrThread,
							pDisk,
							0,
							NULL
							);
			if( hThread != NULL ){
			    DEBUGMSG(ATAPI_INIT, (TEXT("ATAPI: IST is started.\r\n")));
			    CloseHandle( hThread );
			}
			else{
				DEBUGMSG(ATAPI_INIT, (TEXT("ATAPI: IST is not stated.\r\n")));
				pDisk = NULL;					// error return value is set
			}
	    }
        return (DWORD)pDisk;
    } else {
        DEBUGMSG(ATAPI_INIT,
            (TEXT("ATAPI:ATA_Init Non-ATA device inserted\r\n")));
        return 0;
    }
}   // ATA_Init


BOOL
ATA_Close(
    DWORD Handle
    )
{
    BOOL bClose = TRUE;
    PDISK pDisk = (PDISK)Handle;
    
    DEBUGMSG(ATAPI_IO, (TEXT("ATAPI: ATA_Close\r\n")));

    if (!IsValidDisk(pDisk)) {
        return FALSE;
    }

    if (pDisk->d_DiskCardState == STATE_OPENED) {
        EnterCriticalSection(&(pDisk->d_DiskCardCrit));
        pDisk->d_OpenCount--;
        if (pDisk->d_OpenCount == 0) {
            pDisk->d_DiskCardState = STATE_CLOSED;
        } else {
            bClose = FALSE;
        }
        LeaveCriticalSection(&(pDisk->d_DiskCardCrit));
    }
    return TRUE;
}   // ATA_Close


//
// Device deinit - devices are expected to close down.
// The device manager does not check the return code.
//
BOOL
ATA_Deinit(
    DWORD dwContext     // pointer to the per disk structure
    )
{
    PDISK pDisk = (PDISK)dwContext;

   DEBUGMSG(ATAPI_INIT, (TEXT("ATAPI: ATA_Deinit\r\n")));

    ATA_Close(dwContext);
    CloseDisk(pDisk);
    return TRUE;
}   // ATA_Deinit

//
// Returns handle value for the open instance.
//
DWORD
ATA_Open(
    DWORD dwData,
    DWORD dwAccess,
    DWORD dwShareMode
    )
{
    PDISK pDisk = (PDISK)dwData;
    DWORD ret = 0;


    DEBUGMSG(ATAPI_IO, (TEXT("ATAPI: ATA_Open(0x%x)\r\n"),dwData));

    if (IsValidDisk(pDisk) == FALSE) {
        DEBUGMSG(ATAPI_IO, (TEXT("ATAPI: ATA_Open - Passed invalid disk handle\r\n")));
        return ret;
    }

    if ((pDisk->d_DiskCardState != STATE_CLOSED) &&
        (pDisk->d_DiskCardState != STATE_OPENED)) {
        SetLastError(GetDiskStateError(pDisk->d_DiskCardState));
        return ret;
    }

    EnterCriticalSection(&(pDisk->d_DiskCardCrit));
    if (pDisk->d_DiskCardState == STATE_CLOSED) {
        pDisk->d_DiskCardState = STATE_OPENED;
    }
    ret = (DWORD)pDisk;
    pDisk->d_OpenCount++;
    LeaveCriticalSection(&(pDisk->d_DiskCardCrit));

    return ret;
}   // ATA_Open


//
// I/O Control function - responds to info, read and write control codes.
// The read and write take a scatter/gather list in pInBuf
//
BOOL
ATA_IOControl(
    DWORD Handle,
    DWORD dwIoControlCode,
    PBYTE pInBuf,
    DWORD nInBufSize,
    PBYTE pOutBuf,
    DWORD nOutBufSize,
    PDWORD pBytesReturned
    )
{
	DWORD	dwWaitTime = INFINITE;
    PDISK pDisk = (PDISK)Handle;
    PSG_REQ pSG;
	DWORD	dwErrcode;

    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_READ:
    case DISK_IOCTL_WRITE:
    case DISK_IOCTL_GETINFO:
    case DISK_IOCTL_SETINFO:
    case DISK_IOCTL_INITIALIZED:
        if (pInBuf == NULL) {
            SetLastError(ERROR_INVALID_PARAMETER);
            return FALSE;
        }
        break;

    case DISK_IOCTL_GETNAME:
        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;
    }

    //
    // Execute dwIoControlCode
    //
    switch (dwIoControlCode) {
    case DISK_IOCTL_READ:
    case DISK_IOCTL_WRITE:
        
		pSG = (PSG_REQ)pInBuf;
		pAPLOutbuf=(PBYTE)pOutBuf;					//CD-ROM data WRITE Application Buf address 
		dwRSize = 0;								//CD-ROM read data size INIT
		CD_ROM_STA.flag = ATAPI_ATAPROC;			// Send ATA Command 
		dwErrcode = DoDiskIO(pDisk, dwIoControlCode, pSG);
        if (dwErrcode == FALSE) {
			SetLastError(pSG->sr_status);
            return FALSE;
        }

		memcpy(pOutBuf,ATAPI_WORK,dwRSize);	//CD-ROM data copy to application area
													//Area3 DRAM area -> pOutbuf ,Size=nOutBufSize
		*pBytesReturned = dwRSize;					//CD-ROM read data size return
 /*****************************************************************************
 * Modification done by Maneesh Gupta
 *
 * Normally the Cd- Drive is not reponding to the Read commands after one read
 * so we are starting the CD-Rom once again.
 * ***************************************************************************/
		StartATAPIUnit();
 /*****************************************************************************
 * End of Modification done by Maneesh Gupta
 * ***************************************************************************/
        return TRUE;

    case DISK_IOCTL_GETINFO:
		CD_ROM_STA.flag = ATAPI_ATAPROC;	// Send ATA Command 
        dwErrcode = GetDiskInfo(pDisk, (PDISK_INFO)pInBuf);
        if (dwErrcode == FALSE) {
            return FALSE;
         }
       return TRUE;

    case DISK_IOCTL_SETINFO:
        SetLastError(SetDiskInfo(pDisk, (PDISK_INFO)pInBuf));
        return TRUE;

    case DISK_IOCTL_INITIALIZED:
        //
        // Load and initialize the associated file system driver
        //
//
// This session initial for FSD. But, we don't have FSD for CD-ROM now. So, we
// mask thes sentence until FSD will be created.
//
//		if (InitFSD((PPOST_INIT_BUF)pInBuf)) {
//			DEBUGMSG(ATAPI_INIT, (TEXT("ATAPI: InitFSD succeeded\r\n")));
//		} else {
//			DEBUGMSG(ATAPI_INIT, (TEXT("ATAPI: InitFSD failed\r\n")));
//		}
		return TRUE;

    case DISK_IOCTL_GETNAME:
        return GetFolderName(pDisk, (LPWSTR)pOutBuf, nOutBufSize, pBytesReturned);
    }
    return FALSE;
}   // ATA_IOControl


DWORD ATA_Read(DWORD Handle, LPVOID pBuffer, DWORD dwNumBytes){return 0;}
DWORD ATA_Write(DWORD Handle, LPCVOID pBuffer, DWORD dwNumBytes){return 0;}
DWORD ATA_Seek(DWORD Handle, long lDistance, DWORD dwMoveMethod){return 0;}
void ATA_PowerUp(void){}
void ATA_PowerDown(void){}

#ifdef DEBUG
typedef struct _EVENT_NAME_TBL {
    CARD_EVENT EventCode;
    LPTSTR    pEventName;
} EVENT_NAME_TBL, *PEVENT_NAME_TBL;

#define LAST_EVENT_CODE ((CARD_EVENT) -1)

//
// Table of callback event codes and their names.
// NOTE: The names with ! at the end are not expected.
//
EVENT_NAME_TBL v_EventNames[] = {
    { CE_BATTERY_DEAD,          TEXT("CE_BATTERY_DEAD") },
    { CE_BATTERY_LOW,           TEXT("CE_BATTERY_LOW") },
    { CE_CARD_LOCK,             TEXT("CE_CARD_LOCK") },
    { CE_CARD_READY,            TEXT("CE_CARD_READY") },
    { CE_CARD_REMOVAL,          TEXT("CE_CARD_REMOVAL") },
    { CE_CARD_UNLOCK,           TEXT("CE_CARD_UNLOCK") },
    { CE_EJECTION_COMPLETE,     TEXT("CE_EJECTION_COMPLETE!") },
    { CE_EJECTION_REQUEST,      TEXT("CE_EJECTION_REQUEST!") },
    { CE_INSERTION_COMPLETE,    TEXT("CE_INSERTION_COMPLETE!") },
    { CE_INSERTION_REQUEST,     TEXT("CE_INSERTION_REQUEST!") },
    { CE_PM_RESUME,             TEXT("CE_PM_RESUME!") },
    { CE_PM_SUSPEND,            TEXT("CE_PM_SUSPEND!") },
    { CE_EXCLUSIVE_COMPLETE,    TEXT("CE_EXCLUSIVE_COMPLETE") },
    { CE_EXCLUSIVE_REQUEST,     TEXT("CE_EXCLUSIVE_REQUEST") },
    { CE_RESET_PHYSICAL,        TEXT("CE_RESET_PHYSICAL") },
    { CE_RESET_REQUEST,         TEXT("CE_RESET_REQUEST") },
    { CE_CARD_RESET,            TEXT("CE_CARD_RESET") },
    { CE_MTD_REQUEST,           TEXT("CE_MTD_REQUEST!") },
    { CE_CLIENT_INFO,           TEXT("CE_CLIENT_INFO!") },
    { CE_TIMER_EXPIRED,         TEXT("CE_TIMER_EXPIRED!") },
    { CE_SS_UPDATED,            TEXT("CE_SS_UPDATED!") },
    { CE_WRITE_PROTECT,         TEXT("CE_WRITE_PROTECT") },
    { CE_CARD_INSERTION,        TEXT("CE_CARD_INSERTION") },
    { CE_RESET_COMPLETE,        TEXT("CE_RESET_COMPLETE") },
    { CE_ERASE_COMPLETE,        TEXT("CE_ERASE_COMPLETE!") },
    { CE_REGISTRATION_COMPLETE, TEXT("CE_REGISTRATION_COMPLETE") },
    { LAST_EVENT_CODE,          TEXT("Unknown Event!") },
};

LPTSTR
FindEventName(
    CARD_EVENT EventCode
    )
{
    PEVENT_NAME_TBL pEvent = v_EventNames;

    while (pEvent->EventCode != LAST_EVENT_CODE) {
        if (pEvent->EventCode == EventCode) {
            return pEvent->pEventName;
        }
        pEvent++;
    }
    return pEvent->pEventName;
}
#endif // DEBUG

//
// I/O access capabilities (wtype)
//
#define ACCESS_MEMORY_ONLY 0
#define ACCESS_IO_8BIT     1
#define ACCESS_IO_16BIT    2
#define ACCESS_IO_ANY      3

//
// ATAInit:
//
// Return pointer to new disk structure or NULL.
//
PDISK
ATAInit(
    LPTSTR ActiveKey
    )
{
    PDISK pDisk;

    pDisk = CreateDiskObject();
    if (pDisk == NULL) {
        DEBUGMSG(ATAPI_INIT|ATAPI_ERROR,
            (TEXT("ATAPI: 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);
    }

    //
    // InitDisk
    //
/*
Defer
    status = InitDisk(pDisk, ActiveKey);
    if (status) {
        DEBUGMSG(ATAPI_PCMCIA|ATAPI_INIT|ATAPI_ERROR,
            (TEXT("ATAPI: InitDisk failed %d\r\n"), status));
        goto ai_fail;
    }
*/

    if (pDisk->d_DiskCardState == STATE_INITING) {
        pDisk->d_DiskCardState = STATE_CLOSED;
        DEBUGMSG(ATAPI_INIT,
            (TEXT("ATAPI: ATAInit returning 0x%x\r\n"), pDisk));
        return pDisk;
    }


//ai_fail:
    CloseDisk(pDisk);
    return NULL;
}   // ATAInit

//
// Function to detect an ATA device.  This detection relies on the fact that
// device.exe has already determined there is a disk device in this socket by
// looking at the CISTPL_FUNCID tuple.  This function will look at the CISTPL_FUNCE
// tuples to see if it is an ATA device.
//
// Return TRUE if there is an ATA device in the specified socket; FALSE if not.
BOOL
ATAPIDetect(
    )
{
	WORD 	dwCount;
	WORD	*rdata;
	USHORT	dwPIOmode;
	BYTE	dwPIOdata;


	CD_ROM_STA.flag = ATAPI_ATAPROC;					// Send ATA Command 
	*ATAPI_DSEL = ATAPI_DEVICESELECT;	
	*ATAPI_COMD = ATPCOM_SOFTRESET; 				    //  ATA Command    ( Device Reset )	
// Execute Device Reset
	dwTimer = 0;
	while( ( *ATAPI_STAT & ATPMASK_BUSY ) == 0x80){		// If Status Reg BSY=0 then next
		Sleep(ATAPI_SLEEP);								// 100ms SLEEP
		dwTimer++;
		if(dwTimer>ATAPI_SLEEP)
	   		break;
	}
	if(dwTimer>ATAPI_SLEEP){
	    SetLastError(ERROR_NOT_READY);
 		RETAILMSG(1, (TEXT("ATPCOM_SOFTRESET Command : GetLastError() = %d\r\n"), GetLastError()));
	    return FALSE;
	}

// Register Check after Device Reset Protocol
	dwTimer = 0;
	while( *ATAPI_STAT != 0x00 ){						// Status          = 00h after Device Reset
		Sleep(ATAPI_SLEEP);								// 100ms SLEEP
		dwTimer++;
		if(dwTimer>ATAPI_SLEEP)
	   		break;
	}
	if(dwTimer>ATAPI_SLEEP){
	    SetLastError(ERROR_NOT_READY);
 		RETAILMSG(1, (TEXT("ATPCOM_SOFTRESET Command : GetLastError() = %d\r\n"), GetLastError()));
	    return FALSE;
	}
	dwTimer = 0;
	
	while( *ATAPI_IRRN != 0x01 ){						// Interrupt       = 01h after Device Reset
		Sleep(ATAPI_SLEEP);								// 100ms SLEEP
		dwTimer++;
		if(dwTimer>ATAPI_SLEEP)
	   		break;
	}
	if(dwTimer>ATAPI_SLEEP){
	    SetLastError(ERROR_NOT_READY);
 		RETAILMSG(1, (TEXT("ATPCOM_SOFTRESET Command : GetLastError() = %d\r\n"), GetLastError()));