//--------------------------------------------------------------
uint32_t USB_OTG_ResetPort(USB_OTG_CORE_HANDLE *pdev)
{
USB_OTG_HPRT0_TypeDef hprt0;
hprt0.d32 = USB_OTG_ReadHPRT0(pdev);
hprt0.b.prtrst = 1;
USB_OTG_WRITE_REG32(pdev->regs.HPRT0, hprt0.d32);
USB_OTG_BSP_mDelay (10); /* See Note #1 */
hprt0.b.prtrst = 0;
USB_OTG_WRITE_REG32(pdev->regs.HPRT0, hprt0.d32);
USB_OTG_BSP_mDelay (20);
return 1;
}
//--------------------------------------------------------------
void USB_OTG_ActiveRemoteWakeup(USB_OTG_CORE_HANDLE * pdev)
{
USB_OTG_DCTL_TypeDef dctl;
USB_OTG_DSTS_TypeDef dsts;
USB_OTG_PCGCCTL_TypeDef power;
if (pdev->dev.DevRemoteWakeup) {
dsts.d32 = USB_OTG_READ_REG32(&pdev->regs.DREGS->DSTS);
if (dsts.b.suspsts == 1) {
if (pdev->cfg.low_power) {
/* un-gate USB Core clock */
power.d32 = USB_OTG_READ_REG32(&pdev->regs.PCGCCTL);
power.b.gatehclk = 0;
power.b.stoppclk = 0;
USB_OTG_WRITE_REG32(pdev->regs.PCGCCTL, power.d32);
}
/* active Remote wakeup signaling */
dctl.d32 = 0;
dctl.b.rmtwkupsig = 1;
USB_OTG_MODIFY_REG32(&pdev->regs.DREGS->DCTL, 0, dctl.d32);
USB_OTG_BSP_mDelay(5);
USB_OTG_MODIFY_REG32(&pdev->regs.DREGS->DCTL, dctl.d32, 0);
}
}
}
void USB_OTG_BSP_ConfigVBUS(USB_OTG_CORE_HANDLE *pdev)
{
#ifndef USE_USB_OTG_HS
GPIO_InitTypeDef GPIO_InitStructure;
#ifdef USE_STM3210C_EVAL
RCC_APB2PeriphClockCmd(HOST_POWERSW_PORT_RCC, ENABLE);
/* Configure Power Switch Vbus Pin */
GPIO_InitStructure.GPIO_Pin = HOST_POWERSW_VBUS;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(HOST_POWERSW_PORT, &GPIO_InitStructure);
#else
#ifdef USE_USB_OTG_FS
RCC_AHB1PeriphClockCmd( RCC_AHB1Periph_GPIOH , ENABLE);
GPIO_InitStructure.GPIO_Pin = HOST_POWERSW_VBUS;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
GPIO_Init(HOST_POWERSW_PORT,&GPIO_InitStructure);
#endif
#endif
/* By Default, DISABLE is needed on output of the Power Switch */
GPIO_SetBits(HOST_POWERSW_PORT, HOST_POWERSW_VBUS);
USB_OTG_BSP_mDelay(200); /* Delay is need for stabilising the Vbus Low
in Reset Condition, when Vbus=1 and Reset-button is pressed by user */
#endif
}
static uint8_t Image_Browser (char* path)
{
FRESULT res;
uint8_t ret = 1;
FILINFO fno;
DIR dir;
char *fn;
uint8_t key = 0;
res = f_opendir(&dir, path);
if (res == FR_OK) {
for (;;) {
res = f_readdir(&dir, &fno);
if (res != FR_OK || fno.fname[0] == 0) break;
if (fno.fname[0] == '.') continue;
fn = fno.fname;
if (fno.fattrib & AM_DIR)
{
continue;
}
else
{
if((strstr(fn, "bmp")) || (strstr(fn, "BMP")))
{
res = f_open(&file, fn, FA_OPEN_EXISTING | FA_READ);
Show_Image();
USB_OTG_BSP_mDelay(100);
ret = 0;
// while((HCD_IsDeviceConnected(&USB_OTG_Core)))// && \
//// (STM_EVAL_PBGetState (BUTTON_KEY) == SET))
// {
// Toggle_Leds();
// }
while(key != '1')
{
SerialKeyPressed((uint8_t*)&key);
Toggle_Leds();
}
key = 0;
f_close(&file);
}
}
}
}
#ifdef USE_USB_OTG_HS
LCD_LOG_SetHeader(" USB OTG HS MSC Host");
#else
LCD_LOG_SetHeader(" USB OTG FS MSC Host");
#endif
LCD_LOG_SetFooter (" USB Host Library v2.1.0" );
LCD_UsrLog("> Disk capacity : %d Bytes\n", USBH_MSC_Param.MSCapacity * \
USBH_MSC_Param.MSPageLength);
USBH_USR_ApplicationState = USH_USR_FS_READLIST;
return ret;
}
void USR_KEYBRD_ProcessData(uint8_t pbuf) {
led_state(4, 1);
USB_OTG_BSP_mDelay(50);
led_state(4, 0);
//lcd_print_strn((char*)&pbuf, 1);
usb_keyboard_key = pbuf;
}
/**
* @brief DFU_Req_DETACH
* Handles the DFU DETACH request.
* @param pdev: device instance
* @param req: pointer to the request structure.
* @retval None.
*/
static void DFU_Req_DETACH(void *pdev, USB_SETUP_REQ *req)
{
if (DeviceState == STATE_dfuIDLE || DeviceState == STATE_dfuDNLOAD_SYNC
|| DeviceState == STATE_dfuDNLOAD_IDLE || DeviceState == STATE_dfuMANIFEST_SYNC
|| DeviceState == STATE_dfuUPLOAD_IDLE )
{
/* Update the state machine */
DeviceState = STATE_dfuIDLE;
DeviceStatus[0] = STATUS_OK;
DeviceStatus[1] = 0;
DeviceStatus[2] = 0;
DeviceStatus[3] = 0; /*bwPollTimeout=0ms*/
DeviceStatus[4] = DeviceState;
DeviceStatus[5] = 0; /*iString*/
wBlockNum = 0;
wlength = 0;
}
/* Check the detach capability in the DFU functional descriptor */
if ((usbd_dfu_CfgDesc[12 + (9 * USBD_ITF_MAX_NUM)]) & DFU_DETACH_MASK)
{
/* Perform an Attach-Detach operation on USB bus */
DCD_DevDisconnect (pdev);
DCD_DevConnect (pdev);
}
else
{
/* Wait for the period of time specified in Detach request */
USB_OTG_BSP_mDelay (req->wValue);
}
}
void USB_OTG_BSP_ConfigVBUS(USB_OTG_CORE_HANDLE *pdev)
{
USB_OTG_BSP_mDelay(200); /* Delay is need for stabilising the Vbus Low
in Reset Condition, when Vbus=1 and Reset-button is pressed by user */
}
/**
* @brief Disconnect device (disable internal pull-up)
* @param pdev: device instance
* @retval : None
*/
void DCD_DevDisconnect (USB_OTG_CORE_HANDLE *pdev)
{
#ifndef USE_OTG_MODE
USB_OTG_DCTL_TypeDef dctl;
dctl.d32 = USB_OTG_READ_REG32(&pdev->regs.DREGS->DCTL);
/* Disconnect device for 3ms */
dctl.b.sftdiscon = 1;
USB_OTG_WRITE_REG32(&pdev->regs.DREGS->DCTL, dctl.d32);
USB_OTG_BSP_mDelay(3);
#endif
}
//--------------------------------------------------------------
void DCD_DevConnect (USB_OTG_CORE_HANDLE *pdev)
{
USB_OTG_DCTL_TypeDef dctl;
dctl.d32 = USB_OTG_READ_REG32(&pdev->regs.DREGS->DCTL);
/* Connect device */
dctl.b.sftdiscon = 0;
USB_OTG_WRITE_REG32(&pdev->regs.DREGS->DCTL, dctl.d32);
USB_OTG_BSP_mDelay(3);
}
int main(void) {
init();
/*
* Disable STDOUT buffering. Otherwise nothing will be printed
* before a newline character or when the buffer is flushed.
*/
setbuf(stdout, NULL);
while(1) {
printf("Test!\n");
USB_OTG_BSP_mDelay(500);
}
return 0;
}
/**
* @brief USB_OTG_BSP_ConfigVBUS
* Configures the IO for the Vbus and OverCurrent
* @param None
* @retval None
*/
void USB_OTG_BSP_ConfigVBUS(USB_OTG_CORE_HANDLE *pdev)
{
GPIO_InitTypeDef GPIO_InitStructure;
RCC_AHB1PeriphClockCmd(HOST_POWERSW_PORT_RCC , ENABLE);
GPIO_InitStructure.GPIO_Pin = HOST_POWERSW_VBUS;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
GPIO_Init(HOST_POWERSW_PORT,&GPIO_InitStructure);
/* By Default, DISABLE is needed on output of the Power Switch */
GPIO_SetBits(HOST_POWERSW_PORT, HOST_POWERSW_VBUS);
USB_OTG_BSP_mDelay(200); /* Delay is need for stabilising the Vbus Low
in Reset Condition, when Vbus=1 and Reset-button is pressed by user */
}
//--------------------------------------------------------------
USB_OTG_STS USB_OTG_SetCurrentMode(USB_OTG_CORE_HANDLE * pdev, uint8_t mode)
{
USB_OTG_STS status = USB_OTG_OK;
USB_OTG_GUSBCFG_TypeDef usbcfg;
usbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GUSBCFG);
usbcfg.b.force_host = 0;
usbcfg.b.force_dev = 0;
if (mode == HOST_MODE) {
usbcfg.b.force_host = 1;
} else if (mode == DEVICE_MODE) {
usbcfg.b.force_dev = 1;
}
USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GUSBCFG, usbcfg.d32);
USB_OTG_BSP_mDelay(50);
return status;
}
/**
* @brief USB_OTG_BSP_Resume
* Handles the USB Resume from Suspend Mode
* @param pdev: Selected device
* @retval Status
*/
void USB_OTG_BSP_Resume(USB_OTG_CORE_HANDLE *pdev)
{
USB_OTG_HPRT0_TypeDef hprt0;
USB_OTG_PCGCCTL_TypeDef power;
hprt0.d32 = 0;
/* switch-off the clocks */
power.d32 = 0;
power.b.stoppclk = 1;
USB_OTG_MODIFY_REG32(pdev->regs.PCGCCTL,power.d32, 0 );
power.b.gatehclk = 1;
USB_OTG_MODIFY_REG32(pdev->regs.PCGCCTL,power.d32, 0);
hprt0.d32 = 0;
hprt0.d32 = USB_OTG_ReadHPRT0(pdev);
hprt0.b.prtsusp = 0;
hprt0.b.prtres = 1;
USB_OTG_WRITE_REG32(pdev->regs.HPRT0, hprt0.d32);
USB_OTG_BSP_mDelay (20);
hprt0.b.prtres = 0;
USB_OTG_WRITE_REG32(pdev->regs.HPRT0, hprt0.d32);
}
//--------------------------------------------------------------
void USB_OTG_DriveVbus (USB_OTG_CORE_HANDLE *pdev, uint8_t state)
{
USB_OTG_HPRT0_TypeDef hprt0;
hprt0.d32 = 0;
/* enable disable the external charge pump */
USB_OTG_BSP_DriveVBUS(pdev, state);
/* Turn on the Host port power. */
hprt0.d32 = USB_OTG_ReadHPRT0(pdev);
if ((hprt0.b.prtpwr == 0 ) && (state == 1 ))
{
hprt0.b.prtpwr = 1;
USB_OTG_WRITE_REG32(pdev->regs.HPRT0, hprt0.d32);
}
if ((hprt0.b.prtpwr == 1 ) && (state == 0 ))
{
hprt0.b.prtpwr = 0;
USB_OTG_WRITE_REG32(pdev->regs.HPRT0, hprt0.d32);
}
USB_OTG_BSP_mDelay(200);
}
void USBH_USR_EnumerationDone(void)
{
// it's a fix, leave it here for the time being
// 1000 is possibly (not certain) better for ath3k
USB_OTG_BSP_mDelay(500);
}
void USR_KEYBRD_Init(void) {
led_state(4, 1);
USB_OTG_BSP_mDelay(100);
led_state(4, 0);
}
void USR_KEYBRD_ProcessData(uint8_t pbuf) {
led_state(4, 1);
USB_OTG_BSP_mDelay(50);
led_state(4, 0);
usb_keyboard_key = pbuf;
}
void USR_MOUSE_Init(void) {
led_state(4, 1);
USB_OTG_BSP_mDelay(100);
led_state(4, 0);
}
void USR_MOUSE_ProcessData(HID_MOUSE_Data_TypeDef *data) {
led_state(4, 1);
USB_OTG_BSP_mDelay(50);
led_state(4, 0);
}
void EnumerationDone()
{
USB_OTG_BSP_mDelay(500);
USBH_USR_MSC_Application();
}
/**
* @brief USBH_Process
* USB Host core main state machine process
* @param None
* @retval None
*/
void USBH_Process(USB_OTG_CORE_HANDLE *pdev , USBH_HOST *phost)
{
volatile USBH_Status status = USBH_FAIL;
/* check for Host port events */
if (((HCD_IsDeviceConnected(pdev) == 0)|| (HCD_IsPortEnabled(pdev) == 0))&& (phost->gState != HOST_IDLE))
{
if(phost->gState != HOST_DEV_DISCONNECTED)
{
phost->gState = HOST_DEV_DISCONNECTED;
}
}
switch (phost->gState)
{
case HOST_IDLE :
if (HCD_IsDeviceConnected(pdev))
{
phost->gState = HOST_WAIT_PRT_ENABLED;
/*wait denounce delay */
USB_OTG_BSP_mDelay(100);
/* Apply a port RESET */
HCD_ResetPort(pdev);
/* User RESET callback*/
phost->usr_cb->ResetDevice();
}
break;
case HOST_WAIT_PRT_ENABLED:
if (pdev->host.PortEnabled == 1)
{
phost->gState = HOST_DEV_ATTACHED;
USB_OTG_BSP_mDelay(50);
}
break;
case HOST_DEV_ATTACHED :
phost->usr_cb->DeviceAttached();
phost->Control.hc_num_out = USBH_Alloc_Channel(pdev, 0x00);
phost->Control.hc_num_in = USBH_Alloc_Channel(pdev, 0x80);
/* Reset USB Device */
if ( HCD_ResetPort(pdev) == 0)
{
phost->usr_cb->ResetDevice();
/* Host is Now ready to start the Enumeration */
phost->device_prop.speed = HCD_GetCurrentSpeed(pdev);
phost->gState = HOST_ENUMERATION;
phost->usr_cb->DeviceSpeedDetected(phost->device_prop.speed);
/* Open Control pipes */
USBH_Open_Channel (pdev,
phost->Control.hc_num_in,
phost->device_prop.address,
phost->device_prop.speed,
EP_TYPE_CTRL,
phost->Control.ep0size);
/* Open Control pipes */
USBH_Open_Channel (pdev,
phost->Control.hc_num_out,
phost->device_prop.address,
phost->device_prop.speed,
EP_TYPE_CTRL,
phost->Control.ep0size);
}
break;
case HOST_ENUMERATION:
/* Check for enumeration status */
if ( USBH_HandleEnum(pdev , phost) == USBH_OK)
{
/* The function shall return USBH_OK when full enumeration is complete */
/* user callback for end of device basic enumeration */
phost->usr_cb->EnumerationDone();
#if defined (USB_OTG_FS_LOW_PWR_MGMT_SUPPORT) || defined (USB_OTG_HS_LOW_PWR_MGMT_SUPPORT)
phost->gState = HOST_SUSPENDED;
#else
phost->gState = HOST_USR_INPUT;
#endif /* LOW_PWR_MGMT_SUPPORT*/
}
break;
case HOST_USR_INPUT:
/*The function should return user response true to move to class state */
if ( phost->usr_cb->UserInput() == USBH_USR_RESP_OK)
{
if((phost->class_cb->Init(pdev, phost))\
== USBH_OK)
{
phost->gState = HOST_CLASS_REQUEST;
}
}
break;
case HOST_CLASS_REQUEST:
/* process class standard control requests state machine */
status = phost->class_cb->Requests(pdev, phost);
if(status == USBH_OK)
{
phost->gState = HOST_CLASS;
}
else
{
USBH_ErrorHandle(phost, status);
}
break;
case HOST_CLASS:
/* process class state machine */
status = phost->class_cb->Machine(pdev, phost);
USBH_ErrorHandle(phost, status);
break;
case HOST_CTRL_XFER:
/* process control transfer state machine */
USBH_HandleControl(pdev, phost);
break;
#if defined (USB_OTG_FS_LOW_PWR_MGMT_SUPPORT) || defined (USB_OTG_HS_LOW_PWR_MGMT_SUPPORT)
case HOST_SUSPENDED:
if (USBH_SetDeviceFeature(pdev, phost, FEATURE_SELECTOR_DEVICE, 0)==USBH_OK)
{
suspend_flag = 1;
USB_OTG_BSP_Suspend(pdev);
phost->usr_cb->UserInput();
PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
/* After wakeup got to HOST_WAKEUP state */
phost->gState = HOST_WAKEUP;
}
break;
case HOST_WAKEUP:
/* issue a ClearDeviceFeature request */
if (USBH_ClearDeviceFeature(pdev, phost, FEATURE_SELECTOR_DEVICE, 0)==USBH_OK)
{
phost->gState = HOST_USR_INPUT;
}
break;
#endif /* USE_HOST_MODE */
case HOST_ERROR_STATE:
/* Re-Initialize Host for new Enumeration */
USBH_DeInit(pdev, phost);
phost->usr_cb->DeInit();
phost->class_cb->DeInit(pdev, &phost->device_prop);
break;
case HOST_DEV_DISCONNECTED :
/* Manage User disconnect operations*/
phost->usr_cb->DeviceDisconnected();
/* Re-Initialize Host for new Enumeration */
USBH_DeInit(pdev, phost);
phost->usr_cb->DeInit();
phost->class_cb->DeInit(pdev, &phost->device_prop);
USBH_DeAllocate_AllChannel(pdev);
phost->gState = HOST_IDLE;
/* Re-Initialize Host for new Enumeration */
HCD_Init(pdev,
#ifdef USE_USB_OTG_FS
USB_OTG_FS_CORE_ID
#else
USB_OTG_HS_CORE_ID
#endif
);
break;
default :
break;
}
}
/**
* @brief USBH_Process
* USB Host core main state machine process
* @param None
* @retval None
*/
void USBH_Process(USB_OTG_CORE_HANDLE *pdev, USBH_HOST *phost)
{
volatile USBH_Status status = USBH_FAIL;
// if (USB_DEBUG) {
// USB_debugEvent();
// xprintf("USBH_Process phost->gState = %d\n", phost->gState);
// }
/* check for Host port events */
if (((HCD_IsDeviceConnected(pdev) == 0) || (HCD_IsPortEnabled(pdev) == 0)) && (phost->gState != HOST_IDLE)) {
if (phost->gState != HOST_DEV_DISCONNECTED) {
phost->gState = HOST_DEV_DISCONNECTED;
// if (USB_DEBUG){
// USB_debugEvent();
// }
}
}
switch (phost->gState) {
case HOST_IDLE:
if (HCD_IsDeviceConnected(pdev)) {
phost->gState = HOST_WAIT_PRT_ENABLED;
/*wait debounce delay */
USB_OTG_BSP_mDelay(200); // was 100
// if (USB_DEBUG){
// USB_debugEvent();
// }
/* Apply a port RESET */
HCD_ResetPort(pdev);
/* User RESET callback*/
phost->usr_cb->ResetDevice();
}
break;
case HOST_WAIT_PRT_ENABLED:
if (pdev->host.PortEnabled == 1) {
phost->gState = HOST_DEV_ATTACHED;
}
break;
case HOST_DEV_ATTACHED:
phost->usr_cb->DeviceAttached();
phost->Control.hc_num_out = USBH_Alloc_Channel(pdev, 0x00);
phost->Control.hc_num_in = USBH_Alloc_Channel(pdev, 0x80);
// if (USB_DEBUG){
// USB_debugEvent();
// }
phost->device_prop.speed = HCD_GetCurrentSpeed(pdev);
phost->gState = HOST_ENUMERATION;
phost->usr_cb->DeviceSpeedDetected(phost->device_prop.speed);
// if (USB_DEBUG){
// USB_debugEvent();
// }
/* Open Control pipes */
USBH_Open_Channel(pdev, phost->Control.hc_num_in, phost->device_prop.address, phost->device_prop.speed, EP_TYPE_CTRL, phost->Control.ep0size);
// if (USB_DEBUG){
// USB_debugEvent();
// }
/* Open Control pipes */
USBH_Open_Channel(pdev, phost->Control.hc_num_out, phost->device_prop.address, phost->device_prop.speed, EP_TYPE_CTRL, phost->Control.ep0size);
// if (USB_DEBUG){
// USB_debugEvent();
// }
break;
case HOST_ENUMERATION:
/* Check for enumeration status */
if (USBH_HandleEnum(pdev, phost) == USBH_OK) {
/* The function shall return USBH_OK when full enumeration is complete */
/* user callback for end of device basic enumeration */
phost->usr_cb->EnumerationDone();
phost->gState = HOST_USR_INPUT;
// if (USB_DEBUG){
// USB_debugEvent();
// }
}
break;
case HOST_USR_INPUT:
/*The function should return user response true to move to class state */
if (phost->usr_cb->UserInput() == USBH_USR_RESP_OK) {
if ((phost->class_cb->Init(pdev, phost))\
== USBH_OK) {
phost->gState = HOST_CLASS_REQUEST;
}
// if (USB_DEBUG){
// USB_debugEvent();
// }
}
break;
case HOST_CLASS_REQUEST:
/* process class standard contol requests state machine */
// if (USB_DEBUG){
// USB_debugEvent();
// }
status = phost->class_cb->Requests(pdev, phost);
if (status == USBH_OK) {
phost->gState = HOST_CLASS;
// if (USB_DEBUG){
// USB_debugEvent();
// }
}
else {
// if (USB_DEBUG){
// USB_debugEvent();
// }
USBH_ErrorHandle(phost, status);
}
break;
case HOST_CLASS:
/* process class state machine */
status = phost->class_cb->Machine(pdev, phost);
// if (USB_DEBUG){
// USB_debugEvent();
// }
USBH_ErrorHandle(phost, status);
break;
case HOST_CTRL_XFER:
/* process control transfer state machine */
// if (USB_DEBUG){
// USB_debugEvent();
// }
USBH_HandleControl(pdev, phost);
break;
case HOST_SUSPENDED:
break;
case HOST_ERROR_STATE:
/* Re-Initilaize Host for new Enumeration */
// if (USB_DEBUG){
// USB_debugEvent();
// }
USBH_DeInit(pdev, phost);
phost->usr_cb->DeInit();
phost->class_cb->DeInit(pdev, &phost->device_prop);
break;
case HOST_DEV_DISCONNECTED:
// if (USB_DEBUG){
// USB_debugEvent();
// }
/* Manage User disconnect operations*/
phost->usr_cb->DeviceDisconnected();
/* Re-Initilaize Host for new Enumeration */
USBH_DeInit(pdev, phost);
phost->usr_cb->DeInit();
phost->class_cb->DeInit(pdev, &phost->device_prop);
USBH_DeAllocate_AllChannel(pdev);
phost->gState = HOST_IDLE;
/* Re-Initilaize Host for new Enumeration */
HCD_Init(pdev,
#ifdef USE_USB_OTG_FS
USB_OTG_FS_CORE_ID
#else
USB_OTG_HS_CORE_ID
#endif
);
break;
default:
break;
}
}
//--------------------------------------------------------------
USB_OTG_STS USB_OTG_CoreInit(USB_OTG_CORE_HANDLE * pdev)
{
USB_OTG_STS status = USB_OTG_OK;
USB_OTG_GUSBCFG_TypeDef usbcfg;
USB_OTG_GCCFG_TypeDef gccfg;
USB_OTG_GI2CCTL_TypeDef i2cctl;
USB_OTG_GAHBCFG_TypeDef ahbcfg;
usbcfg.d32 = 0;
gccfg.d32 = 0;
ahbcfg.d32 = 0;
if (pdev->cfg.phy_itface == USB_OTG_ULPI_PHY) {
gccfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GCCFG);
gccfg.b.pwdn = 0;
if (pdev->cfg.Sof_output) {
gccfg.b.sofouten = 1;
}
USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GCCFG, gccfg.d32);
/* Init The ULPI Interface */
usbcfg.d32 = 0;
usbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GUSBCFG);
usbcfg.b.physel = 0; /* HS Interface */
usbcfg.b.term_sel_dl_pulse = 0; /* Data line pulsing using utmi_txvalid */
usbcfg.b.ulpi_utmi_sel = 1; /* ULPI seleInterfacect */
usbcfg.b.phyif = 0; /* 8 bits */
usbcfg.b.ddrsel = 0; /* single data rate */
usbcfg.b.ulpi_fsls = 0;
usbcfg.b.ulpi_clk_sus_m = 0;
USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GUSBCFG, usbcfg.d32);
/* Reset after a PHY select */
USB_OTG_CoreReset(pdev);
if (pdev->cfg.dma_enable == 1) {
ahbcfg.b.hburstlen = 5; /* 64 x 32-bits */
ahbcfg.b.dmaenable = 1;
USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GAHBCFG, ahbcfg.d32);
}
} else { /* FS interface (embedded Phy or I2C Phy) */
usbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GUSBCFG);;
usbcfg.b.physel = 1; /* FS Interface */
USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GUSBCFG, usbcfg.d32);
/* Reset after a PHY select and set Host mode */
USB_OTG_CoreReset(pdev);
/* Enable the I2C interface and deactivate the power down */
gccfg.d32 = 0;
gccfg.b.pwdn = 1;
if (pdev->cfg.phy_itface == USB_OTG_I2C_PHY) {
gccfg.b.i2cifen = 1;
}
gccfg.b.vbussensingA = 1;
gccfg.b.vbussensingB = 1;
if (pdev->cfg.Sof_output) {
gccfg.b.sofouten = 1;
}
USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GCCFG, gccfg.d32);
USB_OTG_BSP_mDelay(20);
/* Program GUSBCFG.OtgUtmifsSel to I2C */
usbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GUSBCFG);
if (pdev->cfg.phy_itface == USB_OTG_I2C_PHY) {
usbcfg.b.otgutmifssel = 1;
}
USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GUSBCFG, usbcfg.d32);
if (pdev->cfg.phy_itface == USB_OTG_I2C_PHY) {
/*Program GI2CCTL.I2CEn */
i2cctl.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GI2CCTL);
i2cctl.b.i2cdevaddr = 1;
i2cctl.b.i2cen = 0;
i2cctl.b.dat_se0 = 1;
i2cctl.b.addr = 0x2D;
USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GI2CCTL, i2cctl.d32);
USB_OTG_BSP_mDelay(200);
i2cctl.b.i2cen = 1;
USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GI2CCTL, i2cctl.d32);
USB_OTG_BSP_mDelay(200);
}
}
/* case the HS core is working in FS mode */
if (pdev->cfg.dma_enable == 1) {
ahbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GAHBCFG);
ahbcfg.b.hburstlen = 5; /* 64 x 32-bits */
ahbcfg.b.dmaenable = 1;
USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GAHBCFG, ahbcfg.d32);
}
/* initialize OTG features */
return status;
}
/**
* @brief USBH_USR_MSC_Application
* Demo application for mass storage
* @param None
* @retval Staus
*/
int USBH_USR_MSC_Application(void)
{
FRESULT res;
uint8_t writeTextBuff[] = "STM32 Connectivity line Host Demo application using FAT_FS ";
uint16_t bytesWritten, bytesToWrite;
switch(USBH_USR_ApplicationState)
{
case USH_USR_FS_INIT:
/* Initialises the File System*/
if ( f_mount( 0, &fatfs ) != FR_OK ) {
/* efs initialisation fails*/
LCD_ErrLog("> Cannot initialize File System.\n");
return(-1);
}
LCD_UsrLog("> File System initialized.\n");
LCD_UsrLog("> Disk capacity : %d Bytes\n", USBH_MSC_Param.MSCapacity * \
USBH_MSC_Param.MSPageLength);
if(USBH_MSC_Param.MSWriteProtect == DISK_WRITE_PROTECTED) {
LCD_ErrLog((void *)MSG_WR_PROTECT);
}
USBH_USR_ApplicationState = USH_USR_FS_READLIST;
break;
case USH_USR_FS_READLIST:
LCD_UsrLog((void *)MSG_ROOT_CONT);
Explore_Disk("0:/", 1);
line_idx = 0;
USBH_USR_ApplicationState = USH_USR_FS_WRITEFILE;
break;
case USH_USR_FS_WRITEFILE:
LCD_SetTextColor(Green);
LCD_DisplayStringLine( LCD_PIXEL_HEIGHT - 42, " ");
LCD_DisplayStringLine( LCD_PIXEL_HEIGHT - 30, "Press Key to write file");
LCD_SetTextColor(LCD_LOG_DEFAULT_COLOR);
USB_OTG_BSP_mDelay(100);
/*Key B3 in polling*/
while((HCD_IsDeviceConnected(&USB_OTG_Core)) && \
(STM_EVAL_PBGetState (BUTTON_USER) == RESET))
{
Toggle_Leds();
}
/* Writes a text file, STM32.TXT in the disk*/
LCD_UsrLog("> Writing File to disk flash ...\n");
if (USBH_MSC_Param.MSWriteProtect == DISK_WRITE_PROTECTED) {
LCD_ErrLog ( "> Disk flash is write protected \n");
USBH_USR_ApplicationState = USH_USR_FS_DRAW;
break;
}
/* Register work area for logical drives */
f_mount(0, &fatfs);
if (f_open(&file, "0:STM32.TXT",FA_CREATE_ALWAYS | FA_WRITE) == FR_OK) {
/* Write buffer to file */
bytesToWrite = sizeof(writeTextBuff);
res= f_write (&file, writeTextBuff, bytesToWrite, (void *)&bytesWritten);
if((bytesWritten == 0) || (res != FR_OK)) /*EOF or Error*/ {
LCD_ErrLog("> STM32.TXT CANNOT be writen.\n");
} else {
LCD_UsrLog("> 'STM32.TXT' file created\n");
}
/*close file and filesystem*/
f_close(&file);
f_mount(0, NULL);
} else {
LCD_UsrLog ("> STM32.TXT created in the disk\n");
}
USBH_USR_ApplicationState = USH_USR_FS_DRAW;
LCD_SetTextColor(Green);
LCD_DisplayStringLine( LCD_PIXEL_HEIGHT - 42, " ");
LCD_DisplayStringLine( LCD_PIXEL_HEIGHT - 30, "To start Image slide show Press Key.");
LCD_SetTextColor(LCD_LOG_DEFAULT_COLOR);
break;
case USH_USR_FS_DRAW:
/*Key B3 in polling*/
while((HCD_IsDeviceConnected(&USB_OTG_Core)) && \
(STM_EVAL_PBGetState (BUTTON_USER) == RESET))
{
Toggle_Leds();
}
while(HCD_IsDeviceConnected(&USB_OTG_Core))
{
if ( f_mount( 0, &fatfs ) != FR_OK ) {
/* fat_fs initialisation fails*/
return(-1);
}
return Image_Browser("0:/");
}
break;
default: break;
}
return(0);
}
//--------------------------------------------------------------
USB_OTG_STS USB_OTG_CoreInit(USB_OTG_CORE_HANDLE *pdev)
{
USB_OTG_STS status = USB_OTG_OK;
USB_OTG_GUSBCFG_TypeDef usbcfg;
USB_OTG_GCCFG_TypeDef gccfg;
USB_OTG_GAHBCFG_TypeDef ahbcfg;
usbcfg.d32 = 0;
gccfg.d32 = 0;
ahbcfg.d32 = 0;
if (pdev->cfg.phy_itface == USB_OTG_ULPI_PHY)
{
gccfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GCCFG);
gccfg.b.pwdn = 0;
if (pdev->cfg.Sof_output)
{
gccfg.b.sofouten = 1;
}
USB_OTG_WRITE_REG32 (&pdev->regs.GREGS->GCCFG, gccfg.d32);
/* Init The ULPI Interface */
usbcfg.d32 = 0;
usbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GUSBCFG);
usbcfg.b.physel = 0; /* HS Interface */
usbcfg.b.ulpi_ext_vbus_drv = 1; /* Use external VBUS */
usbcfg.b.term_sel_dl_pulse = 0; /* Data line pulsing using utmi_txvalid */
usbcfg.b.ulpi_fsls = 0;
usbcfg.b.ulpi_clk_sus_m = 0;
USB_OTG_WRITE_REG32 (&pdev->regs.GREGS->GUSBCFG, usbcfg.d32);
/* Reset after a PHY select */
USB_OTG_CoreReset(pdev);
if(pdev->cfg.dma_enable == 1)
{
ahbcfg.b.hburstlen = 5; /* 64 x 32-bits*/
ahbcfg.b.dmaenable = 1;
USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GAHBCFG, ahbcfg.d32);
}
}
else /* FS interface (embedded Phy) */
{
usbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GUSBCFG);;
usbcfg.b.physel = 1; /* FS Interface */
USB_OTG_WRITE_REG32 (&pdev->regs.GREGS->GUSBCFG, usbcfg.d32);
/* Reset after a PHY select and set Host mode */
USB_OTG_CoreReset(pdev);
/* Deactivate the power down*/
gccfg.d32 = 0;
gccfg.b.pwdn = 1;
gccfg.b.vbussensingA = 1 ;
gccfg.b.vbussensingB = 1 ;
gccfg.b.disablevbussensing = 1;
if(pdev->cfg.Sof_output)
{
gccfg.b.sofouten = 1;
}
USB_OTG_WRITE_REG32 (&pdev->regs.GREGS->GCCFG, gccfg.d32);
USB_OTG_BSP_mDelay(20);
}
/* case the HS core is working in FS mode */
if(pdev->cfg.dma_enable == 1)
{
ahbcfg.d32 = USB_OTG_READ_REG32(&pdev->regs.GREGS->GAHBCFG);
ahbcfg.b.hburstlen = 5; /* 64 x 32-bits*/
ahbcfg.b.dmaenable = 1;
USB_OTG_WRITE_REG32(&pdev->regs.GREGS->GAHBCFG, ahbcfg.d32);
}
/* initialize OTG features */
return status;
}
/**
* @brief USBH_Process
* USB Host core main state machine process
* @param None
* @retval None
*/
void USBH_Process(USB_OTG_CORE_HANDLE *pdev , USBH_HOST *phost)
{
volatile USBH_Status status = USBH_FAIL;
/* check for Host port events */
if ((HCD_IsDeviceConnected(pdev) == 0)&& (phost->gState != HOST_IDLE))
{
if(phost->gState != HOST_DEV_DISCONNECTED)
{
phost->gState = HOST_DEV_DISCONNECTED;
}
}
switch (phost->gState)
{
case HOST_IDLE :
if (HCD_IsDeviceConnected(pdev))
{
phost->gState = HOST_DEV_ATTACHED;
USB_OTG_BSP_mDelay(100);
}
break;
case HOST_DEV_ATTACHED :
phost->usr_cb->DeviceAttached();
phost->Control.hc_num_out = USBH_Alloc_Channel(pdev, 0x00);
phost->Control.hc_num_in = USBH_Alloc_Channel(pdev, 0x80);
/* Reset USB Device */
if ( HCD_ResetPort(pdev) == 0)
{
phost->usr_cb->ResetDevice();
/* Wait for USB USBH_ISR_PrtEnDisableChange()
Host is Now ready to start the Enumeration
*/
phost->device_prop.speed = HCD_GetCurrentSpeed(pdev);
phost->gState = HOST_ENUMERATION;
phost->usr_cb->DeviceSpeedDetected(phost->device_prop.speed);
/* Open Control pipes */
USBH_Open_Channel (pdev,
phost->Control.hc_num_in,
phost->device_prop.address,
phost->device_prop.speed,
EP_TYPE_CTRL,
phost->Control.ep0size);
/* Open Control pipes */
USBH_Open_Channel (pdev,
phost->Control.hc_num_out,
phost->device_prop.address,
phost->device_prop.speed,
EP_TYPE_CTRL,
phost->Control.ep0size);
}
break;
case HOST_ENUMERATION:
/* Check for enumeration status */
if ( USBH_HandleEnum(pdev , phost) == USBH_OK)
{
/* The function shall return USBH_OK when full enumeration is complete */
/* user callback for end of device basic enumeration */
phost->usr_cb->EnumerationDone();
phost->gState = HOST_USR_INPUT;
}
break;
case HOST_USR_INPUT:
/*The function should return user response true to move to class state */
if ( phost->usr_cb->UserInput() == USBH_USR_RESP_OK)
{
if((phost->class_cb->Init(pdev, phost))\
== USBH_OK)
{
phost->gState = HOST_CLASS_REQUEST;
}
}
break;
case HOST_CLASS_REQUEST:
/* process class standard contol requests state machine */
status = phost->class_cb->Requests(pdev, phost);
if(status == USBH_OK)
{
phost->gState = HOST_CLASS;
}
else
{
USBH_ErrorHandle(phost, status);
}
break;
case HOST_CLASS:
/* process class state machine */
status = phost->class_cb->Machine(pdev, phost);
USBH_ErrorHandle(phost, status);
break;
case HOST_CTRL_XFER:
/* process control transfer state machine */
USBH_HandleControl(pdev, phost);
break;
case HOST_SUSPENDED:
break;
case HOST_ERROR_STATE:
/* Re-Initilaize Host for new Enumeration */
USBH_DeInit(pdev, phost);
phost->usr_cb->DeInit();
phost->class_cb->DeInit(pdev, &phost->device_prop);
break;
case HOST_DEV_DISCONNECTED :
/* Manage User disconnect operations*/
phost->usr_cb->DeviceDisconnected();
/* Re-Initilaize Host for new Enumeration */
USBH_DeInit(pdev, phost);
phost->usr_cb->DeInit();
phost->class_cb->DeInit(pdev, &phost->device_prop);
USBH_DeAllocate_AllChannel(pdev);
phost->gState = HOST_IDLE;
break;
default :
break;
}
}
/**
* @brief USBH_HandleEnum
* This function includes the complete enumeration process
* @param pdev: Selected device
* @retval USBH_Status
*/
static USBH_Status USBH_HandleEnum(USB_OTG_CORE_HANDLE *pdev, USBH_HOST *phost)
{
USBH_Status Status = USBH_BUSY;
uint8_t Local_Buffer[64];
switch (phost->EnumState)
{
case ENUM_IDLE:
/* Get Device Desc for only 1st 8 bytes : To get EP0 MaxPacketSize */
if ( USBH_Get_DevDesc(pdev , phost, 8) == USBH_OK)
{
phost->Control.ep0size = phost->device_prop.Dev_Desc.bMaxPacketSize;
/* Issue Reset */
HCD_ResetPort(pdev);
phost->EnumState = ENUM_GET_FULL_DEV_DESC;
/* modify control channels configuration for MaxPacket size */
USBH_Modify_Channel (pdev,
phost->Control.hc_num_out,
0,
0,
0,
phost->Control.ep0size);
USBH_Modify_Channel (pdev,
phost->Control.hc_num_in,
0,
0,
0,
phost->Control.ep0size);
}
break;
case ENUM_GET_FULL_DEV_DESC:
/* Get FULL Device Desc */
if ( USBH_Get_DevDesc(pdev, phost, USB_DEVICE_DESC_SIZE)\
== USBH_OK)
{
/* user callback for device descriptor available */
phost->usr_cb->DeviceDescAvailable(&phost->device_prop.Dev_Desc);
phost->EnumState = ENUM_SET_ADDR;
}
break;
case ENUM_SET_ADDR:
/* set address */
if ( USBH_SetAddress(pdev, phost, USBH_DEVICE_ADDRESS) == USBH_OK)
{
USB_OTG_BSP_mDelay(2);
phost->device_prop.address = USBH_DEVICE_ADDRESS;
/* user callback for device address assigned */
phost->usr_cb->DeviceAddressAssigned();
phost->EnumState = ENUM_GET_CFG_DESC;
/* modify control channels to update device address */
USBH_Modify_Channel (pdev,
phost->Control.hc_num_in,
phost->device_prop.address,
0,
0,
0);
USBH_Modify_Channel (pdev,
phost->Control.hc_num_out,
phost->device_prop.address,
0,
0,
0);
}
break;
case ENUM_GET_CFG_DESC:
/* get standard configuration descriptor */
if ( USBH_Get_CfgDesc(pdev,
phost,
USB_CONFIGURATION_DESC_SIZE) == USBH_OK)
{
phost->EnumState = ENUM_GET_FULL_CFG_DESC;
}
break;
case ENUM_GET_FULL_CFG_DESC:
/* get FULL config descriptor (config, interface, endpoints) */
if (USBH_Get_CfgDesc(pdev,
phost,
phost->device_prop.Cfg_Desc.wTotalLength) == USBH_OK)
{
/* User callback for configuration descriptors available */
phost->usr_cb->ConfigurationDescAvailable(&phost->device_prop.Cfg_Desc,
phost->device_prop.Itf_Desc,
phost->device_prop.Ep_Desc[0]);
phost->EnumState = ENUM_GET_MFC_STRING_DESC;
}
break;
case ENUM_GET_MFC_STRING_DESC:
if (phost->device_prop.Dev_Desc.iManufacturer != 0)
{ /* Check that Manufacturer String is available */
if ( USBH_Get_StringDesc(pdev,
phost,
phost->device_prop.Dev_Desc.iManufacturer,
Local_Buffer ,
0xff) == USBH_OK)
{
/* User callback for Manufacturing string */
phost->usr_cb->ManufacturerString(Local_Buffer);
phost->EnumState = ENUM_GET_PRODUCT_STRING_DESC;
}
}
else
{
phost->usr_cb->ManufacturerString("N/A");
phost->EnumState = ENUM_GET_PRODUCT_STRING_DESC;
}
break;
case ENUM_GET_PRODUCT_STRING_DESC:
if (phost->device_prop.Dev_Desc.iProduct != 0)
{ /* Check that Product string is available */
if ( USBH_Get_StringDesc(pdev,
phost,
phost->device_prop.Dev_Desc.iProduct,
Local_Buffer,
0xff) == USBH_OK)
{
/* User callback for Product string */
phost->usr_cb->ProductString(Local_Buffer);
phost->EnumState = ENUM_GET_SERIALNUM_STRING_DESC;
}
}
else
{
phost->usr_cb->ProductString("N/A");
phost->EnumState = ENUM_GET_SERIALNUM_STRING_DESC;
}
break;
case ENUM_GET_SERIALNUM_STRING_DESC:
if (phost->device_prop.Dev_Desc.iSerialNumber != 0)
{ /* Check that Serial number string is available */
if ( USBH_Get_StringDesc(pdev,
phost,
phost->device_prop.Dev_Desc.iSerialNumber,
Local_Buffer,
0xff) == USBH_OK)
{
/* User callback for Serial number string */
phost->usr_cb->SerialNumString(Local_Buffer);
phost->EnumState = ENUM_SET_CONFIGURATION;
}
}
else
{
phost->usr_cb->SerialNumString("N/A");
phost->EnumState = ENUM_SET_CONFIGURATION;
}
break;
case ENUM_SET_CONFIGURATION:
/* set configuration (default config) */
if (USBH_SetCfg(pdev,
phost,
phost->device_prop.Cfg_Desc.bConfigurationValue) == USBH_OK)
{
phost->EnumState = ENUM_DEV_CONFIGURED;
}
break;
case ENUM_DEV_CONFIGURED:
/* user callback for enumeration done */
Status = USBH_OK;
break;
default:
break;
}
return Status;
}
/**
* @brief USBH_Process
* USB Host core main state machine process
* @param None
* @retval None
*/
void USBH_Process(USB_OTG_CORE_HANDLE *pdev , USBH_HOST *phost)
{
volatile USBH_Status status = USBH_FAIL;
/* check for Host port events */
if ((HCD_IsDeviceConnected(pdev) == 0)&& (phost->gState != HOST_IDLE))
{
printf("check for Host port events\r\n");
if(phost->gState != HOST_DEV_DISCONNECTED)
{
phost->gState = HOST_DEV_DISCONNECTED;
}
}
switch (phost->gState)
{
case HOST_IDLE :
if (HCD_IsDeviceConnected(pdev))
{
printf("HOST_DEV_ATTACHED is enter\r\n");
phost->gState = HOST_DEV_ATTACHED;
USB_OTG_BSP_mDelay(100);
}
break;
case HOST_DEV_ATTACHED :
phost->usr_cb->DeviceAttached();
phost->Control.hc_num_out = USBH_Alloc_Channel(pdev, 0x00);
phost->Control.hc_num_in = USBH_Alloc_Channel(pdev, 0x80);
/* Reset USB Device */
if ( HCD_ResetPort(pdev) == 0)
{
printf("HOST_DEV_ATTACHED state reset device");
phost->usr_cb->ResetDevice();
/* Wait for USB USBH_ISR_PrtEnDisableChange()
Host is Now ready to start the Enumeration
*/
phost->device_prop.speed = HCD_GetCurrentSpeed(pdev);
phost->gState = HOST_ENUMERATION;
phost->usr_cb->DeviceSpeedDetected(phost->device_prop.speed);
/* Open Control pipes */
USBH_Open_Channel (pdev,
phost->Control.hc_num_in,
phost->device_prop.address,
phost->device_prop.speed,
EP_TYPE_CTRL,
phost->Control.ep0size);
/* Open Control pipes */
USBH_Open_Channel (pdev,
phost->Control.hc_num_out,
phost->device_prop.address,
phost->device_prop.speed,
EP_TYPE_CTRL,
phost->Control.ep0size);
}
// printfpdev_reg(pdev);
break;
case HOST_ENUMERATION:
// printfpdev_reg(pdev);
// printf(" in HOST_ENUMERATION state\r\n ");
/* Check for enumeration status */
if ( USBH_HandleEnum(pdev , phost) == USBH_OK)
{
printf("HOST_ENUMERATION state enumeration is ok");
/* The function shall return USBH_OK when full enumeration is complete */
/* user callback for end of device basic enumeration */
phost->usr_cb->EnumerationDone();
phost->gState = HOST_USR_INPUT;
}
break;
case HOST_USR_INPUT:
/*The function should return user response true to move to class state */
if ( phost->usr_cb->UserInput() == USBH_USR_RESP_OK)
{
printf("HOST_USR_INPUT state : user_input is ok\r\n");
if((phost->class_cb->Init(pdev, phost))\
== USBH_OK)
{
phost->gState = HOST_CLASS_REQUEST;
}
}
// printf("GINTSTS :%X\r\n",(pdev->regs.GREGS->GINTSTS));
break;
case HOST_CLASS_REQUEST:
/* process class standard contol requests state machine */
status = phost->class_cb->Requests(pdev, phost);
if(status == USBH_OK)
{
printf("HOST_CLASS_REQUEST state : contol requests is ok and host class is enter\r\n");
phost->gState = HOST_CLASS;
#if 0
// USB_OTG_WRITE_REG32(&pdev->regs.HREGS->HFNUM,0X43FD039B);
printf("GRXSTSR: %X\r\n", USB_OTG_READ_REG32(&pdev->regs.GREGS->GRXSTSR));
printf("HNPTXSTS: %X\r\n", USB_OTG_READ_REG32(&pdev->regs.GREGS->HNPTXSTS));
printf("HFNUM: %X\r\n", USB_OTG_READ_REG32(&pdev->regs.HREGS->HFNUM));
printf("HNPTXSTS: %X\r\n", USB_OTG_READ_REG32(&pdev->regs.GREGS->HNPTXSTS));
printf("DIEPTSIZ: %X\r\n", USB_OTG_READ_REG32(&pdev->regs.INEP_REGS[8]->DIEPCTL ));
printf("DIEPDMA: %X\r\n", USB_OTG_READ_REG32(&pdev->regs.INEP_REGS[8]->DIEPDMA ));
printfpdev_reg(pdev);
#endif
}
else
{
USBH_ErrorHandle(phost, status);
}
break;
case HOST_CLASS:
/* process class state machine */
status = phost->class_cb->Machine(pdev, phost);
USBH_ErrorHandle(phost, status);
break;
case HOST_CTRL_XFER:
/* process control transfer state machine */
printf("HOST_CTRL_XFER\r\n");
USBH_HandleControl(pdev, phost);
break;
case HOST_SUSPENDED:
printf("HOST_SUSPENDED\r\n");
break;
case HOST_ERROR_STATE:
/* Re-Initilaize Host for new Enumeration */
USBH_DeInit(pdev, phost);
phost->usr_cb->DeInit();
phost->class_cb->DeInit(pdev, &phost->device_prop);
break;
case HOST_DEV_DISCONNECTED :
/* Manage User disconnect operations*/
phost->usr_cb->DeviceDisconnected();//user µ÷ÓÃ
/* Re-Initilaize Host for new Enumeration */
USBH_DeInit(pdev, phost);
phost->usr_cb->DeInit();
phost->class_cb->DeInit(pdev, &phost->device_prop);
USBH_DeAllocate_AllChannel(pdev);
phost->gState = HOST_IDLE;
// NVIC_SystemReset();
break;
default :
break;
}
}