aboutsummaryrefslogtreecommitdiffstats
path: root/os/hal/src/usbh
diff options
context:
space:
mode:
Diffstat (limited to 'os/hal/src/usbh')
-rw-r--r--os/hal/src/usbh/hal_usbh_hid.c311
1 files changed, 311 insertions, 0 deletions
diff --git a/os/hal/src/usbh/hal_usbh_hid.c b/os/hal/src/usbh/hal_usbh_hid.c
new file mode 100644
index 0000000..f8a5c96
--- /dev/null
+++ b/os/hal/src/usbh/hal_usbh_hid.c
@@ -0,0 +1,311 @@
+/*
+ ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio
+ Copyright (C) 2015..2016 Diego Ismirlian, TISA, (dismirlian (at) google's mail)
+
+ Licensed 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 "hal.h"
+
+#if HAL_USBH_USE_HID
+
+#if !HAL_USE_USBH
+#error "USBHHID needs USBH"
+#endif
+
+#include <string.h>
+#include "usbh/dev/hid.h"
+#include "usbh/internal.h"
+
+#if USBHHID_DEBUG_ENABLE_TRACE
+#define udbgf(f, ...) usbDbgPrintf(f, ##__VA_ARGS__)
+#define udbg(f, ...) usbDbgPuts(f, ##__VA_ARGS__)
+#else
+#define udbgf(f, ...) do {} while(0)
+#define udbg(f, ...) do {} while(0)
+#endif
+
+#if USBHHID_DEBUG_ENABLE_INFO
+#define uinfof(f, ...) usbDbgPrintf(f, ##__VA_ARGS__)
+#define uinfo(f, ...) usbDbgPuts(f, ##__VA_ARGS__)
+#else
+#define uinfof(f, ...) do {} while(0)
+#define uinfo(f, ...) do {} while(0)
+#endif
+
+#if USBHHID_DEBUG_ENABLE_WARNINGS
+#define uwarnf(f, ...) usbDbgPrintf(f, ##__VA_ARGS__)
+#define uwarn(f, ...) usbDbgPuts(f, ##__VA_ARGS__)
+#else
+#define uwarnf(f, ...) do {} while(0)
+#define uwarn(f, ...) do {} while(0)
+#endif
+
+#if USBHHID_DEBUG_ENABLE_ERRORS
+#define uerrf(f, ...) usbDbgPrintf(f, ##__VA_ARGS__)
+#define uerr(f, ...) usbDbgPuts(f, ##__VA_ARGS__)
+#else
+#define uerrf(f, ...) do {} while(0)
+#define uerr(f, ...) do {} while(0)
+#endif
+
+
+
+#define USBH_HID_REQ_GET_REPORT 0x01
+#define USBH_HID_REQ_GET_IDLE 0x02
+#define USBH_HID_REQ_GET_PROTOCOL 0x03
+#define USBH_HID_REQ_SET_REPORT 0x09
+#define USBH_HID_REQ_SET_IDLE 0x0A
+#define USBH_HID_REQ_SET_PROTOCOL 0x0B
+
+/*===========================================================================*/
+/* USB Class driver loader for MSD */
+/*===========================================================================*/
+
+USBHHIDDriver USBHHID[HAL_USBHHID_MAX_INSTANCES];
+
+static usbh_baseclassdriver_t *_hid_load(usbh_device_t *dev, const uint8_t *descriptor, uint16_t rem);
+static void _hid_unload(usbh_baseclassdriver_t *drv);
+
+static const usbh_classdriver_vmt_t class_driver_vmt = {
+ _hid_load,
+ _hid_unload
+};
+
+const usbh_classdriverinfo_t usbhhidClassDriverInfo = {
+ 0x03, -1, -1, "HID", &class_driver_vmt
+};
+
+static usbh_baseclassdriver_t *_hid_load(usbh_device_t *dev, const uint8_t *descriptor, uint16_t rem) {
+ int i;
+ USBHHIDDriver *hidp;
+
+ if ((rem < descriptor[0]) || (descriptor[1] != USBH_DT_INTERFACE))
+ return NULL;
+
+ const usbh_interface_descriptor_t * const ifdesc = (const usbh_interface_descriptor_t *)descriptor;
+
+ if ((ifdesc->bAlternateSetting != 0)
+ || (ifdesc->bNumEndpoints < 1)) {
+ return NULL;
+ }
+
+
+ /* alloc driver */
+ for (i = 0; i < HAL_USBHHID_MAX_INSTANCES; i++) {
+ if (USBHHID[i].dev == NULL) {
+ hidp = &USBHHID[i];
+ goto alloc_ok;
+ }
+ }
+
+ uwarn("Can't alloc HID driver");
+
+ /* can't alloc */
+ return NULL;
+
+alloc_ok:
+ /* initialize the driver's variables */
+ hidp->epin.status = USBH_EPSTATUS_UNINITIALIZED;
+#if HAL_USBHHID_USE_INTERRUPT_OUT
+ hidp->epout.status = USBH_EPSTATUS_UNINITIALIZED;
+#endif
+ hidp->ifnum = ifdesc->bInterfaceNumber;
+ usbhEPSetName(&dev->ctrl, "HID[CTRL]");
+
+ /* parse the configuration descriptor */
+ if_iterator_t iif;
+ generic_iterator_t iep;
+ iif.iad = 0;
+ iif.curr = descriptor;
+ iif.rem = rem;
+ for (ep_iter_init(&iep, &iif); iep.valid; ep_iter_next(&iep)) {
+ const usbh_endpoint_descriptor_t *const epdesc = ep_get(&iep);
+ if ((epdesc->bEndpointAddress & 0x80) && (epdesc->bmAttributes == USBH_EPTYPE_INT)) {
+ uinfof("INT IN endpoint found: bEndpointAddress=%02x", epdesc->bEndpointAddress);
+ usbhEPObjectInit(&hidp->epin, dev, epdesc);
+ usbhEPSetName(&hidp->epin, "HID[IIN ]");
+#if HAL_USBHHID_USE_INTERRUPT_OUT
+ } else if (((epdesc->bEndpointAddress & 0x80) == 0)
+ && (epdesc->bmAttributes == USBH_EPTYPE_INT)) {
+ uinfof("INT OUT endpoint found: bEndpointAddress=%02x", epdesc->bEndpointAddress);
+ usbhEPObjectInit(&hidp->epout, dev, epdesc);
+ usbhEPSetName(&hidp->epout, "HID[IOUT]");
+#endif
+ } else {
+ uinfof("unsupported endpoint found: bEndpointAddress=%02x, bmAttributes=%02x",
+ epdesc->bEndpointAddress, epdesc->bmAttributes);
+ }
+ }
+ if (hidp->epin.status != USBH_EPSTATUS_CLOSED) {
+ goto deinit;
+ }
+
+ if (ifdesc->bInterfaceSubClass != 0x01) {
+ hidp->type = USBHHID_DEVTYPE_GENERIC;
+ uinfof("HID: bInterfaceSubClass=%02x, generic HID");
+ if (ifdesc->bInterfaceSubClass != 0x00) {
+ uinfof("HID: bInterfaceSubClass=%02x is an invalid bInterfaceSubClass value");
+ }
+ } else if (ifdesc->bInterfaceProtocol == 0x01) {
+ hidp->type = USBHHID_DEVTYPE_BOOT_KEYBOARD;
+ uinfo("HID: BOOT protocol keyboard found");
+ } else if (ifdesc->bInterfaceProtocol == 0x02) {
+ hidp->type = USBHHID_DEVTYPE_BOOT_MOUSE;
+ uinfo("HID: BOOT protocol mouse found");
+ } else {
+ uerrf("HID: bInterfaceProtocol=%02x is an invalid boot protocol, abort");
+ goto deinit;
+ }
+
+ hidp->state = USBHHID_STATE_ACTIVE;
+
+ return (usbh_baseclassdriver_t *)hidp;
+
+deinit:
+ /* Here, the enpoints are closed, and the driver is unlinked */
+ return NULL;
+}
+
+static void _hid_unload(usbh_baseclassdriver_t *drv) {
+ (void)drv;
+}
+
+static void _in_cb(usbh_urb_t *urb) {
+ USBHHIDDriver *const hidp = (USBHHIDDriver *)urb->userData;
+ switch (urb->status) {
+ case USBH_URBSTATUS_OK:
+
+ break;
+ case USBH_URBSTATUS_DISCONNECTED:
+ uwarn("HID: URB IN disconnected");
+
+ return;
+ default:
+ uerrf("HID: URB IN status unexpected = %d", urb->status);
+ break;
+ }
+ usbhURBObjectResetI(&hidp->in_urb);
+ usbhURBSubmitI(&hidp->in_urb);
+}
+
+void usbhhidStart(USBHHIDDriver *hidp, const USBHHIDConfig *cfg) {
+ osalDbgCheck(hidp && cfg && cfg->report_buffer);
+ osalDbgCheck((hidp->state == USBHHID_STATE_ACTIVE)
+ || (hidp->state == USBHHID_STATE_READY));
+
+ if (hidp->state == USBHHID_STATE_READY)
+ return;
+
+ hidp->config = cfg;
+
+ /* init the URBs */
+ usbhURBObjectInit(&hidp->in_urb, &hidp->epin, _in_cb, hidp, hidp->config->report_buffer, 64);
+
+ /* open the int IN/OUT endpoints */
+ usbhEPOpen(&hidp->epin);
+#if HAL_USBHHID_USE_INTERRUPT_OUT
+ if (hidp->epout.status == USBH_EPSTATUS_CLOSED) {
+ usbhEPOpen(&hidp->epout);
+ }
+#endif
+
+ osalSysLock();
+ usbhURBSubmitI(&hidp->in_urb);
+ osalSysUnlock();
+
+ hidp->state = USBHHID_STATE_READY;
+}
+
+void usbhhidStop(USBHHIDDriver *hidp) {
+ osalDbgCheck((hidp->state == USBHHID_STATE_ACTIVE)
+ || (hidp->state == USBHHID_STATE_READY));
+
+ if (hidp->state != USBHHID_STATE_READY)
+ return;
+
+ osalSysLock();
+ usbhEPCloseS(&hidp->epin);
+#if HAL_USBHHID_USE_INTERRUPT_OUT
+ if (hidp->epout.status != USBH_EPSTATUS_UNINITIALIZED) {
+ usbhEPCloseS(&hidp->epout);
+ }
+#endif
+ hidp->state = USBHHID_STATE_ACTIVE;
+ osalSysUnlock();
+}
+
+usbh_urbstatus_t usbhhidGetReport(USBHHIDDriver *hidp,
+ uint8_t report_id, usbhhid_reporttype_t report_type,
+ void *data, uint16_t len) {
+ osalDbgCheck(hidp);
+ osalDbgAssert((uint8_t)report_type <= USBHHID_REPORTTYPE_FEATURE, "wrong report type");
+ return usbhControlRequest(hidp->dev,
+ USBH_CLASSIN(USBH_REQTYPE_INTERFACE, USBH_HID_REQ_GET_REPORT, ((uint8_t)report_type << 8) | report_id, hidp->ifnum),
+ len, data);
+}
+
+usbh_urbstatus_t usbhhidSetReport(USBHHIDDriver *hidp,
+ uint8_t report_id, usbhhid_reporttype_t report_type,
+ const void *data, uint16_t len) {
+ osalDbgCheck(hidp);
+ osalDbgAssert((uint8_t)report_type <= USBHHID_REPORTTYPE_FEATURE, "wrong report type");
+ return usbhControlRequest(hidp->dev,
+ USBH_CLASSOUT(USBH_REQTYPE_INTERFACE, USBH_HID_REQ_SET_REPORT, ((uint8_t)report_type << 8) | report_id, hidp->ifnum),
+ len, (void *)data);
+}
+
+usbh_urbstatus_t usbhhidGetIdle(USBHHIDDriver *hidp, uint8_t report_id, uint8_t *duration) {
+ osalDbgCheck(hidp);
+ return usbhControlRequest(hidp->dev,
+ USBH_CLASSIN(USBH_REQTYPE_INTERFACE, USBH_HID_REQ_GET_IDLE, report_id, hidp->ifnum),
+ 1, duration);
+}
+
+usbh_urbstatus_t usbhhidSetIdle(USBHHIDDriver *hidp, uint8_t report_id, uint8_t duration) {
+ osalDbgCheck(hidp);
+ return usbhControlRequest(hidp->dev,
+ USBH_CLASSOUT(USBH_REQTYPE_INTERFACE, USBH_HID_REQ_SET_IDLE, (duration << 8) | report_id, hidp->ifnum),
+ 0, NULL);
+}
+
+usbh_urbstatus_t usbhhidGetProtocol(USBHHIDDriver *hidp, uint8_t *protocol) {
+ osalDbgCheck(hidp);
+ return usbhControlRequest(hidp->dev,
+ USBH_CLASSIN(USBH_REQTYPE_INTERFACE, USBH_HID_REQ_GET_PROTOCOL, 0, hidp->ifnum),
+ 1, protocol);
+}
+
+usbh_urbstatus_t usbhhidSetProtocol(USBHHIDDriver *hidp, uint8_t protocol) {
+ osalDbgCheck(hidp);
+ osalDbgAssert(protocol <= 1, "invalid protocol");
+ return usbhControlRequest(hidp->dev,
+ USBH_CLASSOUT(USBH_REQTYPE_INTERFACE, USBH_HID_REQ_SET_PROTOCOL, protocol, hidp->ifnum),
+ 0, NULL);
+}
+
+void usbhhidObjectInit(USBHHIDDriver *hidp) {
+ osalDbgCheck(hidp != NULL);
+ memset(hidp, 0, sizeof(*hidp));
+ hidp->info = &usbhhidClassDriverInfo;
+ hidp->state = USBHHID_STATE_STOP;
+}
+
+void usbhhidInit(void) {
+ uint8_t i;
+ for (i = 0; i < HAL_USBHHID_MAX_INSTANCES; i++) {
+ usbhhidObjectInit(&USBHHID[i]);
+ }
+}
+
+#endif