usbh_usbds_api.c

epson usb2.0 控制芯片 S1R72V05 固件程序。

//
//				  HCD is initialized (release of the memory area used with the stop 
//				  and HCD of the power supply supplied to VBUS of the route hub port
//				  and liberate of the memory used for the device management). 
//				  Moreover, the memory areas of URB and device information etc.
//				  on use with HostStack are released. 
//
// argument 	: none
//
// return		: USBH_USBD_STATUS_SUCCESS			Processing was normally completed.
//				  USBH_USBD_STATUS_UNSCCESSFUL		Host Controller is suspending it.
===============================================================================================*/
long USBH_USBDS_Cleanup( void )
{
	long retValue;

	/* Initialize connected device information. */
	USBH_USBDS_DelALLDev(wURB->psDev);

	/* Initialize HCD. */
	retValue = USBH_HCD_Cleanup();
	if( retValue != USBH_USBD_STATUS_SUCCESS ) {
		return retValue;
	}

	return retValue;
}

/*=============================================================================================
//
// description	: This is call back function to return HCD message.
//
// argument 	: message						Message ( in )
//				: param0						The first native parameter of each message ( in )
//				: vpParam						The second native parameter of each message ( in )
//
// return		: None
===============================================================================================*/
STATIC_T	void USBH_USBDS_HCDCallbackProc ( ULONG message, ULONG param0, void* vpParam )
{
	switch( message ) {
		case USBH_HCD_MSG_INIT_CMP :				/* Initialization ( active setting )	*/
			USBH_USBDS_RootHubActive();
			break ;
		default :
			break ;
	}
}

/*=============================================================================================
// Function_Name: USBH_USBDS_RootHubActive
//
// description	: Carry out root hub initalization ( active setting ).
//
// argument 	: void
//
// return		: USBH_USBD_STATUS_SUCCESS		Normal finish
//				: Others						Abnormal finish
===============================================================================================*/
STATIC_T	long USBH_USBDS_RootHubActive( void )
{
	long retValue;

	switch(USBH_USBD_Mode) {

		case USBH_USBD_MODE_INIT:

			/* Secure memory area for device management use, after receiving HCD active setting finish call back */
			UsbDevInfo = &RootHubDev;
			RootHubDev.sUsbDev.pHCPriv	= NULL ;								/* (out) */
			RootHubDev.sUsbDev.eState	= USBH_USBD_USB_STATE_NOTATTACHED ;		/* USB device state ( in ) */
			RootHubDev.sUsbDev.psParent= NULL ;									/* Set NULL because it is root hub ( in ) */
			RootHubDev.sUsbDev.eSpeed  = USBH_USBD_USB_SPEED_FULL;				/* Set FULL in default ( in ) */
			RootHubDev.sUsbDev.port  = USBH_USBD_HOSTPORTNO;					/* Host port number ( in ) */
			retValue = USBH_HCD_AllocDev((USBH_HCD_USBDEV *)&RootHubDev.sUsbDev);	/* Secure memory area for USB device management use */
			if(retValue != USBH_USBD_STATUS_SUCCESS) {
				return retValue;
			}
			USBH_USBD_Mode = USBH_USBD_MODE_DEVDES8;
		default:
			/* Secure memory area for URB & device management use ( for root hub use ) */

			/* Device recognition ( emulation ) process */
			do{
				retValue = USBH_USBDS_DeviceEnumeration( USBH_USBD_ENUME_ROOTHUB, &RootHubDev, 0 );
				if(retValue != USBH_USBD_STATUS_SUCCESS) {
					return retValue;
				}
			}while( USBH_USBD_Mode != USBH_USBD_MODE_SPORTPWR );
			break;

	}
	return USBH_USBD_STATUS_SUCCESS;
}


/*=============================================================================================================================
// Function_Name: USBH_USBDS_SubmitURB
//
// description	: After checking parameter, pipe of URB passed, carry out registration and execution of URB.
//				  Used when data transfer
//
// argument 	: *psUrb							Pointer to URB structure ( in )
//				: classid							Class ID ( in )
//				: pfnCallback						Pointer to call back function to notify completion ( in )
//
// return		: USBH_USBD_STATUS_SUCCESS			Registration finish normally
//				  USBH_USBD_STATUS_PIPE_ERROR		Case of pipe can't be secured for executing URB
//				  USBH_USBD_STATUS_MEM_ERROR		Memory area can't be secured
//				  USBH_USBD_STATUS_INVALID_PARAMETER There were some error in passed parameter
//				  USBH_USBD_STATUS_UNSUCCESSFUL		 Host Controller on suspension or object device is not found
===============================================================================================================================*/
long USBH_USBDS_SubmitURB( USBH_USBD_URB *psURB, UCHAR	classid, USBH_USBD_CALLBACK pfnCallback )
{
	pfnSubmitURB.Callback = pfnCallback;

	/* Set parameter */
	/* Check URB data contents ( pipe information, transfer type, EP address, USB device address, direction ) -> Carry out in USBH_USBD_SubmitURB() */
	/* Check pipe existence ( based on device management table ) -> Carry out in USBH_HCD_SubmitURB() */
	psURB->pHCPriv = NULL;

	/*** Assume there is no error coming in HCD as presupposition because parameter checking was done in upper task side! ***/
	/*** Return SUBMIT_OK firstly because there is a problem in file system side if HCD call back is called before SUBMIT_OK call back ***/
	USBH_USBDS_ExecCallback(pfnSubmitURB.Callback, USBH_USBD_MSG_SUBMIT_OK, 0, NULL);

	pfnSubmitURB.retValue = USBH_HCD_SubmitURB((USBH_HCD_URB *)psURB);
	return pfnSubmitURB.retValue;
}

/*=============================================================================================================================
// Function_Name: USBH_USBDS_UnlinkURB
//
// description	: Cancel passed URB execution and delete it.
//
// argument 	: *psUrb							URB structure pointer ( in )
//				: classid							Class ID ( in )
//				: pfnCallback						Pointer to call back function to notify completion ( in )
//
// return		: USBH_USBD_STATUS_SUCCESS			 Registration finish normally
//				  USBH_USBD_STATUS_INVALID_PARAMETER There were some errors in passed parameter
//				  USBH_USBD_STATUS_UNSUCCESSFUL		 Host Controller on suspension or object device is not found
===============================================================================================================================*/
long USBH_USBDS_UnlinkURB( USBH_USBD_URB *psURB, UCHAR	classid, USBH_USBD_CALLBACK pfnCallback )
{
	pfnUnlinkURB.Callback = pfnCallback;

	pfnUnlinkURB.retValue = USBH_HCD_UnlinkURB( (USBH_HCD_URB *)psURB );
	if(pfnUnlinkURB.retValue != USBH_USBD_STATUS_SUCCESS) {

		pfnUnlinkURB.retValue = USBH_USBD_STATUS_UNSUCCESSFUL;
		USBH_USBDS_ExecCallback(pfnUnlinkURB.Callback, USBH_USBD_MSG_UNLINK_NG, pfnUnlinkURB.retValue, NULL);
	} else {

		USBH_USBDS_ExecCallback(pfnUnlinkURB.Callback, USBH_USBD_MSG_UNLINK_OK, pfnUnlinkURB.retValue, NULL);
	}

	return pfnUnlinkURB.retValue;
}

/*=============================================================================================
// Function_Name: USBH_USBDS_EntryClass
//
// description	: Register specified class driver.
//
// argument 	: classno							Class driver number ( in )
//				: *classid							Class ID ( out )
//				: pfnCallback						Pointer to call back function to notify completion ( in )
//				: pfnEventCallback					Pointer to the call back function that notifies settlement (in)
//
// return		: USBH_USBD_STATUS_SUCCESS			 Registration finish normally
//				  USBH_USBD_STATUS_INVALID_PARAMETER There were some errors in passed parameter
//				  USBH_USBD_STATUS_UNSUCCESSFUL		 Wrong class ID
===============================================================================================*/
long USBH_USBDS_EntryClass( UCHAR  classno, UCHAR  *classid, USBH_USBD_CALLBACK pfnCallback, USBH_USBD_CALLBACK pfnEventCallback )
{
	USBH_USBD_DEVLIST_HEAD	*Devtmp;
	MSG_USBH_USBD	tmp;


	pfnEntryClass.retValue = USBH_USBD_STATUS_UNSUCCESSFUL;

	/* Confirmation for API abnormal finish */
	if((ClassINFONum >= USBH_USBD_CLASSDRIVERNUM)
	|| (ClassINFO[ClassINFONum].ClassID != 0)) {
		USBH_USBDS_ExecCallback(pfnEventCallback, USBH_USBD_MSG_ENTRYC_NG, 0, NULL);
	} else {

		/* Assign specified class number to class ID */
		*classid = ClassINFO[ClassINFONum].ClassID = ClassINFONum+1;
		ClassINFO[ClassINFONum].ClassNo = classno;

		pfnEntryClass.retValue = USBH_USBD_STATUS_SUCCESS;

		/* Registered call back */
		USBH_USBDS_ExecCallback(pfnEventCallback, USBH_USBD_MSG_ENTRYC_OK, 0, NULL);

		/* Return connecting of un-registered device of class within connected device, in call back function */
		/* Registration of pointer of call back function */
		ClassINFO[ClassINFONum].pfnEntryClassCallback = pfnEventCallback;
		ClassINFONum++;

		Devtmp = DeviceCtlTbl.DevInfo;
		while(Devtmp != NULL) {
			/* Search un-registered device of class ID */
			if(Devtmp->ClassID == 0) {
				/* Notify device connecting message to class. */
				tmp.DevInfo = (USBH_USBD_DEVLIST_HEAD*)Devtmp;
				if(tmp.DevInfo->sUsbDev.devNum != 0) {	/* Judge whether it is device on emulation completion */

					/* Notify connecting to upper class only in case of device besides hub */
					if(*classid != USBH_HSBD_HUB_CLASS_ID) {
						/* Message is returned in call back function */
						/* Class of registration completion or it checks it */
						if( USBH_USBDS_SearchIdentityClass( classno ) != USBH_USBD_STATUS_UNSUCCESSFUL ) {
							Devtmp->ClassID = *classid;
							USBH_USBDS_ExecCallback(pfnEventCallback, USBH_USBD_MSG_CONNECT_OK, tmp.DevInfo->sUsbDev.devNum, Devtmp);
						}
					}
				}
			}
			Devtmp = Devtmp->psNext;
		}
	}

	USBH_USBDS_ExecCallback(pfnCallback, USBH_USBD_MSG_RETURN_VALUE, pfnEntryClass.retValue, NULL);

	return pfnEntryClass.retValue ;
}

/*=============================================================================================
// Function_Name: USBH_USBDS_SetConfiguration
//
// description	: Register pipe based on specified device address, carry out configuration.
//
// argument 	: classid							Class ID ( in )
//				: devaddr							Device address ( in )
//				: *pfnCallback						Pointer to call back function to notify completion ( in )
//
// return		: USBH_USBD_STATUS_SUCCESS			Registration finish normally
//				  USBH_USBD_STATUS_UNSUCCESSFUL		Host Controller on suspension
===============================================================================================*/
long USBH_USBDS_SetConfiguration( UCHAR  classid, UCHAR  devaddr, USBH_USBD_CALLBACK pfnCallback )
{
	USBH_USBD_URB			*TmpUrb ;
	USBH_USBD_DEVLIST_HEAD	*UsbList;
	UCHAR					bConfigurationValue;


	bConfigurationValue = 0;	// Cope with warning for the optimization.


	pfnSetConfiguration.Callback = pfnCallback;

	// Device, configuration check

	// SetConfiguration
	TmpUrb = USBH_USBDS_AddURBList();
	UsbList = SeachDevAddrIDToDevice(classid, devaddr, &pfnSetConfiguration.retValue, &bConfigurationValue);
	if(TmpUrb != (USBH_USBD_URB *)USBH_USBD_STATUS_UNSUCCESSFUL
	&& pfnSetConfiguration.retValue == USBH_USBD_STATUS_SUCCESS) {
		TmpUrb->psDev = &UsbList->sUsbDev;
		if( TmpUrb->psDev->eState == USBH_USBD_USB_STATE_CONFIGURED ) {
			return pfnSetConfiguration.retValue;
		}
		SetMaxPacketSizeToDevice(UsbList);				/* MaxPacketSize setting */

		/* Parameter setting */
		TmpUrb->pipe = USBH_USBD_SetPipeType(USBH_HCD_PIPE_CONTROL, ENUM_EP0, TmpUrb->psDev->devNum, USBH_HCD_DIR_OUT);
		USBH_USBDS_MkSetupPacket((SETUP_REQUEST *)TmpUrb->pSetupPacket, BREQ_SETCONFIGURATION, 0, 0, bConfigurationValue);
		USBH_USBDS_SetTranPara(TmpUrb, 0, 0, 0, USBH_USBDS_SetConfigurationCallbackProc);
		pfnSetConfiguration.retValue = USBH_HCD_SubmitURB((USBH_HCD_URB *)TmpUrb);
	}
	// Update device management table
	// Pipe registration
	return pfnSetConfiguration.retValue;
}

/*=============================================================================================
// Function_Name: USBH_USBDS_Reset
//
// description	: Reset specified device.
//
// argument 	: classid							Class ID ( in )
//				: devaddr							Device address ( in )
//				: *pfnCallback						Pointer to call back function to notify completion ( in )
//
// return		: USBH_USBD_STATUS_SUCCESS			Registration finish normally
//				  USBH_USBD_STATUS_INVALID_PARAMETER There were some errors in passed parameter
//				  USBH_USBD_STATUS_UNSUCCESSFUL		 Host Controller on suspension
===============================================================================================*/
long USBH_USBDS_Reset( UCHAR  classid, UCHAR  devaddr, USBH_USBD_CALLBACK pfnCallback )
{
	USBH_USBD_USBDEV *UsbDev=NULL ;


	UsbDev = USBH_USBDS_SearchDev(devaddr, &pfnReset.retValue);
	if( pfnReset.retValue == STATUS_NO_EXISTENCE_PORT ) {
		return pfnReset.retValue ;
	}
	wURB = USBH_USBDS_AddURBList();

	// Registration of pointer of call back function
	pfnReset.Callback = pfnCallback;

	if(wURB != (USBH_USBD_URB *)USBH_USBD_STATUS_UNSUCCESSFUL) {
		UsbDevInfo = USBH_USBDS_SearchDevList( UsbDev );
		USBH_USBDS_ALLEndpointDisable((USBH_HCD_USBDEV *)&UsbDevInfo->sUsbDev, UsbDevInfo, USBH_USBD_RES);

		// SetPortFeature(PORT_RESET)
		wURB->psDev	= UsbDev->psParent ;							// Search device with same device address based on USB device management structure; /* (in ) */
		wURB->pipe	= USBH_USBD_SetPipeType(USBH_HCD_PIPE_CONTROL, ENUM_EP0, wURB->psDev->devNum, USBH_HCD_DIR_OUT);
		USBH_USBDS_MkSetupPacket((SETUP_REQUEST *)wURB->pSetupPacket, BREQ_SETFEATURE_PORT, 0, UsbDev->port, USBH_USBD_PORT_RESET);
		USBH_USBDS_SetTranPara(wURB, 0, 0, 0, USBH_USBDS_PortResetCallbackProc);
		pfnReset.retValue = USBH_HCD_SubmitURB((USBH_HCD_URB *)wURB);

		connectWaitCount = 0;
		USBH_USBDS_DelListURB(wURB);
	}
	return pfnReset.retValue;
}


/*=============================================================================================
// Function_Name: USBH_USBDS_PortSuspend
//
// description	: Suspend specified device.
//
// argument 	: classid							Class ID ( in )
//				: devaddr							Device address ( in )
//				: *pfnCallback						Pointer to call back function to notify completion ( in )
//
// return		: USBH_USBD_STATUS_SUCCESS			Registration finish normally
//				  USBH_USBD_STATUS_INVALID_PARAMETER There were errors in passed parameter
//				  USBH_USBD_STATUS_UNSUCCESSFUL		 Host Controller on suspension
===============================================================================================*/
long USBH_USBDS_PortSuspend( UCHAR	classid, UCHAR	devaddr, USBH_USBD_CALLBACK pfnCallback )
{
	USBH_USBD_DEVLIST_HEAD	*UsbDevListWK;
	USBH_USBD_USBDEV *UsbDev=NULL ;