You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
315 lines
7.4 KiB
315 lines
7.4 KiB
/*
|
|
* Copyright (c) 2006-2025, RT-Thread Development Team
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2025-11-07 RealThread the first version
|
|
*/
|
|
|
|
#include "drv_otghs_host.h"
|
|
#include <rtthread.h>
|
|
#include <rtdevice.h>
|
|
#include "board.h"
|
|
|
|
#include "drv_usb_hw.h"
|
|
|
|
#if defined(BSP_USING_USB) && defined(RT_USING_USB_HOST)
|
|
|
|
#define OTG_FS_PORT 1
|
|
|
|
usb_core_driver gd_usb_core;
|
|
|
|
static struct rt_completion urb_completion;
|
|
static volatile rt_bool_t connect_status = RT_FALSE;
|
|
|
|
void usbh_connect_callback(usb_core_driver *hhcd)
|
|
{
|
|
uhcd_t hcd = (uhcd_t)hhcd->host.data;
|
|
if (!connect_status)
|
|
{
|
|
connect_status = RT_TRUE;
|
|
rt_usbh_root_hub_connect_handler(hcd, OTG_FS_PORT, RT_FALSE);
|
|
}
|
|
}
|
|
|
|
void usbh_disconnect_callback(usb_core_driver *hhcd)
|
|
{
|
|
uhcd_t hcd = (uhcd_t)hhcd->host.data;
|
|
if (connect_status)
|
|
{
|
|
connect_status = RT_FALSE;
|
|
rt_usbh_root_hub_disconnect_handler(hcd, OTG_FS_PORT);
|
|
}
|
|
}
|
|
|
|
void usbh_hc_notifyurbchange_callback(usb_core_driver *hhcd, uint8_t chnum, usb_urb_state urb_state)
|
|
{
|
|
rt_completion_done(&urb_completion);
|
|
}
|
|
|
|
static rt_err_t drv_reset_port(rt_uint8_t port)
|
|
{
|
|
usb_port_reset(&gd_usb_core);
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
static int drv_pipe_xfer(upipe_t pipe, rt_uint8_t token, void *buffer, int nbytes, int timeout)
|
|
{
|
|
while (1)
|
|
{
|
|
uint8_t dir = (pipe->ep.bEndpointAddress & 0x80) >> 7;
|
|
|
|
if (!connect_status)
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
rt_completion_init(&urb_completion);
|
|
|
|
if (dir == 0)
|
|
{
|
|
if (token == 0)
|
|
{
|
|
usbh_ctlsetup_send(&gd_usb_core, buffer, pipe->pipe_index);
|
|
}
|
|
else
|
|
{
|
|
usbh_data_send(&gd_usb_core, buffer, pipe->pipe_index, nbytes);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
usbh_data_recev(&gd_usb_core, buffer, pipe->pipe_index, nbytes);
|
|
}
|
|
|
|
|
|
rt_completion_wait(&urb_completion, timeout);
|
|
|
|
rt_thread_mdelay(1);
|
|
|
|
if (usbh_urbstate_get(&gd_usb_core, pipe->pipe_index) == URB_NOTREADY)
|
|
{
|
|
if (pipe->ep.bmAttributes == USB_EP_ATTR_INT)
|
|
{
|
|
rt_thread_delay((pipe->ep.bInterval * RT_TICK_PER_SECOND / 1000) > 0 ? (pipe->ep.bInterval * RT_TICK_PER_SECOND / 1000) : 1);
|
|
}
|
|
|
|
usb_pipe_halt(&gd_usb_core, pipe->pipe_index);
|
|
|
|
usbh_pipe_create(&gd_usb_core,
|
|
pipe->inst->address,
|
|
(uint8_t)PORT_SPEED_FULL,
|
|
pipe->pipe_index,
|
|
pipe->ep.bEndpointAddress,
|
|
pipe->ep.bmAttributes,
|
|
pipe->ep.wMaxPacketSize);
|
|
continue;
|
|
}
|
|
else if (usbh_urbstate_get(&gd_usb_core, pipe->pipe_index) == URB_STALL)
|
|
{
|
|
pipe->status = UPIPE_STATUS_STALL;
|
|
if (pipe->callback != RT_NULL)
|
|
{
|
|
pipe->callback(pipe);
|
|
}
|
|
return -1;
|
|
}
|
|
else if (usbh_urbstate_get(&gd_usb_core, pipe->pipe_index) == URB_ERROR)
|
|
{
|
|
pipe->status = UPIPE_STATUS_ERROR;
|
|
if (pipe->callback != RT_NULL)
|
|
{
|
|
pipe->callback(pipe);
|
|
}
|
|
return -1;
|
|
}
|
|
else if (usbh_urbstate_get(&gd_usb_core, pipe->pipe_index) == URB_DONE)
|
|
{
|
|
pipe->status = UPIPE_STATUS_OK;
|
|
if (pipe->callback != RT_NULL)
|
|
{
|
|
pipe->callback(pipe);
|
|
}
|
|
if (pipe->ep.bEndpointAddress & 0x80)
|
|
{
|
|
return usbh_xfercount_get(&gd_usb_core, pipe->pipe_index);
|
|
}
|
|
return nbytes;
|
|
}
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
static rt_uint16_t pipe_index = 0;
|
|
static rt_uint8_t drv_get_free_pipe_index()
|
|
{
|
|
rt_uint8_t idx;
|
|
for (idx = 1; idx < 16; idx++)
|
|
{
|
|
if (!(pipe_index & (0x01 << idx)))
|
|
{
|
|
pipe_index |= (0x01 << idx);
|
|
return (idx - 1);
|
|
}
|
|
}
|
|
return 0xff;
|
|
}
|
|
|
|
static void drv_free_pipe_index(rt_uint8_t index)
|
|
{
|
|
pipe_index &= ~(0x01 << index);
|
|
}
|
|
|
|
static rt_err_t drv_open_pipe(upipe_t pipe)
|
|
{
|
|
pipe->pipe_index = drv_get_free_pipe_index();
|
|
|
|
usbh_pipe_create(&gd_usb_core,
|
|
pipe->inst->address,
|
|
(uint8_t)PORT_SPEED_FULL,
|
|
pipe->pipe_index,
|
|
pipe->ep.bEndpointAddress,
|
|
pipe->ep.bmAttributes,
|
|
pipe->ep.wMaxPacketSize);
|
|
|
|
/* Set DATA0 PID token*/
|
|
if (gd_usb_core.host.pipe[pipe->pipe_index].ep.dir)
|
|
{
|
|
gd_usb_core.host.pipe[pipe->pipe_index].data_toggle_in = 0;
|
|
}
|
|
else
|
|
{
|
|
gd_usb_core.host.pipe[pipe->pipe_index].data_toggle_out = 0;
|
|
}
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
static rt_err_t drv_close_pipe(upipe_t pipe)
|
|
{
|
|
usb_pipe_halt(&gd_usb_core, pipe->pipe_index);
|
|
|
|
drv_free_pipe_index(pipe->pipe_index);
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
struct uhcd_ops _uhcd_ops = {
|
|
drv_reset_port,
|
|
drv_pipe_xfer,
|
|
drv_open_pipe,
|
|
drv_close_pipe,
|
|
};
|
|
|
|
static rt_err_t gd32_hcd_init(rt_device_t device)
|
|
{
|
|
usb_rcu_config();
|
|
|
|
usb_timer_init();
|
|
|
|
/* configure GPIO pin used for switching VBUS power and charge pump I/O */
|
|
usb_vbus_config();
|
|
|
|
uint8_t i = 0U;
|
|
|
|
#ifdef USE_USBHS0
|
|
|
|
#ifdef USE_USB_FS
|
|
usb_para_init(&gd_usb_core, USBHS0, USB_SPEED_FULL);
|
|
#endif
|
|
|
|
#ifdef USE_USB_HS
|
|
usb_para_init(&gd_usb_core, USBHS0, USB_SPEED_HIGH);
|
|
#endif
|
|
|
|
#endif /* USE_USBHS0 */
|
|
|
|
#ifdef USE_USBHS1
|
|
|
|
#ifdef USE_USB_FS
|
|
usb_para_init(&gd_usb_core, USBHS1, USB_SPEED_FULL);
|
|
#endif
|
|
|
|
#ifdef USE_USB_HS
|
|
usb_para_init(&gd_usb_core, USBHS1, USB_SPEED_HIGH);
|
|
#endif
|
|
|
|
#endif /* USE_USBHS1 */
|
|
|
|
gd_usb_core.host.connect_status = 0U;
|
|
|
|
for (i = 0U; i < USBHS_MAX_TX_FIFOS; i++)
|
|
{
|
|
gd_usb_core.host.pipe[i].err_count = 0U;
|
|
gd_usb_core.host.pipe[i].pp_status = PIPE_IDLE;
|
|
gd_usb_core.host.backup_xfercount[i] = 0U;
|
|
}
|
|
|
|
gd_usb_core.host.pipe[0].ep.mps = 8U;
|
|
|
|
usb_basic_init(&gd_usb_core.bp, &gd_usb_core.regs);
|
|
|
|
usb_globalint_disable(&gd_usb_core.regs);
|
|
|
|
usb_core_init(gd_usb_core.bp, &gd_usb_core.regs);
|
|
|
|
#ifndef USE_OTG_MODE
|
|
usb_curmode_set(&gd_usb_core.regs, HOST_MODE);
|
|
#endif /* USE_OTG_MODE */
|
|
|
|
usb_host_init(&gd_usb_core);
|
|
|
|
usb_globalint_enable(&gd_usb_core.regs);
|
|
|
|
#ifdef USE_USB_HS
|
|
#ifdef USE_USBHS0
|
|
pllusb_rcu_config(USBHS0);
|
|
#elif defined USE_USBHS1
|
|
pllusb_rcu_config(USBHS1);
|
|
#else
|
|
#endif
|
|
#endif /* USE_USB_HS */
|
|
|
|
/* enable interrupts */
|
|
usb_intr_config();
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
int gd_usbh_register(void)
|
|
{
|
|
rt_err_t res = -RT_ERROR;
|
|
|
|
uhcd_t uhcd = (uhcd_t)rt_malloc(sizeof(struct uhcd));
|
|
if (uhcd == RT_NULL)
|
|
{
|
|
rt_kprintf("uhcd malloc failed\r\n");
|
|
return -RT_ERROR;
|
|
}
|
|
|
|
rt_memset((void *)uhcd, 0, sizeof(struct uhcd));
|
|
uhcd->parent.type = RT_Device_Class_USBHost;
|
|
uhcd->parent.init = gd32_hcd_init;
|
|
uhcd->parent.user_data = &gd_usb_core;
|
|
|
|
uhcd->ops = &_uhcd_ops;
|
|
uhcd->num_ports = OTG_FS_PORT;
|
|
gd_usb_core.host.data = uhcd;
|
|
|
|
res = rt_device_register(&uhcd->parent, "usbh", RT_DEVICE_FLAG_DEACTIVATE);
|
|
if (res != RT_EOK)
|
|
{
|
|
rt_kprintf("register usb host failed res = %d\r\n", res);
|
|
return -RT_ERROR;
|
|
}
|
|
|
|
rt_usb_host_init("usbh");
|
|
|
|
return RT_EOK;
|
|
}
|
|
INIT_DEVICE_EXPORT(gd_usbh_register);
|
|
|
|
#endif /* BSP_USING_USB && RT_USING_USB_HOST */
|
|
|