michaelh/zephyr
1
0
Fork 0
Code Releases Activity

drivers: usb_dc_mcux_ehci: fix style, variables name

Browse source 
Fix style, variables name, defines.

Signed-off-by: Johann Fischer <j.fischer@phytec.de>
This commit is contained in:
Johann Fischer 2019-12-02 17:00:27 +01:00 • committed by Carles Cufí
commit b04715b3b9
1 changed files with 115 additions and 111 deletions
Download patch file Download diff file Expand all files Collapse all files

226
drivers/usb/device/usb_dc_mcux_ehci.c
View file

@ -26,16 +26,20 @@ static void usb_isr_handler(void);
extern void USB_DeviceEhciIsrFunction(void *deviceHandle);
/* the setup transfer state */
#define SETUP_DATA_STAGE_DONE (0)
#define SETUP_DATA_STAGE_IN (1)
#define SETUP_DATA_STAGE_OUT (2)
#define SETUP_DATA_STAGE_DONE (0)
#define SETUP_DATA_STAGE_IN (1)
#define SETUP_DATA_STAGE_OUT (2)
/* Then endpoint number/index calculation */
#define EP_ADDR2IDX(ep) ((ep) & ~USB_EP_DIR_MASK)
#define EP_ADDR2DIR(ep) ((ep) & USB_EP_DIR_MASK)
#define EP_ABS_IDX(ep) (((ep) & ~USB_EP_DIR_MASK) * 2 + (((ep) & USB_EP_DIR_MASK) >> 7))
#define NUM_OF_EP_MAX DT_USBD_MCUX_EHCI_NUM_BIDIR_EP
#define EP_ADDR2IDX(ep) ((ep) & ~USB_EP_DIR_MASK)
#define EP_ADDR2DIR(ep) ((ep) & USB_EP_DIR_MASK)
#define EP_ABS_IDX(ep) (((ep) & ~USB_EP_DIR_MASK) * 2 + \
(((ep) & USB_EP_DIR_MASK) >> 7))
#define NUM_OF_EP_MAX DT_USBD_MCUX_EHCI_NUM_BIDIR_EP
/* The minimum value is 1 */
#define EP_BUF_NUMOF_BLOCKS ((NUM_OF_EP_MAX + 3) / 4)
#define EP_BUF_NUMOF_BLOCKS ((NUM_OF_EP_MAX + 3) / 4)
/* The max MPS is 1023 for FS, 1024 for HS. */
#if defined(CONFIG_NOCACHE_MEMORY)
#define EP_BUF_NONCACHED
@ -45,7 +49,7 @@ K_MEM_POOL_DEFINE(ep_buf_pool, 16, 1024, EP_BUF_NUMOF_BLOCKS, 4);
#endif
static usb_ep_ctrl_data_t s_ep_ctrl[NUM_OF_EP_MAX];
static usb_device_struct_t s_Device;
static usb_device_struct_t dev_data;
#if ((defined(USB_DEVICE_CONFIG_EHCI)) && (USB_DEVICE_CONFIG_EHCI > 0U))
/* EHCI device driver interface */
@ -57,10 +61,10 @@ static const usb_device_controller_interface_struct_t s_UsbDeviceEhciInterface =
int usb_dc_reset(void)
{
if (s_Device.controllerHandle != NULL) {
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlStop, NULL);
s_Device.interface->deviceDeinit(s_Device.controllerHandle);
s_Device.controllerHandle = NULL;
if (dev_data.controllerHandle != NULL) {
dev_data.interface->deviceControl(dev_data.controllerHandle, kUSB_DeviceControlStop, NULL);
dev_data.interface->deviceDeinit(dev_data.controllerHandle);
dev_data.controllerHandle = NULL;
}
return 0;
@ -68,13 +72,13 @@ int usb_dc_reset(void)
int usb_dc_attach(void)
{
s_Device.eps = &s_ep_ctrl[0];
if (s_Device.attached) {
dev_data.eps = &s_ep_ctrl[0];
if (dev_data.attached) {
LOG_WRN("already attached");
return 0;
}
s_Device.interface = (const usb_device_controller_interface_struct_t *)(&s_UsbDeviceEhciInterface);
if (kStatus_USB_Success != s_Device.interface->deviceInit(CONTROLLER_ID, &s_Device, &s_Device.controllerHandle)) {
dev_data.interface = (const usb_device_controller_interface_struct_t *)(&s_UsbDeviceEhciInterface);
if (kStatus_USB_Success != dev_data.interface->deviceInit(CONTROLLER_ID, &dev_data, &dev_data.controllerHandle)) {
return -EINVAL;
}
@ -82,28 +86,28 @@ int usb_dc_attach(void)
IRQ_CONNECT(DT_USBD_MCUX_EHCI_IRQ, DT_USBD_MCUX_EHCI_IRQ_PRI,
usb_isr_handler, 0, 0);
irq_enable(DT_USBD_MCUX_EHCI_IRQ);
s_Device.attached = 1;
dev_data.attached = 1;
LOG_DBG("attached");
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlRun, NULL);
dev_data.interface->deviceControl(dev_data.controllerHandle, kUSB_DeviceControlRun, NULL);
return 0;
}
int usb_dc_detach(void)
{
LOG_DBG("detached.");
if (s_Device.controllerHandle != NULL) {
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlStop, NULL);
s_Device.interface->deviceDeinit(s_Device.controllerHandle);
s_Device.controllerHandle = NULL;
if (dev_data.controllerHandle != NULL) {
dev_data.interface->deviceControl(dev_data.controllerHandle, kUSB_DeviceControlStop, NULL);
dev_data.interface->deviceDeinit(dev_data.controllerHandle);
dev_data.controllerHandle = NULL;
}
s_Device.attached = 0;
dev_data.attached = 0;
return 0;
}
int usb_dc_set_address(const u8_t addr)
{
LOG_DBG("");
s_Device.address = addr;
dev_data.address = addr;
return 0;
}
@ -139,15 +143,15 @@ int usb_dc_ep_check_cap(const struct usb_dc_ep_cfg_data *const cfg)
int usb_dc_ep_configure(const struct usb_dc_ep_cfg_data *const cfg)
{
u8_t ep_abs_idx = EP_ABS_IDX(cfg->ep_addr);
usb_device_endpoint_init_struct_t epInit;
usb_device_endpoint_init_struct_t ep_init;
struct k_mem_block *block;
struct usb_ep_ctrl_data *eps = &s_Device.eps[ep_abs_idx];
struct usb_ep_ctrl_data *eps = &dev_data.eps[ep_abs_idx];
epInit.zlt = 0U;
epInit.endpointAddress = cfg->ep_addr;
epInit.maxPacketSize = cfg->ep_mps;
epInit.transferType = cfg->ep_type;
s_Device.eps[ep_abs_idx].ep_type = cfg->ep_type;
ep_init.zlt = 0U;
ep_init.endpointAddress = cfg->ep_addr;
ep_init.maxPacketSize = cfg->ep_mps;
ep_init.transferType = cfg->ep_type;
dev_data.eps[ep_abs_idx].ep_type = cfg->ep_type;
if (ep_abs_idx >= NUM_OF_EP_MAX) {
LOG_ERR("Wrong endpoint index/address");
@ -167,19 +171,19 @@ int usb_dc_ep_configure(const struct usb_dc_ep_cfg_data *const cfg)
return -ENOMEM;
}
s_Device.eps[ep_abs_idx].ep_mps = cfg->ep_mps;
if (s_Device.eps[ep_abs_idx].ep_enabled) {
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlEndpointDeinit, (void *)(&cfg->ep_addr));
dev_data.eps[ep_abs_idx].ep_mps = cfg->ep_mps;
if (dev_data.eps[ep_abs_idx].ep_enabled) {
dev_data.interface->deviceControl(dev_data.controllerHandle, kUSB_DeviceControlEndpointDeinit, (void *)(&cfg->ep_addr));
}
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlEndpointInit, &epInit);
dev_data.interface->deviceControl(dev_data.controllerHandle, kUSB_DeviceControlEndpointInit, &ep_init);
/* if it is controlendpoint, controller will prime setup
* here set the occupied flag.
*/
if ((EP_ADDR2IDX(cfg->ep_addr) == USB_CONTROL_ENDPOINT) && (EP_ADDR2DIR(cfg->ep_addr) == USB_EP_DIR_OUT)) {
s_Device.eps[ep_abs_idx].ep_occupied = true;
dev_data.eps[ep_abs_idx].ep_occupied = true;
}
s_Device.eps[ep_abs_idx].ep_enabled = true;
dev_data.eps[ep_abs_idx].ep_enabled = true;
return 0;
}
@ -187,7 +191,7 @@ int usb_dc_ep_set_stall(const u8_t ep)
{
u8_t endpoint = ep;
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlEndpointStall, &endpoint);
dev_data.interface->deviceControl(dev_data.controllerHandle, kUSB_DeviceControlEndpointStall, &endpoint);
return 0;
}
@ -195,7 +199,7 @@ int usb_dc_ep_clear_stall(const u8_t ep)
{
u8_t endpoint = ep;
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlEndpointUnstall, &endpoint);
dev_data.interface->deviceControl(dev_data.controllerHandle, kUSB_DeviceControlEndpointUnstall, &endpoint);
return 0;
}
@ -210,7 +214,7 @@ int usb_dc_ep_is_stalled(const u8_t ep, u8_t *const stalled)
endpointStatus.endpointAddress = ep;
endpointStatus.endpointStatus = kUSB_DeviceEndpointStateIdle;
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlGetEndpointStatus, &endpointStatus);
dev_data.interface->deviceControl(dev_data.controllerHandle, kUSB_DeviceControlGetEndpointStatus, &endpointStatus);
*stalled = endpointStatus.endpointStatus;
return 0;
}
@ -230,22 +234,22 @@ int usb_dc_ep_enable(const u8_t ep)
if (!ep_abs_idx) {
return 0;
}
if (s_Device.eps[ep_abs_idx].ep_occupied) {
if (dev_data.eps[ep_abs_idx].ep_occupied) {
LOG_WRN("endpoint 0x%x already enabled", ep);
return -EALREADY;
}
if ((EP_ADDR2IDX(ep) != USB_CONTROL_ENDPOINT) && (EP_ADDR2DIR(ep) == USB_EP_DIR_OUT)) {
s_Device.interface->deviceRecv(s_Device.controllerHandle,
dev_data.interface->deviceRecv(dev_data.controllerHandle,
ep,
(u8_t *)s_Device.eps[ep_abs_idx].block.data,
(uint32_t)s_Device.eps[ep_abs_idx].ep_mps);
s_Device.eps[ep_abs_idx].ep_occupied = true;
(u8_t *)dev_data.eps[ep_abs_idx].block.data,
(uint32_t)dev_data.eps[ep_abs_idx].ep_mps);
dev_data.eps[ep_abs_idx].ep_occupied = true;
} else {
/* control enpoint just be enabled before enumeration,
* when running here, setup has been primed.
*/
s_Device.eps[ep_abs_idx].ep_occupied = true;
dev_data.eps[ep_abs_idx].ep_occupied = true;
}
return 0;
@ -255,8 +259,8 @@ int usb_dc_ep_disable(const u8_t ep)
{
u8_t ep_abs_idx = EP_ABS_IDX(ep);
s_Device.interface->deviceCancel(s_Device.controllerHandle, ep);
s_Device.eps[ep_abs_idx].ep_enabled = false;
dev_data.interface->deviceCancel(dev_data.controllerHandle, ep);
dev_data.eps[ep_abs_idx].ep_enabled = false;
return 0;
}
@ -279,11 +283,11 @@ int usb_dc_ep_write(const u8_t ep, const u8_t *const data,
const u32_t data_len, u32_t *const ret_bytes)
{
u8_t ep_abs_idx = EP_ABS_IDX(ep);
u8_t *buffer = (u8_t *)s_Device.eps[ep_abs_idx].block.data;
u8_t *buffer = (u8_t *)dev_data.eps[ep_abs_idx].block.data;
u32_t len_to_send;
if (data_len > s_Device.eps[ep_abs_idx].ep_mps) {
len_to_send = s_Device.eps[ep_abs_idx].ep_mps;
if (data_len > dev_data.eps[ep_abs_idx].ep_mps) {
len_to_send = dev_data.eps[ep_abs_idx].ep_mps;
} else {
len_to_send = data_len;
}
@ -294,7 +298,7 @@ int usb_dc_ep_write(const u8_t ep, const u8_t *const data,
#if defined(CONFIG_HAS_MCUX_CACHE) && !defined(EP_BUF_NONCACHED)
DCACHE_CleanByRange((uint32_t)buffer, len_to_send);
#endif
s_Device.interface->deviceSend(s_Device.controllerHandle,
dev_data.interface->deviceSend(dev_data.controllerHandle,
ep,
buffer,
len_to_send);
@ -312,7 +316,7 @@ int usb_dc_ep_read_wait(u8_t ep, u8_t *data, u32_t max_data_len,
u32_t data_len;
u8_t *bufp = NULL;
while (s_Device.eps[ep_abs_idx].ep_occupied) {
while (dev_data.eps[ep_abs_idx].ep_occupied) {
LOG_ERR("Endpoint is occupied by the controller");
return -EBUSY;
}
@ -328,8 +332,8 @@ int usb_dc_ep_read_wait(u8_t ep, u8_t *data, u32_t max_data_len,
/* it is control setup, we should use message.buffer,
* this buffer is from internal setup array.
*/
bufp = s_Device.eps[ep_abs_idx].transfer_message.buffer;
data_len = s_Device.eps[ep_abs_idx].transfer_message.length;
bufp = dev_data.eps[ep_abs_idx].transfer_message.buffer;
data_len = dev_data.eps[ep_abs_idx].transfer_message.length;
if (data_len == USB_UNINITIALIZED_VAL_32) {
if (read_bytes) {
*read_bytes = 0;
@ -359,21 +363,21 @@ int usb_dc_ep_read_wait(u8_t ep, u8_t *data, u32_t max_data_len,
}
if (EP_ADDR2IDX(ep) == USB_ENDPOINT_CONTROL) {
u8_t isSetup = s_Device.eps[0].transfer_message.isSetup;
u8_t *buffer = s_Device.eps[0].transfer_message.buffer;
u8_t isSetup = dev_data.eps[0].transfer_message.isSetup;
u8_t *buffer = dev_data.eps[0].transfer_message.buffer;
if (isSetup) {
if (((usb_setup_struct_t *)buffer)->wLength == 0) {
s_Device.setupDataStage = SETUP_DATA_STAGE_DONE;
dev_data.setupDataStage = SETUP_DATA_STAGE_DONE;
} else if (((usb_setup_struct_t *)buffer)->bmRequestType & USB_REQUEST_TYPE_DIR_MASK) {
s_Device.setupDataStage = SETUP_DATA_STAGE_IN;
dev_data.setupDataStage = SETUP_DATA_STAGE_IN;
} else {
s_Device.setupDataStage = SETUP_DATA_STAGE_OUT;
dev_data.setupDataStage = SETUP_DATA_STAGE_OUT;
}
} else {
if (s_Device.setupDataStage != SETUP_DATA_STAGE_DONE) {
if ((data_len >= max_data_len) || (data_len < s_Device.eps[0].ep_mps)) {
s_Device.setupDataStage = SETUP_DATA_STAGE_DONE;
if (dev_data.setupDataStage != SETUP_DATA_STAGE_DONE) {
if ((data_len >= max_data_len) || (data_len < dev_data.eps[0].ep_mps)) {
dev_data.setupDataStage = SETUP_DATA_STAGE_DONE;
}
}
}
@ -386,24 +390,24 @@ int usb_dc_ep_read_continue(u8_t ep)
/* select the index of the next endpoint buffer */
u8_t ep_abs_idx = EP_ABS_IDX(ep);
if (s_Device.eps[ep_abs_idx].ep_occupied) {
if (dev_data.eps[ep_abs_idx].ep_occupied) {
LOG_WRN("endpoint 0x%x already occupied", ep);
return -EBUSY;
}
if (EP_ADDR2IDX(ep) == USB_ENDPOINT_CONTROL) {
if (s_Device.setupDataStage == SETUP_DATA_STAGE_DONE) {
if (dev_data.setupDataStage == SETUP_DATA_STAGE_DONE) {
return 0;
}
if (s_Device.setupDataStage == SETUP_DATA_STAGE_IN) {
s_Device.setupDataStage = SETUP_DATA_STAGE_DONE;
if (dev_data.setupDataStage == SETUP_DATA_STAGE_IN) {
dev_data.setupDataStage = SETUP_DATA_STAGE_DONE;
}
}
s_Device.interface->deviceRecv(s_Device.controllerHandle,
dev_data.interface->deviceRecv(dev_data.controllerHandle,
ep,
(u8_t *)s_Device.eps[ep_abs_idx].block.data,
s_Device.eps[ep_abs_idx].ep_mps);
s_Device.eps[ep_abs_idx].ep_occupied = true;
(u8_t *)dev_data.eps[ep_abs_idx].block.data,
dev_data.eps[ep_abs_idx].ep_mps);
dev_data.eps[ep_abs_idx].ep_occupied = true;
return 0;
}
@ -434,49 +438,49 @@ int usb_dc_ep_set_callback(const u8_t ep, const usb_dc_ep_callback cb)
{
u8_t ep_abs_idx = EP_ABS_IDX(ep);
if (!s_Device.attached) {
if (!dev_data.attached) {
return -EINVAL;
}
s_Device.eps[ep_abs_idx].callback = cb;
dev_data.eps[ep_abs_idx].callback = cb;
return 0;
}
void usb_dc_set_status_callback(const usb_dc_status_callback cb)
{
s_Device.status_callback = cb;
dev_data.status_callback = cb;
}
int usb_dc_ep_mps(const u8_t ep)
{
u8_t ep_abs_idx = EP_ABS_IDX(ep);
return s_Device.eps[ep_abs_idx].ep_mps;
return dev_data.eps[ep_abs_idx].ep_mps;
}
static void control_endpoint_enable(void)
{
usb_device_endpoint_init_struct_t epInit;
usb_device_endpoint_init_struct_t ep_init;
u8_t ep_abs_idx = 0;
epInit.zlt = 0U;
epInit.transferType = USB_ENDPOINT_CONTROL;
epInit.maxPacketSize = EP0_MAX_PACKET_SIZE;
ep_init.zlt = 0U;
ep_init.transferType = USB_ENDPOINT_CONTROL;
ep_init.maxPacketSize = EP0_MAX_PACKET_SIZE;
epInit.endpointAddress = EP0_OUT;
ep_abs_idx = EP_ABS_IDX(epInit.endpointAddress);
s_Device.eps[ep_abs_idx].ep_mps = EP0_MAX_PACKET_SIZE;
ep_init.endpointAddress = EP0_OUT;
ep_abs_idx = EP_ABS_IDX(ep_init.endpointAddress);
dev_data.eps[ep_abs_idx].ep_mps = EP0_MAX_PACKET_SIZE;
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlEndpointInit, &epInit);
s_Device.eps[ep_abs_idx].ep_occupied = false;
s_Device.eps[ep_abs_idx].ep_enabled = true;
dev_data.interface->deviceControl(dev_data.controllerHandle, kUSB_DeviceControlEndpointInit, &ep_init);
dev_data.eps[ep_abs_idx].ep_occupied = false;
dev_data.eps[ep_abs_idx].ep_enabled = true;
epInit.endpointAddress = EP0_IN;
ep_abs_idx = EP_ABS_IDX(epInit.endpointAddress);
s_Device.eps[ep_abs_idx].ep_mps = EP0_MAX_PACKET_SIZE;
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlEndpointInit, &epInit);
s_Device.eps[ep_abs_idx].ep_occupied = false;
s_Device.eps[ep_abs_idx].ep_enabled = true;
ep_init.endpointAddress = EP0_IN;
ep_abs_idx = EP_ABS_IDX(ep_init.endpointAddress);
dev_data.eps[ep_abs_idx].ep_mps = EP0_MAX_PACKET_SIZE;
dev_data.interface->deviceControl(dev_data.controllerHandle, kUSB_DeviceControlEndpointInit, &ep_init);
dev_data.eps[ep_abs_idx].ep_occupied = false;
dev_data.eps[ep_abs_idx].ep_enabled = true;
}
/* Notify the up layer the KHCI status changed. */
@ -486,43 +490,43 @@ void USB_DeviceNotificationTrigger(void *handle, void *msg)
switch (message->code) {
case kUSB_DeviceNotifyBusReset:
s_Device.address = 0;
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlSetDefaultStatus, NULL);
dev_data.address = 0;
dev_data.interface->deviceControl(dev_data.controllerHandle, kUSB_DeviceControlSetDefaultStatus, NULL);
for (int i = 0; i < NUM_OF_EP_MAX; i++) {
s_Device.eps[i].ep_occupied = false;
s_Device.eps[i].ep_enabled = false;
dev_data.eps[i].ep_occupied = false;
dev_data.eps[i].ep_enabled = false;
}
control_endpoint_enable();
s_Device.status_callback(USB_DC_RESET, NULL);
dev_data.status_callback(USB_DC_RESET, NULL);
break;
case kUSB_DeviceNotifyError:
s_Device.status_callback(USB_DC_ERROR, NULL);
dev_data.status_callback(USB_DC_ERROR, NULL);
break;
case kUSB_DeviceNotifySuspend:
s_Device.status_callback(USB_DC_SUSPEND, NULL);
dev_data.status_callback(USB_DC_SUSPEND, NULL);
break;
case kUSB_DeviceNotifyResume:
s_Device.status_callback(USB_DC_RESUME, NULL);
dev_data.status_callback(USB_DC_RESUME, NULL);
break;
default:
{
u8_t ep_packet_type = 0;
u8_t ep_abs_idx = EP_ABS_IDX(message->code);
s_Device.eps[ep_abs_idx].transfer_message.length = message->length;
s_Device.eps[ep_abs_idx].transfer_message.isSetup = message->isSetup;
s_Device.eps[ep_abs_idx].transfer_message.code = message->code;
s_Device.eps[ep_abs_idx].transfer_message.buffer = message->buffer;
s_Device.eps[ep_abs_idx].ep_occupied = false;
dev_data.eps[ep_abs_idx].transfer_message.length = message->length;
dev_data.eps[ep_abs_idx].transfer_message.isSetup = message->isSetup;
dev_data.eps[ep_abs_idx].transfer_message.code = message->code;
dev_data.eps[ep_abs_idx].transfer_message.buffer = message->buffer;
dev_data.eps[ep_abs_idx].ep_occupied = false;
if (message->isSetup) {
ep_packet_type = USB_DC_EP_SETUP;
} else {
/* IN TOKEN */
if ((message->code & USB_REQUEST_TYPE_DIR_MASK) == USB_REQUEST_TYPE_DIR_IN) {
/* control endpoint 0 and status stage for setAddr transfer */
if ((s_Device.address != 0) && (ep_abs_idx == 1)) {
if ((dev_data.address != 0) && (ep_abs_idx == 1)) {
/* SET ADDRESS in the status stage in the IN transfer*/
s_Device.interface->deviceControl(s_Device.controllerHandle, kUSB_DeviceControlSetDeviceAddress, &s_Device.address);
s_Device.address = 0;
dev_data.interface->deviceControl(dev_data.controllerHandle, kUSB_DeviceControlSetDeviceAddress, &dev_data.address);
dev_data.address = 0;
}
ep_packet_type = USB_DC_EP_DATA_IN;
}
@ -531,14 +535,14 @@ void USB_DeviceNotificationTrigger(void *handle, void *msg)
ep_packet_type = USB_DC_EP_DATA_OUT;
}
}
if (s_Device.eps[ep_abs_idx].callback) {
if (dev_data.eps[ep_abs_idx].callback) {
#if defined(CONFIG_HAS_MCUX_CACHE) && !defined(EP_BUF_NONCACHED)
if (message->length) {
DCACHE_InvalidateByRange((uint32_t)message->buffer,
message->length);
}
#endif
s_Device.eps[ep_abs_idx].callback(message->code,
dev_data.eps[ep_abs_idx].callback(message->code,
ep_packet_type);
}
}
@ -547,5 +551,5 @@ void USB_DeviceNotificationTrigger(void *handle, void *msg)
static void usb_isr_handler(void)
{
USB_DeviceEhciIsrFunction(&s_Device);
USB_DeviceEhciIsrFunction(&dev_data);
}