usbd_if.c

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

// =============================================================================
*/
LONG USBD_IFSuspendProcess(void)
{
	LONG retValue;

	retValue = STATUS_SUCCESS;

	do { /* Don't loop */

		if ((RegRead(REG08_D_NegoControl) & MASK_EnAutoNego) != BIT_EnAutoNego) {
			/* When AutoNego function is not used */
			RegSet(REG08_D_NegoControl,BIT_DisBusDetect);
		}

		RegWrite(REG08_D_SIE_IntStat,BIT_NonJ);						/* Clear NonJ interrupt */
		CLR_BIT(IntStat[IS_SIE_INT_STAT],BIT_NonJ);					/* Clear NonJ */
		RegSet(REG08_D_SIE_IntEnb,BIT_EnNonJ);				/* Enable Non_J interrupt */

	} while (0);

	return retValue;
}
/* =============================================================================
// Function_Name: USBD_IFResumeProcess
// description	: Do process for Resume
// argument		: None
// return		: STATUS_SUCCESS			Finished normally
//				  STATUS_NOT_OPENED			Not be opened yet
// flag			:
// global		:
// =============================================================================
*/
LONG USBD_IFResumeProcess(void)
{
	LONG retValue;
	UCHAR lineState;
	retValue = STATUS_SUCCESS;

	do { /* Don't loop */

		if ((RegRead(REG08_D_NegoControl) & MASK_EnAutoNego) == BIT_EnAutoNego) {
			lineState = (RegRead(REG08_D_USB_Status) & MASK_LineState) >> SHIFT_LineState;
			if (lineState == BIT_LineState_SE0 || lineState == BIT_LineState_K) {
				/* Clear only when LineState is SE0 or K */
				RegClear(REG08_D_NegoControl,BIT_InSUSPEND);
			} else {
				retValue = STATUS_UNSUCCESSFUL;
				break;
			}
		} else {
			/* USB Resume */
			RegWrite(REG08_D_SIE_IntStat,BIT_RestoreCmp);					/* Clear RestoreCmp interrupt */
			CLR_BIT(IntStat[IS_SIE_INT_STAT],BIT_RestoreCmp);				/* Clear RestoreCmp */
			RegSet(REG08_D_NegoControl,BIT_RestoreUSB);
		}
	} while (0);

	return retValue;
}
/* =============================================================================
// Function_Name: USBD_IFChangeTestMode
// description	: Do process for entering USBD2.0 Test Mode
// argument		: testMode	USBD_IF_TESTMODE_J			Test J
//							USBD_IF_TESTMODE_K			Test K
//							USBD_IF_TESTMODE_SE0_NAK		Test SE0 NAK
//							USBD_IF_TESTMODE_PACKET		Test TestPacket
// return		: STATUS_SUCCESS			Finished normally
//				  STATUS_NOT_OPENED			Not be opened yet
//				  STATUS_INVALID_PARAMETER	Parameter error
// flag			:
// global		:
// =============================================================================
*/
LONG USBD_IFChangeTestMode(UCHAR testMode)
{
	LONG retValue;
	UCHAR i;

	retValue = STATUS_SUCCESS;

	do { /* Don't loop */

		switch (testMode) {
			case USBD_IF_TESTMODE_J:
				RegSet(REG08_D_USB_Test,BIT_D_Test_J);
				RegModify(REG08_D_XcvrControl,MASK_D_OpMode,BIT_D_OpMode_DisableBitStuffing);	/* Disable Bitstuffing and NRZI encoding */
				break;
			case USBD_IF_TESTMODE_K:
				RegSet(REG08_D_USB_Test,BIT_D_Test_K);
				RegModify(REG08_D_XcvrControl,MASK_D_OpMode,BIT_D_OpMode_DisableBitStuffing);	/* Disable Bitstuffing and NRZI encoding */
				break;
			case USBD_IF_TESTMODE_SE0_NAK:
				RegSet(REG08_D_USB_Test,BIT_D_Test_SE0_NAK);
				break;
			case USBD_IF_TESTMODE_PACKET:
				/* Prepare to send TestPacket */

				/* Initialize Endpoint */

				/* TestPacket uses EPa */
				RegWrite(REG08_D_EPaConfig_0,BIT_INxOUT_IN | 0x0F);
				RegWrite(REG16_D_EPaMaxSize,0x0040);

				RegWrite(REG08_D_EPbConfig_0,R8_ALLZERO);
				RegWrite(REG16_D_EPbMaxSize,0x0000);

				RegWrite(REG08_D_EPcConfig_0,R8_ALLZERO);
				RegWrite(REG16_D_EPcMaxSize,0x0000);

				/* Clear FIFO */
				RegWrite(REG08_D_EPnControl,BIT_AllFIFO_Clr);
				/* Clear Join */
				RegWrite(REG08_D_ClrAllEPnJoin,BIT_ClrJoinIDE | BIT_ClrJoinFIFO_Stat | BIT_ClrJoinDMA1 | BIT_ClrJoinDMA0 | BIT_ClrJoinCPU_Rd | BIT_ClrJoinCPU_Wr);

				/* Write data for Test Packet */
				RegSet(REG08_D_EPaJoin,BIT_JoinCPU_Wr);
				for (i = 0; i < 52; i+=2) {
					RegWrite(REG08_FIFO_Wr_0,TestPacket[i+0]);
					RegWrite(REG08_FIFO_Wr_1,TestPacket[i+1]);
				}
				RegWrite(REG08_FIFO_Wr_0,TestPacket[i]);
				RegClear(REG08_D_EPaJoin,BIT_JoinCPU_Wr);

				RegSet(REG08_D_USB_Test,BIT_D_Test_Packet);
				break;
			default:
				retValue = STATUS_INVALID_PARAMETER;
				break;
		}

		if (retValue == STATUS_SUCCESS) {
			/* Clear Interrupt Enable register */
			CLR_BIT(IntStat[IS_DEVICE_INT_STAT],MASK_DEVICE_INT_STAT & 0x7F);	/* Clear others except for VBUS_Changed */
			CLR_BIT(IntStat[IS_EPR_INT_STAT],R8_INT_ALLZERO);
			CLR_BIT(IntStat[IS_SIE_INT_STAT],R8_INT_ALLZERO);
			CLR_BIT(IntStat[IS_FIFO_INT_STAT],MASK_FIFO_INT_STAT);
			CLR_BIT(IntStat[IS_EP0_INT_STAT],R8_INT_ALLZERO);
			for (i = 0;i < MAX_EPX;i++) {
				CLR_BIT(IntStat[IS_EPA_INT_STAT + i],R8_INT_ALLZERO);
			}
			RegClear(REG08_D_NegoControl,BIT_EnAutoNego);
			RegWrite(REG08_D_NegoControl,BIT_DisBusDetect | BIT_ActiveUSB);	/* Disable Suspend,Reset */
			/* Enable Test Mode */
			RegSet(REG08_D_USB_Test,BIT_D_EnHS_Test);
		}
	} while (0);

	return retValue;
}
/* =============================================================================
// Function_Name: USBD_IFGetAddress
// description	: Get value of USBD Address
// argument		: pAddress	Pointer to return USB Address
// return		: STATUS_SUCCESS			Finished normally
//				  STATUS_NOT_OPENED			Not be opened yet
// flag			:
// global		:
// =============================================================================
*/
LONG USBD_IFGetAddress(UCHAR *pAddress)
{
	LONG retValue;

	retValue = STATUS_SUCCESS;

	do { /* Don't loop */

		*pAddress = RegRead(REG08_D_USB_Address);
	} while (0);

	return retValue;
}
/* =============================================================================
// Function_Name: USBD_IFSetAddress
// description	: Set USBD Address
// argument		: address	USB Address
// return		: STATUS_SUCCESS			Finished normally
//				  STATUS_NOT_OPENED			Not be opened yet
// flag			:
// global		:
// =============================================================================
*/
LONG USBD_IFSetAddress(UCHAR address)
{
	LONG retValue;

	retValue = STATUS_SUCCESS;

	do { /* Don't loop */

		RegWrite(REG08_D_USB_Address,address);		/* Set USB Address */

	} while (0);

	return retValue;
}
/* =============================================================================
// Function_Name: USBD_IFGetOpMode
// description	: Get value of OpMode
// argument		: pOpMode	Pointer to return OpMode
// return		: STATUS_SUCCESS			Finished normally
//				  STATUS_NOT_OPENED			Not be opened yet
// flag			:
// global		:
// =============================================================================
*/
LONG USBD_IFGetOpMode(UCHAR *pOpMode)
{
	LONG retValue;

	retValue = STATUS_SUCCESS;

	do { /* Don't loop */

		*pOpMode = (RegRead(REG08_D_XcvrControl) & MASK_D_OpMode) >> SHIFT_D_OpMode;
	} while (0);

	return retValue;
}
/* =============================================================================
// Function_Name: USBD_IFSetOpMode
// description	: Set value of OpMode
// argument		: OpMode					Setting value of OpMode
//											USBD_IF_OPMODE_NORMAL 		Normal state
//											USBD_IF_OPMODE_NONDRIVE		Non-Drive
//											USBD_IF_OPMODE_DISBITSTUFF	Disable Bitstuffing and NRZI encoding
//											USBD_IF_OPMODE_PWDOWN		Power-Down
// return		: STATUS_SUCCESS			Finished normally
//				  STATUS_NOT_OPENED			Not be opened yet
// flag			:
// global		:
// =============================================================================
*/
LONG USBD_IFSetOpMode(UCHAR opMode)
{
	LONG retValue;

	retValue = STATUS_SUCCESS;

	do { /* Don't loop */

		if (!(opMode == USBD_IF_OPMODE_NORMAL || opMode == USBD_IF_OPMODE_PWDOWN ||
				opMode == USBD_IF_OPMODE_NONDRIVE || opMode == USBD_IF_OPMODE_DISBITSTUFF)) {
			retValue = STATUS_INVALID_PARAMETER;
			break;
		}

		RegModify(REG08_D_XcvrControl,MASK_D_OpMode,opMode);
	} while (0);

	return retValue;
}
/* =============================================================================
// Function_Name: USBD_IFGetState
// description	: Return state of LineState,VBUS,FSxHS and value of SOF
// argument		: pUSBDState	Pointer to return information
// return		: STATUS_SUCCESS			Finished normally
//				  STATUS_NOT_OPENED			Not be opened yet
// flag			:
// global		:
// =============================================================================
*/
LONG USBD_IFGetState(PUSBD_IF_USB_STATE pUsbState)
{
	LONG retValue;
	UCHAR sofh,sofl;
	UCHAR vbus[6];
	UCHAR lineState;

	retValue = STATUS_SUCCESS;

	do { /* Don't loop */

		vbus[0] = (RegRead(REG08_D_USB_Status) & MASK_VBUS) >> SHIFT_VBUS;

		lineState = (RegRead(REG08_D_USB_Status) & MASK_LineState) >> SHIFT_LineState;
		switch (lineState) {
			case BIT_LineState_SE0:
				pUsbState->LineState = USBD_IF_LINESTATE_SE0;
				break;
			case BIT_LineState_J:
				pUsbState->LineState = USBD_IF_LINESTATE_J;
				break;
			case BIT_LineState_K:
				pUsbState->LineState = USBD_IF_LINESTATE_K;
				break;
			case BIT_LineState_SE1:
				pUsbState->LineState = USBD_IF_LINESTATE_SE1;
				break;
			default:
				/* It doesn't come here */
				;
		}
		vbus[1] = (RegRead(REG08_D_USB_Status) & MASK_VBUS) >> SHIFT_VBUS;

		if ((RegRead(REG08_D_USB_Status) & MASK_FSxHS) == BIT_FSxHS_HSmode) {
			pUsbState->Speed = USBD_IF_SPEEDMODE_HS;
		} else {
			pUsbState->Speed = USBD_IF_SPEEDMODE_FS;
		}

		vbus[2] = (RegRead(REG08_D_USB_Status) & MASK_VBUS) >> SHIFT_VBUS;

		sofh = RegRead(REG08_D_FrameNumber_H);
		sofl = RegRead(REG08_D_FrameNumber_L);
		pUsbState->SOF = MAKEWORD(sofl,sofh);

		vbus[3] = (RegRead(REG08_D_USB_Status) & MASK_VBUS) >> SHIFT_VBUS;
		vbus[4] = (vbus[0] + vbus[1] + vbus[2] + vbus[3]) == 4 ? 1 : 0;
		if (vbus[4] == 0) {
			pUsbState->VBUS = USBD_IF_VBUS_LOW;
		} else {
			pUsbState->VBUS = USBD_IF_VBUS_HIGH;
		}

		pUsbState->Reseved = 0;

	} while (0);

	return retValue;
}
/* =============================================================================
// Function_Name: USBD_IFGetSetupPacket
// description	: Return the Request Data which has been received by Setup Stage
// argument		: pRequestPacket	Pointer to return Request Data
// return		: STATUS_SUCCESS			Finished normally
//				  STATUS_NOT_OPENED			Not be opened yet
// flag			:
// global		:
// =============================================================================
*/
LONG USBD_IFGetSetupPacket(PUSBD_IF_REQUEST_PACKET pRequestPacket)
{
	LONG retValue;
	UCHAR low,high;

	retValue = STATUS_SUCCESS;

	do { /* Don't loop */

		pRequestPacket->bmRequestType = RegRead(REG08_D_EP0SETUP_0);
		pRequestPacket->bRequest	  = RegRead(REG08_D_EP0SETUP_1);
		low  = RegRead(REG08_D_EP0SETUP_2);
		high = RegRead(REG08_D_EP0SETUP_3);
		pRequestPacket->wValue		  = MAKEWORD(low,high);
		low  = RegRead(REG08_D_EP0SETUP_4);
		high = RegRead(REG08_D_EP0SETUP_5);
		pRequestPacket->wIndex		  = MAKEWORD(low,high);
		low  = RegRead(REG08_D_EP0SETUP_6);
		high = RegRead(REG08_D_EP0SETUP_7);
		pRequestPacket->wLength 	  = MAKEWORD(low,high);

		/* Release the Protect for EP0 here */
		RegClear(REG08_D_SETUP_Control,BIT_ProtectEP0);
	} while (0);

	return retValue;
}
/* =============================================================================
// Function_Name: USBD_IFGetEP0Direction
// description	: Get current direction of transfer in EP0
// argumen		: direction		Pointer to return direction of transfer
//								USBD_IF_DIR_DEVICE_TO_HOST	IN
//								USBD_IF_DIR_HOST_TO_DEVICE	OUT
// return		: STATUS_SUCCESS			Finished normally
//				  STATUS_NOT_OPENED			Not be opened yet
// flag			:
// global		:
// =============================================================================
*/
LONG USBD_IFGetEP0Direction(UCHAR *direction)
{
	LONG retValue;

	retValue = STATUS_SUCCESS;

	do { /* Don't loop */

		if ((RegRead(REG08_D_EP0Control) & MASK_INxOUT) != BIT_INxOUT_OUT) {
			*direction = USBD_IF_DIR_DEVICE_TO_HOST;
		} else {
			*direction = USBD_IF_DIR_HOST_TO_DEVICE;
		}
	} while (0);

	return retValue;
}
/* =============================================================================
// Function_Name: USBD_IFSetEP0Direction
// description	: Set direction of transfer in EP0
// argument		: direction		Direction of transfer
//								USBD_IF_DIR_DEVICE_TO_HOST	IN
//								USBD_IF_DIR_HOST_TO_DEVICE	OUT
// return		: STATUS_SUCCESS			Finished normally
//				  STATUS_NOT_OPENED			Not be opened yet
//				  STATUS_INVALID_PARAMETER	Parameter error
// flag			:
// global		:
// =============================================================================
*/
LONG USBD_IFSetEP0Direction(UCHAR direction)
{
	LONG retValue;

	retValue = STATUS_SUCCESS;

	do { /* Don't loop */

		if (direction == USBD_IF_DIR_DEVICE_TO_HOST) {
			RegSet(REG08_D_EP0Control,BIT_INxOUT_IN);
		} else if (direction == USBD_IF_DIR_HOST_TO_DEVICE) {
			RegClear(REG08_D_EP0Control,BIT_INxOUT_IN);
		} else {
			retValue = STATUS_INVALID_PARAMETER;
		}

	} while (0);

	return retValue;