Uppgiften som vi tilldelades av Alstom såg vi från början som något avlägset och komplicerat som krävde en stor insats. Och en stor insats inte minst med research och förberedande jobb har krävts. Vad man däremot upplevde efterhand var att lösningen och teknikerna som har nyttjas har krupit allt närmare vår utbildning. Detta har gjort att uppgiften blivit mer och mer intressant ju längre och djupare vi tagit oss. Vår uppfattning från början var att USB var ett komplicerat och tekniskt svårt sätt att kommunicera. Men tekniken har mycket gemensamt med både dagens Ethernet och gammal teknik som RS-232. Vilket gör att man kunde nyttja mycket utav den kunskap vi tagit till oss under vår utbildning.
Att däremot lämna uppgiften och inte direkt få fram, ett för ändamålet konkret exempel med tillhörande Fläktbuss implementering, känns lite vemodigt. Men i det stora hela att jobba med projektet och dess utformning och upplägg har givit oss nya erfarenheter och en ny syn på oss själva och vad vi faktiskt lärt oss på universitetet.
7 REFERENSER
Internet – www.xat.nl/en/riscos/sw/usb/class.htm
© Copyright X-Ample Technology bv. Last changed: Wed,03 May 2006 Internet – www.arm.com
© Copyright ARM
Internet – www.usb.org/developers/
Site sponsored by USB Implementers Forum, Inc., creators of USB technology.
Internet – en.wikipedia.org/wiki/USB
Internet – www.smallformfactors.com – USB fundamentals 101 Joel Huebner, Jacyl Technology, Inc.
Whitepaper – USB specification 2.0 2000-04-21
Appendix A – Generell USB kod
UserFunc_t UsbUserFun [UsbLastEvent] = {
// Ep 10 In
// UsbConnectEvent NULL,
// UsbSuspendEvent NULL,
// UsbErrorEvent NULL,
// UsbSofEvent NULL,
// UsbHighPrioIntrEvent NULL,
};
/*************************************************************************
* Function Name: USB_Cmd
* Parameters: Int16U Command, Int8U Data *
* Return: Int32U - command result *
* Description: Implement commands transmit to USB Engine *
*************************************************************************/
Int32U USB_Cmd (Int16U Command, Int8U Data) {
Int32U cpu_sr, tmp = 0;
// Disable interrurp and save current state of the interrupt flags cpu_sr = disable_IRQ();
DEVINTCLR = bmUSB_CommDataFullInterrupt | bmUSB_CommRegEmptyInterrupt;
// Load commonad in USB engine
CMDCODE = ((Command&0xFF) << 16) + USB_CMD_WR;
// Wait until command is accepted
while ((DEVINTS & bmUSB_CommRegEmptyInterrupt) == 0);
// clear Command reg. empry interrupt DEVINTCLR = bmUSB_CommRegEmptyInterrupt;
// determinate next phase of the command switch (Command)
{
case CMD_USB_SET_ADDRESS:
case CMD_USB_CFG_DEV:
case CMD_USB_SET_MODE:
case CMD_USB_SET_DEV_STAT:
CMDCODE = (Data << 16) + USB_DATA_WR;
while ((DEVINTS & bmUSB_CommRegEmptyInterrupt) == 0);
break;
case CMD_USB_RD_FRAME_NUMB:
case CMD_USB_RD_TEST_REG:
CMDCODE = (Command << 16) + USB_DATA_RD;
while ((DEVINTS & bmUSB_CommDataFullInterrupt) == 0);
DEVINTCLR = bmUSB_CommDataFullInterrupt;
tmp = CMDDATA;
CMDCODE = (Command << 16) + USB_DATA_RD;
while ((DEVINTS & bmUSB_CommDataFullInterrupt) == 0);
tmp |= CMDDATA << 8;
break;
case CMD_USB_GET_DEV_STAT:
case CMD_USB_GET_ERROR:
case CMD_USB_RD_ERROR_STAT:
case CMD_USB_CLR_BUF:
CMDCODE = (Command << 16) + USB_DATA_RD;
while ((DEVINTS & bmUSB_CommDataFullInterrupt) == 0);
case CMD_USB_SEL_EP:
case CMD_USB_SEL_CLR_INT_EP:
CMDCODE = (Command << 16) + USB_DATA_RD;
while ((DEVINTS & bmUSB_CommDataFullInterrupt) == 0);
tmp = CMDDATA;
break;
case CMD_USB_SET_EP_STAT:
CMDCODE = (Data << 16) + USB_DATA_WR;
while ((DEVINTS & bmUSB_CommRegEmptyInterrupt) == 0);
break;
} break;
}
// restore the interrupt flags restore_IRQ(cpu_sr);
return(tmp);
}
/*************************************************************************
* Function Name: USB_UserFuncRegistered
* Parameters: UserFunc_t UserFunc, UsbUserEvent_t UserFuncInd *
* Return: UserFunc_t *
* Description: Registered User callback function *
*************************************************************************/
UserFunc_t USB_UserFuncRegistered (UserFunc_t UserFunc, UsbUserEvent_t UserFuncInd) {
UserFunc_t PrevUserFunc = UsbUserFun[UserFuncInd];
UsbUserFun[UserFuncInd] = (UserFunc_t) UserFunc;
return (PrevUserFunc);
}
/*************************************************************************
* Function Name: USB_EpIntrClr
* Parameters: USB_Endpoint_t EndPoint *
* Return: Int8U *
* Description: Clear the EP interrupt flag and return the current EP status *
*************************************************************************/
Int8U USB_EpIntrClr(USB_Endpoint_t EndPoint) {
ENDPINTCLR = 1 << EndPoint;
while ((DEVINTS & bmUSB_CommDataFullInterrupt) == 0);
return(CMDDATA);
}
/*************************************************************************
* Function Name: USB_HwInit
* Parameters: LPC_VicIrqSlots_t IntrSlot *
* Return: none *
* Description: Init USB *
*************************************************************************/
void USB_HwInit(LPC_VicIrqSlots_t IntrSlot) { USBINTS_bit.EN_USB_INTS = 0;
/* Turn on USB */
PM_OpenPeripheral(0x80000000);
// Enable Vbus sense and Connect PINSEL1_bit.P0_23 = 1;
PINSEL1_bit.P0_31 = 2;
// Init Pll for USB engine freq - 48MHz
//USB_PLL_M, USB_PLL_P are define in lpc_usb_cfg.h PLL48CFG_bit.MSEL = USB_PLL_M-1;
PLL48CFG_bit.PSEL = USB_PLL_P;
PLL48CON_bit.PLLE = TRUE; // Enable PLL PLL48FEED = PLLFEED_DATA1;
PLL48FEED = PLLFEED_DATA2;
while (!PLL48STAT_bit.PLOCK); // Wait PLL lock
PLL48CON_bit.PLLC = TRUE; // Connect PLL PLL48FEED = PLLFEED_DATA1;
PLL48FEED = PLLFEED_DATA2;
// USB interrupt connect to VIC
VIC_SetVectoredIRQ(USB_ISR,(LPC_VicIrqSlots_t)IntrSlot,VIC_USB);
VIC_EnableInt(1<<VIC_USB);
// Enable USB inerrupts USBINTS_bit.EN_USB_INTS = 1;
// Disconnect device USB_Connect(FALSE);
// Set Arrdess 0 USB_SetDefAdd();
// Init controls endpoints USB_HwReset();
// Init Device state var
USB_DevStatus.Data = USB_Cmd(CMD_USB_GET_DEV_STAT,0);
}
/*************************************************************************
* Function Name: USB_HwReset * Parameters: none
*
* Return: none *
* Description: Reset Usb engine *
*************************************************************************/
void USB_HwReset (void) {
// Disable all endpoint interrups ENDPINTEN = 0;
// Frame is Hp interrupt DEVINTPRI = 1;
// Clear all interupts flag
ENDPINTCLR = DEVINTCLR = 0xFFFFFFFF;
// USB_Configure USB_Configure(FALSE);
// EndPoint Init
USB_RealizeEndPoint(CTRL_ENP_OUT,0,Ep0MaxSize,TRUE);
USB_RealizeEndPoint(CTRL_ENP_IN, 1,Ep0MaxSize,TRUE);
#if USB_DMA > 0
// Enable End_of_Transfer_Interrupt and // System_Error_Interrupt USB DMA interrupts USB_DmaReset(DMA_INT_ENABLE_MASK);
#endif
// Enable Device interrups
DEVINTEN = bmUSB_SlowInterrupt | bmUSB_DevStatusInterrupt | (USB_HIGH_PRIORITY_EVENT ? bmUSB_FastInterrupt : 0) | (USB_SOF_EVENT ? bmUSB_FrameInterrupt : 0) | (USB_ERROR_EVENT ? bmUSB_ErrorInterrupt : 0);
}
/*************************************************************************
* Function Name: USB_SetEpPrio
* Parameters: USB_Endpoint_t EndPoint,Boolean EpPrio *
* Return: none *
* Description: Set Endpoint priority *
*************************************************************************/
inline
void USB_SetEpPrio (USB_Endpoint_t EndPoint,Boolean EpPrio) {
Int32U Mask = 1 << EndPoint;
USB_EpSoftPrio = (EpPrio)?(USB_EpSoftPrio | Mask):(USB_EpSoftPrio & ~Mask);
}
/*************************************************************************
* Function Name: USB_RealizeEndPoint
* Parameters: USB_Endpoint_t EndPoint, Boolean EpPrio, * Int32U MaxPacketSize, Boolean IntrEna *
* Return: none *
* Description: Enable or disable endpoint *
*************************************************************************/
void USB_RealizeEndPoint( USB_Endpoint_t EndPoint, Boolean EpPrio, Int32U MaxPacketSize, Boolean IntrEna) {
// Clear Realize interrupt bit DEVINTCLR = bmUSB_EPRealizeInterrupt;
// Realize endpoit
while ((DEVINTS & bmUSB_EPRealizeInterrupt) == 0);
// Enable endpoint interrup
// Disable relevant endpoint and interrupt REALIZEENDP &= Mask;
ENDPINTEN &= Mask;
} }
/*************************************************************************
* Function Name: USB_ClearBuffer
* Parameters: USB_Endpoint_t EndPoint - endpoiunt index *
* Return: Int32U Packet overwrite statrus *
* Description: Clear buffer of the corresponding endpoint *
*************************************************************************/
Int32U USB_ClearBuffer(USB_Endpoint_t EndPoint) {
// Select endpoint
USB_Cmd(CMD_USB_SEL_EP | EndPoint,0);
// Clear selected end point
return(USB_Cmd(CMD_USB_CLR_BUF,0));
}
/*************************************************************************
* Function Name: USB_ValidateBuffer
* Parameters: USB_Endpoint_t EndPoint - endpoiunt index *
* Return: none *
* Description: Validate buffer(only for IN Endpoints) *
*************************************************************************/
void USB_ValidateBuffer(USB_Endpoint_t EndPoint) {
if (EndPoint & 1) {
USB_Cmd(CMD_USB_SEL_EP | EndPoint,0);
USB_Cmd(CMD_USB_VAL_BUF,0);
} }
/*************************************************************************
* Function Name: USB_SetAdd
* Parameters: Int32U DevAdd - device address between 0 - 127 *
* Return: none *
* Description: Set device address *
*************************************************************************/
void USB_SetAdd(Int32U DevAdd) {
USB_Cmd(CMD_USB_SET_ADDRESS,DevAdd | 0x80);
USB_Cmd(CMD_USB_SET_ADDRESS,DevAdd | 0x80);
}
/*************************************************************************
* Function Name: USB_Connect * Parameters: Boolean Conn *
* Return: none *
* Description: Connect Usb *
*************************************************************************/
void USB_Connect (Boolean Conn)
{
USB_Cmd(CMD_USB_SET_DEV_STAT, (Conn ? bmUSB_Connect : 0));
}
/*************************************************************************
* Function Name: USB_Configure * Parameters: Boolean Configure *
* Return: none *
* Description: Configure device
* When Configure != 0 enable all Realize Ep
*
*************************************************************************/
void USB_Configure (Boolean Configure) {
USB_Cmd(CMD_USB_CFG_DEV,Configure);
}
/*************************************************************************
* Function Name: USB_WakeUp * Parameters: none
void USB_WakeUp (void) {
USB_Cmd(CMD_USB_SET_DEV_STAT, bmUSB_Suspend | (USB_DevStatus.Connect?bmUSB_Connect:0));
}
/*************************************************************************
* Function Name: USB_GetDevStatus
* Parameters: USB_DevStatusReqType_t Type *
* Return: Boolean *
* Description: Return USB device status *
*************************************************************************/
Boolean USB_GetDevStatus (USB_DevStatusReqType_t Type) {
switch (Type) {
case USB_DevConnectStatus:
return(USB_DevStatus.Connect);
case USB_SuspendStatus:
return(USB_DevStatus.Suspend);
case USB_ResetStatus:
return(USB_DevStatus.Reset);
}
return(FALSE);
}
/*************************************************************************
* Function Name: USB_SetStallEP
* Parameters: USB_Endpoint_t EndPoint, Boolean Stall *
* Return: none *
* Description: The endpoint stall/unstall *
*************************************************************************/
void USB_SetStallEP (USB_Endpoint_t EndPoint, Boolean Stall) {
USB_Cmd(CMD_USB_SET_EP_STAT | EndPoint, (Stall ? bmUSB_EpStall : 0));
}
/*************************************************************************
* Function Name: USB_GetStallEP * Parameters: USB_Endpoint_t EndPoint *
* Return: Boolean *
* Description: Get stall state of the endpoint *
*************************************************************************/
Boolean USB_GetStallEP (USB_Endpoint_t EndPoint) {
* Parameters: USB_Endpoint_t EndPoint, Int32U * pData, Int32U Count *
* Return: none *
* Description: Endpoint Write (IN) *
*************************************************************************/
void USB_EpWrite (USB_Endpoint_t EndPoint, Int32U * pData, Int32U Count) {
// Convert EP physical address to logical and set write enable bit USBCTRL = ((EndPoint << 1) & 0x3C) | bmUSB_CtrlWrEna;
// Get data size
while (USBCTRL_bit.WR_EN);
}
while (USBCTRL_bit.WR_EN);
}
USBCTRL = 0;
USB_Cmd(CMD_USB_SEL_EP | EndPoint, 0);
USB_Cmd(CMD_USB_VAL_BUF, 0);
}
/*************************************************************************
* Function Name: USB_EpRead
* Parameters: USB_Endpoint_t EndPoint, Int32U * pData, Int32U Count *
* Return: Int32 *
* Description: Endpoint Read (OUT) *
*************************************************************************/
Int32U USB_EpRead (USB_Endpoint_t EndPoint, Int32U * pData, Int32U Count) {
// Convert EP physical address to logical and set read enable bit USBCTRL = ((EndPoint << 1) & 0x3C) | bmUSB_CtrlRdEna;
while (RCVEPKTLEN_bit.PKT_RDY == 0);
// Get data size
Count = RCVEPKTLEN_bit.PKT_LNGTH;
// Read data from SIE buffer while (RCVEPKTLEN_bit.DV) {
*pData++ = RCVEDATA;
}
USBCTRL = 0;
USB_Cmd(CMD_USB_SEL_EP | EndPoint, 0);
if(USB_Cmd(CMD_USB_CLR_BUF, 0) & bmUSB_PacketOverWritten) {
* Function Name: USB_ISR * Parameters: none *
* Return: none *
* Description: USB interrupt subroutine *
*************************************************************************/
void USB_ISR (void) {
Int32U EpIntr,Val,EpIntHold;
UsbDevIntrStat_t UsbDevIntrSt = {DEVINTS};
#if USB_DMA > 0
if (USBINTS & 3)
{
USB_DevStatus.Data = USB_Cmd(CMD_USB_GET_DEV_STAT,0);
// Device connection status
// Output ctrl EP
++Val,EpIntHold >>= 1) {
// First Software High proirity and then low proirity Int32U UsbDmaInt = 0,Tmp;
Int32U UsbDmaCurrPriorityInt = USB_EpSoftPrio & UsbDmaInt;
for(Int32U Val = 2, EpMask = 4; UsbDmaCurrPriorityInt; ++Val,EpMask <<= 1) {
Int32U EpPriorityMask = UsbDmaCurrPriorityInt & EpMask;
if(EpPriorityMask == 0)
* Function Name: USB_EpLogToPhysAdd * Parameters: Int8U EpLogAdd
*
* Return: USB_Endpoint_t *
* Description: Convert the logical to physical address *
*************************************************************************/
USB_Endpoint_t USB_EpLogToPhysAdd (Int8U EpLogAdd) {
USB_Endpoint_t Address = (USB_Endpoint_t)((EpLogAdd & 0x0F)<<1);
if(EpLogAdd & 0x80) {
++Address;
}
return(Address);
}
/*************************************************************************
* Function Name: USB_GetFrameNumb * Parameters: none
*
* Return: Int32U *
* Description: Retunr curent value of SOF number *
*************************************************************************/
#if USB_SOF_EVENT > 0
Int32U USB_GetFrameNumb (void) {
return(USB_SofNumbHold);
}
__no_init pUSB_DmaDesc_t USB_DDCA[ENP_MAX_NUMB];
#pragma location="DMA_RAM"
__no_init USB_DmaDesc_t USB_DmaDesc[DMA_DD_MAX_NUMB];
/*************************************************************************
* Function Name: USB_DmaReset * Parameters: Int32U IntrEna *
* Return: none *
* Description: Reset USB DMA *
*************************************************************************/
void USB_DmaReset (Int32U IntrEna) {
// End of Transfer Interrupt Clear EOTINTCLR = 0xFFFFFFFF;
// New DD Request Interrupt Clear NEWDDRINTCLR = 0xFFFFFFFF;
// System Error Interrupt Clear SYSERRINTCLR = 0xFFFFFFFF;
for(Int32U i = 0; i < ENP_MAX_NUMB; ++i) {
USB_DDCA[i] = NULL;
}
// Set USB UDCA Head register UDCAHEAD = (Int32U)&USB_DDCA;
// Enable DMA interrupts DMAINTEN = IntrEna;
}
/*************************************************************************
* Function Name: USB_DmaInitTransfer
* Parameters: USB_Endpoint_t EndPoint, Int32U DmaDescInd, * pInt32U pData, Int32U EpMaxSize, Int32U Size
* pDmaIsoPacket_t pDmaIsoPacket, Boolean EpTransferType *
UsbDmaStateCode_t USB_DmaInitTransfer (USB_Endpoint_t EndPoint,
Int32U DmaDescInd, pInt32U pData, Int32U EpMaxSize, Int32U Size, pDmaIsoPacket_t pDmaIsoPacket, Boolean EpTransferType)
{
Int32U EpReg;
if ((EndPoint == CTRL_ENP_OUT) || (EndPoint == CTRL_ENP_IN)) {
return(UsbDmaParametersError);
}
if (USB_DmaDesc[DmaDescInd].Status == UsbDmaBeingServiced) {
return(UsbDmaBeingServiced);
}
// Init DMA Descriptor
USB_DmaDesc[DmaDescInd].pNextDD = NULL;
USB_DmaDesc[DmaDescInd].NextDDValid = FALSE;
USB_DmaDesc[DmaDescInd].pDmaIsoPacket = pDmaIsoPacket;
USB_DmaDesc[DmaDescInd].DmaMode = UsbDmaNormalMode;
USB_DmaDesc[DmaDescInd].Isochronous = EpTransferType;
USB_DmaDesc[DmaDescInd].pDmaBuffer = pData;
USB_DmaDesc[DmaDescInd].DmaBufferLegtn = Size;
USB_DmaDesc[DmaDescInd].MaxPacketSize = EpMaxSize;
USB_DmaDesc[DmaDescInd].Status = UsbDmaNoServiced;
// Set DD
USB_DDCA[EndPoint] = &USB_DmaDesc[DmaDescInd];
// Enable DMA Transfer EPDMAEN = 1 << EndPoint;
// Check state of IN/OUT Ep buffer
EpReg = USB_Cmd(CMD_USB_SEL_EP | EndPoint,0);
if( ((EndPoint & 1) && !(EpReg & 0x60)) ||
(!(EndPoint & 1) && ((EpReg & 0x60) == 0x60))) {
if((USB_DmaDesc[DmaDescInd].DdState != UsbDmaBeingServiced)) {
// Retrigger DMA Transfer DMARQSTSET = 1 << EndPoint;
} }
return(UsbDmaNoServiced);
}
/*************************************************************************
* Function Name: USB_DmaGetDesc * Parameters: Int32U DmaDescInd *
* Return: pUSB_DmaDesc_t *
* Description: Retur pointer to DMA descriptor *
*************************************************************************/
pUSB_DmaDesc_t USB_DmaGetDesc (Int32U DmaDescInd) {
return(&USB_DmaDesc[DmaDescInd]);
}
/*************************************************************************
* Function Name: USB_DmaDisable * Parameters: USB_Endpoint_t EndPoint *
* Return: none *
* Description: Disable DMA transfer for the EP *
*************************************************************************/
void USB_DmaDisable (USB_Endpoint_t EndPoint) {
EPDMADIS = 1 << EndPoint;
}
/*************************************************************************
* Function Name: USB_DmaRestattTransfer
* Parameters: USB_Endpoint_t EndPoint, Int32U DmaDescInd, * pInt32U pData, Int32U EpMaxSize, Int32U Size
* pDmaIsoPacket_t pDmaIsoPacket, Boolean EpTransferType *
* Return: none *
* Description: Restart DMA Transfer *
*************************************************************************/
void USB_DmaRestattTransfer (USB_Endpoint_t EndPoint,Int32U DmaDescInd)
{
// Init DD DMA status
USB_DmaDesc[DmaDescInd].Status = UsbDmaNoServiced;
// Enable DMA Transfer EPDMAEN = 1 << EndPoint;
// Check state of IN/OUT Ep buffer
Int32U EpReg = USB_Cmd(CMD_USB_SEL_EP | EndPoint,0);
if(!(EndPoint & 1) && ((EpReg & 0x60) == 0x60)) {
// Retrigger DMA Transfer DMARQSTSET = 1 << EndPoint;
}
else if ((EndPoint & 1) && !(EpReg & 0x60)) {
// Retrigger DMA Transfer
DMARQSTSET = 1 << EndPoint; // À çàùî å òàêà êîé ùå ìè êàæå????
} }
#endif // USB_DMA
usb_9.c
* Description : USB chapter 9 (device framework) module *
UsbDevCtrl_t UsbDevCtrl = {{UsbDevStatusUnknow,UsbDevStatusNoSuspend},0,0,0,0};
// User funcrions
CommUserFpnt_t UsbCoreUserFun[UsbUserLastInd] = {
// UsbUserClass NULL,
// UsbUserVendor NULL,
// UsbClassEp0OutPacket NULL,
// UsbVendorEp0OutPacket NULL,
// UsbUserConfigure NULL,
* Function Name: UsbCoreInit
* Parameters: CommUserFpnt_t UserCoreConfigure *
* Return: none *
* Description: USB init core *
*************************************************************************/
void UsbCoreInit (CommUserFpnt_t UserCoreConfigure) {
UsbEp0Ctrl.EpStatus.Status = UsbSetupPacket;
UserCoreConfigure(NULL);
UsbCoreUserFuncRegistered(UserCoreConfigure,UsbUserConfigure);
UsbSetDevState(UsbDevStatusUnknow);
// Registerd Core functions
USB_UserFuncRegistered(UsbDevResetCallback ,UsbResetEvent );
USB_UserFuncRegistered(UsbDevConnectCallback,UsbConnectEvent);
USB_UserFuncRegistered(UsbDevSuspendCallback,UsbSuspendEvent);
USB_UserFuncRegistered(UsbCtrlEpCallback ,UsbEp0Out );
USB_UserFuncRegistered(UsbCtrlEpCallback ,UsbEp0In );
}
/*************************************************************************
* Function Name: UsbCoreUserFuncRegistered
* Parameters: CommUserFpnt_t UserFunc, UsbCoreUserFuncInd_t UserFuncInd *
* Return: CommUserFpnt_t *
* Description: Registed User core callback function *
*************************************************************************/
CommUserFpnt_t UsbCoreUserFuncRegistered (CommUserFpnt_t UserCoreFunc, UsbCoreUserFuncInd_t UserFuncInd) {
CommUserFpnt_t PrevUserFunc = UsbCoreUserFun[UserFuncInd];
UsbCoreUserFun[UserFuncInd] = UserCoreFunc;
return(PrevUserFunc);
}
/*************************************************************************
* Function Name: UsbCoreReq
* Parameters: UsbCoreReqType_t Type *
* Return: Int32U *
* Description: Return different device states *
*************************************************************************/
Int32U UsbCoreReq (UsbCoreReqType_t Type) {
switch(Type) {
case UsbCoreReqDevState:
return(UsbDevCtrl.State.DS);
case UsbCoreReqDevSusState:
return(UsbDevCtrl.State.Suspend);
case UsbCoreReqConfiquration:
return(UsbDevCtrl.Configuration);
case UsbCoreReqInterface:
return(UsbDevCtrl.Interface);
case UsbCoreReqAlternateSetting:
return(UsbDevCtrl.AlternateSetting);
case UsbCoreReqDevOwnAddress:
return(UsbDevCtrl.DevAdd);
case UsbCoreReqWakeUpEnableStatus:
return(UsbDevCtrl.Feature.RemoteWakeupEnable);
case UsbCoreReqSelfPoweredStatus:
return(UsbDevCtrl.Feature.SelfPowered);
}
return((Int32U) -1);
}
/*************************************************************************
* Function Name: UsbWakeUp * Parameters: none *
* Return: none *
* Description: WakeUp device from suspend mode *
*************************************************************************/
void UsbWakeUp (void) {
if(UsbDevCtrl.Feature.RemoteWakeupEnable && UsbDevCtrl.State.Suspend) {
USB_WakeUp();
} }
/*************************************************************************
* Function Name: UsbSetDevState * Parameters: _UsbDevState_t DevState *
* Return: none *
* Description: Set device state *
*************************************************************************/
void UsbSetDevState (_UsbDevState_t DevState) {
UsbDevCtrl.State.DS = DevState;
switch (DevState) {
case UsbDevStatusConfigured:
USB_Configure(TRUE);
break;
case UsbDevStatusAddress:
UsbDevCtrl.Configuration = UsbDevCtrl.AlternateSetting =\
UsbDevCtrl.Interface = 0;
USB_Configure(FALSE);
break;
default:
UsbDevCtrl.DevAdd = UsbDevCtrl.Configuration = \ UsbDevCtrl.AlternateSetting = UsbDevCtrl.Interface = 0;
/*************************************************************************
* Function Name: UsbGetDevState * Parameters: none
*
* Return: UsbDevState_t *
* Description: Get device state *
*************************************************************************/
UsbDevState_t UsbGetDevState (void) {
return(UsbDevCtrl.State);
}
/*************************************************************************
* Function Name: UsbSetDevSuspend * Parameters: none
*
* Return: UsbDevState_t *
* Description: Set device suspend mode *
*************************************************************************/
void UsbSetDevSuspend (Boolean Suspend) {
UsbDevCtrl.State.Suspend = Suspend ? UsbDevStatusSuspend : UsbDevStatusNoSuspend;
}
/*************************************************************************
* Function Name: UsbFindInterface
* Parameters: UsbStandardConfigurationDescriptor_t * pConfiguration * Int32U Interface,Int32U AlternativeSetting
*
* Return: UsbCommStatus_t *
* Description: Set Interface and Alternative setting state *
*************************************************************************/
UsbCommStatus_t UsbFindInterface (UsbStandardConfigurationDescriptor_t * pConfiguration,
UsbDevCtrl_t * UsbDev) {
UsbStandardInterfaceDescriptor_t *pData;
// Find Interface
for(pData = (UsbStandardInterfaceDescriptor_t *)pConfiguration;
(Int8U*)pData < (Int8U *)pConfiguration + pConfiguration->wTotalLength;
pData =(UsbStandardInterfaceDescriptor_t *)((Int8U *)pData + pData->bLength)) {
if((pData->bDescriptorType == UsbDescriptorInterface) &&
(pData->bInterfaceNumber == UsbDev->Interface) &&
(pData->bAlternateSetting == UsbDev->AlternateSetting)) {
return(UsbPass);
} }
return(UsbFault);
}
/*************************************************************************
* Function Name: UsbFindConfiguration * Parameters: Int32U
*
* Return: UsbStandardConfigurationDescriptor_t * *
* Description: Return pointer to current configuration *
*************************************************************************/
UsbStandardConfigurationDescriptor_t * UsbFindConfiguration(Int32U Configuration) {
UsbStandardConfigurationDescriptor_t * pData =
(UsbStandardConfigurationDescriptor_t *) &UsbStandardConfigurationDescriptor[0];
while(pData->bLength) {
if(pData->bDescriptorType == UsbDescriptorConfiguration) {
if(pData->bConfigurationValue == Configuration) {
return(pData);
} }
pData = (UsbStandardConfigurationDescriptor_t *)((Int8U *)pData +
pData->bLength);
}
return(NULL);
}
/*************************************************************************
* Function Name: UsbDevConnectCallback
* Parameters: void * pArg *
* Return: none *
* Description: USB connect callback *
*************************************************************************/
void UsbDevConnectCallback (void * pArg) {
UsbSetDevState(pArg?UsbDevStatusAttached:UsbDevStatusUnknow);
if(UsbCoreUserFun[UsbUserConnect] != NULL) {
UsbCoreUserFun[UsbUserConnect](pArg);
} }
/*************************************************************************
* Function Name: UsbDevSuspendCallback * Parameters: void * pArg
*
* Return: none *
* Description: USB suspend callback *
*************************************************************************/
void UsbDevSuspendCallback (void * pArg) {
UsbSetDevSuspend(pArg?UsbDevStatusSuspend:UsbDevStatusNoSuspend);
if(UsbCoreUserFun[UsbUserSuspend] != NULL) {
UsbCoreUserFun[UsbUserSuspend](pArg);
} }
/*************************************************************************
* Function Name: UsbDevResetCallback * Parameters: void * pArg
*
* Return: none *
* Description: USB reset callback *
*************************************************************************/
void UsbDevResetCallback (void * pArg) {
UsbSetDevState(UsbDevStatusDefault);
UsbCoreUserFun[UsbUserConfigure](NULL);
if(UsbCoreUserFun[UsbUserReset] != NULL) {
UsbCoreUserFun[UsbUserReset](pArg);
} }
/*************************************************************************
* Function Name: UsbEp0SetupWrite * Parameters: none
*
* Return: none *
* Description: USB EP Write implement (IN) *
*************************************************************************/
void UsbEp0SetupWrite (void) {
Int32U CurrCount = Ep0MaxSize;
if((UsbEp0Ctrl.Counter == Ep0MaxSize) && UsbEp0Ctrl.EpStatus.NoZeroLength) {
UsbEp0Ctrl.EpStatus.Status = UsbEpSetupLastIn;
}
else if(UsbEp0Ctrl.Counter < Ep0MaxSize) {
CurrCount = UsbEp0Ctrl.Counter;
UsbEp0Ctrl.EpStatus.Status = UsbEpSetupLastIn;
} else {
UsbEp0Ctrl.EpStatus.Status = UsbEpSetupDataIn;
}
USB_EpWrite(CTRL_ENP_IN,(Int32U *)UsbEp0Ctrl.pData,CurrCount);
UsbEp0Ctrl.Counter -= CurrCount;
UsbEp0Ctrl.pData += CurrCount;
*
* Return: UsbCommStatus_t *
* Description: Set configuration state *
*************************************************************************/
inline
UsbCommStatus_t UsbSetConfigurtonState (Int32U Configuration) {
if(Configuration) {
// Find configuration
UsbStandardConfigurationDescriptor_t * pData = UsbFindConfiguration(Configuration);
UsbDevCtrl_t UsbDevCtrlNew = UsbDevCtrl;
if(pData == NULL) {
return(UsbFault);
}
// Set Interfce and Alternative Setting UsbDevCtrlNew.Configuration = Configuration;
UsbDevCtrlNew.Interface = UsbDevCtrlNew.AlternateSetting = 0;
UsbDevCtrlNew.Feature.RemoteWakeupEnable = 0;
UsbDevCtrlNew.Feature.SelfPowered = pData->bmAttributes.SelfPowered?1:0;
// Whether the interface is exist into current conficuration?
if(UsbFindInterface(pData,&UsbDevCtrlNew) != UsbPass) {
return(UsbFault);
}
// User function that realize EP and init buffers
UsbCoreUserFun[UsbUserConfigure]((void *)&UsbDevCtrlNew);
UsbDevCtrl = UsbDevCtrlNew;
UsbSetDevState(UsbDevStatusConfigured);
} else {
UsbCoreUserFun[UsbUserConfigure](NULL);
UsbSetDevState(UsbDevStatusAddress);
}
return(UsbPass);
}
/*************************************************************************
* Function Name: UsbDevStatus
* Parameters: Int8U * pData, Int16U Index *
* Return: UsbCommStatus_t *
* Description: Usb Return device status into pData *
*************************************************************************/
inline
UsbCommStatus_t UsbDevStatus(Int8U * pData, Int16U Index) {
if(Index == 0) {
UsbEp0Ctrl.pData = pData;
UsbEp0Ctrl.Counter = 2;
*pData++ = UsbDevCtrl.Feature.Data;
*pData = 0;
return(UsbPass);
}
return(UsbFault);
}
/*************************************************************************
* Function Name: UsbInterfaceStatus * Parameters: Int8U * pData, Int16U Index *
* Return: UsbCommStatus_t *
* Description: Usb Return interface status into pData *
*************************************************************************/
inline
UsbCommStatus_t UsbInterfaceStatus(Int8U * pData, Int16U Index) {
UsbEp0Ctrl.pData = pData;
UsbEp0Ctrl.Counter = 2;
*pData++ = 0;
*pData = 0;
return(UsbPass);
}
/*************************************************************************
* Function Name: UsbEpStatus
* Parameters: Int8U * pData, Int16U Index
*
* Return: UsbCommStatus_t *
* Description: Usb Return Ep status into pData *
*************************************************************************/
inline
UsbCommStatus_t UsbEpStatus(Int8U * pData, Int16U Index) {
if((Index & 0x7F) > 16) {
return(UsbFault);
}
UsbEp0Ctrl.pData = pData;
UsbEp0Ctrl.Counter = 2;
*pData++ = USB_GetStallEP(USB_EpLogToPhysAdd(Index)) ? 1:0;
*pData = 0;
return(UsbPass);
}
/*************************************************************************
* Function Name: UsbGetStatus * Parameters: none
*
* Return: none *
* Description: Usb Get status implement *
*************************************************************************/
inline
void UsbGetStatus (void) {
if((UsbDevCtrl.State.DS >= UsbDevStatusAddress) &&
// Length must be 2
(UsbEp0SetupPacket.wLength.Word == 2) &&
// Direction of data from device
(UsbEp0SetupPacket.mRequestType.Dir == 1) &&
// wValue mut be 0
(UsbEp0SetupPacket.wValue.Word == 0) ) {
// This request is valid only for Address and Configured device's states switch(UsbEp0SetupPacket.mRequestType.Recipient)
{
case UsbRecipientDevice:
if(UsbDevStatus(EpCtrlDataBuf,UsbEp0SetupPacket.wIndex.Word) == UsbPass) {
case UsbRecipientInterface:
if(UsbInterfaceStatus(EpCtrlDataBuf,UsbEp0SetupPacket.wIndex.Word) == UsbPass) {
case UsbRecipientEndpoint:
if(UsbEpStatus(EpCtrlDataBuf,UsbEp0SetupPacket.wIndex.Word) == UsbPass) {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} } else {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} }
*
* Description: USB Clear Device feature implement *
*************************************************************************/
inline
UsbCommStatus_t UsbClearDevFeature(Int16U Feature,Int16U Index) {
if((Index != 0) || (Feature != UsbDeviceRemoteWakeupSelector)) {
return(UsbFault);
}
UsbDevCtrl.Feature.RemoteWakeupEnable = 0;
return(UsbPass);
}
/*************************************************************************
* Function Name: UsbClearInterfaceFeature * Parameters: Int16U Feature,Int16U Index *
* Return: UsbCommStatus_t *
* Description: USB Clear Interface feature implement *
*************************************************************************/
inline
UsbCommStatus_t UsbClearInterfaceFeature(Int16U Feature,Int16U Index) {
return(UsbFault);
}
/*************************************************************************
* Function Name: UsbClearEpFeature
* Parameters: Int16U Feature,Int16U Index *
* Return: UsbCommStatus_t *
* Description: USB Clear Ep feature implement *
*************************************************************************/
inline
UsbCommStatus_t UsbClearEpFeature(Int16U Feature,Int16U Index) {
USB_Endpoint_t UsbEpAdd;
if(((Index & 0x7F) > 16) || (Feature != UsbEpHaltSelector)) {
return(UsbFault);
}
UsbEpAdd = USB_EpLogToPhysAdd(Index);
USB_SetStallEP(UsbEpAdd,FALSE);
if (UsbUserFun[UsbEpAdd] != NULL) {
UsbUserFun[UsbEpAdd]((void *)UsbEpUnstall);
}
return(UsbPass);
}
/*************************************************************************
* Function Name: UsbClearFeature * Parameters: none
*
* Return: none *
* Description: USB Clear feature implement *
*************************************************************************/
inline
void UsbClearFeature (void) {
if((UsbDevCtrl.State.DS >= UsbDevStatusAddress) &&
// Length must be 0
(UsbEp0SetupPacket.wLength.Word == 0)) {
switch(UsbEp0SetupPacket.mRequestType.Recipient) {
case UsbRecipientDevice:
if(UsbClearDevFeature(UsbEp0SetupPacket.wValue.Word,UsbEp0SetupPacket.wIndex.Word) ==
UsbPass) {
USB_EpWrite(CTRL_ENP_IN,NULL,0);
UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
}
case UsbRecipientInterface:
if((UsbDevCtrl.State.DS > UsbDevStatusAddress) &&
(UsbClearInterfaceFeature(UsbEp0SetupPacket.wValue.Word,UsbEp0SetupPacket.wIndex.Word ) == UsbPass))
{
USB_EpWrite(CTRL_ENP_IN,NULL,0);
UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
}
case UsbRecipientEndpoint:
if(((UsbDevCtrl.State.DS > UsbDevStatusAddress) ||
((UsbEp0SetupPacket.wIndex.Word & 0x7F) == 0)) &&
(UsbClearEpFeature(UsbEp0SetupPacket.wValue.Word,UsbEp0SetupPacket.wIndex.Word) ==
UsbPass)) {
USB_EpWrite(CTRL_ENP_IN,NULL,0);
UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
}
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} } else {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} }
/*************************************************************************
* Function Name: UsbSetFeature
* Parameters: Int16U Feature,Int16U Index *
* Return: UsbCommStatus_t *
* Description: USB Set Device feature implement *
*************************************************************************/
inline
UsbCommStatus_t UsbSetDevFeature(Int16U Feature,Int16U Index) {
if((Index != 0) || (Feature != UsbDeviceRemoteWakeupSelector)) {
return(UsbFault);
}
UsbDevCtrl.Feature.RemoteWakeupEnable = 1;
return(UsbPass);
}
/*************************************************************************
* Function Name: UsbSetInterfaceFeature * Parameters: Int16U Feature,Int16U Index *
* Return: UsbCommStatus_t *
* Description: USB Set Interface feature implement *
*************************************************************************/
inline
UsbCommStatus_t UsbSetInterfaceFeature(Int16U Feature,Int16U Index) {
return(UsbFault);
}
/*************************************************************************
* Function Name: UsbSetEpFeature
* Parameters: Int16U Feature,Int16U Index *
* Return: UsbCommStatus_t *
* Description: USB Set Ep feature implement *
*************************************************************************/
inline
UsbCommStatus_t UsbSetEpFeature(Int16U Feature,Int16U Index) {
UsbEpAdd = USB_EpLogToPhysAdd(Index);
USB_SetStallEP(UsbEpAdd,TRUE);
if (UsbUserFun[UsbEpAdd] != NULL) {
UsbUserFun[UsbEpAdd]((void *)UsbEpStall);
}
return(UsbPass);
}
/*************************************************************************
* Function Name: UsbSetFeature * Parameters: none
*
* Return: none *
* Description: USB Set feature implement *
*************************************************************************/
inline
void UsbSetFeature (void) {
if((UsbDevCtrl.State.DS >= UsbDevStatusAddress) &&
// Length must be 0
(UsbEp0SetupPacket.wLength.Word == 0)) {
switch(UsbEp0SetupPacket.mRequestType.Recipient) {
case UsbRecipientDevice:
if(UsbSetDevFeature(UsbEp0SetupPacket.wValue.Word,UsbEp0SetupPacket.wIndex.Word) ==
UsbPass) {
USB_EpWrite(CTRL_ENP_IN,NULL,0);
UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
}
case UsbRecipientInterface:
if((UsbDevCtrl.State.DS > UsbDevStatusAddress) &&
(UsbSetInterfaceFeature(UsbEp0SetupPacket.wValue.Word,UsbEp0SetupPacket.wIndex.Word)
== UsbPass)) {
USB_EpWrite(CTRL_ENP_IN,NULL,0);
UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
}
case UsbRecipientEndpoint:
if(((UsbDevCtrl.State.DS > UsbDevStatusAddress) ||
((UsbEp0SetupPacket.wIndex.Lo & 0x7F) == 0)) &&
(UsbSetEpFeature(UsbEp0SetupPacket.wValue.Word,UsbEp0SetupPacket.wIndex.Word) ==
UsbPass)) {
USB_EpWrite(CTRL_ENP_IN,NULL,0);
UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
}
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} } else {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} }
/*************************************************************************
* Function Name: UsbSetAddress * Parameters: none
*
* Return: none *
* Description: USB Set address request implement *
*************************************************************************/
inline
void UsbSetAddress (void) {
if((UsbDevCtrl.State.DS >= UsbDevStatusDefault) &&
(UsbEp0SetupPacket.mRequestType.Recipient == 0) &&
(UsbEp0SetupPacket.wIndex.Word == 0) &&
(UsbEp0SetupPacket.wLength.Word == 0) &&
(UsbEp0SetupPacket.wValue.Word < 128)) {
USB_EpWrite(CTRL_ENP_IN,NULL,0);
UsbEp0Ctrl.EpStatus.Status = UsbEpStatusInSetAdd;
} else {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} }
/*************************************************************************
* Function Name: UsbGetDescriptorDevice * Parameters: Int8U Index - must be 0 *
* Return: UsbCommStatus_t *
* Description: USB get device's descriptor request implement *
*************************************************************************/
inline
UsbCommStatus_t UsbGetDescriptorDevice(Int8U Index) {
if(Index == 0) {
UsbEp0Ctrl.Counter = UsbStandardDeviceDescriptorStr.bLength;
UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
if(UsbEp0Ctrl.Counter >= UsbEp0SetupPacket.wLength.Word) {
UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
}
UsbEp0Ctrl.pData = (Int8U *)&UsbStandardDeviceDescriptorStr;
UsbEp0SetupWrite();
return(UsbPass);
}
return(UsbFault);
}
/*************************************************************************
* Function Name: UsbGetDescriptorConfiguration * Parameters: Int8U Index
*
* Return: UsbCommStatus_t *
* Description: USB get configuration's descriptor request implement *
*************************************************************************/
inline
UsbCommStatus_t UsbGetDescriptorConfiguration(Int8U Index) {
UsbStandardConfigurationDescriptor_t *pData;
for(pData = (UsbStandardConfigurationDescriptor_t
*)UsbStandardConfigurationDescriptor;
pData->bLength;
pData=(UsbStandardConfigurationDescriptor_t*)((Int8U *)pData + pData->bLength)) {
if((pData->bDescriptorType == UsbDescriptorConfiguration) &&
((UsbStandardDeviceDescriptorStr.bNumConfigurations == 1) ||
(pData->bConfigurationValue == Index)))
UsbEp0Ctrl.Counter = ((UsbStandardConfigurationDescriptor_t*)pData)->wTotalLength;
UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
if(UsbEp0Ctrl.Counter > UsbEp0SetupPacket.wLength.Word) {
UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
}
UsbEp0Ctrl.pData = (Int8U *)pData;
* Function Name: UsbGetDescriptorString * Parameters: Int8U Index
*
* Return: UsbCommStatus_t *
* Description: USB get string's descriptor request implement *
*************************************************************************/
inline
UsbCommStatus_t UsbGetDescriptorString(Int8U Index) {
Int8U **pData;
Int32U i;
if(Index == 0) {
UsbEp0Ctrl.Counter = UsbLanguagesStr[UsbDescLengthOffset];
UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
if(UsbEp0Ctrl.Counter >= UsbEp0SetupPacket.wLength.Word) {
UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
}
UsbEp0Ctrl.pData = (Int8U *)&UsbLanguagesStr;
UsbEp0SetupWrite();
for(i = 2; i < UsbLanguagesStr[UsbDescLengthOffset]; i+=2) {
if((UsbLanguagesStr[i] == UsbEp0SetupPacket.wIndex.Lo) &&
(UsbLanguagesStr[i+1] == UsbEp0SetupPacket.wIndex.Hi)) {
break;
}
++LanguagesOffset;
}
if(i >= UsbLanguagesStr[UsbDescLengthOffset]) {
return(UsbFault);
}
// Find String index
for(pData = (Int8U **)UsbString[LanguagesOffset]; pData ; ++pData) {
UsbEp0Ctrl.Counter = *(*pData+UsbDescLengthOffset);
UsbEp0Ctrl.EpStatus.NoZeroLength = FALSE;
if(UsbEp0Ctrl.Counter >= UsbEp0SetupPacket.wLength.Word) {
UsbEp0Ctrl.Counter = UsbEp0SetupPacket.wLength.Word;
UsbEp0Ctrl.EpStatus.NoZeroLength = TRUE;
}
UsbEp0Ctrl.pData = *pData;
UsbEp0SetupWrite();
}
return(UsbPass);
}
/*************************************************************************
* Function Name: UsbGetDescriptor * Parameters: none
*
* Return: none *
* Description: USB get descriptor request implement *
*************************************************************************/
inline
void UsbGetDescriptor (void) {
if(UsbDevCtrl.State.DS >= UsbDevStatusDefault) {
switch(UsbEp0SetupPacket.wValue.Hi) {
case UsbDescriptorDevice:
if(UsbGetDescriptorDevice(UsbEp0SetupPacket.wValue.Lo) != UsbPass) {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} break;
case UsbDescriptorConfiguration:
if(UsbGetDescriptorConfiguration(UsbEp0SetupPacket.wValue.Lo) != UsbPass) {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} break;
case UsbDescriptorString:
if(UsbGetDescriptorString(UsbEp0SetupPacket.wValue.Lo) != UsbPass) {
((Int32U)UsbCoreUserFun[UsbUserGetDescriptor](&UsbEp0Ctrl) != UsbPass)) {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} }
/*************************************************************************
* Function Name: UsbSetDescriptor * Parameters: none
*
* Return: none *
* Description: USB Set descriptor *
*************************************************************************/
inline
void UsbSetDescriptor(void) {
if(UsbDevCtrl.State.DS >= UsbDevStatusAddress) {
// This request is valid only for Address state and Configured state.
// If supported
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} else {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} }
/*************************************************************************
* Function Name: UsbGetConfiguration * Parameters: none
*
* Return: none *
* Description: USB Get configuration implement *
*************************************************************************/
inline
void UsbGetConfiguration(void) {
if((UsbDevCtrl.State.DS >= UsbDevStatusAddress) &&
(UsbEp0SetupPacket.wValue.Word == 0) &&
(UsbEp0SetupPacket.wIndex.Word == 0) &&
(UsbEp0SetupPacket.wLength.Word == 1)) {
UsbEp0Ctrl.Counter = 1;
EpCtrlDataBuf[0] = UsbCoreReq(UsbCoreReqConfiquration);
UsbEp0Ctrl.pData = EpCtrlDataBuf;
UsbEp0SetupWrite();
} else {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} }
/*************************************************************************
* Function Name: UsbSetConfiguration * Parameters: none
*************************************************************************/
inline
void UsbSetConfiguration(void) {
if((UsbDevCtrl.State.DS >= UsbDevStatusAddress) &&
(UsbEp0SetupPacket.wIndex.Word == 0) &&
(UsbEp0SetupPacket.wLength.Word == 0) &&
(UsbSetConfigurtonState(UsbEp0SetupPacket.wValue.Lo) == UsbPass)) {
USB_EpWrite(CTRL_ENP_IN,NULL,0);
UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
} else {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} }
/*************************************************************************
* Function Name: UsbGetInterface * Parameters: none
*
* Return: none *
* Description: Implement get interface request *
*************************************************************************/
inline
void UsbGetInterface (void) {
if((UsbDevCtrl.State.DS == UsbDevStatusConfigured) &&
(UsbEp0SetupPacket.wIndex.Word == UsbDevCtrl.Interface) &&
(UsbEp0SetupPacket.wLength.Word == 1) &&
(UsbEp0SetupPacket.wValue.Word == 0)) {
UsbEp0Ctrl.Counter = 1;
EpCtrlDataBuf[0] = UsbDevCtrl.AlternateSetting;
UsbEp0Ctrl.pData = EpCtrlDataBuf;
UsbEp0SetupWrite();
} else {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} }
/*************************************************************************
* Function Name: UsbSetInterface * Parameters: none
*
* Return: none *
* Description: Implement set interface request *
*************************************************************************/
inline
void UsbSetInterface (void) {
if((UsbDevCtrl.State.DS == UsbDevStatusConfigured) &&
(UsbEp0SetupPacket.wLength.Word == 0)) {
UsbStandardConfigurationDescriptor_t * pData = UsbFindConfiguration(UsbDevCtrl.Configuration);
UsbDevCtrl_t UsbDevCtrlNew = UsbDevCtrl;
UsbDevCtrlNew.Interface = UsbEp0SetupPacket.wIndex.Word;
UsbDevCtrlNew.AlternateSetting = UsbEp0SetupPacket.wValue.Word;
UsbDevCtrlNew.Feature.RemoteWakeupEnable = 0;
// Whether the interface is exist into current conficuration?
if(UsbFindInterface(pData,&UsbDevCtrlNew) != UsbPass) {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
return;
}
UsbCoreUserFun[UsbUserConfigure]((void *)&UsbDevCtrlNew);
UsbDevCtrl = UsbDevCtrlNew;
USB_EpWrite(CTRL_ENP_IN,NULL,0);
UsbEp0Ctrl.EpStatus.Status = UsbEpStatusIn;
} else {
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} }
/*************************************************************************
* Function Name: UsbSynchFrame * Parameters: none
*
* Return: none *
* Description: Implement synch frame request *
*************************************************************************/
inline
void UsbSynchFrame (void) {
if( USB_SOF_EVENT &&
(UsbDevCtrl.State.DS == UsbDevStatusConfigured) &&
(UsbEp0SetupPacket.wLength.Word == 2) &&
(UsbEp0SetupPacket.wValue.Word == 0)) {
Int32U FrameNumb = 0;
#if USB_SOF_EVENT > 0
FrameNumb = USB_GetFrameNumb();
#endif
UsbEp0Ctrl.EpStatus.Status = UsbEpStall;
} }
/*************************************************************************
* Function Name: UsbCtrlEpCallback * Parameters: void * pArg
*
* Return: none *
* Description: USB Ctrl EP Callback
* Description: USB Ctrl EP Callback