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.
291 lines
10 KiB
291 lines
10 KiB
/* |
|
* Copyright 2024 NXP |
|
* |
|
* SPDX-License-Identifier: Apache-2.0 |
|
*/ |
|
|
|
#define DT_DRV_COMPAT nxp_uhc_ohci |
|
|
|
#include <soc.h> |
|
#include <string.h> |
|
#include <stdio.h> |
|
#include <zephyr/device.h> |
|
#include <zephyr/kernel.h> |
|
#include <zephyr/sys/byteorder.h> |
|
#include <zephyr/init.h> |
|
#include <zephyr/sys/byteorder.h> |
|
#include <zephyr/drivers/usb/uhc.h> |
|
#include <zephyr/drivers/pinctrl.h> |
|
|
|
#include "uhc_common.h" |
|
#include "usb.h" |
|
#include "usb_host_config.h" |
|
#include "usb_host_mcux_drv_port.h" |
|
#include "uhc_mcux_common.h" |
|
#include "usb_host_ohci.h" |
|
|
|
#include <zephyr/logging/log.h> |
|
LOG_MODULE_DECLARE(uhc_mcux); |
|
|
|
K_MEM_SLAB_DEFINE_STATIC(mcux_uhc_transfer_pool, sizeof(usb_host_transfer_t), |
|
USB_HOST_CONFIG_MAX_TRANSFERS, sizeof(void *)); |
|
|
|
#define PRV_DATA_HANDLE(_handle) CONTAINER_OF(_handle, struct uhc_mcux_data, mcux_host) |
|
|
|
static void uhc_mcux_thread(void *p1, void *p2, void *p3) |
|
{ |
|
const struct device *dev = p1; |
|
struct uhc_mcux_data *priv = uhc_get_private(dev); |
|
|
|
while (true) { |
|
USB_HostOhciTaskFunction((void *)(&priv->mcux_host)); |
|
} |
|
} |
|
|
|
static void uhc_mcux_isr(const struct device *dev) |
|
{ |
|
struct uhc_mcux_data *priv = uhc_get_private(dev); |
|
|
|
USB_HostOhciIsrFunction((void *)(&priv->mcux_host)); |
|
} |
|
|
|
/* MCUX controller dirver uses this callback to notify upper layer suspend related event */ |
|
static usb_status_t mcux_host_callback(usb_device_handle deviceHandle, |
|
usb_host_configuration_handle configurationHandle, |
|
uint32_t eventCode) |
|
{ |
|
/* TODO: nothing need to do here currently. |
|
* It will be used when implementing suspend/resume in future. |
|
*/ |
|
return kStatus_USB_Success; |
|
} |
|
|
|
static int uhc_mcux_init(const struct device *dev) |
|
{ |
|
const struct uhc_mcux_config *config = dev->config; |
|
struct uhc_mcux_data *priv = uhc_get_private(dev); |
|
k_thread_entry_t thread_entry = NULL; |
|
usb_status_t status; |
|
|
|
if ((priv->controller_id >= kUSB_ControllerOhci0) && |
|
(priv->controller_id <= kUSB_ControllerOhci1)) { |
|
thread_entry = uhc_mcux_thread; |
|
} |
|
|
|
if (thread_entry == NULL) { |
|
return -ENOMEM; |
|
} |
|
|
|
priv->dev = dev; |
|
/* Init MCUX USB host driver. */ |
|
priv->mcux_host.deviceCallback = mcux_host_callback; |
|
status = priv->mcux_if->controllerCreate(priv->controller_id, &priv->mcux_host, |
|
&(priv->mcux_host.controllerHandle)); |
|
if (status != kStatus_USB_Success) { |
|
return -ENOMEM; |
|
} |
|
|
|
/* Create MCUX USB host driver task */ |
|
k_thread_create(&priv->drv_stack_data, config->drv_stack, CONFIG_UHC_NXP_THREAD_STACK_SIZE, |
|
thread_entry, (void *)dev, NULL, NULL, K_PRIO_COOP(2), 0, K_NO_WAIT); |
|
k_thread_name_set(&priv->drv_stack_data, "uhc_mcux_ohci"); |
|
|
|
return 0; |
|
} |
|
|
|
/* MCUX hal controller driver transfer callback */ |
|
static void uhc_mcux_transfer_callback(void *param, usb_host_transfer_t *transfer, |
|
usb_status_t status) |
|
{ |
|
const struct device *dev = (const struct device *)param; |
|
struct uhc_transfer *const xfer = (struct uhc_transfer *const)(transfer->uhc_xfer); |
|
int err = -EIO; |
|
|
|
if (status == kStatus_USB_Success) { |
|
err = 0; |
|
|
|
if ((xfer->ep == 0) && (transfer->setupPacket->bRequest == USB_SREQ_SET_ADDRESS)) { |
|
usb_host_pipe_t *mcux_ep; |
|
|
|
/* MCUX hal controller driver needs set the ep0's address |
|
* by using kUSB_HostUpdateControlEndpointAddress after set_address. |
|
* When executing kUSB_HostUpdateControlEndpointAddress, |
|
* USB_HostHelperGetPeripheralInformation is called from MCUX hal |
|
* controller driver to get the address. But |
|
* USB_HostHelperGetPeripheralInformation can't get right address for udev |
|
* before this set_address control transfer result call back to host stack. |
|
* So, add one flag and execute kUSB_HostUpdateControlEndpointAddress later |
|
* when there is ep0 transfer. |
|
*/ |
|
mcux_ep = uhc_mcux_init_hal_ep(dev, xfer); |
|
if (mcux_ep != NULL) { |
|
mcux_ep->update_addr = 1U; |
|
} |
|
} |
|
} |
|
|
|
if ((xfer->buf != NULL) && (transfer->transferBuffer != NULL)) { |
|
if (transfer->transferSofar > 0) { |
|
net_buf_add(xfer->buf, transfer->transferSofar); |
|
} |
|
} |
|
|
|
transfer->setupPacket = NULL; |
|
transfer->transferBuffer = NULL; |
|
k_mem_slab_free(&mcux_uhc_transfer_pool, transfer); |
|
uhc_xfer_return(dev, xfer, err); |
|
} |
|
|
|
static usb_host_transfer_t *uhc_mcux_hal_init_transfer(const struct device *dev, |
|
usb_host_pipe_handle mcux_ep_handle, |
|
struct uhc_transfer *const xfer) |
|
{ |
|
usb_host_transfer_t *mcux_xfer; |
|
|
|
if (k_mem_slab_alloc(&mcux_uhc_transfer_pool, (void **)&mcux_xfer, K_NO_WAIT)) { |
|
return NULL; |
|
} |
|
(void)uhc_mcux_hal_init_transfer_common(dev, mcux_xfer, mcux_ep_handle, xfer, |
|
uhc_mcux_transfer_callback); |
|
|
|
return mcux_xfer; |
|
} |
|
|
|
static int uhc_mcux_enqueue(const struct device *dev, struct uhc_transfer *const xfer) |
|
{ |
|
usb_host_pipe_t *mcux_ep; |
|
struct uhc_mcux_data *priv = uhc_get_private(dev); |
|
usb_status_t status; |
|
usb_host_transfer_t *mcux_xfer; |
|
|
|
uhc_xfer_append(dev, xfer); |
|
|
|
/* firstly check and init the mcux endpoint handle */ |
|
mcux_ep = uhc_mcux_init_hal_ep(dev, xfer); |
|
if (mcux_ep == NULL) { |
|
return -ENOMEM; |
|
} |
|
|
|
/* Initialize MCUX hal transfer. */ |
|
mcux_xfer = uhc_mcux_hal_init_transfer(dev, mcux_ep, xfer); |
|
if (mcux_xfer == NULL) { |
|
return -ENOMEM; |
|
} |
|
|
|
if (mcux_ep->endpointAddress == 0 && mcux_ep->update_addr) { |
|
mcux_ep->update_addr = 0; |
|
/* update control endpoint address here */ |
|
uhc_mcux_control(dev, kUSB_HostUpdateControlEndpointAddress, mcux_ep); |
|
} |
|
|
|
uhc_mcux_lock(dev); |
|
/* give the transfer to MCUX drv. */ |
|
status = priv->mcux_if->controllerWritePipe(priv->mcux_host.controllerHandle, |
|
mcux_ep, mcux_xfer); |
|
uhc_mcux_unlock(dev); |
|
if (status != kStatus_USB_Success) { |
|
return -ENOMEM; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static inline void uhc_mcux_get_hal_driver_id(struct uhc_mcux_data *priv, |
|
const struct uhc_mcux_config *config) |
|
{ |
|
/* |
|
* MCUX USB controller drivers use an ID to tell the HAL drivers |
|
* which controller is being used. This part of the code converts |
|
* the base address to the ID value. |
|
*/ |
|
uintptr_t usb_base_addrs[] = USBFSH_BASE_ADDRS; |
|
|
|
/* get the right controller id */ |
|
priv->controller_id = 0xFFu; /* invalid value */ |
|
for (uint8_t i = 0; i < ARRAY_SIZE(usb_base_addrs); i++) { |
|
if (usb_base_addrs[i] == config->base) { |
|
priv->controller_id = kUSB_ControllerOhci0 + i; |
|
break; |
|
} |
|
} |
|
} |
|
|
|
static int uhc_mcux_driver_preinit(const struct device *dev) |
|
{ |
|
const struct uhc_mcux_config *config = dev->config; |
|
struct uhc_data *data = dev->data; |
|
struct uhc_mcux_data *priv = uhc_get_private(dev); |
|
|
|
uhc_mcux_get_hal_driver_id(priv, config); |
|
if (priv->controller_id == 0xFFu) { |
|
return -ENOMEM; |
|
} |
|
|
|
k_mutex_init(&data->mutex); |
|
pinctrl_apply_state(config->pincfg, PINCTRL_STATE_DEFAULT); |
|
LOG_DBG("MCUX controller initialized"); |
|
|
|
return 0; |
|
} |
|
|
|
static const struct uhc_api mcux_uhc_api = { |
|
.lock = uhc_mcux_lock, |
|
.unlock = uhc_mcux_unlock, |
|
.init = uhc_mcux_init, |
|
.enable = uhc_mcux_enable, |
|
.disable = uhc_mcux_disable, |
|
.shutdown = uhc_mcux_shutdown, |
|
|
|
.bus_reset = uhc_mcux_bus_reset, |
|
.sof_enable = uhc_mcux_sof_enable, |
|
.bus_suspend = uhc_mcux_bus_suspend, |
|
.bus_resume = uhc_mcux_bus_resume, |
|
|
|
.ep_enqueue = uhc_mcux_enqueue, |
|
.ep_dequeue = uhc_mcux_dequeue, |
|
}; |
|
|
|
static const usb_host_controller_interface_t uhc_mcux_if = { |
|
USB_HostOhciCreate, USB_HostOhciDestory, USB_HostOhciOpenPipe, USB_HostOhciClosePipe, |
|
USB_HostOhciWritePipe, USB_HostOhciReadPipe, USB_HostOhciIoctl, |
|
}; |
|
|
|
#define UHC_MCUX_OHCI_DEVICE_DEFINE(n) \ |
|
static void uhc_irq_enable_func##n(const struct device *dev) \ |
|
{ \ |
|
IRQ_CONNECT(DT_INST_IRQN(n), DT_INST_IRQ(n, priority), uhc_mcux_isr, \ |
|
DEVICE_DT_INST_GET(n), 0); \ |
|
\ |
|
irq_enable(DT_INST_IRQN(n)); \ |
|
} \ |
|
\ |
|
static void uhc_irq_disable_func##n(const struct device *dev) \ |
|
{ \ |
|
irq_disable(DT_INST_IRQN(n)); \ |
|
} \ |
|
\ |
|
static K_KERNEL_STACK_DEFINE(drv_stack_##n, CONFIG_UHC_NXP_THREAD_STACK_SIZE); \ |
|
\ |
|
PINCTRL_DT_INST_DEFINE(n); \ |
|
\ |
|
static struct uhc_mcux_config priv_config_##n = { \ |
|
.base = DT_INST_REG_ADDR(n), \ |
|
.irq_enable_func = uhc_irq_enable_func##n, \ |
|
.irq_disable_func = uhc_irq_disable_func##n, \ |
|
.drv_stack = drv_stack_##n, \ |
|
.pincfg = PINCTRL_DT_INST_DEV_CONFIG_GET(n), \ |
|
}; \ |
|
\ |
|
static struct uhc_mcux_data priv_data_##n = { \ |
|
.mcux_if = &uhc_mcux_if, \ |
|
}; \ |
|
\ |
|
static struct uhc_data uhc_data_##n = { \ |
|
.mutex = Z_MUTEX_INITIALIZER(uhc_data_##n.mutex), \ |
|
.priv = &priv_data_##n, \ |
|
}; \ |
|
\ |
|
DEVICE_DT_INST_DEFINE(n, uhc_mcux_driver_preinit, NULL, &uhc_data_##n, &priv_config_##n, \ |
|
POST_KERNEL, CONFIG_KERNEL_INIT_PRIORITY_DEVICE, &mcux_uhc_api); |
|
|
|
DT_INST_FOREACH_STATUS_OKAY(UHC_MCUX_OHCI_DEVICE_DEFINE)
|
|
|