From 5ecaf7722b5f1f9d0c41213fc5c129b451302f99 Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Mon, 5 Jun 2017 10:18:45 -0300 Subject: USB Host fixes - Cleaned up alignment macros for GCC & IAR - Corrected EP halt and Clear halt behaviours - Initialization of class drivers by USB Host main driver - Minor cosmetic fixes - Updated USB_HOST testhal app --- os/hal/src/hal_usbh.c | 66 +++++++++++++++++++++++++++---------- os/hal/src/usbh/hal_usbh_debug.c | 9 ++--- os/hal/src/usbh/hal_usbh_desciter.c | 24 ++++++-------- os/hal/src/usbh/hal_usbh_ftdi.c | 18 +++++++--- os/hal/src/usbh/hal_usbh_hub.c | 15 ++++++--- os/hal/src/usbh/hal_usbh_msd.c | 31 ++++++++++------- 6 files changed, 104 insertions(+), 59 deletions(-) (limited to 'os/hal/src') diff --git a/os/hal/src/hal_usbh.c b/os/hal/src/hal_usbh.c index befe17f..0d0bf06 100644 --- a/os/hal/src/hal_usbh.c +++ b/os/hal/src/hal_usbh.c @@ -19,10 +19,14 @@ #if HAL_USE_USBH -#include "usbh/dev/hub.h" #include "usbh/internal.h" #include +//devices +#include "usbh/dev/hub.h" +#include "usbh/dev/ftdi.h" +#include "usbh/dev/msd.h" + #if USBH_DEBUG_ENABLE_TRACE #define udbgf(f, ...) usbDbgPrintf(f, ##__VA_ARGS__) #define udbg(f, ...) usbDbgPuts(f, ##__VA_ARGS__) @@ -107,11 +111,14 @@ void usbhObjectInit(USBHDriver *usbh) { } void usbhInit(void) { +#if HAL_USBH_USE_FTDI + usbhftdiInit(); +#endif +#if HAL_USBH_USE_MSD + usbhmsdInit(); +#endif #if HAL_USBH_USE_HUB - uint8_t i; - for (i = 0; i < HAL_USBHHUB_MAX_INSTANCES; i++) { - usbhhubObjectInit(&USBHHUBD[i]); - } + usbhhubInit(); #endif usbh_lld_init(); } @@ -128,7 +135,6 @@ void usbhStart(USBHDriver *usbh) { osalSysUnlock(); } - void usbhStop(USBHDriver *usbh) { //TODO: implement (void)usbh; @@ -181,6 +187,22 @@ static void _ep0_object_init(usbh_device_t *dev, uint16_t wMaxPacketSize) { usbhEPSetName(&dev->ctrl, "DEV[CTRL]"); } +bool usbhEPResetS(usbh_ep_t *ep) { + osalDbgCheckClassS(); + osalDbgCheck(ep != NULL); + osalDbgAssert((ep->status == USBH_EPSTATUS_OPEN) || (ep->status == USBH_EPSTATUS_HALTED), "invalid state"); + osalDbgAssert(ep->type != USBH_EPTYPE_CTRL, "don't need to reset control endpoint"); + + usbh_urbstatus_t ret = usbhControlRequest(ep->device, + USBH_STANDARDOUT(USBH_REQTYPE_ENDPOINT, USBH_REQ_CLEAR_FEATURE, 0, ep->address | (ep->in ? 0x80 : 0x00)), + 0, 0); + + /* TODO: GET_STATUS to see if endpoint is still halted */ + if ((ret == USBH_URBSTATUS_OK) && usbh_lld_ep_reset(ep)) { + return HAL_SUCCESS; + } + return HAL_FAILED; +} /*===========================================================================*/ /* URB API. */ @@ -258,7 +280,6 @@ bool _usbh_urb_abortI(usbh_urb_t *urb, usbh_urbstatus_t status) { _usbh_urb_completeI(urb, status); return TRUE; -// case USBH_URBSTATUS_QUEUED: case USBH_URBSTATUS_PENDING: return usbh_lld_urb_abort(urb, status); } @@ -271,11 +292,18 @@ void _usbh_urb_abort_and_waitS(usbh_urb_t *urb, usbh_urbstatus_t status) { if (_usbh_urb_abortI(urb, status) == FALSE) { uwarn("URB wasn't aborted immediately, suspend"); osalThreadSuspendS(&urb->abortingThread); - urb->abortingThread = 0; - } else { + osalDbgAssert(urb->abortingThread == 0, "maybe we should uncomment the line below"); + //urb->abortingThread = 0; + } +#if !(USBH_DEBUG_ENABLE && USBH_DEBUG_ENABLE_WARNINGS) + else { osalOsRescheduleS(); } +#else uwarn("URB aborted"); + osalOsRescheduleS(); /* debug printing functions call I-class functions inside + which may cause a priority violation without this call */ +#endif } bool usbhURBCancelI(usbh_urb_t *urb) { @@ -295,9 +323,9 @@ msg_t usbhURBWaitTimeoutS(usbh_urb_t *urb, systime_t timeout) { switch (urb->status) { case USBH_URBSTATUS_INITIALIZED: case USBH_URBSTATUS_PENDING: -// case USBH_URBSTATUS_QUEUED: ret = osalThreadSuspendTimeoutS(&urb->waitingThread, timeout); - urb->waitingThread = 0; + osalDbgAssert(urb->waitingThread == 0, "maybe we should uncomment the line below"); + //urb->waitingThread = 0; break; case USBH_URBSTATUS_OK: @@ -408,7 +436,7 @@ usbh_urbstatus_t usbhControlRequest(usbh_device_t *dev, uint16_t wLength, uint8_t *buff) { - const USBH_DEFINE_BUFFER(usbh_control_request_t, req) = { + USBH_DEFINE_BUFFER(const usbh_control_request_t req) = { bmRequestType, bRequest, wValue, @@ -511,7 +539,7 @@ bool usbhStdReqGetInterface(usbh_device_t *dev, uint8_t bInterfaceNumber, uint8_t *bAlternateSetting) { - USBH_DEFINE_BUFFER(uint8_t, alt); + USBH_DEFINE_BUFFER(uint8_t alt); usbh_urbstatus_t ret = usbhControlRequest(dev, USBH_GET_INTERFACE(bInterfaceNumber), 1, &alt); if (ret != USBH_URBSTATUS_OK) @@ -720,7 +748,7 @@ static bool _device_enumerate(usbh_device_t *dev) { #if USBH_DEBUG_ENABLE && USBH_DEBUG_ENABLE_INFO void usbhDevicePrintInfo(usbh_device_t *dev) { - USBH_DEFINE_BUFFER(char, str[64]); + USBH_DEFINE_BUFFER(char str[64]); usbh_device_descriptor_t *const desc = &dev->devDesc; uinfo("----- Device info -----"); @@ -934,7 +962,7 @@ static void _port_connected(usbh_port_t *port) { uint8_t i; uint8_t retries; usbh_devspeed_t speed; - USBH_DEFINE_BUFFER(usbh_string_descriptor_t, strdesc); + USBH_DEFINE_BUFFER(usbh_string_descriptor_t strdesc); uinfof("Port %d connected, wait debounce...", port->number); @@ -1313,9 +1341,11 @@ static bool _classdriver_load(usbh_device_t *dev, uint8_t class, success: /* Link this driver to the device */ - drv->next = dev->drivers; - dev->drivers = drv; - drv->dev = dev; + if (!drv->dev) { + drv->next = dev->drivers; + dev->drivers = drv; + drv->dev = dev; + } return HAL_SUCCESS; } diff --git a/os/hal/src/usbh/hal_usbh_debug.c b/os/hal/src/usbh/hal_usbh_debug.c index 51ca166..497aa39 100644 --- a/os/hal/src/usbh/hal_usbh_debug.c +++ b/os/hal/src/usbh/hal_usbh_debug.c @@ -17,15 +17,13 @@ #include "hal.h" -#if HAL_USE_USBH +#if HAL_USE_USBH && USBH_DEBUG_ENABLE #include "ch.h" #include "usbh/debug.h" #include #include "chprintf.h" -#if USBH_DEBUG_ENABLE - #define MAX_FILLER 11 #define FLOAT_PRECISION 9 #define MPRINTF_USE_FLOAT 0 @@ -472,8 +470,8 @@ void usbDbgSystemHalted(void) { } } -static void usb_debug_thread(void *p) { - USBHDriver *host = (USBHDriver *)p; +static void usb_debug_thread(void *arg) { + USBHDriver *host = (USBHDriver *)arg; uint8_t state = 0; chRegSetThreadName("USBH_DBG"); @@ -531,6 +529,5 @@ void usbDbgInit(USBHDriver *host) { iqObjectInit(&USBH_DEBUG_USBHD.iq, USBH_DEBUG_USBHD.dbg_buff, sizeof(USBH_DEBUG_USBHD.dbg_buff), 0, 0); chThdCreateStatic(USBH_DEBUG_USBHD.waDebug, sizeof(USBH_DEBUG_USBHD.waDebug), NORMALPRIO, usb_debug_thread, &USBH_DEBUG_USBHD); } -#endif #endif diff --git a/os/hal/src/usbh/hal_usbh_desciter.c b/os/hal/src/usbh/hal_usbh_desciter.c index 63137d4..48d9d87 100644 --- a/os/hal/src/usbh/hal_usbh_desciter.c +++ b/os/hal/src/usbh/hal_usbh_desciter.c @@ -134,22 +134,18 @@ void cs_iter_next(generic_iterator_t *ics) { if ((curr[0] < 2) || (rem < 2) || (rem < curr[0])) return; - //for (;;) { - rem -= curr[0]; - curr += curr[0]; + rem -= curr[0]; + curr += curr[0]; - if ((curr[0] < 2) || (rem < 2) || (rem < curr[0])) - return; - - if ((curr[1] == USBH_DT_INTERFACE_ASSOCIATION) - || (curr[1] == USBH_DT_INTERFACE) - || (curr[1] == USBH_DT_CONFIG) - || (curr[1] == USBH_DT_ENDPOINT)) { - return; - } + if ((curr[0] < 2) || (rem < 2) || (rem < curr[0])) + return; - // break; - //} + if ((curr[1] == USBH_DT_INTERFACE_ASSOCIATION) + || (curr[1] == USBH_DT_INTERFACE) + || (curr[1] == USBH_DT_CONFIG) + || (curr[1] == USBH_DT_ENDPOINT)) { + return; + } ics->valid = 1; ics->rem = rem; diff --git a/os/hal/src/usbh/hal_usbh_ftdi.c b/os/hal/src/usbh/hal_usbh_ftdi.c index 4bd7296..12ed0f9 100644 --- a/os/hal/src/usbh/hal_usbh_ftdi.c +++ b/os/hal/src/usbh/hal_usbh_ftdi.c @@ -16,7 +16,6 @@ */ #include "hal.h" -#include "hal_usbh.h" #if HAL_USBH_USE_FTDI @@ -114,8 +113,7 @@ static usbh_baseclassdriver_t *_ftdi_load(usbh_device_t *dev, const uint8_t *des if ((rem < descriptor[0]) || (descriptor[1] != USBH_DT_INTERFACE)) return NULL; - const usbh_interface_descriptor_t * const ifdesc = (const usbh_interface_descriptor_t * const)descriptor; - if (ifdesc->bInterfaceNumber != 0) { + if (((const usbh_interface_descriptor_t *)descriptor)->bInterfaceNumber != 0) { uwarn("FTDI: Will allocate driver along with IF #0"); } @@ -324,7 +322,7 @@ static usbh_urbstatus_t _ftdi_port_control(USBHFTDIPortDriver *ftdipp, osalDbgCheck(bRequest < sizeof_array(bmRequestType)); osalDbgCheck(bRequest != 1); - const USBH_DEFINE_BUFFER(usbh_control_request_t, req) = { + USBH_DEFINE_BUFFER(const usbh_control_request_t req) = { bmRequestType[bRequest], bRequest, wValue, @@ -387,7 +385,7 @@ static usbh_urbstatus_t _set_baudrate(USBHFTDIPortDriver *ftdipp, uint32_t baudr if (ftdipp->ftdip->dev->basicConfigDesc.bNumInterfaces > 1) wIndex = (wIndex << 8) | (ftdipp->ifnum + 1); - const USBH_DEFINE_BUFFER(usbh_control_request_t, req) = { + USBH_DEFINE_BUFFER(const usbh_control_request_t req) = { USBH_REQTYPE_VENDOR | USBH_REQTYPE_OUT | USBH_REQTYPE_DEVICE, FTDI_COMMAND_SETBAUD, wValue, @@ -714,4 +712,14 @@ void usbhftdipObjectInit(USBHFTDIPortDriver *ftdipp) { ftdipp->state = USBHFTDIP_STATE_STOP; } +void usbhftdiInit(void) { + uint8_t i; + for (i = 0; i < HAL_USBHFTDI_MAX_INSTANCES; i++) { + usbhftdiObjectInit(&USBHFTDID[i]); + } + for (i = 0; i < HAL_USBHFTDI_MAX_PORTS; i++) { + usbhftdipObjectInit(&FTDIPD[i]); + } +} + #endif diff --git a/os/hal/src/usbh/hal_usbh_hub.c b/os/hal/src/usbh/hal_usbh_hub.c index 56257b2..15c3534 100644 --- a/os/hal/src/usbh/hal_usbh_hub.c +++ b/os/hal/src/usbh/hal_usbh_hub.c @@ -15,10 +15,7 @@ limitations under the License. */ -#include #include "hal.h" -#include "hal_usbh.h" -#include "usbh/internal.h" #if HAL_USBH_USE_HUB @@ -28,6 +25,7 @@ #include #include "usbh/dev/hub.h" +#include "usbh/internal.h" #if USBHHUB_DEBUG_ENABLE_TRACE #define udbgf(f, ...) usbDbgPrintf(f, ##__VA_ARGS__) @@ -63,7 +61,7 @@ USBHHubDriver USBHHUBD[HAL_USBHHUB_MAX_INSTANCES]; -usbh_port_t USBHPorts[HAL_USBHHUB_MAX_PORTS]; +static usbh_port_t USBHPorts[HAL_USBHHUB_MAX_PORTS]; static usbh_baseclassdriver_t *hub_load(usbh_device_t *dev, const uint8_t *descriptor, uint16_t rem); static void hub_unload(usbh_baseclassdriver_t *drv); @@ -290,9 +288,18 @@ void usbhhubObjectInit(USBHHubDriver *hubdp) { memset(hubdp, 0, sizeof(*hubdp)); hubdp->info = &usbhhubClassDriverInfo; } + +void usbhhubInit(void) { + uint8_t i; + for (i = 0; i < HAL_USBHHUB_MAX_INSTANCES; i++) { + usbhhubObjectInit(&USBHHUBD[i]); + } +} + #else #if HAL_USE_USBH +#include void _usbhub_port_object_init(usbh_port_t *port, USBHDriver *usbh, uint8_t number) { memset(port, 0, sizeof(*port)); port->number = number; diff --git a/os/hal/src/usbh/hal_usbh_msd.c b/os/hal/src/usbh/hal_usbh_msd.c index 7a4f826..0f02e03 100644 --- a/os/hal/src/usbh/hal_usbh_msd.c +++ b/os/hal/src/usbh/hal_usbh_msd.c @@ -16,7 +16,6 @@ */ #include "hal.h" -#include "hal_usbh.h" #if HAL_USBH_USE_MSD @@ -91,8 +90,8 @@ const usbh_classdriverinfo_t usbhmsdClassDriverInfo = { static usbh_baseclassdriver_t *_msd_load(usbh_device_t *dev, const uint8_t *descriptor, uint16_t rem) { int i; USBHMassStorageDriver *msdp; - uint8_t luns; // should declare it here to eliminate 'control bypass initialization' warning - usbh_urbstatus_t stat; // should declare it here to eliminate 'control bypass initialization' warning + uint8_t luns; + usbh_urbstatus_t stat; if ((rem < descriptor[0]) || (descriptor[1] != USBH_DT_INTERFACE)) return NULL; @@ -157,7 +156,7 @@ alloc_ok: /* read the number of LUNs */ uinfo("Reading Max LUN:"); - USBH_DEFINE_BUFFER(uint8_t, buff[4]); + USBH_DEFINE_BUFFER(uint8_t buff[4]); stat = usbhControlRequest(dev, USBH_CLASSIN(USBH_REQTYPE_INTERFACE, MSD_GET_MAX_LUN, 0, msdp->ifnum), 1, buff); @@ -240,7 +239,7 @@ static void _msd_unload(usbh_baseclassdriver_t *drv) { /* USB Bulk Only Transport SCSI Command block wrapper */ -PACKED_STRUCT { +typedef PACKED_STRUCT { uint32_t dCBWSignature; uint32_t dCBWTag; uint32_t dCBWDataTransferLength; @@ -253,9 +252,8 @@ PACKED_STRUCT { #define MSD_CBWFLAGS_D2H 0x80 #define MSD_CBWFLAGS_H2D 0x00 - /* USB Bulk Only Transport SCSI Command status wrapper */ -PACKED_STRUCT { +typedef PACKED_STRUCT { uint32_t dCSWSignature; uint32_t dCSWTag; uint32_t dCSWDataResidue; @@ -299,7 +297,7 @@ typedef struct { /* Request sense */ #define SCSI_CMD_REQUEST_SENSE 0x03 -PACKED_STRUCT { +typedef PACKED_STRUCT { uint8_t byte[18]; } scsi_sense_response_t; @@ -333,7 +331,7 @@ PACKED_STRUCT { /* Inquiry */ #define SCSI_CMD_INQUIRY 0x12 -PACKED_STRUCT { +typedef PACKED_STRUCT { uint8_t peripheral; uint8_t removable; uint8_t version; @@ -349,14 +347,14 @@ PACKED_STRUCT { /* Read Capacity 10 */ #define SCSI_CMD_READ_CAPACITY_10 0x25 -PACKED_STRUCT { +typedef PACKED_STRUCT { uint32_t last_block_addr; uint32_t block_size; } scsi_readcapacity10_response_t; /* Start/Stop Unit */ #define SCSI_CMD_START_STOP_UNIT 0x1B -PACKED_STRUCT { +typedef PACKED_STRUCT { uint8_t op_code; uint8_t lun_immed; uint8_t res1; @@ -682,7 +680,7 @@ bool usbhmsdLUNConnect(USBHMassStorageLUNDriver *lunp) { USBH_DEFINE_BUFFER(union { scsi_inquiry_response_t inq; - scsi_readcapacity10_response_t cap; }, u); + scsi_readcapacity10_response_t cap; } u); uinfo("INQUIRY..."); res = scsi_inquiry(lunp, &u.inq); @@ -936,4 +934,13 @@ void usbhmsdObjectInit(USBHMassStorageDriver *msdp) { osalMutexObjectInit(&msdp->mtx); } +void usbhmsdInit(void) { + uint8_t i; + for (i = 0; i < HAL_USBHMSD_MAX_INSTANCES; i++) { + usbhmsdObjectInit(&USBHMSD[i]); + } + for (i = 0; i < HAL_USBHMSD_MAX_LUNS; i++) { + usbhmsdLUNObjectInit(&MSBLKD[i]); + } +} #endif -- cgit v1.2.3 From cc347f02ba4c15d150c93bb6b40ede09498c658d Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Mon, 5 Jun 2017 10:26:17 -0300 Subject: Fix possible race condition in FTDI driver stop --- os/hal/src/usbh/hal_usbh_ftdi.c | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) (limited to 'os/hal/src') diff --git a/os/hal/src/usbh/hal_usbh_ftdi.c b/os/hal/src/usbh/hal_usbh_ftdi.c index 12ed0f9..cce899c 100644 --- a/os/hal/src/usbh/hal_usbh_ftdi.c +++ b/os/hal/src/usbh/hal_usbh_ftdi.c @@ -209,7 +209,7 @@ alloc_ok: } -static void _stop(USBHFTDIPortDriver *ftdipp); +static void _stopS(USBHFTDIPortDriver *ftdipp); static void _ftdi_unload(usbh_baseclassdriver_t *drv) { osalDbgCheck(drv != NULL); USBHFTDIDriver *const ftdip = (USBHFTDIDriver *)drv; @@ -217,7 +217,10 @@ static void _ftdi_unload(usbh_baseclassdriver_t *drv) { osalMutexLock(&ftdip->mtx); while (ftdipp) { - _stop(ftdipp); + osalSysLock(); + _stopS(ftdipp); + osalOsRescheduleS(); + osalSysUnlock(); ftdipp = ftdipp->next; } @@ -624,29 +627,27 @@ static const struct FTDIPortDriverVMT async_channel_vmt = { }; -static void _stop(USBHFTDIPortDriver *ftdipp) { - osalSysLock(); +static void _stopS(USBHFTDIPortDriver *ftdipp) { + if (ftdipp->state != USBHFTDIP_STATE_READY) + return; chVTResetI(&ftdipp->vt); usbhEPCloseS(&ftdipp->epin); usbhEPCloseS(&ftdipp->epout); chThdDequeueAllI(&ftdipp->iq_waiting, Q_RESET); chThdDequeueAllI(&ftdipp->oq_waiting, Q_RESET); - osalOsRescheduleS(); ftdipp->state = USBHFTDIP_STATE_ACTIVE; - osalSysUnlock(); } void usbhftdipStop(USBHFTDIPortDriver *ftdipp) { osalDbgCheck((ftdipp->state == USBHFTDIP_STATE_ACTIVE) || (ftdipp->state == USBHFTDIP_STATE_READY)); - if (ftdipp->state == USBHFTDIP_STATE_ACTIVE) { - return; - } - - osalMutexLock(&ftdipp->ftdip->mtx); - _stop(ftdipp); - osalMutexUnlock(&ftdipp->ftdip->mtx); + osalSysLock(); + chMtxLockS(&ftdipp->ftdip->mtx); + _stopS(ftdipp); + chMtxUnlockS(&ftdipp->ftdip->mtx); + osalOsRescheduleS(); + osalSysUnlock(); } void usbhftdipStart(USBHFTDIPortDriver *ftdipp, const USBHFTDIPortConfig *config) { -- cgit v1.2.3 From 835bb887c0557f0f26716c7f3570f6049925b1ec Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Mon, 5 Jun 2017 10:38:05 -0300 Subject: Add AOA (Android Accessory) class driver --- os/hal/src/hal_usbh.c | 9 +- os/hal/src/usbh/hal_usbh_aoa.c | 678 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 686 insertions(+), 1 deletion(-) create mode 100644 os/hal/src/usbh/hal_usbh_aoa.c (limited to 'os/hal/src') diff --git a/os/hal/src/hal_usbh.c b/os/hal/src/hal_usbh.c index 0d0bf06..350d1a7 100644 --- a/os/hal/src/hal_usbh.c +++ b/os/hal/src/hal_usbh.c @@ -24,6 +24,7 @@ //devices #include "usbh/dev/hub.h" +#include "usbh/dev/aoa.h" #include "usbh/dev/ftdi.h" #include "usbh/dev/msd.h" @@ -114,6 +115,9 @@ void usbhInit(void) { #if HAL_USBH_USE_FTDI usbhftdiInit(); #endif +#if HAL_USBH_USE_AOA + usbhaoaInit(); +#endif #if HAL_USBH_USE_MSD usbhmsdInit(); #endif @@ -1303,7 +1307,10 @@ static const usbh_classdriverinfo_t *usbh_classdrivers_lookup[] = { &usbhmsdClassDriverInfo, #endif #if HAL_USBH_USE_HUB - &usbhhubClassDriverInfo + &usbhhubClassDriverInfo, +#endif +#if HAL_USBH_USE_AOA + &usbhaoaClassDriverInfo, /* Leave always last */ #endif }; diff --git a/os/hal/src/usbh/hal_usbh_aoa.c b/os/hal/src/usbh/hal_usbh_aoa.c new file mode 100644 index 0000000..458cc20 --- /dev/null +++ b/os/hal/src/usbh/hal_usbh_aoa.c @@ -0,0 +1,678 @@ +/* + 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_AOA + +#if !HAL_USE_USBH +#error "USBHAOA needs USBH" +#endif + +#include +#include "usbh/dev/aoa.h" +#include "usbh/internal.h" + +//#pragma GCC optimize("Og") + + +#if USBHAOA_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 USBHAOA_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 USBHAOA_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 USBHAOA_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 + + +/*===========================================================================*/ +/* Constants */ +/*===========================================================================*/ + +#if !defined(HAL_USBHAOA_DEFAULT_MANUFACTURER) +#define HAL_USBHAOA_DEFAULT_MANUFACTURER "ChibiOS" +#endif + +#if !defined(HAL_USBHAOA_DEFAULT_MODEL) +#define HAL_USBHAOA_DEFAULT_MODEL "USBH AOA Driver" +#endif + +#if !defined(HAL_USBHAOA_DEFAULT_DESCRIPTION) +#define HAL_USBHAOA_DEFAULT_DESCRIPTION "ChibiOS USBH AOA Driver" +#endif + +#if !defined(HAL_USBHAOA_DEFAULT_VERSION) +#define HAL_USBHAOA_DEFAULT_VERSION CH_KERNEL_VERSION +#endif + +#if !defined(HAL_USBHAOA_DEFAULT_URI) +#define HAL_USBHAOA_DEFAULT_URI NULL +#endif + +#if !defined(HAL_USBHAOA_DEFAULT_SERIAL) +#define HAL_USBHAOA_DEFAULT_SERIAL NULL +#endif + +#if !defined(HAL_USBHAOA_DEFAULT_AUDIO_MODE) +#define HAL_USBHAOA_DEFAULT_AUDIO_MODE USBHAOA_AUDIO_MODE_DISABLED +#endif + +#define AOA_GOOGLE_VID 0x18D1 +#define AOA_GOOGLE_PID_ACCESSORY 0x2D00 +#define AOA_GOOGLE_PID_ACCESSORY_ABD 0x2D01 +#define AOA_GOOGLE_PID_AUDIO 0x2D02 +#define AOA_GOOGLE_PID_AUDIO_ABD 0x2D03 +#define AOA_GOOGLE_PID_ACCESSORY_AUDIO 0x2D04 +#define AOA_GOOGLE_PID_ACCESSORY_AUDIO_ABD 0x2D05 + +#define AOA_ACCESSORY_GET_PROTOCOL 51 +#define AOA_ACCESSORY_SEND_STRING 52 +#define AOA_ACCESSORY_START 53 + +#define AOA_SET_AUDIO_MODE 58 + +static bool _get_protocol(usbh_device_t *dev, uint16_t *protocol); +static bool _accessory_start(usbh_device_t *dev); +static bool _set_audio_mode(usbh_device_t *dev, uint16_t mode); +static bool _send_string(usbh_device_t *dev, uint8_t index, const char *string); + + +static void _stop_channelS(USBHAOAChannel *aoacp); + +/*===========================================================================*/ +/* USB Class driver loader for AOA */ +/*===========================================================================*/ +USBHAOADriver USBHAOAD[HAL_USBHAOA_MAX_INSTANCES]; + +static usbh_baseclassdriver_t *_aoa_load(usbh_device_t *dev, const uint8_t *descriptor, uint16_t rem); +static void _aoa_unload(usbh_baseclassdriver_t *drv); + +static const usbh_classdriver_vmt_t class_driver_vmt = { + _aoa_load, + _aoa_unload +}; + +const usbh_classdriverinfo_t usbhaoaClassDriverInfo = { + 0xff, 0xff, 0xff, "AOA", &class_driver_vmt +}; + +#if defined(HAL_USBHAOA_FILTER_CALLBACK) +extern usbhaoa_filter_callback_t HAL_USBHAOA_FILTER_CALLBACK; +#endif + +static usbh_baseclassdriver_t *_aoa_load(usbh_device_t *dev, const uint8_t *descriptor, uint16_t rem) { + int i; + USBHAOADriver *aoap; + + if (dev->devDesc.idVendor != AOA_GOOGLE_VID) { + uint16_t protocol; + static const USBHAOAConfig config = { + { + HAL_USBHAOA_DEFAULT_MANUFACTURER, + HAL_USBHAOA_DEFAULT_MODEL, + HAL_USBHAOA_DEFAULT_DESCRIPTION, + HAL_USBHAOA_DEFAULT_VERSION, + HAL_USBHAOA_DEFAULT_URI, + HAL_USBHAOA_DEFAULT_SERIAL + }, + + { + HAL_USBHAOA_DEFAULT_AUDIO_MODE, + } + }; + + uinfo("AOA: Unrecognized VID"); + +#if defined(HAL_USBHAOA_FILTER_CALLBACK) + if (!HAL_USBHAOA_FILTER_CALLBACK(dev, descriptor, rem, &config)) { + return NULL; + } +#endif + + uinfo("AOA: Try if it's an Android device"); + if (_get_protocol(dev, &protocol) != HAL_SUCCESS) { + return NULL; + } + uinfof("AOA: Possible Android device found (protocol=%d)", protocol); + + if (config.channel.manufacturer != NULL) { + if ((_send_string(dev, USBHAOA_ACCESSORY_STRING_MANUFACTURER, config.channel.manufacturer) != HAL_SUCCESS) + || (_send_string(dev, USBHAOA_ACCESSORY_STRING_MODEL, config.channel.model) != HAL_SUCCESS) + || (_send_string(dev, USBHAOA_ACCESSORY_STRING_DESCRIPTION, config.channel.description) != HAL_SUCCESS) + || (_send_string(dev, USBHAOA_ACCESSORY_STRING_VERSION, config.channel.version) != HAL_SUCCESS) + || (_send_string(dev, USBHAOA_ACCESSORY_STRING_URI, config.channel.uri) != HAL_SUCCESS) + || (_send_string(dev, USBHAOA_ACCESSORY_STRING_SERIAL, config.channel.serial) != HAL_SUCCESS)) { + uerr("AOA: Can't send string; abort start"); + return NULL; + } + } + + if (protocol > 1) { + if (_set_audio_mode(dev, (uint16_t)(config.audio.mode)) != HAL_SUCCESS) { + uerr("AOA: Can't set audio mode; abort channel start"); + return NULL; + } + } + + if (_accessory_start(dev) != HAL_SUCCESS) { + uerr("AOA: Can't start accessory; abort channel start"); + } + + return NULL; + } + + /* AOAv2: + 0x2D00 accessory Provides two bulk endpoints for communicating with an Android application. + 0x2D01 accessory + adb For debugging purposes during accessory development. Available only if the user has enabled USB Debugging in the Android device settings. + 0x2D02 audio For streaming audio from an Android device to an accessory. + 0x2D03 audio + adb + 0x2D04 accessory + audio + 0x2D05 accessory + audio + adb + */ + + switch (dev->devDesc.idProduct) { + case AOA_GOOGLE_PID_ACCESSORY: + case AOA_GOOGLE_PID_ACCESSORY_ABD: +// case AOA_GOOGLE_PID_AUDIO: +// case AOA_GOOGLE_PID_AUDIO_ABD: + case AOA_GOOGLE_PID_ACCESSORY_AUDIO: + case AOA_GOOGLE_PID_ACCESSORY_AUDIO_ABD: + break; + default: + uerr("AOA: Unrecognized PID"); + return NULL; + } + + 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->bInterfaceClass != 0xff) + || (ifdesc->bInterfaceSubClass != 0xff) + || (ifdesc->bInterfaceProtocol != 0x00) + || (ifdesc->bNumEndpoints < 2)) { + uerr("AOA: This IF is not the Accessory IF"); + return NULL; + } + + uinfof("AOA: Found Accessory Interface #%d", ifdesc->bInterfaceNumber); + + for (i = 0; i < HAL_USBHAOA_MAX_INSTANCES; i++) { + if (USBHAOAD[i].dev == NULL) { + aoap = &USBHAOAD[i]; + goto alloc_ok; + } + } + + uwarn("AOA: Can't alloc driver"); + + /* can't alloc */ + return NULL; + +alloc_ok: + /* initialize the driver's variables */ + usbhEPSetName(&dev->ctrl, "AOA[CTRL]"); + aoap->state = USBHAOA_STATE_ACTIVE; + + generic_iterator_t iep; + if_iterator_t iif; + iif.iad = 0; + iif.curr = descriptor; + iif.rem = rem; + + aoap->channel.epin.status = USBH_EPSTATUS_UNINITIALIZED; + aoap->channel.epout.status = USBH_EPSTATUS_UNINITIALIZED; + + 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_BULK)) { + uinfof("AOA: BULK IN endpoint found: bEndpointAddress=%02x", epdesc->bEndpointAddress); + usbhEPObjectInit(&aoap->channel.epin, dev, epdesc); + usbhEPSetName(&aoap->channel.epin, "AOA[BIN ]"); + } else if (((epdesc->bEndpointAddress & 0x80) == 0) + && (epdesc->bmAttributes == USBH_EPTYPE_BULK)) { + uinfof("AOA: BULK OUT endpoint found: bEndpointAddress=%02x", epdesc->bEndpointAddress); + usbhEPObjectInit(&aoap->channel.epout, dev, epdesc); + usbhEPSetName(&aoap->channel.epout, "AOA[BOUT]"); + } else { + uinfof("AOA: unsupported endpoint found: bEndpointAddress=%02x, bmAttributes=%02x", + epdesc->bEndpointAddress, epdesc->bmAttributes); + } + } + + if ((aoap->channel.epin.status != USBH_EPSTATUS_CLOSED) + || (aoap->channel.epout.status != USBH_EPSTATUS_CLOSED)) { + uwarn("AOA: Couldn't find endpoints"); + aoap->state = USBHAOA_STATE_STOP; + return NULL; + } + + aoap->state = USBHAOA_STATE_READY; + aoap->channel.state = USBHAOA_CHANNEL_STATE_ACTIVE; + uwarn("AOA: Ready"); + return (usbh_baseclassdriver_t *)aoap; +} + +static void _aoa_unload(usbh_baseclassdriver_t *drv) { + osalDbgCheck(drv != NULL); + USBHAOADriver *const aoap = (USBHAOADriver *)drv; + osalSysLock(); + _stop_channelS(&aoap->channel); + aoap->channel.state = USBHAOA_CHANNEL_STATE_STOP; + aoap->state = USBHAOA_STATE_STOP; + osalOsRescheduleS(); + osalSysUnlock(); +} + +/* ------------------------------------ */ +/* Accessory data channel */ +/* ------------------------------------ */ + +static void _submitOutI(USBHAOAChannel *aoacp, uint32_t len) { + udbgf("AOA: Submit OUT %d", len); + aoacp->oq_urb.requestedLength = len; + usbhURBObjectResetI(&aoacp->oq_urb); + usbhURBSubmitI(&aoacp->oq_urb); +} + +static void _out_cb(usbh_urb_t *urb) { + USBHAOAChannel *const aoacp = (USBHAOAChannel *)urb->userData; + switch (urb->status) { + case USBH_URBSTATUS_OK: + aoacp->oq_ptr = aoacp->oq_buff; + aoacp->oq_counter = 64; + chThdDequeueNextI(&aoacp->oq_waiting, Q_OK); + chnAddFlagsI(aoacp, CHN_OUTPUT_EMPTY | CHN_TRANSMISSION_END); + return; + case USBH_URBSTATUS_DISCONNECTED: + uwarn("AOA: URB OUT disconnected"); + chThdDequeueNextI(&aoacp->oq_waiting, Q_RESET); + chnAddFlagsI(aoacp, CHN_OUTPUT_EMPTY); + return; + default: + uerrf("AOA: URB OUT status unexpected = %d", urb->status); + break; + } + usbhURBObjectResetI(&aoacp->oq_urb); + usbhURBSubmitI(&aoacp->oq_urb); +} + +static size_t _write_timeout(USBHAOAChannel *aoacp, const uint8_t *bp, + size_t n, systime_t timeout) { + chDbgCheck(n > 0U); + + size_t w = 0; + chSysLock(); + while (true) { + if (aoacp->state != USBHAOA_CHANNEL_STATE_READY) { + chSysUnlock(); + return w; + } + while (usbhURBIsBusy(&aoacp->oq_urb)) { + if (chThdEnqueueTimeoutS(&aoacp->oq_waiting, timeout) != Q_OK) { + chSysUnlock(); + return w; + } + } + + *aoacp->oq_ptr++ = *bp++; + if (--aoacp->oq_counter == 0) { + _submitOutI(aoacp, 64); + chSchRescheduleS(); + } + chSysUnlock(); /* Gives a preemption chance in a controlled point.*/ + + w++; + if (--n == 0U) + return w; + + chSysLock(); + } +} + +static msg_t _put_timeout(USBHAOAChannel *aoacp, uint8_t b, systime_t timeout) { + + chSysLock(); + if (aoacp->state != USBHAOA_CHANNEL_STATE_READY) { + chSysUnlock(); + return Q_RESET; + } + + while (usbhURBIsBusy(&aoacp->oq_urb)) { + msg_t msg = chThdEnqueueTimeoutS(&aoacp->oq_waiting, timeout); + if (msg < Q_OK) { + chSysUnlock(); + return msg; + } + } + + *aoacp->oq_ptr++ = b; + if (--aoacp->oq_counter == 0) { + _submitOutI(aoacp, 64); + chSchRescheduleS(); + } + chSysUnlock(); + return Q_OK; +} + +static size_t _write(USBHAOAChannel *aoacp, const uint8_t *bp, size_t n) { + return _write_timeout(aoacp, bp, n, TIME_INFINITE); +} + +static msg_t _put(USBHAOAChannel *aoacp, uint8_t b) { + return _put_timeout(aoacp, b, TIME_INFINITE); +} + +static void _submitInI(USBHAOAChannel *aoacp) { + udbg("AOA: Submit IN"); + usbhURBObjectResetI(&aoacp->iq_urb); + usbhURBSubmitI(&aoacp->iq_urb); +} + +static void _in_cb(usbh_urb_t *urb) { + USBHAOAChannel *const aoacp = (USBHAOAChannel *)urb->userData; + switch (urb->status) { + case USBH_URBSTATUS_OK: + if (urb->actualLength == 0) { + udbgf("AOA: URB IN no data"); + } else { + udbgf("AOA: URB IN data len=%d", urb->actualLength); + aoacp->iq_ptr = aoacp->iq_buff; + aoacp->iq_counter = urb->actualLength; + chThdDequeueNextI(&aoacp->iq_waiting, Q_OK); + chnAddFlagsI(aoacp, CHN_INPUT_AVAILABLE); + } + break; + case USBH_URBSTATUS_DISCONNECTED: + uwarn("AOA: URB IN disconnected"); + chThdDequeueNextI(&aoacp->iq_waiting, Q_RESET); + break; + default: + uerrf("AOA: URB IN status unexpected = %d", urb->status); + _submitInI(aoacp); + break; + } +} + +static size_t _read_timeout(USBHAOAChannel *aoacp, uint8_t *bp, + size_t n, systime_t timeout) { + size_t r = 0; + + chDbgCheck(n > 0U); + + chSysLock(); + while (true) { + if (aoacp->state != USBHAOA_CHANNEL_STATE_READY) { + chSysUnlock(); + return r; + } + while (aoacp->iq_counter == 0) { + if (!usbhURBIsBusy(&aoacp->iq_urb)) + _submitInI(aoacp); + if (chThdEnqueueTimeoutS(&aoacp->iq_waiting, timeout) != Q_OK) { + chSysUnlock(); + return r; + } + } + *bp++ = *aoacp->iq_ptr++; + if (--aoacp->iq_counter == 0) { + _submitInI(aoacp); + chSchRescheduleS(); + } + chSysUnlock(); + + r++; + if (--n == 0U) + return r; + + chSysLock(); + } +} + +static msg_t _get_timeout(USBHAOAChannel *aoacp, systime_t timeout) { + uint8_t b; + + chSysLock(); + if (aoacp->state != USBHAOA_CHANNEL_STATE_READY) { + chSysUnlock(); + return Q_RESET; + } + while (aoacp->iq_counter == 0) { + if (!usbhURBIsBusy(&aoacp->iq_urb)) + _submitInI(aoacp); + msg_t msg = chThdEnqueueTimeoutS(&aoacp->iq_waiting, timeout); + if (msg < Q_OK) { + chSysUnlock(); + return msg; + } + } + b = *aoacp->iq_ptr++; + if (--aoacp->iq_counter == 0) { + _submitInI(aoacp); + chSchRescheduleS(); + } + chSysUnlock(); + + return (msg_t)b; +} + +static msg_t _get(USBHAOAChannel *aoacp) { + return _get_timeout(aoacp, TIME_INFINITE); +} + +static size_t _read(USBHAOAChannel *aoacp, uint8_t *bp, size_t n) { + return _read_timeout(aoacp, bp, n, TIME_INFINITE); +} + +static const struct AOADriverVMT async_channel_vmt = { + (size_t (*)(void *, const uint8_t *, size_t))_write, + (size_t (*)(void *, uint8_t *, size_t))_read, + (msg_t (*)(void *, uint8_t))_put, + (msg_t (*)(void *))_get, + (msg_t (*)(void *, uint8_t, systime_t))_put_timeout, + (msg_t (*)(void *, systime_t))_get_timeout, + (size_t (*)(void *, const uint8_t *, size_t, systime_t))_write_timeout, + (size_t (*)(void *, uint8_t *, size_t, systime_t))_read_timeout +}; + +static void _stop_channelS(USBHAOAChannel *aoacp) { + if (aoacp->state != USBHAOA_CHANNEL_STATE_READY) + return; + uwarn("AOA: Stop channel"); + chVTResetI(&aoacp->vt); + usbhEPCloseS(&aoacp->epin); + usbhEPCloseS(&aoacp->epout); + chThdDequeueAllI(&aoacp->iq_waiting, Q_RESET); + chThdDequeueAllI(&aoacp->oq_waiting, Q_RESET); + chnAddFlagsI(aoacp, CHN_DISCONNECTED); + aoacp->state = USBHAOA_CHANNEL_STATE_ACTIVE; +} + +static void _vt(void *p) { + USBHAOAChannel *const aoacp = (USBHAOAChannel *)p; + chSysLockFromISR(); + uint32_t len = aoacp->oq_ptr - aoacp->oq_buff; + if (len && !usbhURBIsBusy(&aoacp->oq_urb)) { + _submitOutI(aoacp, len); + } + if ((aoacp->iq_counter == 0) && !usbhURBIsBusy(&aoacp->iq_urb)) { + _submitInI(aoacp); + } + chVTSetI(&aoacp->vt, MS2ST(16), _vt, aoacp); + chSysUnlockFromISR(); +} + +void usbhaoaChannelStart(USBHAOADriver *aoap) { + + osalDbgCheck(aoap); + + USBHAOAChannel *const aoacp = (USBHAOAChannel *)&aoap->channel; + + osalDbgCheck(aoap->state == USBHAOA_STATE_READY); + + osalDbgCheck((aoacp->state == USBHAOA_CHANNEL_STATE_ACTIVE) + || (aoacp->state == USBHAOA_CHANNEL_STATE_READY)); + + if (aoacp->state == USBHAOA_CHANNEL_STATE_READY) + return; + + usbhURBObjectInit(&aoacp->oq_urb, &aoacp->epout, _out_cb, aoacp, aoacp->oq_buff, 0); + chThdQueueObjectInit(&aoacp->oq_waiting); + aoacp->oq_counter = 64; + aoacp->oq_ptr = aoacp->oq_buff; + usbhEPOpen(&aoacp->epout); + + usbhURBObjectInit(&aoacp->iq_urb, &aoacp->epin, _in_cb, aoacp, aoacp->iq_buff, 64); + chThdQueueObjectInit(&aoacp->iq_waiting); + aoacp->iq_counter = 0; + aoacp->iq_ptr = aoacp->iq_buff; + usbhEPOpen(&aoacp->epin); + osalSysLock(); + usbhURBSubmitI(&aoacp->iq_urb); + osalSysUnlock(); + + chVTObjectInit(&aoacp->vt); + chVTSet(&aoacp->vt, MS2ST(16), _vt, aoacp); + + aoacp->state = USBHAOA_CHANNEL_STATE_READY; + + osalEventBroadcastFlags(&aoacp->event, CHN_CONNECTED | CHN_OUTPUT_EMPTY); +} + +void usbhaoaChannelStop(USBHAOADriver *aoap) { + osalDbgCheck((aoap->channel.state == USBHAOA_CHANNEL_STATE_ACTIVE) + || (aoap->channel.state == USBHAOA_CHANNEL_STATE_READY)); + osalSysLock(); + _stop_channelS(&aoap->channel); + osalOsRescheduleS(); + osalSysUnlock(); +} + +/* ------------------------------------ */ +/* General AOA functions */ +/* ------------------------------------ */ +static bool _get_protocol(usbh_device_t *dev, uint16_t *protocol) { + USBH_DEFINE_BUFFER(uint16_t proto); + + usbh_urbstatus_t ret = usbhControlRequest(dev, + USBH_REQTYPE_IN | USBH_REQTYPE_VENDOR | USBH_REQTYPE_DEVICE, + AOA_ACCESSORY_GET_PROTOCOL, + 0, + 0, + 2, + (uint8_t *)&proto); + + if ((ret != USBH_URBSTATUS_OK) || (proto > 2)) + return HAL_FAILED; + + *protocol = proto; + return HAL_SUCCESS; +} + +static bool _accessory_start(usbh_device_t *dev) { + usbh_urbstatus_t ret = usbhControlRequest(dev, + USBH_REQTYPE_OUT | USBH_REQTYPE_VENDOR | USBH_REQTYPE_DEVICE, + AOA_ACCESSORY_START, + 0, + 0, + 0, + NULL); + + if (ret != USBH_URBSTATUS_OK) + return HAL_FAILED; + + return HAL_SUCCESS; +} + +static bool _set_audio_mode(usbh_device_t *dev, uint16_t mode) { + usbh_urbstatus_t ret = usbhControlRequest(dev, + USBH_REQTYPE_OUT | USBH_REQTYPE_VENDOR | USBH_REQTYPE_DEVICE, + AOA_SET_AUDIO_MODE, + mode, + 0, + 0, + NULL); + + if (ret != USBH_URBSTATUS_OK) + return HAL_FAILED; + + return HAL_SUCCESS; +} + +static bool _send_string(usbh_device_t *dev, uint8_t index, const char *string) +{ + USBH_DEFINE_BUFFER(const char nullstr[1]) = {0}; + if (string == NULL) + string = nullstr; + + usbh_urbstatus_t ret = usbhControlRequest(dev, + USBH_REQTYPE_OUT | USBH_REQTYPE_VENDOR | USBH_REQTYPE_DEVICE, + AOA_ACCESSORY_SEND_STRING, + 0, + index, + strlen(string) + 1, + (uint8_t *)string); + + if (ret != USBH_URBSTATUS_OK) + return HAL_FAILED; + + return HAL_SUCCESS; +} + +void usbhaoaObjectInit(USBHAOADriver *aoap) { + osalDbgCheck(aoap != NULL); + memset(aoap, 0, sizeof(*aoap)); + aoap->info = &usbhaoaClassDriverInfo; + aoap->state = USBHAOA_STATE_STOP; + aoap->channel.vmt = &async_channel_vmt; + osalEventObjectInit(&aoap->channel.event); + aoap->channel.state = USBHAOA_CHANNEL_STATE_STOP; +} + +void usbhaoaInit(void) { + uint8_t i; + for (i = 0; i < HAL_USBHAOA_MAX_INSTANCES; i++) { + usbhaoaObjectInit(&USBHAOAD[i]); + } +} + +#endif -- cgit v1.2.3 From b58a299521ea3df51fa66a2f2a787b248a1d3ee4 Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Mon, 5 Jun 2017 10:41:42 -0300 Subject: Rework Mass Storage Driver - Implemented (hopefully) correct Mass Storage Reset Recovery protocol - Implemented auto-sense protocol for SCSI command failure --- os/hal/src/usbh/hal_usbh_msd.c | 606 ++++++++++++++++++++++------------------- 1 file changed, 332 insertions(+), 274 deletions(-) (limited to 'os/hal/src') diff --git a/os/hal/src/usbh/hal_usbh_msd.c b/os/hal/src/usbh/hal_usbh_msd.c index 0f02e03..a0d9361 100644 --- a/os/hal/src/usbh/hal_usbh_msd.c +++ b/os/hal/src/usbh/hal_usbh_msd.c @@ -261,32 +261,170 @@ typedef PACKED_STRUCT { } msd_csw_t; #define MSD_CSW_SIGNATURE 0x53425355 - -typedef union { - msd_cbw_t cbw; - msd_csw_t csw; +typedef struct { + msd_cbw_t *cbw; + uint8_t csw_status; + uint32_t data_processed; } msd_transaction_t; typedef enum { - MSD_TRANSACTIONRESULT_OK, - MSD_TRANSACTIONRESULT_DISCONNECTED, - MSD_TRANSACTIONRESULT_STALL, - MSD_TRANSACTIONRESULT_BUS_ERROR, - MSD_TRANSACTIONRESULT_SYNC_ERROR -} msd_transaction_result_t; + MSD_BOTRESULT_OK, + MSD_BOTRESULT_DISCONNECTED, + MSD_BOTRESULT_ERROR +} msd_bot_result_t; typedef enum { - MSD_COMMANDRESULT_PASSED = 0, - MSD_COMMANDRESULT_FAILED = 1, - MSD_COMMANDRESULT_PHASE_ERROR = 2 -} msd_command_result_t; - -typedef struct { - msd_transaction_result_t tres; - msd_command_result_t cres; + MSD_RESULT_OK = MSD_BOTRESULT_OK, + MSD_RESULT_DISCONNECTED = MSD_BOTRESULT_DISCONNECTED, + MSD_RESULT_TRANSPORT_ERROR = MSD_BOTRESULT_ERROR, + MSD_RESULT_FAILED } msd_result_t; +#define CSW_STATUS_PASSED 0 +#define CSW_STATUS_FAILED 1 +#define CSW_STATUS_PHASE_ERROR 2 + +static bool _msd_bot_reset(USBHMassStorageDriver *msdp) { + + usbh_urbstatus_t res; + res = usbhControlRequest(msdp->dev, USBH_CLASSOUT(USBH_REQTYPE_CLASS, 0xFF, 0, msdp->ifnum), 0, NULL); + if (res != USBH_URBSTATUS_OK) { + return FALSE; + } + + osalThreadSleepMilliseconds(100); + + return usbhEPReset(&msdp->epin) && usbhEPReset(&msdp->epout); +} + +static msd_bot_result_t _msd_bot_transaction(msd_transaction_t *tran, USBHMassStorageLUNDriver *lunp, void *data) { + + uint32_t data_actual_len, actual_len; + usbh_urbstatus_t status; + USBH_DEFINE_BUFFER(msd_csw_t csw); + + tran->cbw->bCBWLUN = (uint8_t)(lunp - &lunp->msdp->luns[0]); + tran->cbw->dCBWSignature = MSD_CBW_SIGNATURE; + tran->cbw->dCBWTag = ++lunp->msdp->tag; + tran->data_processed = 0; + + /* control phase */ + status = usbhBulkTransfer(&lunp->msdp->epout, &tran->cbw, + sizeof(tran->cbw), &actual_len, MS2ST(1000)); + + if (status == USBH_URBSTATUS_CANCELLED) { + uerr("\tMSD: Control phase: USBH_URBSTATUS_CANCELLED"); + return MSD_BOTRESULT_DISCONNECTED; + } + + if ((status != USBH_URBSTATUS_OK) || (actual_len != sizeof(tran->cbw))) { + uerrf("\tMSD: Control phase: status = %d (!= OK), actual_len = %d (expected to send %d)", + status, actual_len, sizeof(tran->cbw)); + _msd_bot_reset(lunp->msdp); + return MSD_BOTRESULT_ERROR; + } + + + /* data phase */ + data_actual_len = 0; + if (tran->cbw->dCBWDataTransferLength) { + usbh_ep_t *const ep = tran->cbw->bmCBWFlags & MSD_CBWFLAGS_D2H ? &lunp->msdp->epin : &lunp->msdp->epout; + status = usbhBulkTransfer( + ep, + data, + tran->cbw->dCBWDataTransferLength, + &data_actual_len, MS2ST(20000)); + + if (status == USBH_URBSTATUS_CANCELLED) { + uerr("\tMSD: Data phase: USBH_URBSTATUS_CANCELLED"); + return MSD_BOTRESULT_DISCONNECTED; + } + + if (status == USBH_URBSTATUS_STALL) { + uerrf("\tMSD: Data phase: USBH_URBSTATUS_STALL, clear halt"); + status = usbhEPReset(ep); + } + + if (status != USBH_URBSTATUS_OK) { + uerrf("\tMSD: Data phase: status = %d (!= OK), resetting", status); + _msd_bot_reset(lunp->msdp); + return MSD_BOTRESULT_ERROR; + } + } + + + /* status phase */ + status = usbhBulkTransfer(&lunp->msdp->epin, &csw, + sizeof(csw), &actual_len, MS2ST(1000)); + + if (status == USBH_URBSTATUS_STALL) { + uwarn("\tMSD: Status phase: USBH_URBSTATUS_STALL, clear halt and retry"); + + status = usbhEPReset(&lunp->msdp->epin); + + if (status == USBH_URBSTATUS_OK) { + status = usbhBulkTransfer(&lunp->msdp->epin, &csw, + sizeof(csw), &actual_len, MS2ST(1000)); + } + } + + if (status == USBH_URBSTATUS_CANCELLED) { + uerr("\tMSD: Status phase: USBH_URBSTATUS_CANCELLED"); + return MSD_BOTRESULT_DISCONNECTED; + } + + if (status != USBH_URBSTATUS_OK) { + uerrf("\tMSD: Status phase: status = %d (!= OK), resetting", status); + _msd_bot_reset(lunp->msdp); + return MSD_BOTRESULT_ERROR; + } + + /* validate CSW */ + if ((actual_len != sizeof(csw)) + || (csw.dCSWSignature != MSD_CSW_SIGNATURE) + || (csw.dCSWTag != lunp->msdp->tag) + || (csw.bCSWStatus >= CSW_STATUS_PHASE_ERROR)) { + /* CSW is not valid */ + uerrf("\tMSD: Status phase: Invalid CSW: len=%d, dCSWSignature=%x, dCSWTag=%x (expected %x), bCSWStatus=%d, resetting", + actual_len, + csw.dCSWSignature, + csw.dCSWTag, + lunp->msdp->tag, + csw.bCSWStatus); + _msd_bot_reset(lunp->msdp); + return MSD_BOTRESULT_ERROR; + } + + /* check if CSW is meaningful */ + if ((csw.bCSWStatus != CSW_STATUS_PHASE_ERROR) + && (csw.dCSWDataResidue > tran->cbw->dCBWDataTransferLength)) { + /* CSW is not meaningful */ + uerrf("\tMSD: Status phase: CSW not meaningful: bCSWStatus=%d, dCSWDataResidue=%u, dCBWDataTransferLength=%u, resetting", + csw.bCSWStatus, + csw.dCSWDataResidue, + tran->cbw->dCBWDataTransferLength); + _msd_bot_reset(lunp->msdp); + return MSD_BOTRESULT_ERROR; + } + + if (csw.bCSWStatus == CSW_STATUS_PHASE_ERROR) { + uerr("\tMSD: Status phase: Phase error, resetting"); + _msd_bot_reset(lunp->msdp); + return MSD_BOTRESULT_ERROR; + } + + tran->data_processed = tran->cbw->dCBWDataTransferLength - csw.dCSWDataResidue; + if (data_actual_len < tran->data_processed) { + tran->data_processed = data_actual_len; + } + + tran->csw_status = csw.bCSWStatus; + + return MSD_BOTRESULT_OK; +} + + /* ----------------------------------------------------- */ /* SCSI Commands */ /* ----------------------------------------------------- */ @@ -366,216 +504,175 @@ typedef PACKED_STRUCT { /* test unit ready */ #define SCSI_CMD_TEST_UNIT_READY 0x00 -/* Other commands, TODO: use or remove them -#define SCSI_CMD_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1E -#define SCSI_CMD_VERIFY_10 0x2F -#define SCSI_CMD_SEND_DIAGNOSTIC 0x1D -#define SCSI_CMD_MODE_SENSE_6 0x1A -*/ - -static inline void _prepare_cbw(msd_transaction_t *tran, USBHMassStorageLUNDriver *lunp) { - tran->cbw.bCBWLUN = (uint8_t)(lunp - &lunp->msdp->luns[0]); - memset(&tran->cbw.CBWCB, 0, sizeof(tran->cbw.CBWCB)); -} +static msd_result_t scsi_requestsense(USBHMassStorageLUNDriver *lunp, scsi_sense_response_t *resp); -static msd_transaction_result_t _msd_transaction(msd_transaction_t *tran, USBHMassStorageLUNDriver *lunp, void *data) { +static msd_result_t _scsi_perform_transaction(USBHMassStorageLUNDriver *lunp, + msd_transaction_t *transaction, void *data) { - uint32_t actual_len; - usbh_urbstatus_t status; - - tran->cbw.dCBWSignature = MSD_CBW_SIGNATURE; - tran->cbw.dCBWTag = ++lunp->msdp->tag; - - /* control phase */ - status = usbhBulkTransfer(&lunp->msdp->epout, &tran->cbw, - sizeof(tran->cbw), &actual_len, MS2ST(1000)); - - if (status == USBH_URBSTATUS_CANCELLED) { - uerr("\tMSD: Control phase: USBH_URBSTATUS_CANCELLED"); - return MSD_TRANSACTIONRESULT_DISCONNECTED; - } else if (status == USBH_URBSTATUS_STALL) { - uerr("\tMSD: Control phase: USBH_URBSTATUS_STALL"); - return MSD_TRANSACTIONRESULT_STALL; - } else if (status != USBH_URBSTATUS_OK) { - uerrf("\tMSD: Control phase: status = %d, != OK", status); - return MSD_TRANSACTIONRESULT_BUS_ERROR; - } else if (actual_len != sizeof(tran->cbw)) { - uerrf("\tMSD: Control phase: wrong actual_len = %d", actual_len); - return MSD_TRANSACTIONRESULT_BUS_ERROR; + msd_bot_result_t res; + res = _msd_bot_transaction(transaction, lunp, data); + if (res != MSD_BOTRESULT_OK) { + return (msd_result_t)res; } - - /* data phase */ - if (tran->cbw.dCBWDataTransferLength) { - status = usbhBulkTransfer( - tran->cbw.bmCBWFlags & MSD_CBWFLAGS_D2H ? &lunp->msdp->epin : &lunp->msdp->epout, - data, - tran->cbw.dCBWDataTransferLength, - &actual_len, MS2ST(20000)); - - if (status == USBH_URBSTATUS_CANCELLED) { - uerr("\tMSD: Data phase: USBH_URBSTATUS_CANCELLED"); - return MSD_TRANSACTIONRESULT_DISCONNECTED; - } else if (status == USBH_URBSTATUS_STALL) { - uerr("\tMSD: Data phase: USBH_URBSTATUS_STALL"); - return MSD_TRANSACTIONRESULT_STALL; - } else if (status != USBH_URBSTATUS_OK) { - uerrf("\tMSD: Data phase: status = %d, != OK", status); - return MSD_TRANSACTIONRESULT_BUS_ERROR; - } else if (actual_len != tran->cbw.dCBWDataTransferLength) { - uerrf("\tMSD: Data phase: wrong actual_len = %d", actual_len); - return MSD_TRANSACTIONRESULT_BUS_ERROR; + if (transaction->csw_status == CSW_STATUS_FAILED) { + if (transaction->cbw->CBWCB[0] != SCSI_CMD_REQUEST_SENSE) { + /* do auto-sense (except for SCSI_CMD_REQUEST_SENSE!) */ + uwarn("\tMSD: Command failed, auto-sense"); + USBH_DEFINE_BUFFER(scsi_sense_response_t sense); + if (scsi_requestsense(lunp, &sense) == MSD_RESULT_OK) { + uwarnf("\tMSD: REQUEST SENSE: Sense key=%x, ASC=%02x, ASCQ=%02x", + sense.byte[2] & 0xf, sense.byte[12], sense.byte[13]); + } } + return MSD_RESULT_FAILED; } - - /* status phase */ - status = usbhBulkTransfer(&lunp->msdp->epin, &tran->csw, - sizeof(tran->csw), &actual_len, MS2ST(1000)); - - if (status == USBH_URBSTATUS_CANCELLED) { - uerr("\tMSD: Status phase: USBH_URBSTATUS_CANCELLED"); - return MSD_TRANSACTIONRESULT_DISCONNECTED; - } else if (status == USBH_URBSTATUS_STALL) { - uerr("\tMSD: Status phase: USBH_URBSTATUS_STALL"); - return MSD_TRANSACTIONRESULT_STALL; - } else if (status != USBH_URBSTATUS_OK) { - uerrf("\tMSD: Status phase: status = %d, != OK", status); - return MSD_TRANSACTIONRESULT_BUS_ERROR; - } else if (actual_len != sizeof(tran->csw)) { - uerrf("\tMSD: Status phase: wrong actual_len = %d", actual_len); - return MSD_TRANSACTIONRESULT_BUS_ERROR; - } else if (tran->csw.dCSWSignature != MSD_CSW_SIGNATURE) { - uerr("\tMSD: Status phase: wrong signature"); - return MSD_TRANSACTIONRESULT_BUS_ERROR; - } else if (tran->csw.dCSWTag != lunp->msdp->tag) { - uerrf("\tMSD: Status phase: wrong tag (expected %d, got %d)", - lunp->msdp->tag, tran->csw.dCSWTag); - return MSD_TRANSACTIONRESULT_SYNC_ERROR; - } - - if (tran->csw.dCSWDataResidue) { - uwarnf("\tMSD: Residue=%d", tran->csw.dCSWDataResidue); - } - - return MSD_TRANSACTIONRESULT_OK; + return MSD_RESULT_OK; } - static msd_result_t scsi_inquiry(USBHMassStorageLUNDriver *lunp, scsi_inquiry_response_t *resp) { + USBH_DEFINE_BUFFER(msd_cbw_t cbw); msd_transaction_t transaction; msd_result_t res; - _prepare_cbw(&transaction, lunp); - transaction.cbw.dCBWDataTransferLength = sizeof(scsi_inquiry_response_t); - transaction.cbw.bmCBWFlags = MSD_CBWFLAGS_D2H; - transaction.cbw.bCBWCBLength = 6; - transaction.cbw.CBWCB[0] = SCSI_CMD_INQUIRY; - transaction.cbw.CBWCB[4] = sizeof(scsi_inquiry_response_t); - - res.tres = _msd_transaction(&transaction, lunp, resp); - if (res.tres == MSD_TRANSACTIONRESULT_OK) { - res.cres = (msd_command_result_t) transaction.csw.bCSWStatus; + memset(cbw.CBWCB, 0, sizeof(cbw.CBWCB)); + cbw.dCBWDataTransferLength = sizeof(scsi_inquiry_response_t); + cbw.bmCBWFlags = MSD_CBWFLAGS_D2H; + cbw.bCBWCBLength = 6; + cbw.CBWCB[0] = SCSI_CMD_INQUIRY; + cbw.CBWCB[4] = sizeof(scsi_inquiry_response_t); + transaction.cbw = &cbw; + + res = _scsi_perform_transaction(lunp, &transaction, resp); + if (res == MSD_RESULT_OK) { + //transaction is OK; check length + if (transaction.data_processed < cbw.dCBWDataTransferLength) { + res = MSD_RESULT_TRANSPORT_ERROR; + } } + return res; } static msd_result_t scsi_requestsense(USBHMassStorageLUNDriver *lunp, scsi_sense_response_t *resp) { + USBH_DEFINE_BUFFER(msd_cbw_t cbw); msd_transaction_t transaction; msd_result_t res; - _prepare_cbw(&transaction, lunp); - transaction.cbw.dCBWDataTransferLength = sizeof(scsi_sense_response_t); - transaction.cbw.bmCBWFlags = MSD_CBWFLAGS_D2H; - transaction.cbw.bCBWCBLength = 12; - transaction.cbw.CBWCB[0] = SCSI_CMD_REQUEST_SENSE; - transaction.cbw.CBWCB[4] = sizeof(scsi_sense_response_t); - - res.tres = _msd_transaction(&transaction, lunp, resp); - if (res.tres == MSD_TRANSACTIONRESULT_OK) { - res.cres = (msd_command_result_t) transaction.csw.bCSWStatus; + memset(cbw.CBWCB, 0, sizeof(cbw.CBWCB)); + cbw.dCBWDataTransferLength = sizeof(scsi_sense_response_t); + cbw.bmCBWFlags = MSD_CBWFLAGS_D2H; + cbw.bCBWCBLength = 12; + cbw.CBWCB[0] = SCSI_CMD_REQUEST_SENSE; + cbw.CBWCB[4] = sizeof(scsi_sense_response_t); + + res = _scsi_perform_transaction(lunp, &transaction, resp); + if (res == MSD_RESULT_OK) { + //transaction is OK; check length + if (transaction.data_processed < cbw.dCBWDataTransferLength) { + res = MSD_RESULT_TRANSPORT_ERROR; + } } + return res; } static msd_result_t scsi_testunitready(USBHMassStorageLUNDriver *lunp) { + USBH_DEFINE_BUFFER(msd_cbw_t cbw); msd_transaction_t transaction; - msd_result_t res; - _prepare_cbw(&transaction, lunp); - transaction.cbw.dCBWDataTransferLength = 0; - transaction.cbw.bmCBWFlags = MSD_CBWFLAGS_D2H; - transaction.cbw.bCBWCBLength = 6; - transaction.cbw.CBWCB[0] = SCSI_CMD_TEST_UNIT_READY; + memset(cbw.CBWCB, 0, sizeof(cbw.CBWCB)); + cbw.dCBWDataTransferLength = 0; + cbw.bmCBWFlags = MSD_CBWFLAGS_D2H; + cbw.bCBWCBLength = 6; + cbw.CBWCB[0] = SCSI_CMD_TEST_UNIT_READY; - res.tres = _msd_transaction(&transaction, lunp, NULL); - if (res.tres == MSD_TRANSACTIONRESULT_OK) { - res.cres = (msd_command_result_t) transaction.csw.bCSWStatus; - } - return res; + return _scsi_perform_transaction(lunp, &transaction, NULL); } static msd_result_t scsi_readcapacity10(USBHMassStorageLUNDriver *lunp, scsi_readcapacity10_response_t *resp) { + USBH_DEFINE_BUFFER(msd_cbw_t cbw); msd_transaction_t transaction; msd_result_t res; - _prepare_cbw(&transaction, lunp); - transaction.cbw.dCBWDataTransferLength = sizeof(scsi_readcapacity10_response_t); - transaction.cbw.bmCBWFlags = MSD_CBWFLAGS_D2H; - transaction.cbw.bCBWCBLength = 12; - transaction.cbw.CBWCB[0] = SCSI_CMD_READ_CAPACITY_10; - - res.tres = _msd_transaction(&transaction, lunp, resp); - if (res.tres == MSD_TRANSACTIONRESULT_OK) { - res.cres = (msd_command_result_t) transaction.csw.bCSWStatus; + memset(cbw.CBWCB, 0, sizeof(cbw.CBWCB)); + cbw.dCBWDataTransferLength = sizeof(scsi_readcapacity10_response_t); + cbw.bmCBWFlags = MSD_CBWFLAGS_D2H; + cbw.bCBWCBLength = 12; + cbw.CBWCB[0] = SCSI_CMD_READ_CAPACITY_10; + + res = _scsi_perform_transaction(lunp, &transaction, resp); + if (res == MSD_RESULT_OK) { + //transaction is OK; check length + if (transaction.data_processed < cbw.dCBWDataTransferLength) { + res = MSD_RESULT_TRANSPORT_ERROR; + } } + return res; } -static msd_result_t scsi_read10(USBHMassStorageLUNDriver *lunp, uint32_t lba, uint16_t n, uint8_t *data) { +static msd_result_t scsi_read10(USBHMassStorageLUNDriver *lunp, uint32_t lba, uint16_t n, uint8_t *data, uint32_t *actual_len) { + USBH_DEFINE_BUFFER(msd_cbw_t cbw); msd_transaction_t transaction; msd_result_t res; - _prepare_cbw(&transaction, lunp); - transaction.cbw.dCBWDataTransferLength = n * lunp->info.blk_size; - transaction.cbw.bmCBWFlags = MSD_CBWFLAGS_D2H; - transaction.cbw.bCBWCBLength = 10; - transaction.cbw.CBWCB[0] = SCSI_CMD_READ_10; - transaction.cbw.CBWCB[2] = (uint8_t)(lba >> 24); - transaction.cbw.CBWCB[3] = (uint8_t)(lba >> 16); - transaction.cbw.CBWCB[4] = (uint8_t)(lba >> 8); - transaction.cbw.CBWCB[5] = (uint8_t)(lba); - transaction.cbw.CBWCB[7] = (uint8_t)(n >> 8); - transaction.cbw.CBWCB[8] = (uint8_t)(n); - - res.tres = _msd_transaction(&transaction, lunp, data); - if (res.tres == MSD_TRANSACTIONRESULT_OK) { - res.cres = (msd_command_result_t) transaction.csw.bCSWStatus; + memset(cbw.CBWCB, 0, sizeof(cbw.CBWCB)); + cbw.dCBWDataTransferLength = n * lunp->info.blk_size; + cbw.bmCBWFlags = MSD_CBWFLAGS_D2H; + cbw.bCBWCBLength = 10; + cbw.CBWCB[0] = SCSI_CMD_READ_10; + cbw.CBWCB[2] = (uint8_t)(lba >> 24); + cbw.CBWCB[3] = (uint8_t)(lba >> 16); + cbw.CBWCB[4] = (uint8_t)(lba >> 8); + cbw.CBWCB[5] = (uint8_t)(lba); + cbw.CBWCB[7] = (uint8_t)(n >> 8); + cbw.CBWCB[8] = (uint8_t)(n); + + res = _scsi_perform_transaction(lunp, &transaction, data); + if (actual_len) { + *actual_len = transaction.data_processed; + } + if (res == MSD_RESULT_OK) { + //transaction is OK; check length + if (transaction.data_processed < cbw.dCBWDataTransferLength) { + res = MSD_RESULT_TRANSPORT_ERROR; + } } + return res; } -static msd_result_t scsi_write10(USBHMassStorageLUNDriver *lunp, uint32_t lba, uint16_t n, const uint8_t *data) { +static msd_result_t scsi_write10(USBHMassStorageLUNDriver *lunp, uint32_t lba, uint16_t n, const uint8_t *data, uint32_t *actual_len) { + USBH_DEFINE_BUFFER(msd_cbw_t cbw); msd_transaction_t transaction; msd_result_t res; - _prepare_cbw(&transaction, lunp); - transaction.cbw.dCBWDataTransferLength = n * lunp->info.blk_size; - transaction.cbw.bmCBWFlags = MSD_CBWFLAGS_H2D; - transaction.cbw.bCBWCBLength = 10; - transaction.cbw.CBWCB[0] = SCSI_CMD_WRITE_10; - transaction.cbw.CBWCB[2] = (uint8_t)(lba >> 24); - transaction.cbw.CBWCB[3] = (uint8_t)(lba >> 16); - transaction.cbw.CBWCB[4] = (uint8_t)(lba >> 8); - transaction.cbw.CBWCB[5] = (uint8_t)(lba); - transaction.cbw.CBWCB[7] = (uint8_t)(n >> 8); - transaction.cbw.CBWCB[8] = (uint8_t)(n); - - res.tres = _msd_transaction(&transaction, lunp, (uint8_t *)data); - if (res.tres == MSD_TRANSACTIONRESULT_OK) { - res.cres = (msd_command_result_t) transaction.csw.bCSWStatus; + memset(cbw.CBWCB, 0, sizeof(cbw.CBWCB)); + cbw.dCBWDataTransferLength = n * lunp->info.blk_size; + cbw.bmCBWFlags = MSD_CBWFLAGS_H2D; + cbw.bCBWCBLength = 10; + cbw.CBWCB[0] = SCSI_CMD_WRITE_10; + cbw.CBWCB[2] = (uint8_t)(lba >> 24); + cbw.CBWCB[3] = (uint8_t)(lba >> 16); + cbw.CBWCB[4] = (uint8_t)(lba >> 8); + cbw.CBWCB[5] = (uint8_t)(lba); + cbw.CBWCB[7] = (uint8_t)(n >> 8); + cbw.CBWCB[8] = (uint8_t)(n); + + res = _scsi_perform_transaction(lunp, &transaction, (void *)data); + if (actual_len) { + *actual_len = transaction.data_processed; + } + if (res == MSD_RESULT_OK) { + //transaction is OK; check length + if (transaction.data_processed < cbw.dCBWDataTransferLength) { + res = MSD_RESULT_TRANSPORT_ERROR; + } } + return res; } @@ -598,34 +695,6 @@ static const struct USBHMassStorageDriverVMT blk_vmt = { (bool (*)(void *, BlockDeviceInfo *))usbhmsdLUNGetInfo }; - - -static uint32_t _requestsense(USBHMassStorageLUNDriver *lunp) { - scsi_sense_response_t sense; - msd_result_t res; - - res = scsi_requestsense(lunp, &sense); - if (res.tres != MSD_TRANSACTIONRESULT_OK) { - uerr("\tREQUEST SENSE: Transaction error"); - goto failed; - } else if (res.cres == MSD_COMMANDRESULT_FAILED) { - uerr("\tREQUEST SENSE: Command Failed"); - goto failed; - } else if (res.cres == MSD_COMMANDRESULT_PHASE_ERROR) { - //TODO: Do reset, etc. - uerr("\tREQUEST SENSE: Command Phase Error"); - goto failed; - } - - uerrf("\tREQUEST SENSE: Sense key=%x, ASC=%02x, ASCQ=%02x", - sense.byte[2] & 0xf, sense.byte[12], sense.byte[13]); - - return (sense.byte[2] & 0xf) | (sense.byte[12] << 8) | (sense.byte[13] << 16); - -failed: - return 0xffffffff; -} - void usbhmsdLUNObjectInit(USBHMassStorageLUNDriver *lunp) { osalDbgCheck(lunp != NULL); memset(lunp, 0, sizeof(*lunp)); @@ -678,29 +747,25 @@ bool usbhmsdLUNConnect(USBHMassStorageLUNDriver *lunp) { osalMutexLock(&msdp->mtx); - USBH_DEFINE_BUFFER(union { - scsi_inquiry_response_t inq; - scsi_readcapacity10_response_t cap; } u); - - uinfo("INQUIRY..."); - res = scsi_inquiry(lunp, &u.inq); - if (res.tres != MSD_TRANSACTIONRESULT_OK) { - uerr("\tINQUIRY: Transaction error"); - goto failed; - } else if (res.cres == MSD_COMMANDRESULT_FAILED) { - uerr("\tINQUIRY: Command Failed"); - _requestsense(lunp); - goto failed; - } else if (res.cres == MSD_COMMANDRESULT_PHASE_ERROR) { - //TODO: Do reset, etc. - uerr("\tINQUIRY: Command Phase Error"); - goto failed; - } + { + USBH_DEFINE_BUFFER(scsi_inquiry_response_t inq); + uinfo("INQUIRY..."); + res = scsi_inquiry(lunp, &inq); + if (res == MSD_RESULT_DISCONNECTED) { + goto failed; + } else if (res == MSD_RESULT_TRANSPORT_ERROR) { + //retry? + goto failed; + } else if (res == MSD_RESULT_FAILED) { + //retry? + goto failed; + } - uinfof("\tPDT=%02x", u.inq.peripheral & 0x1f); - if (u.inq.peripheral != 0) { - uerr("\tUnsupported PDT"); - goto failed; + uinfof("\tPDT=%02x", inq.peripheral & 0x1f); + if (inq.peripheral != 0) { + uerr("\tUnsupported PDT"); + goto failed; + } } // Test if unit ready @@ -708,41 +773,40 @@ bool usbhmsdLUNConnect(USBHMassStorageLUNDriver *lunp) { for (i = 0; i < 10; i++) { uinfo("TEST UNIT READY..."); res = scsi_testunitready(lunp); - if (res.tres != MSD_TRANSACTIONRESULT_OK) { - uerr("\tTEST UNIT READY: Transaction error"); + if (res == MSD_RESULT_DISCONNECTED) { goto failed; - } else if (res.cres == MSD_COMMANDRESULT_FAILED) { - uerr("\tTEST UNIT READY: Command Failed"); - _requestsense(lunp); - continue; - } else if (res.cres == MSD_COMMANDRESULT_PHASE_ERROR) { - //TODO: Do reset, etc. - uerr("\tTEST UNIT READY: Command Phase Error"); + } else if (res == MSD_RESULT_TRANSPORT_ERROR) { + //retry? goto failed; + } else if (res == MSD_RESULT_FAILED) { + uinfo("\tTEST UNIT READY: Command Failed, retry"); + osalThreadSleepMilliseconds(200); + continue; } uinfo("\tReady."); break; - // osalThreadSleepMilliseconds(200); // will raise 'code is unreachable' warning } if (i == 10) goto failed; - // Read capacity - uinfo("READ CAPACITY(10)..."); - res = scsi_readcapacity10(lunp, &u.cap); - if (res.tres != MSD_TRANSACTIONRESULT_OK) { - uerr("\tREAD CAPACITY(10): Transaction error"); - goto failed; - } else if (res.cres == MSD_COMMANDRESULT_FAILED) { - uerr("\tREAD CAPACITY(10): Command Failed"); - _requestsense(lunp); - goto failed; - } else if (res.cres == MSD_COMMANDRESULT_PHASE_ERROR) { - //TODO: Do reset, etc. - uerr("\tREAD CAPACITY(10): Command Phase Error"); - goto failed; - } - lunp->info.blk_size = __REV(u.cap.block_size); - lunp->info.blk_num = __REV(u.cap.last_block_addr) + 1; + { + USBH_DEFINE_BUFFER(scsi_readcapacity10_response_t cap); + // Read capacity + uinfo("READ CAPACITY(10)..."); + res = scsi_readcapacity10(lunp, &cap); + if (res == MSD_RESULT_DISCONNECTED) { + goto failed; + } else if (res == MSD_RESULT_TRANSPORT_ERROR) { + //retry? + goto failed; + } else if (res == MSD_RESULT_FAILED) { + //retry? + goto failed; + } + + lunp->info.blk_size = __REV(cap.block_size); + lunp->info.blk_num = __REV(cap.last_block_addr) + 1; + } + uinfof("\tBlock size=%dbytes, blocks=%u (~%u MB)", lunp->info.blk_size, lunp->info.blk_num, (uint32_t)(((uint64_t)lunp->info.blk_size * lunp->info.blk_num) / (1024UL * 1024UL))); @@ -792,6 +856,7 @@ bool usbhmsdLUNRead(USBHMassStorageLUNDriver *lunp, uint32_t startblk, bool ret = HAL_FAILED; uint16_t blocks; msd_result_t res; + uint32_t actual_len; osalSysLock(); if (lunp->state != BLK_READY) { @@ -808,18 +873,14 @@ bool usbhmsdLUNRead(USBHMassStorageLUNDriver *lunp, uint32_t startblk, } else { blocks = (uint16_t)n; } - res = scsi_read10(lunp, startblk, blocks, buffer); - if (res.tres != MSD_TRANSACTIONRESULT_OK) { - uerr("\tREAD (10): Transaction error"); + res = scsi_read10(lunp, startblk, blocks, buffer, &actual_len); + if (res == MSD_RESULT_DISCONNECTED) { goto exit; - } else if (res.cres == MSD_COMMANDRESULT_FAILED) { - //TODO: request sense, and act appropriately - uerr("\tREAD (10): Command Failed"); - _requestsense(lunp); + } else if (res == MSD_RESULT_TRANSPORT_ERROR) { + //retry? goto exit; - } else if (res.cres == MSD_COMMANDRESULT_PHASE_ERROR) { - //TODO: Do reset, etc. - uerr("\tREAD (10): Command Phase Error"); + } else if (res == MSD_RESULT_FAILED) { + //retry? goto exit; } n -= blocks; @@ -849,6 +910,7 @@ bool usbhmsdLUNWrite(USBHMassStorageLUNDriver *lunp, uint32_t startblk, bool ret = HAL_FAILED; uint16_t blocks; msd_result_t res; + uint32_t actual_len; osalSysLock(); if (lunp->state != BLK_READY) { @@ -865,18 +927,14 @@ bool usbhmsdLUNWrite(USBHMassStorageLUNDriver *lunp, uint32_t startblk, } else { blocks = (uint16_t)n; } - res = scsi_write10(lunp, startblk, blocks, buffer); - if (res.tres != MSD_TRANSACTIONRESULT_OK) { - uerr("\tWRITE (10): Transaction error"); + res = scsi_write10(lunp, startblk, blocks, buffer, &actual_len); + if (res == MSD_RESULT_DISCONNECTED) { goto exit; - } else if (res.cres == MSD_COMMANDRESULT_FAILED) { - //TODO: request sense, and act appropriately - uerr("\tWRITE (10): Command Failed"); - _requestsense(lunp); + } else if (res == MSD_RESULT_TRANSPORT_ERROR) { + //retry? goto exit; - } else if (res.cres == MSD_COMMANDRESULT_PHASE_ERROR) { - //TODO: Do reset, etc. - uerr("\tWRITE (10): Command Phase Error"); + } else if (res == MSD_RESULT_FAILED) { + //retry? goto exit; } n -= blocks; -- cgit v1.2.3 From 0260fd851a68e5026eb63369de28946a1f72dc1c Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Mon, 5 Jun 2017 10:45:23 -0300 Subject: Added PID for FTDI-enabled ETT USB-Serial --- os/hal/src/usbh/hal_usbh_ftdi.c | 1 + 1 file changed, 1 insertion(+) (limited to 'os/hal/src') diff --git a/os/hal/src/usbh/hal_usbh_ftdi.c b/os/hal/src/usbh/hal_usbh_ftdi.c index cce899c..e7ea7d3 100644 --- a/os/hal/src/usbh/hal_usbh_ftdi.c +++ b/os/hal/src/usbh/hal_usbh_ftdi.c @@ -104,6 +104,7 @@ static usbh_baseclassdriver_t *_ftdi_load(usbh_device_t *dev, const uint8_t *des case 0x6011: case 0x6014: case 0x6015: + case 0xE2E6: break; default: uerr("FTDI: Unrecognized PID"); -- cgit v1.2.3 From 5bc62c93e02b0f1ac9a92ed110a1cf2aa42f7cf2 Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Mon, 5 Jun 2017 10:53:59 -0300 Subject: Add HID class driver --- os/hal/src/hal_usbh.c | 7 + os/hal/src/usbh/hal_usbh_hid.c | 311 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 318 insertions(+) create mode 100644 os/hal/src/usbh/hal_usbh_hid.c (limited to 'os/hal/src') diff --git a/os/hal/src/hal_usbh.c b/os/hal/src/hal_usbh.c index 350d1a7..39f48e1 100644 --- a/os/hal/src/hal_usbh.c +++ b/os/hal/src/hal_usbh.c @@ -27,6 +27,7 @@ #include "usbh/dev/aoa.h" #include "usbh/dev/ftdi.h" #include "usbh/dev/msd.h" +#include "usbh/dev/hid.h" #if USBH_DEBUG_ENABLE_TRACE #define udbgf(f, ...) usbDbgPrintf(f, ##__VA_ARGS__) @@ -121,6 +122,9 @@ void usbhInit(void) { #if HAL_USBH_USE_MSD usbhmsdInit(); #endif +#if HAL_USBH_USE_HID + usbhhidInit(); +#endif #if HAL_USBH_USE_HUB usbhhubInit(); #endif @@ -1306,6 +1310,9 @@ static const usbh_classdriverinfo_t *usbh_classdrivers_lookup[] = { #if HAL_USBH_USE_MSD &usbhmsdClassDriverInfo, #endif +#if HAL_USBH_USE_HID + &usbhhidClassDriverInfo, +#endif #if HAL_USBH_USE_HUB &usbhhubClassDriverInfo, #endif 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 +#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 -- cgit v1.2.3 From 61c3a28398c7cb0da4a2cdca2a8fc0ebf6f66271 Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Mon, 5 Jun 2017 11:04:30 -0300 Subject: Mass license dates update --- os/hal/src/hal_usbh.c | 4 ++-- os/hal/src/usbh/hal_usbh_aoa.c | 4 ++-- os/hal/src/usbh/hal_usbh_debug.c | 4 ++-- os/hal/src/usbh/hal_usbh_desciter.c | 4 ++-- os/hal/src/usbh/hal_usbh_ftdi.c | 4 ++-- os/hal/src/usbh/hal_usbh_hid.c | 4 ++-- os/hal/src/usbh/hal_usbh_hub.c | 4 ++-- os/hal/src/usbh/hal_usbh_msd.c | 4 ++-- os/hal/src/usbh/hal_usbh_uvc.c | 4 ++-- 9 files changed, 18 insertions(+), 18 deletions(-) (limited to 'os/hal/src') diff --git a/os/hal/src/hal_usbh.c b/os/hal/src/hal_usbh.c index 39f48e1..80180d6 100644 --- a/os/hal/src/hal_usbh.c +++ b/os/hal/src/hal_usbh.c @@ -1,6 +1,6 @@ /* - ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio - Copyright (C) 2015 Diego Ismirlian, TISA, (dismirlian (at) google's mail) + ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio + Copyright (C) 2015..2017 Diego Ismirlian, (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. diff --git a/os/hal/src/usbh/hal_usbh_aoa.c b/os/hal/src/usbh/hal_usbh_aoa.c index 458cc20..2d96235 100644 --- a/os/hal/src/usbh/hal_usbh_aoa.c +++ b/os/hal/src/usbh/hal_usbh_aoa.c @@ -1,6 +1,6 @@ /* - ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio - Copyright (C) 2015..2016 Diego Ismirlian, TISA, (dismirlian (at) google's mail) + ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio + Copyright (C) 2015..2017 Diego Ismirlian, (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. diff --git a/os/hal/src/usbh/hal_usbh_debug.c b/os/hal/src/usbh/hal_usbh_debug.c index 497aa39..7c4ff7d 100644 --- a/os/hal/src/usbh/hal_usbh_debug.c +++ b/os/hal/src/usbh/hal_usbh_debug.c @@ -1,6 +1,6 @@ /* - ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio - Copyright (C) 2015 Diego Ismirlian, TISA, (dismirlian (at) google's mail) + ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio + Copyright (C) 2015..2017 Diego Ismirlian, (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. diff --git a/os/hal/src/usbh/hal_usbh_desciter.c b/os/hal/src/usbh/hal_usbh_desciter.c index 48d9d87..3695881 100644 --- a/os/hal/src/usbh/hal_usbh_desciter.c +++ b/os/hal/src/usbh/hal_usbh_desciter.c @@ -1,6 +1,6 @@ /* - ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio - Copyright (C) 2015 Diego Ismirlian, TISA, (dismirlian (at) google's mail) + ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio + Copyright (C) 2015..2017 Diego Ismirlian, (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. diff --git a/os/hal/src/usbh/hal_usbh_ftdi.c b/os/hal/src/usbh/hal_usbh_ftdi.c index e7ea7d3..aa6ec1a 100644 --- a/os/hal/src/usbh/hal_usbh_ftdi.c +++ b/os/hal/src/usbh/hal_usbh_ftdi.c @@ -1,6 +1,6 @@ /* - ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio - Copyright (C) 2015 Diego Ismirlian, TISA, (dismirlian (at) google's mail) + ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio + Copyright (C) 2015..2017 Diego Ismirlian, (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. diff --git a/os/hal/src/usbh/hal_usbh_hid.c b/os/hal/src/usbh/hal_usbh_hid.c index f8a5c96..6280d49 100644 --- a/os/hal/src/usbh/hal_usbh_hid.c +++ b/os/hal/src/usbh/hal_usbh_hid.c @@ -1,6 +1,6 @@ /* - ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio - Copyright (C) 2015..2016 Diego Ismirlian, TISA, (dismirlian (at) google's mail) + ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio + Copyright (C) 2015..2017 Diego Ismirlian, (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. diff --git a/os/hal/src/usbh/hal_usbh_hub.c b/os/hal/src/usbh/hal_usbh_hub.c index 15c3534..4b5af58 100644 --- a/os/hal/src/usbh/hal_usbh_hub.c +++ b/os/hal/src/usbh/hal_usbh_hub.c @@ -1,6 +1,6 @@ /* - ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio - Copyright (C) 2015 Diego Ismirlian, TISA, (dismirlian (at) google's mail) + ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio + Copyright (C) 2015..2017 Diego Ismirlian, (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. diff --git a/os/hal/src/usbh/hal_usbh_msd.c b/os/hal/src/usbh/hal_usbh_msd.c index a0d9361..73e2413 100644 --- a/os/hal/src/usbh/hal_usbh_msd.c +++ b/os/hal/src/usbh/hal_usbh_msd.c @@ -1,6 +1,6 @@ /* - ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio - Copyright (C) 2015 Diego Ismirlian, TISA, (dismirlian (at) google's mail) + ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio + Copyright (C) 2015..2017 Diego Ismirlian, (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. diff --git a/os/hal/src/usbh/hal_usbh_uvc.c b/os/hal/src/usbh/hal_usbh_uvc.c index 09a0f1d..025fbee 100644 --- a/os/hal/src/usbh/hal_usbh_uvc.c +++ b/os/hal/src/usbh/hal_usbh_uvc.c @@ -1,6 +1,6 @@ /* - ChibiOS - Copyright (C) 2006..2015 Giovanni Di Sirio - Copyright (C) 2015 Diego Ismirlian, TISA, (dismirlian (at) google's mail) + ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio + Copyright (C) 2015..2017 Diego Ismirlian, (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. -- cgit v1.2.3 From 0bf5a7aa4c0d6dcf8660d200452b584ef107eed5 Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Tue, 6 Jun 2017 09:21:10 -0300 Subject: Fixed bugs in new MSD driver implementation --- os/hal/src/usbh/hal_usbh_msd.c | 19 +++++++++++++------ 1 file changed, 13 insertions(+), 6 deletions(-) (limited to 'os/hal/src') diff --git a/os/hal/src/usbh/hal_usbh_msd.c b/os/hal/src/usbh/hal_usbh_msd.c index 73e2413..6abc48c 100644 --- a/os/hal/src/usbh/hal_usbh_msd.c +++ b/os/hal/src/usbh/hal_usbh_msd.c @@ -193,7 +193,9 @@ alloc_ok: osalSysUnlock(); /* connect the LUN (TODO: review if it's best to leave the LUN disconnected) */ + msdp->dev = dev; usbhmsdLUNConnect(&MSBLKD[i]); + msdp->dev = NULL; luns--; } } @@ -310,17 +312,17 @@ static msd_bot_result_t _msd_bot_transaction(msd_transaction_t *tran, USBHMassSt tran->data_processed = 0; /* control phase */ - status = usbhBulkTransfer(&lunp->msdp->epout, &tran->cbw, - sizeof(tran->cbw), &actual_len, MS2ST(1000)); + status = usbhBulkTransfer(&lunp->msdp->epout, tran->cbw, + sizeof(*tran->cbw), &actual_len, MS2ST(1000)); if (status == USBH_URBSTATUS_CANCELLED) { uerr("\tMSD: Control phase: USBH_URBSTATUS_CANCELLED"); return MSD_BOTRESULT_DISCONNECTED; } - if ((status != USBH_URBSTATUS_OK) || (actual_len != sizeof(tran->cbw))) { + if ((status != USBH_URBSTATUS_OK) || (actual_len != sizeof(*tran->cbw))) { uerrf("\tMSD: Control phase: status = %d (!= OK), actual_len = %d (expected to send %d)", - status, actual_len, sizeof(tran->cbw)); + status, actual_len, sizeof(*tran->cbw)); _msd_bot_reset(lunp->msdp); return MSD_BOTRESULT_ERROR; } @@ -566,6 +568,7 @@ static msd_result_t scsi_requestsense(USBHMassStorageLUNDriver *lunp, scsi_sense cbw.bCBWCBLength = 12; cbw.CBWCB[0] = SCSI_CMD_REQUEST_SENSE; cbw.CBWCB[4] = sizeof(scsi_sense_response_t); + transaction.cbw = &cbw; res = _scsi_perform_transaction(lunp, &transaction, resp); if (res == MSD_RESULT_OK) { @@ -587,6 +590,7 @@ static msd_result_t scsi_testunitready(USBHMassStorageLUNDriver *lunp) { cbw.bmCBWFlags = MSD_CBWFLAGS_D2H; cbw.bCBWCBLength = 6; cbw.CBWCB[0] = SCSI_CMD_TEST_UNIT_READY; + transaction.cbw = &cbw; return _scsi_perform_transaction(lunp, &transaction, NULL); } @@ -601,6 +605,7 @@ static msd_result_t scsi_readcapacity10(USBHMassStorageLUNDriver *lunp, scsi_rea cbw.bmCBWFlags = MSD_CBWFLAGS_D2H; cbw.bCBWCBLength = 12; cbw.CBWCB[0] = SCSI_CMD_READ_CAPACITY_10; + transaction.cbw = &cbw; res = _scsi_perform_transaction(lunp, &transaction, resp); if (res == MSD_RESULT_OK) { @@ -630,6 +635,7 @@ static msd_result_t scsi_read10(USBHMassStorageLUNDriver *lunp, uint32_t lba, ui cbw.CBWCB[5] = (uint8_t)(lba); cbw.CBWCB[7] = (uint8_t)(n >> 8); cbw.CBWCB[8] = (uint8_t)(n); + transaction.cbw = &cbw; res = _scsi_perform_transaction(lunp, &transaction, data); if (actual_len) { @@ -661,6 +667,7 @@ static msd_result_t scsi_write10(USBHMassStorageLUNDriver *lunp, uint32_t lba, u cbw.CBWCB[5] = (uint8_t)(lba); cbw.CBWCB[7] = (uint8_t)(n >> 8); cbw.CBWCB[8] = (uint8_t)(n); + transaction.cbw = &cbw; res = _scsi_perform_transaction(lunp, &transaction, (void *)data); if (actual_len) { @@ -747,7 +754,7 @@ bool usbhmsdLUNConnect(USBHMassStorageLUNDriver *lunp) { osalMutexLock(&msdp->mtx); - { + { USBH_DEFINE_BUFFER(scsi_inquiry_response_t inq); uinfo("INQUIRY..."); res = scsi_inquiry(lunp, &inq); @@ -769,7 +776,7 @@ bool usbhmsdLUNConnect(USBHMassStorageLUNDriver *lunp) { } // Test if unit ready - uint8_t i; + uint8_t i; for (i = 0; i < 10; i++) { uinfo("TEST UNIT READY..."); res = scsi_testunitready(lunp); -- cgit v1.2.3 From 108ae2534cf5e487b569ea34bdae4e86b9c2d024 Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Tue, 6 Jun 2017 09:23:07 -0300 Subject: Fixed endpoint halt reset implementation --- os/hal/src/hal_usbh.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) (limited to 'os/hal/src') diff --git a/os/hal/src/hal_usbh.c b/os/hal/src/hal_usbh.c index 80180d6..11add0d 100644 --- a/os/hal/src/hal_usbh.c +++ b/os/hal/src/hal_usbh.c @@ -195,8 +195,7 @@ static void _ep0_object_init(usbh_device_t *dev, uint16_t wMaxPacketSize) { usbhEPSetName(&dev->ctrl, "DEV[CTRL]"); } -bool usbhEPResetS(usbh_ep_t *ep) { - osalDbgCheckClassS(); +bool usbhEPReset(usbh_ep_t *ep) { osalDbgCheck(ep != NULL); osalDbgAssert((ep->status == USBH_EPSTATUS_OPEN) || (ep->status == USBH_EPSTATUS_HALTED), "invalid state"); osalDbgAssert(ep->type != USBH_EPTYPE_CTRL, "don't need to reset control endpoint"); @@ -206,9 +205,12 @@ bool usbhEPResetS(usbh_ep_t *ep) { 0, 0); /* TODO: GET_STATUS to see if endpoint is still halted */ + osalSysLock(); if ((ret == USBH_URBSTATUS_OK) && usbh_lld_ep_reset(ep)) { + osalSysUnlock(); return HAL_SUCCESS; } + osalSysUnlock(); return HAL_FAILED; } -- cgit v1.2.3 From 1bb8f56c3b0107b35ecfa4feab66fac99865f747 Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Tue, 6 Jun 2017 09:24:10 -0300 Subject: HID class driver fixes --- os/hal/src/usbh/hal_usbh_hid.c | 45 +++++++++++++++++++++++++++--------------- 1 file changed, 29 insertions(+), 16 deletions(-) (limited to 'os/hal/src') diff --git a/os/hal/src/usbh/hal_usbh_hid.c b/os/hal/src/usbh/hal_usbh_hid.c index 6280d49..9e248cb 100644 --- a/os/hal/src/usbh/hal_usbh_hid.c +++ b/os/hal/src/usbh/hal_usbh_hid.c @@ -72,7 +72,7 @@ /* USB Class driver loader for MSD */ /*===========================================================================*/ -USBHHIDDriver USBHHID[HAL_USBHHID_MAX_INSTANCES]; +USBHHIDDriver USBHHIDD[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); @@ -103,8 +103,8 @@ static usbh_baseclassdriver_t *_hid_load(usbh_device_t *dev, const uint8_t *desc /* alloc driver */ for (i = 0; i < HAL_USBHHID_MAX_INSTANCES; i++) { - if (USBHHID[i].dev == NULL) { - hidp = &USBHHID[i]; + if (USBHHIDD[i].dev == NULL) { + hidp = &USBHHIDD[i]; goto alloc_ok; } } @@ -153,9 +153,10 @@ alloc_ok: if (ifdesc->bInterfaceSubClass != 0x01) { hidp->type = USBHHID_DEVTYPE_GENERIC; - uinfof("HID: bInterfaceSubClass=%02x, generic HID"); + uinfof("HID: bInterfaceSubClass=%02x, generic HID", ifdesc->bInterfaceSubClass); if (ifdesc->bInterfaceSubClass != 0x00) { - uinfof("HID: bInterfaceSubClass=%02x is an invalid bInterfaceSubClass value"); + uinfof("HID: bInterfaceSubClass=%02x is an invalid bInterfaceSubClass value", + ifdesc->bInterfaceSubClass); } } else if (ifdesc->bInterfaceProtocol == 0x01) { hidp->type = USBHHID_DEVTYPE_BOOT_KEYBOARD; @@ -164,7 +165,8 @@ alloc_ok: hidp->type = USBHHID_DEVTYPE_BOOT_MOUSE; uinfo("HID: BOOT protocol mouse found"); } else { - uerrf("HID: bInterfaceProtocol=%02x is an invalid boot protocol, abort"); + uerrf("HID: bInterfaceProtocol=%02x is an invalid boot protocol, abort", + ifdesc->bInterfaceProtocol); goto deinit; } @@ -185,12 +187,17 @@ static void _in_cb(usbh_urb_t *urb) { USBHHIDDriver *const hidp = (USBHHIDDriver *)urb->userData; switch (urb->status) { case USBH_URBSTATUS_OK: - + if (hidp->config->cb_report) { + hidp->config->cb_report(hidp, urb->actualLength); + } break; case USBH_URBSTATUS_DISCONNECTED: uwarn("HID: URB IN disconnected"); return; + case USBH_URBSTATUS_TIMEOUT: + //no data + break; default: uerrf("HID: URB IN status unexpected = %d", urb->status); break; @@ -200,7 +207,8 @@ static void _in_cb(usbh_urb_t *urb) { } void usbhhidStart(USBHHIDDriver *hidp, const USBHHIDConfig *cfg) { - osalDbgCheck(hidp && cfg && cfg->report_buffer); + osalDbgCheck(hidp && cfg); + osalDbgCheck(cfg->report_buffer && (cfg->protocol <= USBHHID_PROTOCOL_REPORT)); osalDbgCheck((hidp->state == USBHHID_STATE_ACTIVE) || (hidp->state == USBHHID_STATE_READY)); @@ -210,7 +218,8 @@ void usbhhidStart(USBHHIDDriver *hidp, const USBHHIDConfig *cfg) { hidp->config = cfg; /* init the URBs */ - usbhURBObjectInit(&hidp->in_urb, &hidp->epin, _in_cb, hidp, hidp->config->report_buffer, 64); + usbhURBObjectInit(&hidp->in_urb, &hidp->epin, _in_cb, hidp, + cfg->report_buffer, cfg->report_len); /* open the int IN/OUT endpoints */ usbhEPOpen(&hidp->epin); @@ -220,6 +229,8 @@ void usbhhidStart(USBHHIDDriver *hidp, const USBHHIDConfig *cfg) { } #endif + usbhhidSetProtocol(hidp, cfg->protocol); + osalSysLock(); usbhURBSubmitI(&hidp->in_urb); osalSysUnlock(); @@ -251,7 +262,8 @@ usbh_urbstatus_t usbhhidGetReport(USBHHIDDriver *hidp, 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), + USBH_CLASSIN(USBH_REQTYPE_INTERFACE, USBH_HID_REQ_GET_REPORT, + ((uint8_t)report_type << 8) | report_id, hidp->ifnum), len, data); } @@ -261,7 +273,8 @@ usbh_urbstatus_t usbhhidSetReport(USBHHIDDriver *hidp, 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), + USBH_CLASSOUT(USBH_REQTYPE_INTERFACE, USBH_HID_REQ_SET_REPORT, + ((uint8_t)report_type << 8) | report_id, hidp->ifnum), len, (void *)data); } @@ -275,8 +288,8 @@ usbh_urbstatus_t usbhhidGetIdle(USBHHIDDriver *hidp, uint8_t report_id, uint8_t 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_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) { @@ -290,8 +303,8 @@ 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); + USBH_CLASSOUT(USBH_REQTYPE_INTERFACE, USBH_HID_REQ_SET_PROTOCOL, + protocol, hidp->ifnum), 0, NULL); } void usbhhidObjectInit(USBHHIDDriver *hidp) { @@ -304,7 +317,7 @@ void usbhhidObjectInit(USBHHIDDriver *hidp) { void usbhhidInit(void) { uint8_t i; for (i = 0; i < HAL_USBHHID_MAX_INSTANCES; i++) { - usbhhidObjectInit(&USBHHID[i]); + usbhhidObjectInit(&USBHHIDD[i]); } } -- cgit v1.2.3 From 9349f7400432ae5a999c524b89da8a835da59b08 Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Tue, 6 Jun 2017 10:21:00 -0300 Subject: Clean up request type helpers --- os/hal/src/hal_usbh.c | 101 +++++++++++++++++++--------------------- os/hal/src/usbh/hal_usbh_aoa.c | 8 ++-- os/hal/src/usbh/hal_usbh_ftdi.c | 12 ++--- os/hal/src/usbh/hal_usbh_hid.c | 26 +++++------ os/hal/src/usbh/hal_usbh_msd.c | 8 ++-- 5 files changed, 75 insertions(+), 80 deletions(-) (limited to 'os/hal/src') diff --git a/os/hal/src/hal_usbh.c b/os/hal/src/hal_usbh.c index 11add0d..538f36e 100644 --- a/os/hal/src/hal_usbh.c +++ b/os/hal/src/hal_usbh.c @@ -201,8 +201,9 @@ bool usbhEPReset(usbh_ep_t *ep) { osalDbgAssert(ep->type != USBH_EPTYPE_CTRL, "don't need to reset control endpoint"); usbh_urbstatus_t ret = usbhControlRequest(ep->device, - USBH_STANDARDOUT(USBH_REQTYPE_ENDPOINT, USBH_REQ_CLEAR_FEATURE, 0, ep->address | (ep->in ? 0x80 : 0x00)), - 0, 0); + USBH_REQTYPE_STANDARDOUT(USBH_REQTYPE_RECIP_ENDPOINT), + USBH_REQ_CLEAR_FEATURE, + 0, ep->address | (ep->in ? 0x80 : 0x00), 0, 0); /* TODO: GET_STATUS to see if endpoint is still halted */ osalSysLock(); @@ -460,27 +461,19 @@ usbh_urbstatus_t usbhControlRequest(usbh_device_t *dev, /* Standard request helpers. */ /*===========================================================================*/ -#define USBH_GET_DESCRIPTOR(type, value, index) \ - USBH_STANDARDIN(type, \ - USBH_REQ_GET_DESCRIPTOR, \ - value, \ - index) \ - -#define USBH_GETDEVICEDESCRIPTOR \ - USBH_GET_DESCRIPTOR(USBH_REQTYPE_DEVICE, (USBH_DT_DEVICE << 8) | 0, 0) - -#define USBH_GETCONFIGURATIONDESCRIPTOR(index) \ - USBH_GET_DESCRIPTOR(USBH_REQTYPE_DEVICE, (USBH_DT_CONFIG << 8) | index, 0) - -#define USBH_GETSTRINGDESCRIPTOR(index, langID) \ - USBH_GET_DESCRIPTOR(USBH_REQTYPE_DEVICE, (USBH_DT_STRING << 8) | index, langID) - bool usbhStdReqGetDeviceDescriptor(usbh_device_t *dev, uint16_t wLength, uint8_t *buf) { usbh_device_descriptor_t *desc; - usbh_urbstatus_t ret = usbhControlRequest(dev, USBH_GETDEVICEDESCRIPTOR, wLength, buf); + + usbh_urbstatus_t ret = usbhControlRequest(dev, + USBH_REQTYPE_STANDARDIN(USBH_REQTYPE_RECIP_DEVICE), + USBH_REQ_GET_DESCRIPTOR, + (USBH_DT_DEVICE << 8) | 0, 0, + wLength, buf); + desc = (usbh_device_descriptor_t *)buf; + if ((ret != USBH_URBSTATUS_OK) || (desc->bLength != USBH_DT_DEVICE_SIZE) || (desc->bDescriptorType != USBH_DT_DEVICE)) { @@ -493,8 +486,15 @@ bool usbhStdReqGetConfigurationDescriptor(usbh_device_t *dev, uint8_t index, uint16_t wLength, uint8_t *buf) { - usbh_urbstatus_t ret = usbhControlRequest(dev, USBH_GETCONFIGURATIONDESCRIPTOR(index), wLength, buf); + + usbh_urbstatus_t ret = usbhControlRequest(dev, + USBH_REQTYPE_STANDARDIN(USBH_REQTYPE_RECIP_DEVICE), + USBH_REQ_GET_DESCRIPTOR, + (USBH_DT_CONFIG << 8) | index, 0, + wLength, buf); + usbh_config_descriptor_t *const desc = (usbh_config_descriptor_t *)buf; + if ((ret != USBH_URBSTATUS_OK) || (desc->bLength < USBH_DT_CONFIG_SIZE) || (desc->bDescriptorType != USBH_DT_CONFIG)) { @@ -511,7 +511,13 @@ bool usbhStdReqGetStringDescriptor(usbh_device_t *dev, osalDbgAssert(wLength >= USBH_DT_STRING_SIZE, "wrong size"); usbh_string_descriptor_t *desc = (usbh_string_descriptor_t *)buf; - usbh_urbstatus_t ret = usbhControlRequest(dev, USBH_GETSTRINGDESCRIPTOR(index, langID), wLength, buf); + + usbh_urbstatus_t ret = usbhControlRequest(dev, + USBH_REQTYPE_STANDARDIN(USBH_REQTYPE_RECIP_DEVICE), + USBH_REQ_GET_DESCRIPTOR, + (USBH_DT_STRING << 8) | index, langID, + wLength, buf); + if ((ret != USBH_URBSTATUS_OK) || (desc->bLength < USBH_DT_STRING_SIZE) || (desc->bDescriptorType != USBH_DT_STRING)) { @@ -520,25 +526,17 @@ bool usbhStdReqGetStringDescriptor(usbh_device_t *dev, return HAL_SUCCESS; } - - -#define USBH_SET_INTERFACE(interface, alt) \ - USBH_STANDARDOUT(USBH_REQTYPE_INTERFACE, \ - USBH_REQ_SET_INTERFACE, \ - alt, \ - interface) \ - -#define USBH_GET_INTERFACE(interface) \ - USBH_STANDARDIN(USBH_REQTYPE_INTERFACE, \ - USBH_REQ_GET_INTERFACE, \ - 0, \ - interface) \ - bool usbhStdReqSetInterface(usbh_device_t *dev, uint8_t bInterfaceNumber, uint8_t bAlternateSetting) { - usbh_urbstatus_t ret = usbhControlRequest(dev, USBH_SET_INTERFACE(bInterfaceNumber, bAlternateSetting), 0, NULL); + usbh_urbstatus_t ret = usbhControlRequest(dev, + USBH_REQTYPE_STANDARDOUT(USBH_REQTYPE_RECIP_INTERFACE), + USBH_REQ_SET_INTERFACE, + bAlternateSetting, + bInterfaceNumber, + 0, NULL); + if (ret != USBH_URBSTATUS_OK) return HAL_FAILED; @@ -551,7 +549,13 @@ bool usbhStdReqGetInterface(usbh_device_t *dev, USBH_DEFINE_BUFFER(uint8_t alt); - usbh_urbstatus_t ret = usbhControlRequest(dev, USBH_GET_INTERFACE(bInterfaceNumber), 1, &alt); + usbh_urbstatus_t ret = usbhControlRequest(dev, + USBH_REQTYPE_STANDARDIN(USBH_REQTYPE_RECIP_INTERFACE), + USBH_REQ_GET_INTERFACE, + 0, + bInterfaceNumber, + 1, &alt); + if (ret != USBH_URBSTATUS_OK) return HAL_FAILED; @@ -596,7 +600,8 @@ static void _device_initialize(usbh_device_t *dev, usbh_devspeed_t speed) { static bool _device_setaddress(usbh_device_t *dev, uint8_t address) { usbh_urbstatus_t ret = usbhControlRequest(dev, - USBH_STANDARDOUT(USBH_REQTYPE_DEVICE, USBH_REQ_SET_ADDRESS, address, 0), + USBH_REQTYPE_STANDARDOUT(USBH_REQTYPE_RECIP_DEVICE), + USBH_REQ_SET_ADDRESS, address, 0, 0, 0); if (ret != USBH_URBSTATUS_OK) @@ -649,22 +654,12 @@ static void _device_free_full_cfgdesc(usbh_device_t *dev) { } } - -#define USBH_SET_CONFIGURATION(type, value, index) \ - USBH_STANDARDOUT(type, \ - USBH_REQ_SET_CONFIGURATION, \ - value, \ - index) \ - -#define USBH_SETDEVICECONFIGURATION(index) \ - USBH_SET_CONFIGURATION(USBH_REQTYPE_DEVICE, index, 0) - - static bool _device_set_configuration(usbh_device_t *dev, uint8_t configuration) { usbh_urbstatus_t ret = usbhControlRequest(dev, - USBH_SETDEVICECONFIGURATION(configuration), - 0, - 0); + USBH_REQTYPE_STANDARDOUT(USBH_REQTYPE_RECIP_DEVICE), + USBH_REQ_SET_CONFIGURATION, + configuration, + 0, 0, 0); if (ret != USBH_URBSTATUS_OK) return HAL_FAILED; return HAL_SUCCESS; @@ -894,7 +889,7 @@ static void _port_reset(usbh_port_t *port) { #if HAL_USBH_USE_HUB port->hub, #endif - USBH_REQTYPE_OUT | USBH_REQTYPE_CLASS | USBH_REQTYPE_OTHER, + USBH_REQTYPE_DIR_OUT | USBH_REQTYPE_TYPE_CLASS | USBH_REQTYPE_RECIP_OTHER, USBH_REQ_SET_FEATURE, USBH_PORT_FEAT_RESET, port->number, @@ -908,7 +903,7 @@ static void _port_update_status(usbh_port_t *port) { #if HAL_USBH_USE_HUB port->hub, #endif - USBH_REQTYPE_IN | USBH_REQTYPE_CLASS | USBH_REQTYPE_OTHER, + USBH_REQTYPE_DIR_IN | USBH_REQTYPE_TYPE_CLASS | USBH_REQTYPE_RECIP_OTHER, USBH_REQ_GET_STATUS, 0, port->number, diff --git a/os/hal/src/usbh/hal_usbh_aoa.c b/os/hal/src/usbh/hal_usbh_aoa.c index 2d96235..1fa49f8 100644 --- a/os/hal/src/usbh/hal_usbh_aoa.c +++ b/os/hal/src/usbh/hal_usbh_aoa.c @@ -594,7 +594,7 @@ static bool _get_protocol(usbh_device_t *dev, uint16_t *protocol) { USBH_DEFINE_BUFFER(uint16_t proto); usbh_urbstatus_t ret = usbhControlRequest(dev, - USBH_REQTYPE_IN | USBH_REQTYPE_VENDOR | USBH_REQTYPE_DEVICE, + USBH_REQTYPE_DIR_IN | USBH_REQTYPE_TYPE_VENDOR | USBH_REQTYPE_RECIP_DEVICE, AOA_ACCESSORY_GET_PROTOCOL, 0, 0, @@ -610,7 +610,7 @@ static bool _get_protocol(usbh_device_t *dev, uint16_t *protocol) { static bool _accessory_start(usbh_device_t *dev) { usbh_urbstatus_t ret = usbhControlRequest(dev, - USBH_REQTYPE_OUT | USBH_REQTYPE_VENDOR | USBH_REQTYPE_DEVICE, + USBH_REQTYPE_DIR_OUT | USBH_REQTYPE_TYPE_VENDOR | USBH_REQTYPE_RECIP_DEVICE, AOA_ACCESSORY_START, 0, 0, @@ -625,7 +625,7 @@ static bool _accessory_start(usbh_device_t *dev) { static bool _set_audio_mode(usbh_device_t *dev, uint16_t mode) { usbh_urbstatus_t ret = usbhControlRequest(dev, - USBH_REQTYPE_OUT | USBH_REQTYPE_VENDOR | USBH_REQTYPE_DEVICE, + USBH_REQTYPE_DIR_OUT | USBH_REQTYPE_TYPE_VENDOR | USBH_REQTYPE_RECIP_DEVICE, AOA_SET_AUDIO_MODE, mode, 0, @@ -645,7 +645,7 @@ static bool _send_string(usbh_device_t *dev, uint8_t index, const char *string) string = nullstr; usbh_urbstatus_t ret = usbhControlRequest(dev, - USBH_REQTYPE_OUT | USBH_REQTYPE_VENDOR | USBH_REQTYPE_DEVICE, + USBH_REQTYPE_DIR_OUT | USBH_REQTYPE_TYPE_VENDOR | USBH_REQTYPE_RECIP_DEVICE, AOA_ACCESSORY_SEND_STRING, 0, index, diff --git a/os/hal/src/usbh/hal_usbh_ftdi.c b/os/hal/src/usbh/hal_usbh_ftdi.c index aa6ec1a..ce96958 100644 --- a/os/hal/src/usbh/hal_usbh_ftdi.c +++ b/os/hal/src/usbh/hal_usbh_ftdi.c @@ -316,11 +316,11 @@ static usbh_urbstatus_t _ftdi_port_control(USBHFTDIPortDriver *ftdipp, uint8_t *buff) { static const uint8_t bmRequestType[] = { - USBH_REQTYPE_VENDOR | USBH_REQTYPE_OUT | USBH_REQTYPE_DEVICE, //0 FTDI_COMMAND_RESET - USBH_REQTYPE_VENDOR | USBH_REQTYPE_OUT | USBH_REQTYPE_DEVICE, //1 FTDI_COMMAND_MODEMCTRL - USBH_REQTYPE_VENDOR | USBH_REQTYPE_OUT | USBH_REQTYPE_DEVICE, //2 FTDI_COMMAND_SETFLOW - USBH_REQTYPE_VENDOR | USBH_REQTYPE_OUT | USBH_REQTYPE_DEVICE, //3 FTDI_COMMAND_SETBAUD - USBH_REQTYPE_VENDOR | USBH_REQTYPE_OUT | USBH_REQTYPE_DEVICE, //4 FTDI_COMMAND_SETDATA + USBH_REQTYPE_TYPE_VENDOR | USBH_REQTYPE_DIR_OUT | USBH_REQTYPE_RECIP_DEVICE, //0 FTDI_COMMAND_RESET + USBH_REQTYPE_TYPE_VENDOR | USBH_REQTYPE_DIR_OUT | USBH_REQTYPE_RECIP_DEVICE, //1 FTDI_COMMAND_MODEMCTRL + USBH_REQTYPE_TYPE_VENDOR | USBH_REQTYPE_DIR_OUT | USBH_REQTYPE_RECIP_DEVICE, //2 FTDI_COMMAND_SETFLOW + USBH_REQTYPE_TYPE_VENDOR | USBH_REQTYPE_DIR_OUT | USBH_REQTYPE_RECIP_DEVICE, //3 FTDI_COMMAND_SETBAUD + USBH_REQTYPE_TYPE_VENDOR | USBH_REQTYPE_DIR_OUT | USBH_REQTYPE_RECIP_DEVICE, //4 FTDI_COMMAND_SETDATA }; osalDbgCheck(bRequest < sizeof_array(bmRequestType)); @@ -390,7 +390,7 @@ static usbh_urbstatus_t _set_baudrate(USBHFTDIPortDriver *ftdipp, uint32_t baudr wIndex = (wIndex << 8) | (ftdipp->ifnum + 1); USBH_DEFINE_BUFFER(const usbh_control_request_t req) = { - USBH_REQTYPE_VENDOR | USBH_REQTYPE_OUT | USBH_REQTYPE_DEVICE, + USBH_REQTYPE_TYPE_VENDOR | USBH_REQTYPE_DIR_OUT | USBH_REQTYPE_RECIP_DEVICE, FTDI_COMMAND_SETBAUD, wValue, wIndex, diff --git a/os/hal/src/usbh/hal_usbh_hid.c b/os/hal/src/usbh/hal_usbh_hid.c index 9e248cb..e98dff7 100644 --- a/os/hal/src/usbh/hal_usbh_hid.c +++ b/os/hal/src/usbh/hal_usbh_hid.c @@ -262,9 +262,8 @@ usbh_urbstatus_t usbhhidGetReport(USBHHIDDriver *hidp, 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_REQTYPE_CLASSIN(USBH_REQTYPE_RECIP_INTERFACE), USBH_HID_REQ_GET_REPORT, + ((uint8_t)report_type << 8) | report_id, hidp->ifnum, len, data); } usbh_urbstatus_t usbhhidSetReport(USBHHIDDriver *hidp, @@ -273,38 +272,37 @@ usbh_urbstatus_t usbhhidSetReport(USBHHIDDriver *hidp, 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_REQTYPE_CLASSOUT(USBH_REQTYPE_RECIP_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_REQTYPE_CLASSIN(USBH_REQTYPE_RECIP_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_REQTYPE_CLASSOUT(USBH_REQTYPE_RECIP_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_REQTYPE_CLASSIN(USBH_REQTYPE_RECIP_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); + USBH_REQTYPE_CLASSOUT(USBH_REQTYPE_RECIP_INTERFACE), USBH_HID_REQ_SET_PROTOCOL, + protocol, hidp->ifnum, 0, NULL); } void usbhhidObjectInit(USBHHIDDriver *hidp) { diff --git a/os/hal/src/usbh/hal_usbh_msd.c b/os/hal/src/usbh/hal_usbh_msd.c index 6abc48c..121e730 100644 --- a/os/hal/src/usbh/hal_usbh_msd.c +++ b/os/hal/src/usbh/hal_usbh_msd.c @@ -158,8 +158,8 @@ alloc_ok: uinfo("Reading Max LUN:"); USBH_DEFINE_BUFFER(uint8_t buff[4]); stat = usbhControlRequest(dev, - USBH_CLASSIN(USBH_REQTYPE_INTERFACE, MSD_GET_MAX_LUN, 0, msdp->ifnum), - 1, buff); + USBH_REQTYPE_CLASSIN(USBH_REQTYPE_RECIP_INTERFACE), + MSD_GET_MAX_LUN, 0, msdp->ifnum, 1, buff); if (stat == USBH_URBSTATUS_OK) { msdp->max_lun = buff[0] + 1; uinfof("\tmax_lun = %d", msdp->max_lun); @@ -290,7 +290,9 @@ typedef enum { static bool _msd_bot_reset(USBHMassStorageDriver *msdp) { usbh_urbstatus_t res; - res = usbhControlRequest(msdp->dev, USBH_CLASSOUT(USBH_REQTYPE_CLASS, 0xFF, 0, msdp->ifnum), 0, NULL); + res = usbhControlRequest(msdp->dev, + USBH_REQTYPE_CLASSOUT(USBH_REQTYPE_RECIP_INTERFACE), + 0xFF, 0, msdp->ifnum, 0, NULL); if (res != USBH_URBSTATUS_OK) { return FALSE; } -- cgit v1.2.3 From e2f7c9277c18b497935ac13d37e6ffab83da675b Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Tue, 6 Jun 2017 10:24:39 -0300 Subject: mend --- os/hal/src/hal_usbh.c | 2 +- os/hal/src/usbh/hal_usbh_hub.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) (limited to 'os/hal/src') diff --git a/os/hal/src/hal_usbh.c b/os/hal/src/hal_usbh.c index 538f36e..457abba 100644 --- a/os/hal/src/hal_usbh.c +++ b/os/hal/src/hal_usbh.c @@ -1119,7 +1119,7 @@ static void _hub_update_status(USBHDriver *host, USBHHubDriver *hub) { uint32_t stat; if (usbhhubControlRequest(host, hub, - USBH_REQTYPE_IN | USBH_REQTYPE_CLASS | USBH_REQTYPE_DEVICE, + USBH_REQTYPE_DIR_IN | USBH_REQTYPE_TYPE_CLASS | USBH_REQTYPE_RECIP_DEVICE, USBH_REQ_GET_STATUS, 0, 0, diff --git a/os/hal/src/usbh/hal_usbh_hub.c b/os/hal/src/usbh/hal_usbh_hub.c index 4b5af58..3a84175 100644 --- a/os/hal/src/usbh/hal_usbh_hub.c +++ b/os/hal/src/usbh/hal_usbh_hub.c @@ -198,7 +198,7 @@ alloc_ok: /* read Hub descriptor */ uinfo("Read Hub descriptor"); if (usbhhubControlRequest(dev->host, hubdp, - USBH_REQTYPE_IN | USBH_REQTYPE_CLASS | USBH_REQTYPE_DEVICE, + USBH_REQTYPE_DIR_IN | USBH_REQTYPE_TYPE_CLASS | USBH_REQTYPE_RECIP_DEVICE, USBH_REQ_GET_DESCRIPTOR, (USBH_DT_HUB << 8), 0, sizeof(hubdp->hubDesc), (uint8_t *)&hubdp->hubDesc) != USBH_URBSTATUS_OK) { -- cgit v1.2.3 From 50dda7cff22574816f415d5c5003240badcf3d32 Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Tue, 6 Jun 2017 15:21:37 -0300 Subject: Add UVC driver and test/example --- os/hal/src/hal_usbh.c | 12 +- os/hal/src/usbh/hal_usbh_uvc.c | 679 +++++++++++++++++++++++++++++++++++++++-- 2 files changed, 669 insertions(+), 22 deletions(-) (limited to 'os/hal/src') diff --git a/os/hal/src/hal_usbh.c b/os/hal/src/hal_usbh.c index 457abba..d242086 100644 --- a/os/hal/src/hal_usbh.c +++ b/os/hal/src/hal_usbh.c @@ -28,6 +28,7 @@ #include "usbh/dev/ftdi.h" #include "usbh/dev/msd.h" #include "usbh/dev/hid.h" +#include "usbh/dev/uvc.h" #if USBH_DEBUG_ENABLE_TRACE #define udbgf(f, ...) usbDbgPrintf(f, ##__VA_ARGS__) @@ -125,6 +126,9 @@ void usbhInit(void) { #if HAL_USBH_USE_HID usbhhidInit(); #endif +#if HAL_USBH_USE_UVC + usbhuvcInit(); +#endif #if HAL_USBH_USE_HUB usbhhubInit(); #endif @@ -421,7 +425,8 @@ usbh_urbstatus_t usbhControlRequestExtended(usbh_device_t *dev, uint32_t *actual_len, systime_t timeout) { - _check_dev(dev); + if (!dev) return USBH_URBSTATUS_DISCONNECTED; + osalDbgCheck(req != NULL); usbh_urb_t urb; @@ -1310,6 +1315,9 @@ static const usbh_classdriverinfo_t *usbh_classdrivers_lookup[] = { #if HAL_USBH_USE_HID &usbhhidClassDriverInfo, #endif +#if HAL_USBH_USE_UVC + &usbhuvcClassDriverInfo, +#endif #if HAL_USBH_USE_HUB &usbhhubClassDriverInfo, #endif @@ -1341,7 +1349,7 @@ static bool _classdriver_load(usbh_device_t *dev, uint8_t class, #if HAL_USBH_USE_IAD /* special case: */ if (info == &usbhiadClassDriverInfo) - return HAL_SUCCESS; + goto success; //return HAL_SUCCESS; #endif if (drv != NULL) diff --git a/os/hal/src/usbh/hal_usbh_uvc.c b/os/hal/src/usbh/hal_usbh_uvc.c index 025fbee..72c15c0 100644 --- a/os/hal/src/usbh/hal_usbh_uvc.c +++ b/os/hal/src/usbh/hal_usbh_uvc.c @@ -1,22 +1,17 @@ /* - ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio - Copyright (C) 2015..2017 Diego Ismirlian, (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. -*/ + * usbh_uvc.c + * + * Created on: 14 de set. de 2015 + * Author: Diego Ismirlian (dismirlian (at) google's mail (dot) com) + * + * License: + * + * This file is free for non-commercial use until the company I work for decides what to do. + * If in doubt, please contact me. + * + */ #include "hal.h" -#include "hal_usbh.h" #if HAL_USBH_USE_UVC @@ -28,6 +23,10 @@ #error "USBHUVC needs HAL_USBH_USE_IAD" #endif +#include "usbh/dev/uvc.h" +#include "usbh/internal.h" +#include + #if USBHUVC_DEBUG_ENABLE_TRACE #define udbgf(f, ...) usbDbgPrintf(f, ##__VA_ARGS__) #define udbg(f, ...) usbDbgPuts(f, ##__VA_ARGS__) @@ -61,6 +60,9 @@ #endif +USBHUVCDriver USBHUVCD[HAL_USBHUVC_MAX_INSTANCES]; + + static usbh_baseclassdriver_t *uvc_load(usbh_device_t *dev, const uint8_t *descriptor, uint16_t rem); static void uvc_unload(usbh_baseclassdriver_t *drv); @@ -73,16 +75,653 @@ const usbh_classdriverinfo_t usbhuvcClassDriverInfo = { 0x0e, 0x03, 0x00, "UVC", &class_driver_vmt }; +static bool _request(USBHUVCDriver *uvcdp, + uint8_t bRequest, uint8_t entity, uint8_t control, + uint16_t wLength, uint8_t *data, uint8_t interf) { + + usbh_urbstatus_t res; + + if (bRequest & 0x80) { + res = usbhControlRequest(uvcdp->dev, + USBH_REQTYPE_CLASSIN(USBH_REQTYPE_RECIP_INTERFACE), + bRequest, + ((control) << 8), + (interf) | ((entity) << 8), + wLength, data); + } else { + res = usbhControlRequest(uvcdp->dev, + USBH_REQTYPE_CLASSOUT(USBH_REQTYPE_RECIP_INTERFACE), + bRequest, + ((control) << 8), + (interf) | ((entity) << 8), + wLength, data); + } + + if (res != USBH_URBSTATUS_OK) + return HAL_FAILED; + + return HAL_SUCCESS; +} + +bool usbhuvcVCRequest(USBHUVCDriver *uvcdp, + uint8_t bRequest, uint8_t entity, uint8_t control, + uint16_t wLength, uint8_t *data) { + return _request(uvcdp, bRequest, entity, control, wLength, data, if_get(&uvcdp->ivc)->bInterfaceNumber); +} + +bool usbhuvcVSRequest(USBHUVCDriver *uvcdp, + uint8_t bRequest, uint8_t control, + uint16_t wLength, uint8_t *data) { + + return _request(uvcdp, bRequest, 0, control, wLength, data, if_get(&uvcdp->ivs)->bInterfaceNumber); +} + +static bool _set_vs_alternate(USBHUVCDriver *uvcdp, uint16_t min_ep_size) { + + if (min_ep_size == 0) { + uinfo("Selecting Alternate setting 0"); + return usbhStdReqSetInterface(uvcdp->dev, if_get(&uvcdp->ivs)->bInterfaceNumber, 0); + } + + if_iterator_t iif = uvcdp->ivs; + generic_iterator_t iep; + const usbh_endpoint_descriptor_t *ep = NULL; + uint8_t alt = 0; + uint16_t sz = 0xffff; + + uinfof("Searching alternate setting with min_ep_size=%d", min_ep_size); + + for (; iif.valid; if_iter_next(&iif)) { + const usbh_interface_descriptor_t *const ifdesc = if_get(&iif); + + if ((ifdesc->bInterfaceClass != UVC_CC_VIDEO) + || (ifdesc->bInterfaceSubClass != UVC_SC_VIDEOSTREAMING)) + continue; + + uinfof("\tScanning alternate setting=%d", ifdesc->bAlternateSetting); + + if (ifdesc->bNumEndpoints == 0) + continue; + + for (ep_iter_init(&iep, &iif); iep.valid; ep_iter_next(&iep)) { + const usbh_endpoint_descriptor_t *const epdesc = ep_get(&iep); + if (((epdesc->bmAttributes & 0x03) == USBH_EPTYPE_ISO) + && ((epdesc->bEndpointAddress & 0x80) == USBH_EPDIR_IN)) { + + uinfof("\t Endpoint wMaxPacketSize = %d", epdesc->wMaxPacketSize); + + if (epdesc->wMaxPacketSize >= min_ep_size) { + if (epdesc->wMaxPacketSize < sz) { + uinfo("\t Found new optimal alternate setting"); + sz = epdesc->wMaxPacketSize; + alt = ifdesc->bAlternateSetting; + ep = epdesc; + } + } + } + } + } + + if (ep && alt) { + uinfof("\tSelecting Alternate setting %d", alt); + if (usbhStdReqSetInterface(uvcdp->dev, if_get(&uvcdp->ivs)->bInterfaceNumber, alt) == HAL_SUCCESS) { + usbhEPObjectInit(&uvcdp->ep_iso, uvcdp->dev, ep); + usbhEPSetName(&uvcdp->ep_iso, "UVC[ISO ]"); + return HAL_SUCCESS; + } + } + + return HAL_FAILED; +} + +#if USBH_DEBUG_ENABLE && USBHUVC_DEBUG_ENABLE_INFO +void usbhuvcPrintProbeCommit(const usbh_uvc_ctrl_vs_probecommit_data_t *pc) { + + //uinfof("UVC: probe/commit data:"); + uinfof("\tbmHint=%04x", pc->bmHint); + uinfof("\tbFormatIndex=%d, bFrameIndex=%d, dwFrameInterval=%u", + pc->bFormatIndex, pc->bFrameIndex, pc->dwFrameInterval); + uinfof("\twKeyFrameRate=%d, wPFrameRate=%d, wCompQuality=%u, wCompWindowSize=%u", + pc->wKeyFrameRate, pc->wPFrameRate, pc->wCompQuality, pc->wCompWindowSize); + uinfof("\twDelay=%d", pc->wDelay); + uinfof("\tdwMaxVideoFrameSize=%u", pc->dwMaxVideoFrameSize); + uinfof("\tdwMaxPayloadTransferSize=%u", pc->dwMaxPayloadTransferSize); +/* uinfof("\tdwClockFrequency=%u", pc->dwClockFrequency); + uinfof("\tbmFramingInfo=%02x", pc->bmFramingInfo); + uinfof("\tbPreferedVersion=%d, bMinVersion=%d, bMaxVersion=%d", + pc->bPreferedVersion, pc->bMinVersion, pc->bMaxVersion); */ +} +#endif + +static void _post(USBHUVCDriver *uvcdp, usbh_urb_t *urb, memory_pool_t *mp, uint16_t type) { + usbhuvc_message_base_t *const msg = (usbhuvc_message_base_t *)urb->buff - 1; + msg->timestamp = osalOsGetSystemTimeX(); + + usbhuvc_message_base_t *const new_msg = (usbhuvc_message_base_t *)chPoolAllocI(mp); + if (new_msg != NULL) { + /* allocated the new buffer, now try to post the message to the mailbox */ + if (chMBPostI(&uvcdp->mb, (msg_t)msg) == MSG_OK) { + /* everything OK, complete the missing fields */ + msg->type = type; + msg->length = urb->actualLength; + + /* change the URB's buffer to the newly allocated one */ + urb->buff = (uint8_t *)(new_msg + 1); + } else { + /* couldn't post the message, free the newly allocated buffer */ + uerr("UVC: error, mailbox overrun"); + chPoolFreeI(&uvcdp->mp_status, new_msg); + } + } else { + uerrf("UVC: error, %s pool overrun", mp == &uvcdp->mp_data ? "data" : "status"); + } +} + +static void _cb_int(usbh_urb_t *urb) { + USBHUVCDriver *uvcdp = (USBHUVCDriver *)urb->userData; + + switch (urb->status) { + case USBH_URBSTATUS_OK: + if (urb->actualLength >= 2) { + _post(uvcdp, urb, &uvcdp->mp_status, USBHUVC_MESSAGETYPE_STATUS); + } else { + uerrf("UVC: INT IN, actualLength=%d", urb->actualLength); + } + break; + case USBH_URBSTATUS_TIMEOUT: /* the device NAKed */ + udbg("UVC: INT IN no info"); + break; + case USBH_URBSTATUS_DISCONNECTED: + case USBH_URBSTATUS_CANCELLED: + uwarn("UVC: INT IN status = DISCONNECTED/CANCELLED, aborting"); + return; + default: + uerrf("UVC: INT IN error, unexpected status = %d", urb->status); + break; + } + + usbhURBObjectResetI(urb); + usbhURBSubmitI(urb); +} + +static void _cb_iso(usbh_urb_t *urb) { + USBHUVCDriver *uvcdp = (USBHUVCDriver *)urb->userData; + + if ((urb->status == USBH_URBSTATUS_DISCONNECTED) + || (urb->status == USBH_URBSTATUS_CANCELLED)) { + uwarn("UVC: ISO IN status = DISCONNECTED/CANCELLED, aborting"); + return; + } + + if (urb->status != USBH_URBSTATUS_OK) { + uerrf("UVC: ISO IN error, unexpected status = %d", urb->status); + } else if (urb->actualLength >= 2) { + const uint8_t *const buff = (const uint8_t *)urb->buff; + if (buff[0] < 2) { + uerrf("UVC: ISO IN, bHeaderLength=%d", buff[0]); + } else if (buff[0] > urb->actualLength) { + uerrf("UVC: ISO IN, bHeaderLength=%d > actualLength=%d", buff[0], urb->actualLength); + } else { + udbgf("UVC: ISO IN len=%d, hdr=%d, FID=%d, EOF=%d, ERR=%d, EOH=%d", + urb->actualLength, + buff[0], + buff[1] & UVC_HDR_FID, + buff[1] & UVC_HDR_EOF, + buff[1] & UVC_HDR_ERR, + buff[1] & UVC_HDR_EOH); + + if ((urb->actualLength > buff[0]) + || (buff[1] & (UVC_HDR_EOF | UVC_HDR_ERR))) { + _post(uvcdp, urb, &uvcdp->mp_data, USBHUVC_MESSAGETYPE_DATA); + } else { + udbgf("UVC: ISO IN skip: len=%d, hdr=%d, FID=%d, EOF=%d, ERR=%d, EOH=%d", + urb->actualLength, + buff[0], + buff[1] & UVC_HDR_FID, + buff[1] & UVC_HDR_EOF, + buff[1] & UVC_HDR_ERR, + buff[1] & UVC_HDR_EOH); + } + } + } else if (urb->actualLength > 0) { + uerrf("UVC: ISO IN, actualLength=%d", urb->actualLength); + } + + usbhURBObjectResetI(urb); + usbhURBSubmitI(urb); +} + + +bool usbhuvcStreamStart(USBHUVCDriver *uvcdp, uint16_t min_ep_sz) { + bool ret = HAL_FAILED; + osalSysLock(); + osalDbgCheck(uvcdp && (uvcdp->state != USBHUVC_STATE_UNINITIALIZED) && + (uvcdp->state != USBHUVC_STATE_BUSY)); + if (uvcdp->state == USBHUVC_STATE_STREAMING) { + osalSysUnlock(); + return HAL_SUCCESS; + } + if (uvcdp->state != USBHUVC_STATE_READY) { + osalSysUnlock(); + return HAL_FAILED; + } + uvcdp->state = USBHUVC_STATE_BUSY; + osalSysUnlock(); + + //set the alternate setting + if (_set_vs_alternate(uvcdp, min_ep_sz) != HAL_SUCCESS) + goto exit; + + //reserve working RAM + uint32_t datapackets; + uint32_t data_sz = (uvcdp->ep_iso.wMaxPacketSize + sizeof(usbhuvc_message_data_t) + 3) & ~3; + + datapackets = HAL_USBHUVC_WORK_RAM_SIZE / data_sz; + if (datapackets == 0) { + uerr("Not enough work RAM"); + goto failed; + } + + uint32_t workramsz = datapackets * data_sz; + uinfof("Reserving %u bytes of RAM (%d data packets of %d bytes)", workramsz, datapackets, data_sz); + if (datapackets > (HAL_USBHUVC_MAX_MAILBOX_SZ - HAL_USBHUVC_STATUS_PACKETS_COUNT)) { + uwarn("Mailbox may overflow, use a larger HAL_USBHUVC_MAX_MAILBOX_SZ. UVC will under-utilize the assigned work RAM."); + } + chMBResumeX(&uvcdp->mb); + + uvcdp->mp_data_buffer = chHeapAlloc(NULL, workramsz); + if (uvcdp->mp_data_buffer == NULL) { + uerr("Couldn't reserve RAM"); + goto failed; + } + + //initialize the mempool + const uint8_t *elem = (const uint8_t *)uvcdp->mp_data_buffer; + chPoolObjectInit(&uvcdp->mp_data, data_sz, NULL); + while (datapackets--) { + chPoolFree(&uvcdp->mp_data, (void *)elem); + elem += data_sz; + } + + //open the endpoint + usbhEPOpen(&uvcdp->ep_iso); + + //allocate 1 buffer and submit the first transfer + usbhuvc_message_data_t *const msg = (usbhuvc_message_data_t *)chPoolAlloc(&uvcdp->mp_data); + osalDbgCheck(msg); + usbhURBObjectInit(&uvcdp->urb_iso, &uvcdp->ep_iso, _cb_iso, uvcdp, msg->data, uvcdp->ep_iso.wMaxPacketSize); + osalSysLock(); + usbhURBSubmitI(&uvcdp->urb_iso); + osalOsRescheduleS(); + osalSysUnlock(); + + ret = HAL_SUCCESS; + goto exit; + +failed: + _set_vs_alternate(uvcdp, 0); + if (uvcdp->mp_data_buffer) + chHeapFree(uvcdp->mp_data_buffer); + +exit: + osalSysLock(); + if (ret == HAL_SUCCESS) + uvcdp->state = USBHUVC_STATE_STREAMING; + else + uvcdp->state = USBHUVC_STATE_READY; + osalSysUnlock(); + return ret; +} + +bool usbhuvcStreamStop(USBHUVCDriver *uvcdp) { + osalSysLock(); + osalDbgCheck(uvcdp && (uvcdp->state != USBHUVC_STATE_UNINITIALIZED) && + (uvcdp->state != USBHUVC_STATE_BUSY)); + if (uvcdp->state != USBHUVC_STATE_STREAMING) { + osalSysUnlock(); + return HAL_SUCCESS; + } + uvcdp->state = USBHUVC_STATE_BUSY; + + //close the ISO endpoint + usbhEPCloseS(&uvcdp->ep_iso); + + //purge the mailbox + chMBResetI(&uvcdp->mb); //TODO: the status messages are lost!! + chMtxLockS(&uvcdp->mtx); + osalSysUnlock(); + + //free the working memory + chHeapFree(uvcdp->mp_data_buffer); + uvcdp->mp_data_buffer = 0; + + //set alternate setting to 0 + _set_vs_alternate(uvcdp, 0); + + osalSysLock(); + uvcdp->state = USBHUVC_STATE_READY; + chMtxUnlockS(&uvcdp->mtx); + osalSysUnlock(); + return HAL_SUCCESS; +} + +bool usbhuvcFindVSDescriptor(USBHUVCDriver *uvcdp, + generic_iterator_t *ics, + uint8_t bDescriptorSubtype, + bool start) { + + if (start) + cs_iter_init(ics, (generic_iterator_t *)&uvcdp->ivs); + else + cs_iter_next(ics); + + for (; ics->valid; cs_iter_next(ics)) { + if (ics->curr[1] != UVC_CS_INTERFACE) + break; + if (ics->curr[2] == bDescriptorSubtype) + return HAL_SUCCESS; + if (!start) + break; + } + return HAL_FAILED; +} + +void usbhuvcResetPC(USBHUVCDriver *uvcdp) { + memset(&uvcdp->pc, 0, sizeof(uvcdp->pc)); +} + +bool usbhuvcProbe(USBHUVCDriver *uvcdp) { +// memset(&uvcdp->pc_min, 0, sizeof(uvcdp->pc_min)); +// memset(&uvcdp->pc_max, 0, sizeof(uvcdp->pc_max)); + + if (usbhuvcVSRequest(uvcdp, UVC_SET_CUR, UVC_CTRL_VS_PROBE_CONTROL, sizeof(uvcdp->pc), (uint8_t *)&uvcdp->pc) != HAL_SUCCESS) + return HAL_FAILED; + if (usbhuvcVSRequest(uvcdp, UVC_GET_CUR, UVC_CTRL_VS_PROBE_CONTROL, sizeof(uvcdp->pc), (uint8_t *)&uvcdp->pc) != HAL_SUCCESS) + return HAL_FAILED; + if (usbhuvcVSRequest(uvcdp, UVC_GET_MAX, UVC_CTRL_VS_PROBE_CONTROL, sizeof(uvcdp->pc_max), (uint8_t *)&uvcdp->pc_max) != HAL_SUCCESS) + return HAL_FAILED; + if (usbhuvcVSRequest(uvcdp, UVC_GET_MIN, UVC_CTRL_VS_PROBE_CONTROL, sizeof(uvcdp->pc_min), (uint8_t *)&uvcdp->pc_min) != HAL_SUCCESS) + return HAL_FAILED; + return HAL_SUCCESS; +} + +bool usbhuvcCommit(USBHUVCDriver *uvcdp) { + if (usbhuvcVSRequest(uvcdp, UVC_SET_CUR, UVC_CTRL_VS_COMMIT_CONTROL, sizeof(uvcdp->pc), (uint8_t *)&uvcdp->pc) != HAL_SUCCESS) + return HAL_FAILED; + + osalSysLock(); + if (uvcdp->state == USBHUVC_STATE_ACTIVE) + uvcdp->state = USBHUVC_STATE_READY; + osalSysUnlock(); + return HAL_SUCCESS; +} + +uint32_t usbhuvcEstimateRequiredEPSize(USBHUVCDriver *uvcdp, const uint8_t *formatdesc, + const uint8_t *framedesc, uint32_t dwFrameInterval) { + + osalDbgCheck(framedesc); + osalDbgCheck(framedesc[0] > 3); + osalDbgCheck(framedesc[1] == UVC_CS_INTERFACE); + osalDbgCheck(formatdesc); + osalDbgCheck(formatdesc[0] > 3); + osalDbgCheck(formatdesc[1] == UVC_CS_INTERFACE); + + uint16_t w, h, div, mul; + uint8_t bpp; + + switch (framedesc[2]) { + case UVC_VS_FRAME_MJPEG: { + const usbh_uvc_frame_mjpeg_t *frame = (const usbh_uvc_frame_mjpeg_t *)framedesc; + //const usbh_uvc_format_mjpeg_t *fmt = (const usbh_uvc_format_mjpeg_t *)formatdesc; + w = frame->wWidth; + h = frame->wHeight; + bpp = 16; //TODO: check this!! + mul = 1; + div = 5; //TODO: check this estimate + } break; + case UVC_VS_FRAME_UNCOMPRESSED: { + const usbh_uvc_frame_uncompressed_t *frame = (const usbh_uvc_frame_uncompressed_t *)framedesc; + const usbh_uvc_format_uncompressed *fmt = (const usbh_uvc_format_uncompressed *)formatdesc; + w = frame->wWidth; + h = frame->wHeight; + bpp = fmt->bBitsPerPixel; + mul = div = 1; + } break; + default: + uwarn("Unsupported format"); + return 0xffffffff; + } + + uint32_t sz = w * h / 8 * bpp; + sz *= 10000000UL / dwFrameInterval; + sz /= 1000; + + if (uvcdp->dev->speed == USBH_DEVSPEED_HIGH) + div *= 8; + + return (sz * mul) / div + 12; +} + +void usbhuvcObjectInit(USBHUVCDriver *uvcdp) { + osalDbgCheck(uvcdp != NULL); + memset(uvcdp, 0, sizeof(*uvcdp)); + uvcdp->info = &usbhuvcClassDriverInfo; + chMBObjectInit(&uvcdp->mb, uvcdp->mb_buff, HAL_USBHUVC_MAX_MAILBOX_SZ); + chMtxObjectInit(&uvcdp->mtx); + uvcdp->state = USBHUVC_STATE_STOP; +} + static usbh_baseclassdriver_t *uvc_load(usbh_device_t *dev, const uint8_t *descriptor, uint16_t rem) { - (void)dev; - (void)descriptor; - (void)rem; + + USBHUVCDriver *uvcdp; + uint8_t i; + + if (descriptor[1] != USBH_DT_INTERFACE_ASSOCIATION) + return NULL; + + /* alloc driver */ + for (i = 0; i < HAL_USBHUVC_MAX_INSTANCES; i++) { + if (USBHUVCD[i].dev == NULL) { + uvcdp = &USBHUVCD[i]; + goto alloc_ok; + } + } + + uwarn("Can't alloc UVC driver"); + + /* can't alloc */ return NULL; + +alloc_ok: + /* initialize the driver's variables */ + uvcdp->ivc.curr = uvcdp->ivs.curr = NULL; + + usbhEPSetName(&dev->ctrl, "UVC[CTRL]"); + + const usbh_ia_descriptor_t *iad = (const usbh_ia_descriptor_t *)descriptor; + if_iterator_t iif; + generic_iterator_t ics; + generic_iterator_t iep; + + iif.iad = iad; + iif.curr = descriptor; + iif.rem = rem; + + for (if_iter_next(&iif); iif.valid; if_iter_next(&iif)) { + if (iif.iad != iad) break; + + const usbh_interface_descriptor_t *const ifdesc = if_get(&iif); + if (ifdesc->bInterfaceClass != UVC_CC_VIDEO) { + uwarnf("Skipping Interface %d (class != UVC_CC_VIDEO)", + ifdesc->bInterfaceNumber); + continue; + } + + uinfof("Interface %d, Alt=%d, Class=UVC_CC_VIDEO, Subclass=%02x", + ifdesc->bInterfaceNumber, + ifdesc->bAlternateSetting, + ifdesc->bInterfaceSubClass); + + switch (ifdesc->bInterfaceSubClass) { + case UVC_SC_VIDEOCONTROL: + if (uvcdp->ivc.curr == NULL) { + uvcdp->ivc = iif; + } + for (cs_iter_init(&ics, (generic_iterator_t *)&iif); ics.valid; cs_iter_next(&ics)) { + if (ics.curr[1] != UVC_CS_INTERFACE) { + uwarnf("Unknown descriptor=%02X", ics.curr[1]); + continue; + } + switch (ics.curr[2]) { + case UVC_VC_HEADER: + uinfo(" VC_HEADER"); break; + case UVC_VC_INPUT_TERMINAL: + uinfof(" VC_INPUT_TERMINAL, ID=%d", ics.curr[3]); break; + case UVC_VC_OUTPUT_TERMINAL: + uinfof(" VC_OUTPUT_TERMINAL, ID=%d", ics.curr[3]); break; + case UVC_VC_SELECTOR_UNIT: + uinfof(" VC_SELECTOR_UNIT, ID=%d", ics.curr[3]); break; + case UVC_VC_PROCESSING_UNIT: + uinfof(" VC_PROCESSING_UNIT, ID=%d", ics.curr[3]); break; + case UVC_VC_EXTENSION_UNIT: + uinfof(" VC_EXTENSION_UNIT, ID=%d", ics.curr[3]); break; + default: + uwarnf("Unknown video bDescriptorSubtype=%02x", ics.curr[2]); + break; + } + } + break; + case UVC_SC_VIDEOSTREAMING: + if (uvcdp->ivs.curr == NULL) { + uvcdp->ivs = iif; + } + for (cs_iter_init(&ics, (generic_iterator_t *)&iif); ics.valid; cs_iter_next(&ics)) { + if (ics.curr[1] != UVC_CS_INTERFACE) { + uwarnf("Unknown descriptor=%02X", ics.curr[1]); + continue; + } + switch (ics.curr[2]) { + case UVC_VS_INPUT_HEADER: + uinfo(" VS_INPUT_HEADER"); break; + case UVC_VS_OUTPUT_HEADER: + uinfo(" VS_OUTPUT_HEADER"); break; + case UVC_VS_STILL_IMAGE_FRAME: + uinfo(" VS_STILL_IMAGE_FRAME"); break; + + case UVC_VS_FORMAT_UNCOMPRESSED: + uinfof(" VS_FORMAT_UNCOMPRESSED, bFormatIndex=%d", ics.curr[3]); break; + case UVC_VS_FORMAT_MPEG2TS: + uinfof(" VS_FORMAT_MPEG2TS, bFormatIndex=%d", ics.curr[3]); break; + case UVC_VS_FORMAT_DV: + uinfof(" VS_FORMAT_DV, bFormatIndex=%d", ics.curr[3]); break; + case UVC_VS_FORMAT_MJPEG: + uinfof(" VS_FORMAT_MJPEG, bFormatIndex=%d", ics.curr[3]); break; + case UVC_VS_FORMAT_FRAME_BASED: + uinfof(" VS_FORMAT_FRAME_BASED, bFormatIndex=%d", ics.curr[3]); break; + case UVC_VS_FORMAT_STREAM_BASED: + uinfof(" VS_FORMAT_STREAM_BASED, bFormatIndex=%d", ics.curr[3]); break; + + case UVC_VS_FRAME_UNCOMPRESSED: + uinfof(" VS_FRAME_UNCOMPRESSED, bFrameIndex=%d", ics.curr[3]); break; + case UVC_VS_FRAME_MJPEG: + uinfof(" VS_FRAME_MJPEG, bFrameIndex=%d", ics.curr[3]); break; + case UVC_VS_FRAME_FRAME_BASED: + uinfof(" VS_FRAME_FRAME_BASED, bFrameIndex=%d", ics.curr[3]); break; + + case UVC_VS_COLOR_FORMAT: + uinfo(" VS_COLOR_FORMAT"); break; + default: + uwarnf("Unknown video bDescriptorSubtype=%02x", ics.curr[2]); + break; + } + } + break; + default: + uwarnf("Unknown video bInterfaceSubClass=%02x", ifdesc->bInterfaceSubClass); + break; + } + + for (ep_iter_init(&iep, &iif); iep.valid; ep_iter_next(&iep)) { + const usbh_endpoint_descriptor_t *const epdesc = ep_get(&iep); + + if ((ifdesc->bInterfaceSubClass == UVC_SC_VIDEOCONTROL) + && ((epdesc->bmAttributes & 0x03) == USBH_EPTYPE_INT) + && ((epdesc->bEndpointAddress & 0x80) == USBH_EPDIR_IN)) { + /* found VC interrupt endpoint */ + uinfof(" VC Interrupt endpoint; %02x, bInterval=%d", + epdesc->bEndpointAddress, epdesc->bInterval); + usbhEPObjectInit(&uvcdp->ep_int, dev, epdesc); + usbhEPSetName(&uvcdp->ep_int, "UVC[INT ]"); + } else if ((ifdesc->bInterfaceSubClass == UVC_SC_VIDEOSTREAMING) + && ((epdesc->bmAttributes & 0x03) == USBH_EPTYPE_ISO) + && ((epdesc->bEndpointAddress & 0x80) == USBH_EPDIR_IN)) { + /* found VS isochronous endpoint */ + uinfof(" VS Isochronous endpoint; %02x, bInterval=%d, bmAttributes=%02x", + epdesc->bEndpointAddress, epdesc->bInterval, epdesc->bmAttributes); + } else { + /* unknown EP */ + uwarnf(" , bEndpointAddress=%02x, bmAttributes=%02x", + epdesc->bEndpointAddress, epdesc->bmAttributes); + } + + for (cs_iter_init(&ics, &iep); ics.valid; cs_iter_next(&ics)) { + uinfof(" CS_ENDPOINT bLength=%d, bDescriptorType=%02X", + ics.curr[0], ics.curr[1]); + } + } + } + + if ((uvcdp->ivc.curr == NULL) || (uvcdp->ivs.curr == NULL)) { + return NULL; + } + +// uvcdp->dev = dev; + + _set_vs_alternate(uvcdp, 0); + + /* initialize the INT endpoint */ + chPoolObjectInit(&uvcdp->mp_status, sizeof(usbhuvc_message_status_t), NULL); + for(i = 0; i < HAL_USBHUVC_STATUS_PACKETS_COUNT; i++) + chPoolFree(&uvcdp->mp_status, &uvcdp->mp_status_buffer[i]); + + usbhEPOpen(&uvcdp->ep_int); + + usbhuvc_message_status_t *const msg = (usbhuvc_message_status_t *)chPoolAlloc(&uvcdp->mp_status); + osalDbgCheck(msg); + usbhURBObjectInit(&uvcdp->urb_int, &uvcdp->ep_int, _cb_int, uvcdp, msg->data, USBHUVC_MAX_STATUS_PACKET_SZ); + osalSysLock(); + usbhURBSubmitI(&uvcdp->urb_int); + uvcdp->state = USBHUVC_STATE_ACTIVE; + osalOsRescheduleS(); + osalSysUnlock(); + + dev->keepFullCfgDesc++; + return (usbh_baseclassdriver_t *)uvcdp; } static void uvc_unload(usbh_baseclassdriver_t *drv) { - (void)drv; + USBHUVCDriver *const uvcdp = (USBHUVCDriver *)drv; + + usbhuvcStreamStop(uvcdp); + + usbhEPClose(&uvcdp->ep_int); + + //TODO: free + + if (drv->dev->keepFullCfgDesc) + drv->dev->keepFullCfgDesc--; + + osalSysLock(); + uvcdp->state = USBHUVC_STATE_STOP; + osalSysUnlock(); +} + +void usbhuvcInit(void) { + uint8_t i; + for (i = 0; i < HAL_USBHUVC_MAX_INSTANCES; i++) { + usbhuvcObjectInit(&USBHUVCD[i]); + } } #endif -- cgit v1.2.3 From 5a876ba2b04ee0933ced272b04e2ee481e48a1b1 Mon Sep 17 00:00:00 2001 From: Diego Ismirlian Date: Tue, 6 Jun 2017 15:25:05 -0300 Subject: USBH: License change for UVC driver --- os/hal/src/usbh/hal_usbh_uvc.c | 24 ++++++++++++++---------- 1 file changed, 14 insertions(+), 10 deletions(-) (limited to 'os/hal/src') diff --git a/os/hal/src/usbh/hal_usbh_uvc.c b/os/hal/src/usbh/hal_usbh_uvc.c index 72c15c0..9cbbb03 100644 --- a/os/hal/src/usbh/hal_usbh_uvc.c +++ b/os/hal/src/usbh/hal_usbh_uvc.c @@ -1,14 +1,18 @@ /* - * usbh_uvc.c - * - * Created on: 14 de set. de 2015 - * Author: Diego Ismirlian (dismirlian (at) google's mail (dot) com) - * - * License: - * - * This file is free for non-commercial use until the company I work for decides what to do. - * If in doubt, please contact me. - * + ChibiOS - Copyright (C) 2006..2017 Giovanni Di Sirio + Copyright (C) 2015..2017 Diego Ismirlian, (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" -- cgit v1.2.3