usbdetection.c

card 的检测读取等功能操作,主要用于多媒体,数码的各种卡的操作.

#include "Config.h"		// Global Configuration - do not remove!

#ifdef I86_USB_SUPPORT

#ifdef _DEBUG
#include "Debug\dbgmain.h"
#undef IFTRACE
#define IFTRACE if (gTraceUSBHub)
#endif

#include "Include\sysdefs.h"
#include "CPU\v186t\v186t.h"
#include "MediaCards\Fcu\_I86_FCU_LL_\Fcu.h"
#include "Kernel\uITRON\rtos.h"
#include "Kernel\Timers\Timers.h"
#include "Kernel\eventdef.h"
#include "Kernel\ker_api.h"
//#include "Decoder\Decoder.h"
#include "MediaCards\Include\CardType.h"
#include "io_hal_api.h"
#include "services\include\_heap.h"
#include "coreapi\coreapi.h"
#include "MediaCards\Usb\Usb.h"
#include "Mediacards\usb\UsbDeviceListManagement.h"
#include "MediaCards\Media\Mass_Storage\fx_mass_storage.h"
#include "MediaCards\Include\CardType.h"
#include "Mediacards\usb\vusb.h"
#include "Playcore\exception\exception.h"
#ifdef D_GINGER_I86
#include "Drive\ZFE\reader\READER.h"
#include "Drive\CardReader\CardReaderDriver.h"
#endif
#ifdef D_GINGER_I96
#include "Drive\ZFE\disc\reader\READER.h"
#include "Drive\ZFE\card\CardReaderDriver.h"
#include "Playcore\Coremain\CoreDefs.h"
#endif
#ifdef D_AV_RECEIVER
#include "Playcore\Coremain\BrowseHandler.h"
#endif

#ifdef D_GINGER_I86
#undef far
#define far
#endif

#ifdef D_USB_REMOVE_PATCH
void USB_RemoveAll(void);
#endif

#define USB_ENUMERATION_RETRY_TIMES 3

extern void  UsbResetDetachOnTheFlyDetection(void);
extern BOOL UsbIsDetachOnTheFlyHappened(void);
extern CORE_STATE gcs;
extern CONST UINT USB_SP_MAPPING_SIZE[];

extern UINT8 far aUsbInternalMem[];
// Buffer for building CBW 
extern PSCBW far psCbw;
// Buffer for receiving CSW
extern PSCSW far psCsw;
// Pipes for Host mass-storage
extern HPIPE far hBulkOut;
extern HPIPE far hBulkIn;
extern BOOL far gbIsUSBDriver;

STATIC UINT8* spBlockInSRAM = aUsbInternalMem;
BOOL gbRootUSBAttached = FALSE;
STATIC UINT8 scUSBCurrentWorkingDevice = 0;
STATIC UINT8	cUsbEnumerationRetryCounter = 0;
STATIC BOOL	bIsUnsupportedDevice = FALSE;
BOOL gbTimeoutError = FALSE;

#ifdef D_USB_REMOVE_PATCH
static BOOL far b_UsbAllRemoved = FALSE;
#endif

STATIC UINT  USB_MassStorageTestUnitStatus(HDEVICE pDeviceHandler, UINT8 cLun);
#ifdef D_SUPPORT_USB_HUB
STATIC BOOL USB_NewDevice(PHUB_DEVICE_BLOCK pBlockInSRAM, PHUB_PORT_DEVICE_INFO pNewDeviceInfo);
#else
STATIC BOOL USB_NewDevice(PHUB_DEVICE_BLOCK pBlockInSRAM);
#endif
STATIC VOID USB_RemoveDevice(UINT8 cIndex, USB_DEVICE_TYPE wDeviceType);
STATIC VOID USB_RemoveAllDevice(USB_DEVICE_TYPE oDeviceType);
STATIC UINT USB_MassStorageWaitForUnitReady(HDEVICE pDeviceHandler, UINT8* pTempData);

BOOL USB_SetWorkingDevice(UINT8 cIndex, USB_DEVICE_TYPE wDeviceType)
{
	if(wDeviceType == USB_DEVICE_TYPE_MASS_STORAGE)
	{
		if(((PMASS_STORAGE_DEVICE_BLOCK)spBlockInSRAM)->mwDeviceType != USB_DEVICE_TYPE_MASS_STORAGE
			 || scUSBCurrentWorkingDevice != cIndex)
		{
			dbg_printf(("UsbSetWorkingDevice() Calling...\n"));
			#ifdef D_SUPPORT_USB_HUB
			if(USB_GetMassStorageBlock(cIndex, (PMASS_STORAGE_DEVICE_BLOCK)spBlockInSRAM))
			{
			#endif
				scUSBCurrentWorkingDevice = cIndex;
				UsbUpdateDeviceAddr(((PMASS_STORAGE_DEVICE_BLOCK)spBlockInSRAM)->moDevice.byDeviceAddr);
			#ifdef D_SUPPORT_USB_HUB
			}
			else
				dbg_printf(("No Such Device or Get Device Block Fail\n"));
			#endif
		}
	}
	else
	{
		dbg_printf(("UsbSetWorkingDevice(): unsupport device.\n"));
		return FALSE;
	}

	return TRUE;
}

/*--------------------------------------------------------
function: Usb_NewDevice
description:	Init hub and mass storage data structure.
input:	pBlockBufInSRAM: buffer used to store hub device infor.
		pNewDeviceInfo: new device information for hub port.
return : TRUE--success, FALSE--error.
--------------------------------------------------------*/
#ifdef D_SUPPORT_USB_HUB
STATIC BOOL USB_NewDevice(PHUB_DEVICE_BLOCK pBlockBufInSRAM, PHUB_PORT_DEVICE_INFO pNewDeviceInfo)
#else
STATIC BOOL USB_NewDevice(PHUB_DEVICE_BLOCK pBlockBufInSRAM)
#endif
{
     	UINT8* pDescriptorBuffer;	 
	HPORT pPort;
	HDEVICE pDevice;
	HDESC pDesc;
	PSUSBSTDINTERDESC pInterfaceDesc;
	UINT8* pBackupDeviceBlock;
	INT32 lNumberOfBytesRead;

	pDescriptorBuffer = MEM_Allocate(DEFAULT_HEAP, 100);

	if(NULL == pDescriptorBuffer)
		{
		dbg_printf(("USB_NewDevice(): Can not allocate memory for DescriptorBuffer\n"));
		return FALSE;
		}

	pBackupDeviceBlock = MEM_Allocate(DEFAULT_HEAP, USB_INTERNAL_USAGE_HEAP_SIZE);

	if(NULL == pBackupDeviceBlock)
		{
		dbg_printf(("USB_NewDevice(): Can not allocate memory for BackupDeviceBlock\n"));
		MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
		return FALSE;
		}
	dbg_printf(("USB_NewDevice() Calling...\n"));

	if(pBlockBufInSRAM != NULL)
	{
		UsbMem_Backup();
		memcpy(pBackupDeviceBlock, aUsbInternalMem, USB_INTERNAL_USAGE_HEAP_SIZE);
	}

	pPort = UsbHostPortConnect();

	pDevice = UsbHostDeviceOpen(pPort, pDescriptorBuffer);

	if(pDevice == NULL)
	{
		dbg_printf(("USB_NewDevice(): Device Open fail\n"));
		if(pBlockBufInSRAM != NULL)
		{
			UsbMem_Backup();
			memcpy(pBackupDeviceBlock, aUsbInternalMem, USB_INTERNAL_USAGE_HEAP_SIZE);
		}	
		MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
		MEM_Free(DEFAULT_HEAP, pBackupDeviceBlock);
		return FALSE;
	}

	dbg_printf(("USB_NewDevice(): Start reading descriptor.\n"));

	//get standard device descriptor
	pDesc = UsbHostGetFirstDescriptor( pDevice, USB_HGFD_CURRENT_SPEED);

	pInterfaceDesc = UsbHostGetNextDescriptor( pDesc, USB_HGND_INTERFACE_DESC );

#ifdef D_SUPPORT_USB_HUB
	//Hub device
	if ( ((PSUSBSTDDEVDESC)pDesc)->byDeviceClass == USB_CLASS_HUB)
	{
		PHUB_DEVICE_BLOCK pNewHubDevice;
		SUSBHUBDESC oHubDesc;
		UINT8 cPortCount;
		UINT8 cNewIndex;
		HPIPE pDefaultPipe;
		BOOL bReturnValue;

		dbg_printf(("USB_NewDevice(): Hub Inserted.\n"));
		pDefaultPipe = UsbHostGetDefaultPipe(pDevice);

		//get port number
	        bReturnValue = UsbHostHubGetHubDescriptor( pDefaultPipe,
                                (PBYTE)&oHubDesc,
                                (PLONG)&lNumberOfBytesRead,
                                USB_WAIT_FOREVER );
		if(bReturnValue == FALSE)
		{
			if(pBlockBufInSRAM != NULL)
			{
				UsbMem_Backup();
				memcpy(pBackupDeviceBlock, aUsbInternalMem, USB_INTERNAL_USAGE_HEAP_SIZE);
			}
			MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
			MEM_Free(DEFAULT_HEAP, pBackupDeviceBlock);
			return FALSE;
		}

		pNewHubDevice = (PHUB_DEVICE_BLOCK)pDevice;

		pNewHubDevice->mcMaxChild = oHubDesc.bNbrPorts;

		if(pBlockBufInSRAM != NULL)
			pNewHubDevice->moPointer.mcIndexofParent = scUSBCurrentWorkingDevice;
		else
			pNewHubDevice->moPointer.mcIndexofParent = USB_LIST_NULL_INDEX;

		for(cPortCount=0; cPortCount<pNewHubDevice->mcMaxChild; cPortCount++)
		{
			bReturnValue = UsbHostHubSetFeature( pDefaultPipe,
			          cPortCount + 1,
			          USB_HUB_FS_PORT_POWER,
			          USB_WAIT_FOREVER );
			if(bReturnValue == FALSE)
			{
				dbg_printf(("USB_NewDevice(): Hub port power up fail.\n"));
				if(pBlockBufInSRAM != NULL)
				{
					UsbMem_Backup();
					memcpy(pBackupDeviceBlock, aUsbInternalMem, USB_INTERNAL_USAGE_HEAP_SIZE);
				}
				MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
				MEM_Free(DEFAULT_HEAP, pBackupDeviceBlock);
				return FALSE;
			}

			bReturnValue = UsbHostHubClearFeature( pDefaultPipe,
			                        USB_HUB_FS_C_PORT_CONNECTION,
			                        0,
			                        cPortCount + 1,
			                        USB_WAIT_FOREVER );
			if(bReturnValue == FALSE)
			{
				if(pBlockBufInSRAM != NULL)
				{
					UsbMem_Backup();
					memcpy(pBackupDeviceBlock, aUsbInternalMem, USB_INTERNAL_USAGE_HEAP_SIZE);
				}
				MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
				MEM_Free(DEFAULT_HEAP, pBackupDeviceBlock);
				return FALSE;
			}
			

			bReturnValue = UsbHostHubSetFeature( pDefaultPipe,
			          cPortCount + 1,
			          USB_HUB_FS_PORT_RESET,
			          USB_WAIT_FOREVER );
			if(bReturnValue == FALSE)
			{
				dbg_printf(("USB_NewDevice(): Hub port reset fail\n"));
				if(pBlockBufInSRAM != NULL)
				{
					UsbMem_Backup();
					memcpy(pBackupDeviceBlock, aUsbInternalMem, USB_INTERNAL_USAGE_HEAP_SIZE);
				}
				MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
				MEM_Free(DEFAULT_HEAP, pBackupDeviceBlock);
				return FALSE;
			}
			
			bReturnValue = UsbHostHubClearFeature( pDefaultPipe,
			                        USB_HUB_FS_C_PORT_RESET,
			                        0,
			                        cPortCount + 1,
			                        USB_WAIT_FOREVER );
			if(bReturnValue == FALSE)
			{
				if(pBlockBufInSRAM != NULL)
				{
					UsbMem_Backup();
					memcpy(pBackupDeviceBlock, aUsbInternalMem, USB_INTERNAL_USAGE_HEAP_SIZE);
				}
				MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
				MEM_Free(DEFAULT_HEAP, pBackupDeviceBlock);
				return FALSE;
			}
			
			bReturnValue = UsbHostHubSetFeature( pDefaultPipe,
			          cPortCount + 1,
			          USB_HUB_FS_PORT_RESET,
			          USB_WAIT_FOREVER );
			if(bReturnValue == FALSE)
			{
				dbg_printf(("USB_NewDevice(): Hub port reset fail\n"));
				if(pBlockBufInSRAM != NULL)
				{
					UsbMem_Backup();
					memcpy(pBackupDeviceBlock, aUsbInternalMem, USB_INTERNAL_USAGE_HEAP_SIZE);
				}
				MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
				MEM_Free(DEFAULT_HEAP, pBackupDeviceBlock);
				return FALSE;
			}
			
			
			bReturnValue = UsbHostHubClearFeature( pDefaultPipe,
			                        USB_HUB_FS_C_PORT_RESET,
			                        0,
			                        cPortCount + 1,
			                        USB_WAIT_FOREVER );
			if(bReturnValue == FALSE)
			{
				if(pBlockBufInSRAM != NULL)
				{
					UsbMem_Backup();
					memcpy(pBackupDeviceBlock, aUsbInternalMem, USB_INTERNAL_USAGE_HEAP_SIZE);
				}
				MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
				MEM_Free(DEFAULT_HEAP, pBackupDeviceBlock);
				return FALSE;
			}
			
			

			pNewHubDevice->maPortStatus[cPortCount] = NOT_AVAILABLE;
			pNewHubDevice->maPortDeviceInfo[cPortCount].mwPortDeviceIndex = USB_LIST_NULL_INDEX;
			pNewHubDevice->maPortDeviceInfo[cPortCount].mwPortDeviceType = 0;
			pNewHubDevice->maPortDeviceInfo[cPortCount].mwPortNumber = 0;
			pNewHubDevice->mwDeviceType = USB_DEVICE_TYPE_HUB;
		}

		if(USB_AddHubDeviceBlock(pNewHubDevice, &cNewIndex))
		{
			pNewDeviceInfo->mwPortDeviceIndex = cNewIndex;
			pNewDeviceInfo->mwPortDeviceType = USB_DEVICE_TYPE_HUB;
			pNewDeviceInfo->mwPortNumber = 0;//((PSUSBPORT)hPort)->uiPortNum; //hPort is NULL
		}
		else
		{
			dbg_printf(("USB_NewDevice(): Add New Hub Device Block Fail\n"));
			if(pBlockBufInSRAM != NULL)
			{
				UsbMem_Restore();
				memcpy(aUsbInternalMem, pBackupDeviceBlock, USB_INTERNAL_USAGE_HEAP_SIZE);
			}
			MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
			MEM_Free(DEFAULT_HEAP, pBackupDeviceBlock);
			return FALSE;		
		}
		
		
	}
	else 
#endif//D_SUPPORT_USB_HUB
	if ( (( pInterfaceDesc->byDeviceSubClass == MASS_STORAGE_SFF_8070)
		|| ( pInterfaceDesc->byDeviceSubClass == MASS_STORAGE_SCSI_TRANSPARENT ))
		&& ( pInterfaceDesc->byDeviceProtocol == MASS_STORAGE_BULK_ONLY ))
	{
#ifdef D_SUPPORT_USB_HUB

		UINT8 cNewIndex;
#endif
		PMASS_STORAGE_DEVICE_BLOCK pNewMassStorageDevice;
		FX_MASS_STORAGE* pMassStorage;
		UINT8 cUnitCount;
		SUSBSETUPPACKET  oSetupPacket;
		UINT8 cMaxLun;

		dbg_printf(("USB_NewDevice(): Mass Storage Inserted.\n"));
		pMassStorage = HostMassStorageOpen(pDevice);

		if(pMassStorage == NULL)
		{
			if(pBlockBufInSRAM != NULL)
				{
					UsbMem_Backup();
					memcpy(pBackupDeviceBlock, aUsbInternalMem, USB_INTERNAL_USAGE_HEAP_SIZE);
				}
		}

		oSetupPacket.byRequest = USB_MASS_STORAGE_GET_MAX_LUN;
		oSetupPacket.byRequestType = USB_CLASS_DEVICE_2_HOST_INTERFACE_REQUEST;
		oSetupPacket.wIndex = 0;
		oSetupPacket.wLength = 1;
		oSetupPacket.wValue = 0;

		if(!UsbHostControlTransfer(pMassStorage->hCtrl, &oSetupPacket, &cMaxLun, (PLONG)&lNumberOfBytesRead,USB_WAIT_FOREVER))
		{
			dbg_printf(("USB_NewDevice(): Get USB MAX LUN FAIL.\n"));	
			UsbHostControlTransfer(pMassStorage->hCtrl, &oSetupPacket, &cMaxLun, (PLONG)&lNumberOfBytesRead,USB_WAIT_FOREVER);
		}
		
		{
			UINT8* pUSBInternalMem = aUsbInternalMem;
			UINT8 cSegmentCount;
			UINT8* pUFICMDDataBuff;
			UINT16 wRes;
			
			for(cSegmentCount=0; cSegmentCount<USB_SCBW_STRUCT; cSegmentCount++)
				pUSBInternalMem = pUSBInternalMem + USB_SP_MAPPING_SIZE[cSegmentCount];
			psCbw = (PSCBW)pUSBInternalMem;
			
			psCsw = (PSCSW)(pUSBInternalMem + USB_SP_MAPPING_SIZE[USB_SCBW_STRUCT]);
			memset(psCbw, 0, sizeof(SCBW));
			memset(psCsw, 0, sizeof(SCSW));
			hBulkOut = pMassStorage->hBulkOut;
			hBulkIn = pMassStorage->hBulkIn;
			pUFICMDDataBuff = MEM_Allocate(DEFAULT_HEAP, sizeof(SUFIINQUIRYDATA));
			if(pUFICMDDataBuff == NULL)
			{
				MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
				MEM_Free(DEFAULT_HEAP, pBackupDeviceBlock);
				return FALSE;
			}
			for(cUnitCount=0; cUnitCount<=cMaxLun; cUnitCount++)
			{
				((PSUSBDEVICE)pDevice)->ucCurrLun = cUnitCount;
				wRes = MassStorageUFICommand(pUFICMDDataBuff, UFI_INQUIRY);
				if(wRes == UFI_COMMAND_STATUS_ERROR)
						{
						MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
						MEM_Free(DEFAULT_HEAP, pBackupDeviceBlock);
						MEM_Free(DEFAULT_HEAP, pUFICMDDataBuff);
						return FALSE;
						}
				wRes = MassStorageUFICommand(pUFICMDDataBuff, UFI_REQUEST_SENSE);	
				if(wRes == UFI_COMMAND_STATUS_ERROR)
						{
						MEM_Free(DEFAULT_HEAP, pDescriptorBuffer);
						MEM_Free(DEFAULT_HEAP, pBackupDeviceBlock);
						MEM_Free(DEFAULT_HEAP, pUFICMDDataBuff);
						return FALSE;			
						}
			}
			MEM_Free(DEFAULT_HEAP, pUFICMDDataBuff);			
		}
		
		pNewMassStorageDevice = (PMASS_STORAGE_DEVICE_BLOCK)pDevice;