diff options
| author | sakimusu <[email protected]> | 2022-02-01 23:02:59 +0800 |
|---|---|---|
| committer | sakimusu <[email protected]> | 2022-02-01 23:02:59 +0800 |
| commit | b44617212b6abc1cbce0d39b76dc4efbcbb9f612 (patch) | |
| tree | 91cb85265eceb86228d81f04acf0804d30b25133 /class | |
| parent | eff126805747bde37efda4e4e0d5f5d010e763f5 (diff) | |
add usb host stack(class not release completely)
Diffstat (limited to 'class')
| -rw-r--r-- | class/cdc/usbh_cdc_acm.c | 328 | ||||
| -rw-r--r-- | class/cdc/usbh_cdc_acm.h | 52 | ||||
| -rw-r--r-- | class/hid/usbh_hid.c | 270 | ||||
| -rw-r--r-- | class/hid/usbh_hid.h | 45 | ||||
| -rw-r--r-- | class/hub/usbh_hub.c | 488 | ||||
| -rw-r--r-- | class/hub/usbh_hub.h | 42 | ||||
| -rw-r--r-- | class/msc/usbh_msc.c | 359 | ||||
| -rw-r--r-- | class/msc/usbh_msc.h | 49 |
8 files changed, 1633 insertions, 0 deletions
diff --git a/class/cdc/usbh_cdc_acm.c b/class/cdc/usbh_cdc_acm.c new file mode 100644 index 00000000..ba4790fa --- /dev/null +++ b/class/cdc/usbh_cdc_acm.c @@ -0,0 +1,328 @@ +/**
+ * @file usbh_cdc_acm.c
+ *
+ * Copyright (c) 2022 sakumisu
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership. The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+#include "usbh_core.h"
+#include "usbh_cdc_acm.h"
+
+#define DEV_FORMAT "/dev/ttyACM%d"
+#define DEV_NAMELEN 16
+
+static uint32_t g_devinuse = 0;
+
+void usbh_cdc_acm_callback(void *arg, ssize_t nbytes);
+
+/****************************************************************************
+ * Name: usbh_cdc_acm_devno_alloc
+ *
+ * Description:
+ * Allocate a unique /dev/ttyACM[n] minor number in the range 0-31.
+ *
+ ****************************************************************************/
+
+static int usbh_cdc_acm_devno_alloc(struct usbh_cdc_acm *priv)
+{
+ uint32_t flags;
+ int devno;
+
+ flags = usb_osal_enter_critical_section();
+ for (devno = 0; devno < 32; devno++) {
+ uint32_t bitno = 1 << devno;
+ if ((g_devinuse & bitno) == 0) {
+ g_devinuse |= bitno;
+ priv->minor = devno;
+ usb_osal_leave_critical_section(flags);
+ return 0;
+ }
+ }
+
+ usb_osal_leave_critical_section(flags);
+ return -EMFILE;
+}
+
+/****************************************************************************
+ * Name: usbh_cdc_acm_devno_free
+ *
+ * Description:
+ * Free a /dev/ttyACM[n] minor number so that it can be used.
+ *
+ ****************************************************************************/
+
+static void usbh_cdc_acm_devno_free(struct usbh_cdc_acm *priv)
+{
+ int devno = priv->minor;
+
+ if (devno >= 0 && devno < 32) {
+ uint32_t flags = usb_osal_enter_critical_section();
+ g_devinuse &= ~(1 << devno);
+ usb_osal_leave_critical_section(flags);
+ }
+}
+
+/****************************************************************************
+ * Name: usbh_cdc_acm_mkdevname
+ *
+ * Description:
+ * Format a /dev/ttyACM[n] device name given a minor number.
+ *
+ ****************************************************************************/
+
+static inline void usbh_cdc_acm_mkdevname(struct usbh_cdc_acm *priv, char *devname)
+{
+ snprintf(devname, DEV_NAMELEN, DEV_FORMAT, priv->minor);
+}
+
+int usbh_cdc_acm_set_line_coding(struct usbh_hubport *hport, uint8_t intf, struct cdc_line_coding *line_coding)
+{
+ int ret;
+ struct usb_setup_packet *setup;
+ struct usbh_cdc_acm *cdc_acm_class = (struct usbh_cdc_acm *)hport->config.intf[intf].priv;
+
+ setup = cdc_acm_class->setup;
+
+ if (cdc_acm_class->ctrl_intf != intf) {
+ return -1;
+ }
+
+ setup->bmRequestType = USB_REQUEST_DIR_OUT | USB_REQUEST_CLASS | USB_REQUEST_RECIPIENT_INTERFACE;
+ setup->bRequest = CDC_REQUEST_SET_LINE_CODING;
+ setup->wValue = 0;
+ setup->wIndex = intf;
+ setup->wLength = 7;
+
+ ret = usbh_control_transfer(hport->ep0, setup, (uint8_t *)line_coding);
+ if (ret < 0) {
+ return ret;
+ }
+ memcpy(cdc_acm_class->linecoding, line_coding, sizeof(struct cdc_line_coding));
+ return 0;
+}
+
+int usbh_cdc_acm_get_line_coding(struct usbh_hubport *hport, uint8_t intf, struct cdc_line_coding *line_coding)
+{
+ int ret;
+ struct usb_setup_packet *setup;
+ struct usbh_cdc_acm *cdc_acm_class = (struct usbh_cdc_acm *)hport->config.intf[intf].priv;
+
+ setup = cdc_acm_class->setup;
+
+ if (cdc_acm_class->ctrl_intf != intf) {
+ return -1;
+ }
+
+ setup->bmRequestType = USB_REQUEST_DIR_IN | USB_REQUEST_CLASS | USB_REQUEST_RECIPIENT_INTERFACE;
+ setup->bRequest = CDC_REQUEST_GET_LINE_CODING;
+ setup->wValue = 0;
+ setup->wIndex = intf;
+ setup->wLength = 7;
+
+ ret = usbh_control_transfer(hport->ep0, setup, (uint8_t *)line_coding);
+ if (ret < 0) {
+ return ret;
+ }
+ memcpy(cdc_acm_class->linecoding, line_coding, sizeof(struct cdc_line_coding));
+ return 0;
+}
+
+int usbh_cdc_acm_set_line_state(struct usbh_hubport *hport, uint8_t intf, bool dtr, bool rts)
+{
+ int ret;
+ struct usb_setup_packet *setup;
+ struct usbh_cdc_acm *cdc_acm_class = (struct usbh_cdc_acm *)hport->config.intf[intf].priv;
+
+ setup = cdc_acm_class->setup;
+
+ if (cdc_acm_class->ctrl_intf != intf) {
+ return -1;
+ }
+
+ setup->bmRequestType = USB_REQUEST_DIR_OUT | USB_REQUEST_CLASS | USB_REQUEST_RECIPIENT_INTERFACE;
+ setup->bRequest = CDC_REQUEST_SET_CONTROL_LINE_STATE;
+ setup->wValue = (dtr << 0) | (rts << 1);
+ setup->wIndex = intf;
+ setup->wLength = 0;
+
+ ret = usbh_control_transfer(hport->ep0, setup, NULL);
+ if (ret < 0) {
+ return ret;
+ }
+
+ cdc_acm_class->dtr = dtr;
+ cdc_acm_class->rts = rts;
+
+ return 0;
+}
+USB_NOCACHE_RAM_SECTION uint8_t cdc_buffer[4096];
+
+int usbh_cdc_acm_connect(struct usbh_hubport *hport, uint8_t intf)
+{
+ struct usbh_endpoint_cfg ep_cfg = { 0 };
+ struct usb_endpoint_descriptor *ep_desc;
+ char devname[DEV_NAMELEN];
+ int ret;
+
+ struct usbh_cdc_acm *cdc_acm_class = usb_malloc(sizeof(struct usbh_cdc_acm));
+ if (cdc_acm_class == NULL) {
+ return -ENOMEM;
+ }
+
+ memset(cdc_acm_class, 0, sizeof(struct usbh_cdc_acm));
+
+ usbh_cdc_acm_devno_alloc(cdc_acm_class);
+ usbh_cdc_acm_mkdevname(cdc_acm_class, devname);
+
+ hport->config.intf[intf].priv = cdc_acm_class;
+ hport->config.intf[intf + 1].priv = cdc_acm_class;
+
+ cdc_acm_class->setup = usb_iomalloc(sizeof(struct usb_setup_packet));
+ cdc_acm_class->linecoding = usb_iomalloc(sizeof(struct cdc_line_coding));
+
+ cdc_acm_class->ctrl_intf = intf;
+ cdc_acm_class->data_intf = intf + 1;
+
+ cdc_acm_class->linecoding->dwDTERate = 115200;
+ cdc_acm_class->linecoding->bDataBits = 8;
+ cdc_acm_class->linecoding->bParityType = 0;
+ cdc_acm_class->linecoding->bCharFormat = 0;
+ ret = usbh_cdc_acm_set_line_coding(hport, intf, cdc_acm_class->linecoding);
+ if (ret < 0) {
+ return ret;
+ }
+
+ ret = usbh_cdc_acm_set_line_state(hport, intf, true, true);
+ if (ret < 0) {
+ return ret;
+ }
+
+#if 0
+ ep_desc = &hport->config.intf[intf].ep[0].ep_desc;
+ ep_cfg.ep_addr = ep_desc->bEndpointAddress;
+ ep_cfg.ep_type = ep_desc->bmAttributes & USB_ENDPOINT_TYPE_MASK;
+ ep_cfg.ep_mps = ep_desc->wMaxPacketSize;
+ ep_cfg.ep_interval = ep_desc->bInterval;
+ ep_cfg.hport = hport;
+ usbh_ep_alloc(&cdc_acm_class->intin, &ep_cfg);
+
+#endif
+ for (uint8_t i = 0; i < hport->config.intf[intf + 1].intf_desc.bNumEndpoints; i++) {
+ ep_desc = &hport->config.intf[intf + 1].ep[i].ep_desc;
+
+ ep_cfg.ep_addr = ep_desc->bEndpointAddress;
+ ep_cfg.ep_type = ep_desc->bmAttributes & USB_ENDPOINT_TYPE_MASK;
+ ep_cfg.ep_mps = ep_desc->wMaxPacketSize;
+ ep_cfg.ep_interval = ep_desc->bInterval;
+ ep_cfg.hport = hport;
+ if (ep_desc->bEndpointAddress & 0x80) {
+ usbh_ep_alloc(&cdc_acm_class->bulkin, &ep_cfg);
+ } else {
+ usbh_ep_alloc(&cdc_acm_class->bulkout, &ep_cfg);
+ }
+ }
+
+ USB_LOG_INFO("Register CDC ACM Class:%s\r\n", devname);
+
+ memset(cdc_buffer, 0, 512);
+ ret = usbh_ep_bulk_transfer(cdc_acm_class->bulkin, cdc_buffer, 512);
+ if (ret < 0) {
+ printf("bulk in error\r\n");
+ return ret;
+ }
+ printf("recv over:%d\r\n", ret);
+ for (size_t i = 0; i < ret; i++) {
+ printf("0x%02x ", cdc_buffer[i]);
+ }
+ printf("\r\n");
+ const uint8_t data1[10] = { 0x02, 0x00, 0x00, 0x00, 0x02, 0x02, 0x08, 0x14 };
+
+ memcpy(cdc_buffer, data1, 8);
+ ret = usbh_ep_bulk_transfer(cdc_acm_class->bulkout, cdc_buffer, 8);
+ if (ret < 0) {
+ printf("bulk out error\r\n");
+ return ret;
+ }
+ printf("send over:%d\r\n", ret);
+
+#if 0
+ usbh_ep_bulk_async_transfer(cdc_acm_class->bulkin, cdc_buffer, 512, usbh_cdc_acm_callback, NULL);
+#else
+ ret = usbh_ep_bulk_transfer(cdc_acm_class->bulkin, cdc_buffer, 512);
+ if (ret < 0) {
+ printf("bulk in error\r\n");
+ return ret;
+ }
+ printf("recv over:%d\r\n", ret);
+ for (size_t i = 0; i < ret; i++) {
+ printf("0x%02x ", cdc_buffer[i]);
+ }
+ printf("\r\n");
+#endif
+ return ret;
+}
+
+int usbh_cdc_acm_disconnect(struct usbh_hubport *hport, uint8_t intf)
+{
+ char devname[DEV_NAMELEN];
+ int ret = 0;
+
+ struct usbh_cdc_acm *cdc_acm_class = (struct usbh_cdc_acm *)hport->config.intf[intf].priv;
+
+ if (cdc_acm_class) {
+ usbh_cdc_acm_devno_free(cdc_acm_class);
+ usbh_cdc_acm_mkdevname(cdc_acm_class, devname);
+
+ if (cdc_acm_class->bulkin) {
+ ret = usb_ep_cancel(cdc_acm_class->bulkin);
+ if (ret < 0) {
+ }
+ usbh_ep_free(cdc_acm_class->bulkin);
+ }
+
+ if (cdc_acm_class->bulkout) {
+ ret = usb_ep_cancel(cdc_acm_class->bulkout);
+ if (ret < 0) {
+ }
+ usbh_ep_free(cdc_acm_class->bulkout);
+ }
+ if (cdc_acm_class->setup)
+ usb_iofree(cdc_acm_class->setup);
+ if (cdc_acm_class->linecoding)
+ usb_iofree(cdc_acm_class->linecoding);
+
+ usb_free(cdc_acm_class);
+
+ hport->config.intf[intf].priv = NULL;
+ hport->config.intf[intf + 1].priv = NULL;
+
+ USB_LOG_INFO("Unregister CDC ACM Class:%s\r\n", devname);
+ }
+
+ return ret;
+}
+
+void usb_cdc_acm_callback(void *arg, ssize_t result)
+{
+ printf("result:%d\r\n", result);
+}
+
+const struct usbh_class_driver cdc_acm_class_driver = {
+ .driver_name = "cdc_acm",
+ .connect = usbh_cdc_acm_connect,
+ .disconnect = usbh_cdc_acm_disconnect
+};
\ No newline at end of file diff --git a/class/cdc/usbh_cdc_acm.h b/class/cdc/usbh_cdc_acm.h new file mode 100644 index 00000000..0de425e8 --- /dev/null +++ b/class/cdc/usbh_cdc_acm.h @@ -0,0 +1,52 @@ +/**
+ * @file usbh_cdc_acm.h
+ *
+ * Copyright (c) 2022 sakumisu
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership. The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+#ifndef _USBH_CDC_ACM_H
+#define _USBH_CDC_ACM_H
+
+#include "usb_cdc.h"
+
+struct usbh_cdc_acm {
+ struct usb_setup_packet *setup;
+ struct cdc_line_coding *linecoding;
+ uint8_t ctrl_intf; /* Control interface number */
+ uint8_t data_intf; /* Data interface number */
+ bool dtr;
+ bool rts;
+ uint8_t minor;
+ usbh_epinfo_t bulkin; /* Bulk IN endpoint */
+ usbh_epinfo_t bulkout; /* Bulk OUT endpoint */
+#ifdef HAVE_INTIN_ENDPOINT
+ usbh_epinfo_t intin; /* Interrupt IN endpoint (optional) */
+#endif
+};
+
+extern const struct usbh_class_driver cdc_acm_class_driver;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file diff --git a/class/hid/usbh_hid.c b/class/hid/usbh_hid.c new file mode 100644 index 00000000..c149216f --- /dev/null +++ b/class/hid/usbh_hid.c @@ -0,0 +1,270 @@ +/**
+ * @file usbh_hid.c
+ *
+ * Copyright (c) 2022 sakumisu
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership. The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+#include "usbh_core.h"
+#include "usbh_hid.h"
+
+#define DEV_FORMAT "/dev/input%d"
+#define DEV_NAMELEN 16
+
+static uint32_t g_devinuse = 0;
+
+/****************************************************************************
+ * Name: usbh_hid_devno_alloc
+ *
+ * Description:
+ * Allocate a unique /dev/hid[n] minor number in the range 0-31.
+ *
+ ****************************************************************************/
+
+static int usbh_hid_devno_alloc(struct usbh_hid *priv)
+{
+ uint32_t flags;
+ int devno;
+
+ flags = usb_osal_enter_critical_section();
+ for (devno = 0; devno < 32; devno++) {
+ uint32_t bitno = 1 << devno;
+ if ((g_devinuse & bitno) == 0) {
+ g_devinuse |= bitno;
+ priv->minor = devno;
+ usb_osal_leave_critical_section(flags);
+ return 0;
+ }
+ }
+
+ usb_osal_leave_critical_section(flags);
+ return -EMFILE;
+}
+
+/****************************************************************************
+ * Name: usbh_hid_devno_free
+ *
+ * Description:
+ * Free a /dev/hid[n] minor number so that it can be used.
+ *
+ ****************************************************************************/
+
+static void usbh_hid_devno_free(struct usbh_hid *priv)
+{
+ int devno = priv->minor;
+
+ if (devno >= 0 && devno < 32) {
+ uint32_t flags = usb_osal_enter_critical_section();
+ g_devinuse &= ~(1 << devno);
+ usb_osal_leave_critical_section(flags);
+ }
+}
+
+/****************************************************************************
+ * Name: usbh_hid_mkdevname
+ *
+ * Description:
+ * Format a /dev/hid[n] device name given a minor number.
+ *
+ ****************************************************************************/
+
+static inline void usbh_hid_mkdevname(struct usbh_hid *priv, char *devname)
+{
+ snprintf(devname, DEV_NAMELEN, DEV_FORMAT, priv->minor);
+}
+
+int usbh_hid_get_report_descriptor(struct usbh_hubport *hport, uint8_t intf, uint8_t *buffer)
+{
+ struct usb_setup_packet *setup;
+ struct usbh_hid *hid_class = (struct usbh_hid *)hport->config.intf[intf].priv;
+
+ setup = hid_class->setup;
+
+ if (hid_class->intf != intf) {
+ return -1;
+ }
+
+ setup->bmRequestType = USB_REQUEST_DIR_IN | USB_REQUEST_STANDARD | USB_REQUEST_RECIPIENT_INTERFACE;
+ setup->bRequest = USB_REQUEST_GET_DESCRIPTOR;
+ setup->wValue = HID_DESCRIPTOR_TYPE_HID_REPORT << 8;
+ setup->wIndex = intf;
+ setup->wLength = 128;
+
+ return usbh_control_transfer(hport->ep0, setup, buffer);
+}
+
+int usbh_hid_set_idle(struct usbh_hubport *hport, uint8_t intf, uint8_t report_id, uint8_t duration)
+{
+ int ret;
+ struct usb_setup_packet *setup;
+ struct usbh_hid *hid_class = (struct usbh_hid *)hport->config.intf[intf].priv;
+
+ setup = hid_class->setup;
+
+ if (hid_class->intf != intf) {
+ return -1;
+ }
+
+ setup->bmRequestType = USB_REQUEST_DIR_OUT | USB_REQUEST_CLASS | USB_REQUEST_RECIPIENT_INTERFACE;
+ setup->bRequest = HID_REQUEST_SET_IDLE;
+ setup->wValue = report_id;
+ setup->wIndex = (duration << 8) | intf;
+ setup->wLength = 0;
+
+ ret = usbh_control_transfer(hport->ep0, setup, NULL);
+ if (ret < 0) {
+ return ret;
+ }
+
+ return 0;
+}
+
+int usbh_hid_get_idle(struct usbh_hubport *hport, uint8_t intf, uint8_t *buffer)
+{
+ int ret;
+ struct usb_setup_packet *setup;
+ struct usbh_hid *hid_class = (struct usbh_hid *)hport->config.intf[intf].priv;
+
+ setup = hid_class->setup;
+
+ if (hid_class->intf != intf) {
+ return -1;
+ }
+
+ setup->bmRequestType = USB_REQUEST_DIR_IN | USB_REQUEST_CLASS | USB_REQUEST_RECIPIENT_INTERFACE;
+ setup->bRequest = HID_REQUEST_GET_IDLE;
+ setup->wValue = 0;
+ setup->wIndex = intf;
+ setup->wLength = 1;
+
+ ret = usbh_control_transfer(hport->ep0, setup, buffer);
+ if (ret < 0) {
+ return ret;
+ }
+
+ return 0;
+}
+
+USB_NOCACHE_RAM_SECTION uint8_t report_buffer[128];
+
+void usbh_hid_callback(void *arg, ssize_t nbytes)
+{
+ printf("nbytes:%d\r\n", nbytes);
+}
+
+int usbh_hid_connect(struct usbh_hubport *hport, uint8_t intf)
+{
+ struct usbh_endpoint_cfg ep_cfg = { 0 };
+ struct usb_endpoint_descriptor *ep_desc;
+ char devname[DEV_NAMELEN];
+ int ret;
+
+ struct usbh_hid *hid_class = usb_malloc(sizeof(struct usbh_hid));
+ if (hid_class == NULL) {
+ return -1;
+ }
+ memset(hid_class, 0, sizeof(struct usbh_hid));
+
+ usbh_hid_devno_alloc(hid_class);
+ usbh_hid_mkdevname(hid_class, devname);
+
+ hport->config.intf[intf].priv = hid_class;
+
+ hid_class->setup = usb_iomalloc(sizeof(struct usb_setup_packet));
+ hid_class->intf = intf;
+
+ ret = usbh_hid_set_idle(hport, intf, 0, 0);
+ if (ret < 0) {
+ return ret;
+ }
+
+ ret = usbh_hid_get_report_descriptor(hport, intf, report_buffer);
+ if (ret < 0) {
+ return ret;
+ }
+
+ for (uint8_t i = 0; i < hport->config.intf[intf].intf_desc.bNumEndpoints; i++) {
+ ep_desc = &hport->config.intf[intf].ep[i].ep_desc;
+ ep_cfg.ep_addr = ep_desc->bEndpointAddress;
+ ep_cfg.ep_type = ep_desc->bmAttributes & USB_ENDPOINT_TYPE_MASK;
+ ep_cfg.ep_mps = ep_desc->wMaxPacketSize;
+ ep_cfg.ep_interval = ep_desc->bInterval;
+ ep_cfg.hport = hport;
+ if (ep_desc->bEndpointAddress & 0x80) {
+ usbh_ep_alloc(&hid_class->intin, &ep_cfg);
+ } else {
+ usbh_ep_alloc(&hid_class->intout, &ep_cfg);
+ }
+ }
+
+ USB_LOG_INFO("Register HID Class:%s\r\n", devname);
+
+ ret = usbh_ep_intr_async_transfer(hid_class->intin, report_buffer, 128, usbh_hid_callback, NULL);
+ if (ret < 0) {
+ return ret;
+ }
+#if 0
+ ret = usbh_ep_intr_transfer(hid_class->intin, report_buffer, 128);
+ if (ret < 0) {
+ return ret;
+ }
+ USB_LOG_INFO("recv len:%d\r\n", ret);
+#endif
+ return 0;
+}
+
+int usbh_hid_disconnect(struct usbh_hubport *hport, uint8_t intf)
+{
+ char devname[DEV_NAMELEN];
+ int ret = 0;
+
+ struct usbh_hid *hid_class = (struct usbh_hid *)hport->config.intf[intf].priv;
+
+ if (hid_class) {
+ usbh_hid_devno_free(hid_class);
+ usbh_hid_mkdevname(hid_class, devname);
+
+ if (hid_class->intin) {
+ ret = usb_ep_cancel(hid_class->intin);
+ if (ret < 0) {
+ }
+ usbh_ep_free(hid_class->intin);
+ }
+
+ if (hid_class->intout) {
+ ret = usb_ep_cancel(hid_class->intout);
+ if (ret < 0) {
+ }
+ usbh_ep_free(hid_class->intout);
+ }
+ if (hid_class->setup)
+ usb_iofree(hid_class->setup);
+
+ usb_free(hid_class);
+ hport->config.intf[intf].priv = NULL;
+
+ USB_LOG_INFO("Unregister HID Class:%s\r\n", devname);
+ }
+
+ return ret;
+}
+
+const struct usbh_class_driver hid_class_driver = {
+ .driver_name = "hid",
+ .connect = usbh_hid_connect,
+ .disconnect = usbh_hid_disconnect
+};
\ No newline at end of file diff --git a/class/hid/usbh_hid.h b/class/hid/usbh_hid.h new file mode 100644 index 00000000..7d01f100 --- /dev/null +++ b/class/hid/usbh_hid.h @@ -0,0 +1,45 @@ +/**
+ * @file usbh_hid.h
+ *
+ * Copyright (c) 2022 sakumisu
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership. The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+#ifndef _USBH_HID_H
+#define _USBH_HID_H
+
+#include "usb_hid.h"
+
+struct usbh_hid {
+ struct usb_setup_packet *setup;
+ uint8_t intf; /* interface number */
+ uint8_t minor;
+ usbh_epinfo_t intin; /* INTR IN endpoint */
+ usbh_epinfo_t intout; /* INTR OUT endpoint */
+};
+
+extern const struct usbh_class_driver hid_class_driver;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file diff --git a/class/hub/usbh_hub.c b/class/hub/usbh_hub.c new file mode 100644 index 00000000..992b6aef --- /dev/null +++ b/class/hub/usbh_hub.c @@ -0,0 +1,488 @@ +/**
+ * @file usbh_hub.c
+ *
+ * Copyright (c) 2022 sakumisu
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership. The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+#include "usbh_core.h"
+#include "usbh_hub.h"
+
+#define DEV_FORMAT "/dev/hub%d"
+#define DEV_NAMELEN 16
+
+static uint32_t g_devinuse = 0;
+
+usb_slist_t hub_class_head = USB_SLIST_OBJECT_INIT(hub_class_head);
+
+USB_NOCACHE_RAM_SECTION uint8_t int_buffer[6][USBH_HUB_INTIN_BUFSIZE];
+extern void usbh_external_hport_connect(struct usbh_hubport *hport);
+extern void usbh_external_hport_disconnect(struct usbh_hubport *hport);
+extern void usbh_hport_activate(struct usbh_hubport *hport);
+extern void usbh_hport_deactivate(struct usbh_hubport *hport);
+
+static void usbh_external_hub_callback(void *arg, ssize_t nbytes);
+
+static inline void usbh_hub_register(struct usbh_hub *hub)
+{
+ usb_slist_add_tail(&hub_class_head, &hub->list);
+}
+
+static inline void usbh_hub_unregister(struct usbh_hub *hub)
+{
+ usb_slist_remove(&hub_class_head, &hub->list);
+}
+
+/****************************************************************************
+ * Name: usbh_hub_devno_alloc
+ *
+ * Description:
+ * Allocate a unique /dev/hub[n] minor number in the range 2-31.
+ *
+ ****************************************************************************/
+
+static int usbh_hub_devno_alloc(struct usbh_hub *hub)
+{
+ uint32_t flags;
+ int devno;
+
+ flags = usb_osal_enter_critical_section();
+ for (devno = 2; devno < 32; devno++) {
+ uint32_t bitno = 1 << devno;
+ if ((g_devinuse & bitno) == 0) {
+ g_devinuse |= bitno;
+ hub->index = devno;
+ usb_osal_leave_critical_section(flags);
+ return 0;
+ }
+ }
+
+ usb_osal_leave_critical_section(flags);
+ return -EMFILE;
+}
+
+/****************************************************************************
+ * Name: usbh_hub_devno_free
+ *
+ * Description:
+ * Free a /dev/hub[n] minor number so that it can be used.
+ *
+ ****************************************************************************/
+
+static void usbh_hub_devno_free(struct usbh_hub *hub)
+{
+ int devno = hub->index;
+
+ if (devno >= 2 && devno < 32) {
+ uint32_t flags = usb_osal_enter_critical_section();
+ g_devinuse &= ~(1 << devno);
+ usb_osal_leave_critical_section(flags);
+ }
+}
+
+/****************************************************************************
+ * Name: usbh_hub_mkdevname
+ *
+ * Description:
+ * Format a /dev/hub[n] device name given a minor number.
+ *
+ ****************************************************************************/
+
+static inline void usbh_hub_mkdevname(struct usbh_hub *hub, char *devname)
+{
+ snprintf(devname, DEV_NAMELEN, DEV_FORMAT, hub->index);
+}
+
+int usbh_hub_get_hub_descriptor(struct usbh_hub *hub, uint8_t *buffer)
+{
+ struct usb_setup_packet *setup;
+
+ setup = hub->setup;
+
+ setup->bmRequestType = USB_REQUEST_DIR_IN | USB_REQUEST_CLASS | USB_REQUEST_RECIPIENT_DEVICE;
+ setup->bRequest = USB_REQUEST_GET_DESCRIPTOR;
+ setup->wValue = HUB_DESCRIPTOR_TYPE_HUB << 8;
+ setup->wIndex = 0;
+ setup->wLength = USB_SIZEOF_HUB_DESC;
+
+ return usbh_control_transfer(hub->parent->ep0, setup, buffer);
+}
+
+int usbh_hub_get_status(struct usbh_hub *hub, uint8_t *buffer)
+{
+ struct usb_setup_packet *setup;
+
+ setup = hub->setup;
+
+ setup->bmRequestType = USB_REQUEST_DIR_IN | USB_REQUEST_CLASS | USB_REQUEST_RECIPIENT_DEVICE;
+ setup->bRequest = HUB_REQUEST_GET_STATUS;
+ setup->wValue = 0;
+ setup->wIndex = 0;
+ setup->wLength = 2;
+
+ return usbh_control_transfer(hub->parent->ep0, setup, buffer);
+}
+
+int usbh_hub_get_portstatus(struct usbh_hub *hub, uint8_t port, struct hub_port_status *port_status)
+{
+ struct usb_setup_packet *setup;
+
+ setup = hub->setup;
+
+ setup->bmRequestType = USB_REQUEST_DIR_IN | USB_REQUEST_CLASS | USB_REQUEST_RECIPIENT_OTHER;
+ setup->bRequest = HUB_REQUEST_GET_STATUS;
+ setup->wValue = 0;
+ setup->wIndex = port;
+ setup->wLength = 4;
+
+ return usbh_control_transfer(hub->parent->ep0, setup, (uint8_t *)port_status);
+}
+
+int usbh_hub_set_feature(struct usbh_hub *hub, uint8_t port, uint8_t feature)
+{
+ struct usb_setup_packet *setup;
+
+ setup = hub->setup;
+
+ setup->bmRequestType = USB_REQUEST_DIR_OUT | USB_REQUEST_CLASS | USB_REQUEST_RECIPIENT_OTHER;
+ setup->bRequest = HUB_REQUEST_SET_FEATURE;
+ setup->wValue = feature;
+ setup->wIndex = port;
+ setup->wLength = 0;
+
+ return usbh_control_transfer(hub->parent->ep0, setup, NULL);
+}
+
+int usbh_hub_clear_feature(struct usbh_hub *hub, uint8_t port, uint8_t feature)
+{
+ struct usb_setup_packet *setup;
+
+ setup = hub->setup;
+
+ setup->bmRequestType = USB_REQUEST_DIR_OUT | USB_REQUEST_CLASS | USB_REQUEST_RECIPIENT_OTHER;
+ setup->bRequest = HUB_REQUEST_CLEAR_FEATURE;
+ setup->wValue = feature;
+ setup->wIndex = port;
+ setup->wLength = 0;
+
+ return usbh_control_transfer(hub->parent->ep0, setup, NULL);
+}
+
+static int parse_hub_descriptor(struct usb_hub_descriptor *desc, uint16_t length)
+{
+ if (desc->bLength != USB_SIZEOF_HUB_DESC) {
+ USB_LOG_ERR("invalid device bLength 0x%02x\r\n", desc->bLength);
+ return -1;
+ } else if (desc->bDescriptorType != HUB_DESCRIPTOR_TYPE_HUB) {
+ USB_LOG_ERR("unexpected descriptor 0x%02x\r\n", desc->bDescriptorType);
+ return -2;
+ } else {
+ USB_LOG_INFO("Device Descriptor:\r\n");
+ USB_LOG_INFO("bLength: 0x%02x \r\n", desc->bLength);
+ USB_LOG_INFO("bDescriptorType: 0x%02x \r\n", desc->bDescriptorType);
+ USB_LOG_INFO("bNbrPorts: 0x%02x \r\n", desc->bNbrPorts);
+ USB_LOG_INFO("wHubCharacteristics: 0x%04x \r\n", desc->wHubCharacteristics);
+ USB_LOG_INFO("bPwrOn2PwrGood: 0x%02x \r\n", desc->bPwrOn2PwrGood);
+ USB_LOG_INFO("bHubContrCurrent: 0x%02x \r\n", desc->bHubContrCurrent);
+ USB_LOG_INFO("DeviceRemovable: 0x%02x \r\n", desc->DeviceRemovable);
+ USB_LOG_INFO("PortPwrCtrlMask: 0x%02x \r\n", desc->PortPwrCtrlMask);
+ }
+ return 0;
+}
+
+int usbh_hub_connect(struct usbh_hubport *hport, uint8_t intf)
+{
+ struct usbh_endpoint_cfg ep_cfg = { 0 };
+ struct usb_endpoint_descriptor *ep_desc;
+ char devname[DEV_NAMELEN];
+ int ret;
+ uint8_t *hub_desc_buffer;
+ struct usbh_hub *hub_class;
+
+ hub_class = usb_malloc(sizeof(struct usbh_hub));
+ if (hub_class == NULL) {
+ return -1;
+ }
+ memset(hub_class, 0, sizeof(struct usbh_hub));
+ hub_class->setup = usb_iomalloc(sizeof(struct usb_setup_packet));
+ hub_class->port_status = usb_iomalloc(sizeof(struct hub_port_status));
+
+ hub_desc_buffer = usb_iomalloc(32);
+
+ usbh_hub_devno_alloc(hub_class);
+ usbh_hub_mkdevname(hub_class, devname);
+
+ hub_class->dev_addr = hport->dev_addr;
+ hub_class->parent = hport;
+ hport->config.intf[0].priv = hub_class;
+
+ ret = usbh_hub_get_hub_descriptor(hub_class, hub_desc_buffer);
+ if (ret != 0) {
+ usb_iofree(hub_desc_buffer);
+ return ret;
+ }
+
+ parse_hub_descriptor((struct usb_hub_descriptor *)hub_desc_buffer, USB_SIZEOF_HUB_DESC);
+ memcpy(&hub_class->hub_desc, hub_desc_buffer, USB_SIZEOF_HUB_DESC);
+ usb_iofree(hub_desc_buffer);
+
+ hub_class->nports = hub_class->hub_desc.bNbrPorts;
+
+ for (uint8_t port = 1; port <= hub_class->nports; port++) {
+ hub_class->child[port - 1].port = port;
+ hub_class->child[port - 1].parent = hub_class;
+ }
+
+ hub_class->int_buffer = int_buffer[hub_class->index - 2];
+ usbh_hub_register(hub_class);
+
+ ep_desc = &hport->config.intf[intf].ep[0].ep_desc;
+ ep_cfg.ep_addr = ep_desc->bEndpointAddress;
+ ep_cfg.ep_type = ep_desc->bmAttributes & USB_ENDPOINT_TYPE_MASK;
+ ep_cfg.ep_mps = ep_desc->wMaxPacketSize;
+ ep_cfg.ep_interval = ep_desc->bInterval;
+ ep_cfg.hport = hport;
+ if (ep_desc->bEndpointAddress & 0x80) {
+ usbh_ep_alloc(&hub_class->intin, &ep_cfg);
+ } else {
+ return -1;
+ }
+
+ for (uint8_t port = 1; port <= hub_class->nports; port++) {
+ ret = usbh_hub_set_feature(hub_class, 1, HUB_PORT_FEATURE_POWER);
+ if (ret < 0) {
+ return ret;
+ }
+ }
+
+ for (uint8_t port = 1; port <= hub_class->nports; port++) {
+ ret = usbh_hub_get_portstatus(hub_class, port, hub_class->port_status);
+ USB_LOG_INFO("Port:%d, status:0x%02x, change:0x%02x\r\n", port, hub_class->port_status->wPortStatus, hub_class->port_status->wPortChange);
+ if (ret < 0) {
+ return ret;
+ }
+ }
+
+ USB_LOG_INFO("Register HUB Class:%s\r\n", devname);
+
+ ret = usbh_ep_intr_async_transfer(hub_class->intin, hub_class->int_buffer, USBH_HUB_INTIN_BUFSIZE, usbh_external_hub_callback, hub_class);
+ return 0;
+}
+
+int usbh_hub_disconnect(struct usbh_hubport *hport, uint8_t intf)
+{
+ struct usbh_hubport *child;
+ char devname[DEV_NAMELEN];
+ int ret = 0;
+
+ struct usbh_hub *hub_class = (struct usbh_hub *)hport->config.intf[intf].priv;
+
+ if (hub_class) {
+ usbh_hub_devno_free(hub_class);
+ usbh_hub_mkdevname(hub_class, devname);
+
+ if (hub_class->intin) {
+ ret = usb_ep_cancel(hub_class->intin);
+ if (ret < 0) {
+ }
+ usbh_ep_free(hub_class->intin);
+ }
+
+ if (hub_class->setup)
+ usb_iofree(hub_class->setup);
+ if (hub_class->port_status)
+ usb_iofree(hub_class->port_status);
+
+ for (uint8_t port = 1; port <= hub_class->nports; port++) {
+ child = &hub_class->child[port - 1];
+ usbh_hport_deactivate(child);
+ for (uint8_t i = 0; i < child->config.config_desc.bNumInterfaces; i++) {
+ if (child->config.intf[i].class_driver && child->config.intf[i].class_driver->disconnect) {
+ ret = CLASS_DISCONNECT(child, i);
+ }
+ }
+
+ child->config.config_desc.bNumInterfaces = 0;
+ child->parent = NULL;
+ }
+
+ usbh_hub_unregister(hub_class);
+ usb_free(hub_class);
+ hport->config.intf[intf].priv = NULL;
+
+ USB_LOG_INFO("Unregister HUB Class:%s\r\n", devname);
+ }
+ return ret;
+}
+
+static void usbh_extern_hub_psc_event(void *arg)
+{
+ struct usbh_hub *hub_class;
+ struct usbh_hubport *connport;
+ uint8_t port_change;
+ uint16_t status;
+ uint16_t change;
+ uint16_t mask;
+ uint16_t feat;
+ uint32_t flags;
+ int ret;
+
+ hub_class = (struct usbh_hub *)arg;
+
+ /* Has the hub been disconnected? */
+ if (!hub_class->parent->connected) {
+ return;
+ }
+
+ port_change = hub_class->int_buffer[0];
+ USB_LOG_DBG("port_change:0x%02x\r\n", port_change);
+
+ /* Check for status change on any port */
+ for (uint8_t port = USBH_HUB_PORT_START_INDEX; port <= hub_class->nports; port++) {
+ /* Check if port status has changed */
+ if ((port_change & (1 << port)) == 0) {
+ continue;
+ }
+ USB_LOG_DBG("Port %d change\r\n", port);
+
+ /* Port status changed, check what happened */
+ port_change &= ~(1 << port);
+
+ /* Read hub port status */
+ ret = usbh_hub_get_portstatus(hub_class, port, hub_class->port_status);
+ if (ret < 0) {
+ USB_LOG_ERR("Failed to read port:%d status, errorcode: %d\r\n", port, ret);
+ continue;
+ }
+ status = hub_class->port_status->wPortStatus;
+ change = hub_class->port_status->wPortChange;
+
+ USB_LOG_DBG("Port:%d, status:0x%02x, change:0x%02x\r\n", port, status, change);
+
+ /* First, clear all change bits */
+ mask = 1;
+ feat = HUB_PORT_FEATURE_C_CONNECTION;
+ while (change) {
+ if (change & mask) {
+ ret = usbh_hub_clear_feature(hub_class, port, feat);
+ if (ret < 0) {
+ USB_LOG_ERR("Failed to clear port:%d, change mask:%04x, errorcode:%d\r\n", port, mask, ret);
+ }
+ change &= (~mask);
+ }
+ mask <<= 1;
+ feat++;
+ }
+
+ change = hub_class->port_status->wPortChange;
+
+ /* Handle connect or disconnect, no power management */
+ if (change & HUB_PORT_STATUS_C_CONNECTION) {
+ ret = usbh_hub_get_portstatus(hub_class, port, hub_class->port_status);
+ if (ret < 0) {
+ USB_LOG_ERR("Failed to read port:%d status, errorcode: %d\r\n", port, ret);
+ }
+ status = hub_class->port_status->wPortStatus;
+ change = hub_class->port_status->wPortChange;
+
+ if (status & HUB_PORT_STATUS_CONNECTION) {
+ /* Device connected to a port on the hub */
+ //USB_LOG_INFO("Connection on port:%d\n", port);
+
+ ret = usbh_hub_set_feature(hub_class, port, HUB_PORT_FEATURE_RESET);
+ if (ret < 0) {
+ USB_LOG_ERR("Failed to reset port:%d,errorcode:%d\r\n", port, ret);
+ continue;
+ }
+
+ usb_osal_msleep(100);
+
+ ret = usbh_hub_get_portstatus(hub_class, port, hub_class->port_status);
+ if (ret < 0) {
+ USB_LOG_ERR("Failed to read port:%d status, errorcode: %d\r\n", port, ret);
+ continue;
+ }
+ status = hub_class->port_status->wPortStatus;
+ change = hub_class->port_status->wPortChange;
+
+ USB_LOG_DBG("Port:%d, status:0x%02x, change:0x%02x after reset\r\n", port, status, change);
+
+ if ((status & HUB_PORT_STATUS_RESET) == 0 && (status & HUB_PORT_STATUS_ENABLE) != 0) {
+ if (change & HUB_PORT_STATUS_C_RESET) {
+ ret = usbh_hub_clear_feature(hub_class, port, HUB_PORT_FEATURE_C_RESET);
+ if (ret < 0) {
+ USB_LOG_ERR("Failed to clear port:%d reset change, errorcode: %d\r\n", port, ret);
+ }
+ }
+ connport = &hub_class->child[port - 1];
+
+ if (status & HUB_PORT_STATUS_HIGH_SPEED) {
+ connport->speed = USB_SPEED_HIGH;
+ } else if (status & HUB_PORT_STATUS_LOW_SPEED) {
+ connport->speed = USB_SPEED_LOW;
+ } else {
+ connport->speed = USB_SPEED_FULL;
+ }
+
+ /* Device connected from a port on the hub, wakeup psc thread. */
+ usbh_external_hport_connect(connport);
+
+ } else {
+ USB_LOG_ERR("Failed to enable port:%d\r\n", port);
+ continue;
+ }
+ } else {
+ /* Device disconnected from a port on the hub, wakeup psc thread. */
+ connport = &hub_class->child[port - 1];
+ usbh_external_hport_disconnect(connport);
+ }
+ } else {
+ USB_LOG_WRN("status %04x change %04x not handled\r\n", status, change);
+ }
+ }
+
+ /* Check for hub status change */
+
+ if ((port_change & 1) != 0) {
+ /* Hub status changed */
+ USB_LOG_WRN("Hub status changed, not handled\n");
+ }
+ flags = usb_osal_enter_critical_section();
+ if (hub_class->parent->connected) {
+ ret = usbh_ep_intr_async_transfer(hub_class->intin, hub_class->int_buffer, USBH_HUB_INTIN_BUFSIZE, usbh_external_hub_callback, hub_class);
+ }
+ usb_osal_leave_critical_section(flags);
+}
+
+static void usbh_external_hub_callback(void *arg, ssize_t nbytes)
+{
+ struct usbh_hub *hub_class = (struct usbh_hub *)arg;
+ uint32_t delay = 0;
+ if (nbytes < 0) {
+ hub_class->int_buffer[0] = 0;
+ delay = 100;
+ }
+ if (hub_class->parent->connected) {
+ usb_workqueue_submit(&g_lpworkq, &hub_class->work, usbh_extern_hub_psc_event, (void *)hub_class, delay);
+ }
+}
+
+const struct usbh_class_driver hub_class_driver = {
+ .driver_name = "hub",
+ .connect = usbh_hub_connect,
+ .disconnect = usbh_hub_disconnect
+};
\ No newline at end of file diff --git a/class/hub/usbh_hub.h b/class/hub/usbh_hub.h new file mode 100644 index 00000000..98c46542 --- /dev/null +++ b/class/hub/usbh_hub.h @@ -0,0 +1,42 @@ +/**
+ * @file usbh_hub.h
+ *
+ * Copyright (c) 2022 sakumisu
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership. The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+#ifndef _USBH_HUB_H_
+#define _USBH_HUB_H_
+
+#include "usb_hub.h"
+
+#define USBH_HUB_MAX_PORTS 4
+/* Maximum size of an interrupt IN transfer */
+#define USBH_HUB_INTIN_BUFSIZE ((USBH_HUB_MAX_PORTS + 8) >> 3)
+
+extern const struct usbh_class_driver hub_class_driver;
+extern usb_slist_t hub_class_head;
+extern usb_osal_thread_t hub_thread;
+#ifdef __cplusplus
+extern "C" {
+#endif
+int usbh_hub_initialize(void);
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _USBH_HUB_H_ */
diff --git a/class/msc/usbh_msc.c b/class/msc/usbh_msc.c new file mode 100644 index 00000000..90da54f1 --- /dev/null +++ b/class/msc/usbh_msc.c @@ -0,0 +1,359 @@ +/**
+ * @file usbh_msc.c
+ *
+ * Copyright (c) 2022 sakumisu
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership. The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+#include "usbh_core.h"
+#include "usbh_msc.h"
+
+#define DEV_FORMAT "/dev/sd%c"
+#define DEV_NAMELEN 16
+
+static uint32_t g_devinuse = 0;
+
+/****************************************************************************
+ * Name: usbh_msc_devno_alloc
+ *
+ * Description:
+ * Allocate a unique /dev/ttyACM[n] minor number in the range 0-31.
+ *
+ ****************************************************************************/
+
+static int usbh_msc_devno_alloc(struct usbh_msc *priv)
+{
+ uint32_t flags;
+ int devno;
+
+ flags = usb_osal_enter_critical_section();
+ for (devno = 0; devno < 26; devno++) {
+ uint32_t bitno = 1 << devno;
+ if ((g_devinuse & bitno) == 0) {
+ g_devinuse |= bitno;
+ priv->sdchar = 'a' + devno;
+ usb_osal_leave_critical_section(flags);
+ return 0;
+ }
+ }
+
+ usb_osal_leave_critical_section(flags);
+ return -EMFILE;
+}
+
+/****************************************************************************
+ * Name: usbh_msc_devno_free
+ *
+ * Description:
+ * Free a /dev/sd[n] minor number so that it can be used.
+ *
+ ****************************************************************************/
+
+static void usbh_msc_devno_free(struct usbh_msc *priv)
+{
+ int devno = priv->sdchar - 'a';
+
+ if (devno >= 0 && devno < 26) {
+ uint32_t flags = usb_osal_enter_critical_section();
+ g_devinuse &= ~(1 << devno);
+ usb_osal_leave_critical_section(flags);
+ }
+}
+
+/****************************************************************************
+ * Name: usbh_msc_mkdevname
+ *
+ * Description:
+ * Format a /dev/sd[n] device name given a minor number.
+ *
+ ****************************************************************************/
+
+static inline void usbh_msc_mkdevname(struct usbh_msc *priv, char *devname)
+{
+ snprintf(devname, DEV_NAMELEN, DEV_FORMAT, priv->sdchar);
+}
+
+static int usbh_msc_get_maxlun(struct usbh_hubport *hport, uint8_t intf, uint8_t *buffer)
+{
+ struct usb_setup_packet *setup;
+ struct usbh_msc *msc_class = (struct usbh_msc *)hport->config.intf[intf].priv;
+
+ setup = msc_class->setup;
+
+ if (msc_class->intf != intf) {
+ return -1;
+ }
+
+ setup->bmRequestType = USB_REQUEST_DIR_IN | USB_REQUEST_CLASS | USB_REQUEST_RECIPIENT_INTERFACE;
+ setup->bRequest = MSC_REQUEST_GET_MAX_LUN;
+ setup->wValue = 0;
+ setup->wIndex = intf;
+ setup->wLength = 1;
+
+ return usbh_control_transfer(hport->ep0, setup, buffer);
+}
+
+static void usbh_msc_cbw_dump(struct CBW *cbw)
+{
+ int i;
+
+ USB_LOG_INFO("CBW:\r\n");
+ USB_LOG_INFO(" signature: 0x%08x\r\n", (unsigned int)cbw->dSignature);
+ USB_LOG_INFO(" tag: 0x%08x\r\n", (unsigned int)cbw->dTag);
+ USB_LOG_INFO(" datlen: 0x%08x\r\n", (unsigned int)cbw->dDataLength);
+ USB_LOG_INFO(" flags: 0x%02x\r\n", cbw->bmFlags);
+ USB_LOG_INFO(" lun: 0x%02x\r\n", cbw->bLUN);
+ USB_LOG_INFO(" cblen: 0x%02x\r\n", cbw->bCBLength);
+
+ USB_LOG_INFO("CB:\r\n");
+ for (i = 0; i < cbw->bCBLength; i += 8) {
+ USB_LOG_INFO(" 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\r\n",
+ cbw->CB[i], cbw->CB[i + 1], cbw->CB[i + 2],
+ cbw->CB[i + 3], cbw->CB[i + 4], cbw->CB[i + 5],
+ cbw->CB[i + 6], cbw->CB[i + 7]);
+ }
+}
+
+static void usbh_msc_csw_dump(struct CSW *csw)
+{
+ USB_LOG_INFO("CSW:\r\n");
+ USB_LOG_INFO(" signature: 0x%08x\r\n", (unsigned int)csw->dSignature);
+ USB_LOG_INFO(" tag: 0x%08x\r\n", (unsigned int)csw->dTag);
+ USB_LOG_INFO(" residue: 0x%08x\r\n", (unsigned int)csw->dDataResidue);
+ USB_LOG_INFO(" status: 0x%02x\r\n", csw->bStatus);
+}
+
+static inline int usbh_msc_scsi_testunitready(struct usbh_msc *msc_class)
+{
+ int nbytes;
+ struct CBW *cbw;
+
+ /* Construct the CBW */
+ cbw = (struct CBW *)msc_class->tx_buffer;
+ memset(cbw, 0, USB_SIZEOF_MSC_CBW);
+ cbw->dSignature = MSC_CBW_Signature;
+
+ cbw->bCBLength = 0x06;
+ cbw->CB[0] = SCSI_TEST_UNIT_READY;
+ /* Send the CBW */
+ nbytes = usbh_ep_bulk_transfer(msc_class->bulkout, (uint8_t *)cbw, USB_SIZEOF_MSC_CBW);
+ if (nbytes >= 0) {
+ /* Receive the CSW */
+ nbytes = usbh_ep_bulk_transfer(msc_class->bulkin, msc_class->tx_buffer, USB_SIZEOF_MSC_CSW);
+ if (nbytes >= 0) {
+ usbh_msc_csw_dump((struct CSW *)msc_class->tx_buffer);
+ }
+ }
+ return nbytes < 0 ? (int)nbytes : 0;
+}
+
+static inline int usbh_msc_scsi_requestsense(struct usbh_msc *msc_class)
+{
+ int nbytes;
+ struct CBW *cbw;
+
+ /* Construct the CBW */
+ cbw = (struct CBW *)msc_class->tx_buffer;
+ memset(cbw, 0, USB_SIZEOF_MSC_CBW);
+ cbw->dSignature = MSC_CBW_Signature;
+
+ cbw->bmFlags = 0x80;
+ cbw->bCBLength = 0x06;
+ cbw->dDataLength = 18;
+ cbw->CB[0] = SCSI_REQUEST_SENSE;
+ cbw->CB[4] = 18;
+ /* Send the CBW */
+ nbytes = usbh_ep_bulk_transfer(msc_class->bulkout, (uint8_t *)cbw, USB_SIZEOF_MSC_CBW);
+ if (nbytes >= 0) {
+ /* Receive the sense data response */
+ nbytes = usbh_ep_bulk_transfer(msc_class->bulkin, msc_class->tx_buffer, 18);
+ if (nbytes >= 0) {
+ /* Receive the CSW */
+ nbytes = usbh_ep_bulk_transfer(msc_class->bulkin, msc_class->tx_buffer, USB_SIZEOF_MSC_CSW);
+ if (nbytes >= 0) {
+ usbh_msc_csw_dump((struct CSW *)msc_class->tx_buffer);
+ }
+ }
+ }
+ return nbytes < 0 ? (int)nbytes : 0;
+}
+
+static inline int usbh_msc_scsi_inquiry(struct usbh_msc *msc_class)
+{
+ int nbytes;
+ struct CBW *cbw;
+
+ /* Construct the CBW */
+ cbw = (struct CBW *)msc_class->tx_buffer;
+ memset(cbw, 0, USB_SIZEOF_MSC_CBW);
+ cbw->dSignature = MSC_CBW_Signature;
+
+ cbw->dDataLength = 36;
+ cbw->bmFlags = 0x80;
+ cbw->bCBLength = 6;
+ cbw->CB[0] = SCSI_INQUIRY;
+ cbw->CB[4] = 36;
+
+ /* Send the CBW */
+ nbytes = usbh_ep_bulk_transfer(msc_class->bulkout, (uint8_t *)cbw, USB_SIZEOF_MSC_CBW);
+ if (nbytes >= 0) {
+ /* Receive the sense data response */
+ nbytes = usbh_ep_bulk_transfer(msc_class->bulkin, msc_class->tx_buffer, 36);
+ if (nbytes >= 0) {
+ /* Receive the CSW */
+ nbytes = usbh_ep_bulk_transfer(msc_class->bulkin, msc_class->tx_buffer, USB_SIZEOF_MSC_CSW);
+ if (nbytes >= 0) {
+ usbh_msc_csw_dump((struct CSW *)msc_class->tx_buffer);
+ }
+ }
+ }
+ return nbytes < 0 ? (int)nbytes : 0;
+}
+
+static inline int usbh_msc_scsi_readcapacity10(struct usbh_msc *msc_class)
+{
+ int nbytes;
+ struct CBW *cbw;
+
+ /* Construct the CBW */
+ cbw = (struct CBW *)msc_class->tx_buffer;
+ memset(cbw, 0, USB_SIZEOF_MSC_CBW);
+ cbw->dSignature = MSC_CBW_Signature;
+
+ cbw->dDataLength = 8;
+ cbw->bmFlags = 0x80;
+ cbw->bCBLength = 10;
+ cbw->CB[0] = SCSI_READ_CAPACITY10;
+
+ /* Send the CBW */
+ nbytes = usbh_ep_bulk_transfer(msc_class->bulkout, (uint8_t *)cbw, USB_SIZEOF_MSC_CBW);
+ if (nbytes >= 0) {
+ /* Receive the sense data response */
+ nbytes = usbh_ep_bulk_transfer(msc_class->bulkin, msc_class->tx_buffer, 8);
+ if (nbytes >= 0) {
+ /* Save the capacity information */
+ msc_class->blocknum = GET_BE32(&msc_class->tx_buffer[0]) + 1;
+ msc_class->blocksize = GET_BE32(&msc_class->tx_buffer[4]);
+ USB_LOG_INFO("capacity info:\r\n");
+ USB_LOG_INFO("block num:%d,block size:%d\r\n", (unsigned int)msc_class->blocknum, (unsigned int)msc_class->blocksize);
+ /* Receive the CSW */
+ nbytes = usbh_ep_bulk_transfer(msc_class->bulkin, msc_class->tx_buffer, USB_SIZEOF_MSC_CSW);
+ if (nbytes >= 0) {
+ usbh_msc_csw_dump((struct CSW *)msc_class->tx_buffer);
+ }
+ }
+ }
+ return nbytes < 0 ? (int)nbytes : 0;
+}
+
+int usbh_msc_connect(struct usbh_hubport *hport, uint8_t intf)
+{
+ struct usbh_endpoint_cfg ep_cfg = { 0 };
+ struct usb_endpoint_descriptor *ep_desc;
+
+ char devname[DEV_NAMELEN];
+ int ret;
+
+ struct usbh_msc *msc_class = usb_malloc(sizeof(struct usbh_msc));
+ if (msc_class == NULL) {
+ return -ENOMEM;
+ }
+
+ memset(msc_class, 0, sizeof(struct usbh_msc));
+
+ usbh_msc_devno_alloc(msc_class);
+ usbh_msc_mkdevname(msc_class, devname);
+
+ hport->config.intf[intf].priv = msc_class;
+
+ msc_class->setup = usb_iomalloc(sizeof(struct usb_setup_packet));
+ msc_class->tx_buffer = usb_iomalloc(128);
+
+ ret = usbh_msc_get_maxlun(hport, intf, msc_class->tx_buffer);
+ if (ret < 0) {
+ return ret;
+ }
+
+ USB_LOG_INFO("Get max LUN:%u\r\n", msc_class->tx_buffer[0]);
+
+ for (uint8_t i = 0; i < hport->config.intf[intf].intf_desc.bNumEndpoints; i++) {
+ ep_desc = &hport->config.intf[intf].ep[i].ep_desc;
+
+ ep_cfg.ep_addr = ep_desc->bEndpointAddress;
+ ep_cfg.ep_type = ep_desc->bmAttributes & USB_ENDPOINT_TYPE_MASK;
+ ep_cfg.ep_mps = ep_desc->wMaxPacketSize;
+ ep_cfg.ep_interval = ep_desc->bInterval;
+ ep_cfg.hport = hport;
+ if (ep_desc->bEndpointAddress & 0x80) {
+ usbh_ep_alloc(&msc_class->bulkin, &ep_cfg);
+ } else {
+ usbh_ep_alloc(&msc_class->bulkout, &ep_cfg);
+ }
+ }
+
+ USB_LOG_INFO("Register MSC Class:%s\r\n", devname);
+
+ ret = usbh_msc_scsi_testunitready(msc_class);
+ ret = usbh_msc_scsi_inquiry(msc_class);
+ ret = usbh_msc_scsi_readcapacity10(msc_class);
+
+ return ret;
+}
+
+int usbh_msc_disconnect(struct usbh_hubport *hport, uint8_t intf)
+{
+ char devname[DEV_NAMELEN];
+ int ret = 0;
+
+ struct usbh_msc *msc_class = (struct usbh_msc *)hport->config.intf[intf].priv;
+
+ if (msc_class) {
+ usbh_msc_devno_free(msc_class);
+ usbh_msc_mkdevname(msc_class, devname);
+
+ if (msc_class->bulkin) {
+ ret = usb_ep_cancel(msc_class->bulkin);
+ if (ret < 0) {
+ }
+ usbh_ep_free(msc_class->bulkin);
+ }
+
+ if (msc_class->bulkout) {
+ ret = usb_ep_cancel(msc_class->bulkout);
+ if (ret < 0) {
+ }
+ usbh_ep_free(msc_class->bulkout);
+ }
+
+ if (msc_class->setup)
+ usb_iofree(msc_class->setup);
+
+ usb_free(msc_class);
+
+ hport->config.intf[intf].priv = NULL;
+
+ USB_LOG_INFO("Unregister MSC Class:%s\r\n", devname);
+ }
+
+ return ret;
+}
+
+const struct usbh_class_driver msc_class_driver = {
+ .driver_name = "msc",
+ .connect = usbh_msc_connect,
+ .disconnect = usbh_msc_disconnect
+};
\ No newline at end of file diff --git a/class/msc/usbh_msc.h b/class/msc/usbh_msc.h new file mode 100644 index 00000000..ccc7806e --- /dev/null +++ b/class/msc/usbh_msc.h @@ -0,0 +1,49 @@ +/**
+ * @file usbh_msc.h
+ *
+ * Copyright (c) 2022 sakumisu
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership. The
+ * ASF licenses this file to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations
+ * under the License.
+ *
+ */
+#ifndef _USBH_MSC_H
+#define _USBH_MSC_H
+
+#include "usb_msc.h"
+#include "usb_scsi.h"
+
+struct usbh_msc {
+ struct usb_setup_packet *setup;
+ uint8_t intf; /* Data interface number */
+ uint8_t sdchar;
+ usbh_epinfo_t bulkin; /* Bulk IN endpoint */
+ usbh_epinfo_t bulkout; /* Bulk OUT endpoint */
+ uint8_t *tx_buffer;
+ uint32_t blocknum; /* Number of blocks on the USB mass storage device */
+ uint16_t blocksize; /* Block size of USB mass storage device */
+};
+
+extern const struct usbh_class_driver msc_class_driver;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
\ No newline at end of file |