LayerOne / LayerOne2017_emu

test

Dependencies:   SDFileSystem mbed-dev

Fork of Nucleo_Ex06_EMU by woodstock .

USBHost/USBHost.cpp@4:53ef91c87d74, 2017-05-27 (annotated)

Committer:
charliex
Date:
Sat May 27 02:17:37 2017 +0000
Revision:
4:53ef91c87d74
Parent:
0:3dac1f1bc9e0 
test

Who changed what in which revision?

UserRevisionLine numberNew contents of line
beaglescout007 0:3dac1f1bc9e0 1 /* mbed USBHost Library
beaglescout007 0:3dac1f1bc9e0 2 * Copyright (c) 2006-2013 ARM Limited
beaglescout007 0:3dac1f1bc9e0 3 *
beaglescout007 0:3dac1f1bc9e0 4 * Licensed under the Apache License, Version 2.0 (the "License");
beaglescout007 0:3dac1f1bc9e0 5 * you may not use this file except in compliance with the License.
beaglescout007 0:3dac1f1bc9e0 6 * You may obtain a copy of the License at
beaglescout007 0:3dac1f1bc9e0 7 *
beaglescout007 0:3dac1f1bc9e0 8 * http://www.apache.org/licenses/LICENSE-2.0
beaglescout007 0:3dac1f1bc9e0 9 *
beaglescout007 0:3dac1f1bc9e0 10 * Unless required by applicable law or agreed to in writing, software
beaglescout007 0:3dac1f1bc9e0 11 * distributed under the License is distributed on an "AS IS" BASIS,
beaglescout007 0:3dac1f1bc9e0 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
beaglescout007 0:3dac1f1bc9e0 13 * See the License for the specific language governing permissions and
beaglescout007 0:3dac1f1bc9e0 14 * limitations under the License.
beaglescout007 0:3dac1f1bc9e0 15 */
beaglescout007 0:3dac1f1bc9e0 16
beaglescout007 0:3dac1f1bc9e0 17 #include "USBHost.h"
beaglescout007 0:3dac1f1bc9e0 18
beaglescout007 0:3dac1f1bc9e0 19 #define USB_TRACE1(A) while(0)
beaglescout007 0:3dac1f1bc9e0 20 #undef USB_TEST_ASSERT
beaglescout007 0:3dac1f1bc9e0 21 void usb_test_assert_internal(const char *expr, const char *file, int line);
beaglescout007 0:3dac1f1bc9e0 22 #define USB_TEST_ASSERT(EXPR) while(!(EXPR)){usb_test_assert_internal(#EXPR,__FILE__,__LINE__);}
beaglescout007 0:3dac1f1bc9e0 23
beaglescout007 0:3dac1f1bc9e0 24 USBHost* USBHost::inst = NULL;
beaglescout007 0:3dac1f1bc9e0 25
beaglescout007 0:3dac1f1bc9e0 26 USBHost* USBHost::getHostInst() {
beaglescout007 0:3dac1f1bc9e0 27 if (inst == NULL) {
beaglescout007 0:3dac1f1bc9e0 28 inst = new USBHost();
beaglescout007 0:3dac1f1bc9e0 29 inst->init();
beaglescout007 0:3dac1f1bc9e0 30 }
beaglescout007 0:3dac1f1bc9e0 31 return inst;
beaglescout007 0:3dac1f1bc9e0 32 }
beaglescout007 0:3dac1f1bc9e0 33
beaglescout007 0:3dac1f1bc9e0 34 void USBHost::poll()
beaglescout007 0:3dac1f1bc9e0 35 {
beaglescout007 0:3dac1f1bc9e0 36 if (inst) {
beaglescout007 0:3dac1f1bc9e0 37 inst->task();
beaglescout007 0:3dac1f1bc9e0 38 }
beaglescout007 0:3dac1f1bc9e0 39 }
beaglescout007 0:3dac1f1bc9e0 40
beaglescout007 0:3dac1f1bc9e0 41 USBHost::USBHost() {
beaglescout007 0:3dac1f1bc9e0 42 }
beaglescout007 0:3dac1f1bc9e0 43
beaglescout007 0:3dac1f1bc9e0 44 /* virtual */ bool USBHost::addDevice(USBDeviceConnected* parent, int port, bool lowSpeed) {
beaglescout007 0:3dac1f1bc9e0 45 USBDeviceConnected* dev = new USBDeviceConnected;
beaglescout007 0:3dac1f1bc9e0 46 USBEndpoint* ep = new USBEndpoint(dev);
beaglescout007 0:3dac1f1bc9e0 47 dev->init(0, port, lowSpeed);
beaglescout007 0:3dac1f1bc9e0 48 dev->setAddress(0);
beaglescout007 0:3dac1f1bc9e0 49 dev->setEpCtl(ep);
beaglescout007 0:3dac1f1bc9e0 50 uint8_t desc[18];
beaglescout007 0:3dac1f1bc9e0 51 wait_ms(100);
beaglescout007 0:3dac1f1bc9e0 52
beaglescout007 0:3dac1f1bc9e0 53 int rc = controlRead(dev, 0x80, GET_DESCRIPTOR, 1<<8, 0, desc, 8);
beaglescout007 0:3dac1f1bc9e0 54 USB_TEST_ASSERT(rc == USB_TYPE_OK);
beaglescout007 0:3dac1f1bc9e0 55 if (rc != USB_TYPE_OK) {
beaglescout007 0:3dac1f1bc9e0 56 USB_ERR("ADD DEVICE FAILD");
beaglescout007 0:3dac1f1bc9e0 57 }
beaglescout007 0:3dac1f1bc9e0 58 USB_DBG_HEX(desc, 8);
beaglescout007 0:3dac1f1bc9e0 59 DeviceDescriptor* dev_desc = reinterpret_cast<DeviceDescriptor*>(desc);
beaglescout007 0:3dac1f1bc9e0 60 ep->setSize(dev_desc->bMaxPacketSize);
beaglescout007 0:3dac1f1bc9e0 61
beaglescout007 0:3dac1f1bc9e0 62 int new_addr = USBDeviceConnected::getNewAddress();
beaglescout007 0:3dac1f1bc9e0 63 rc = controlWrite(dev, 0x00, SET_ADDRESS, new_addr, 0, NULL, 0);
beaglescout007 0:3dac1f1bc9e0 64 USB_TEST_ASSERT(rc == USB_TYPE_OK);
beaglescout007 0:3dac1f1bc9e0 65 dev->setAddress(new_addr);
beaglescout007 0:3dac1f1bc9e0 66 wait_ms(100);
beaglescout007 0:3dac1f1bc9e0 67
beaglescout007 0:3dac1f1bc9e0 68 rc = controlRead(dev, 0x80, GET_DESCRIPTOR, 1<<8, 0, desc, sizeof(desc));
beaglescout007 0:3dac1f1bc9e0 69 USB_TEST_ASSERT(rc == USB_TYPE_OK);
beaglescout007 0:3dac1f1bc9e0 70 USB_DBG_HEX(desc, sizeof(desc));
beaglescout007 0:3dac1f1bc9e0 71
beaglescout007 0:3dac1f1bc9e0 72 dev->setVid(dev_desc->idVendor);
beaglescout007 0:3dac1f1bc9e0 73 dev->setPid(dev_desc->idProduct);
beaglescout007 0:3dac1f1bc9e0 74 dev->setClass(dev_desc->bDeviceClass);
beaglescout007 0:3dac1f1bc9e0 75 USB_INFO("parent:%p port:%d speed:%s VID:%04x PID:%04x class:%02x addr:%d",
beaglescout007 0:3dac1f1bc9e0 76 parent, port, (lowSpeed ? "low " : "full"), dev->getVid(), dev->getPid(), dev->getClass(),
beaglescout007 0:3dac1f1bc9e0 77 dev->getAddress());
beaglescout007 0:3dac1f1bc9e0 78
beaglescout007 0:3dac1f1bc9e0 79 DeviceLists.push_back(dev);
beaglescout007 0:3dac1f1bc9e0 80
beaglescout007 0:3dac1f1bc9e0 81 if (dev->getClass() == HUB_CLASS) {
beaglescout007 0:3dac1f1bc9e0 82 const int config = 1;
beaglescout007 0:3dac1f1bc9e0 83 int rc = controlWrite(dev, 0x00, SET_CONFIGURATION, config, 0, NULL, 0);
beaglescout007 0:3dac1f1bc9e0 84 USB_TEST_ASSERT(rc == USB_TYPE_OK);
beaglescout007 0:3dac1f1bc9e0 85 wait_ms(100);
beaglescout007 0:3dac1f1bc9e0 86 Hub(dev);
beaglescout007 0:3dac1f1bc9e0 87 }
beaglescout007 0:3dac1f1bc9e0 88 return true;
beaglescout007 0:3dac1f1bc9e0 89 }
beaglescout007 0:3dac1f1bc9e0 90
beaglescout007 0:3dac1f1bc9e0 91 // enumerate a device with the control USBEndpoint
beaglescout007 0:3dac1f1bc9e0 92 USB_TYPE USBHost::enumerate(USBDeviceConnected * dev, IUSBEnumerator* pEnumerator)
beaglescout007 0:3dac1f1bc9e0 93 {
beaglescout007 0:3dac1f1bc9e0 94 if (dev->getClass() == HUB_CLASS) { // skip hub class
beaglescout007 0:3dac1f1bc9e0 95 return USB_TYPE_OK;
beaglescout007 0:3dac1f1bc9e0 96 }
beaglescout007 0:3dac1f1bc9e0 97 uint8_t desc[18];
beaglescout007 0:3dac1f1bc9e0 98 USB_TYPE rc = controlRead(dev, 0x80, GET_DESCRIPTOR, 1<<8, 0, desc, sizeof(desc));
beaglescout007 0:3dac1f1bc9e0 99 USB_TEST_ASSERT(rc == USB_TYPE_OK);
beaglescout007 0:3dac1f1bc9e0 100 USB_DBG_HEX(desc, sizeof(desc));
beaglescout007 0:3dac1f1bc9e0 101 if (rc != USB_TYPE_OK) {
beaglescout007 0:3dac1f1bc9e0 102 return rc;
beaglescout007 0:3dac1f1bc9e0 103 }
beaglescout007 0:3dac1f1bc9e0 104 DeviceDescriptor* dev_desc = reinterpret_cast<DeviceDescriptor*>(desc);
beaglescout007 0:3dac1f1bc9e0 105 dev->setClass(dev_desc->bDeviceClass);
beaglescout007 0:3dac1f1bc9e0 106 pEnumerator->setVidPid(dev->getVid(), dev->getPid());
beaglescout007 0:3dac1f1bc9e0 107
beaglescout007 0:3dac1f1bc9e0 108 rc = controlRead(dev, 0x80, GET_DESCRIPTOR, 2<<8, 0, desc, 4);
beaglescout007 0:3dac1f1bc9e0 109 USB_TEST_ASSERT(rc == USB_TYPE_OK);
beaglescout007 0:3dac1f1bc9e0 110 USB_DBG_HEX(desc, 4);
beaglescout007 0:3dac1f1bc9e0 111
beaglescout007 0:3dac1f1bc9e0 112 int TotalLength = desc[2]|desc[3]<<8;
beaglescout007 0:3dac1f1bc9e0 113 uint8_t* buf = new uint8_t[TotalLength];
beaglescout007 0:3dac1f1bc9e0 114 rc = controlRead(dev, 0x80, GET_DESCRIPTOR, 2<<8, 0, buf, TotalLength);
beaglescout007 0:3dac1f1bc9e0 115 USB_TEST_ASSERT(rc == USB_TYPE_OK);
beaglescout007 0:3dac1f1bc9e0 116 //USB_DBG_HEX(buf, TotalLength);
beaglescout007 0:3dac1f1bc9e0 117
beaglescout007 0:3dac1f1bc9e0 118 // Parse the configuration descriptor
beaglescout007 0:3dac1f1bc9e0 119 parseConfDescr(dev, buf, TotalLength, pEnumerator);
beaglescout007 0:3dac1f1bc9e0 120 delete[] buf;
beaglescout007 0:3dac1f1bc9e0 121 // only set configuration if not enumerated before
beaglescout007 0:3dac1f1bc9e0 122 if (!dev->isEnumerated()) {
beaglescout007 0:3dac1f1bc9e0 123 USB_DBG("Set configuration 1 on dev: %p", dev);
beaglescout007 0:3dac1f1bc9e0 124 // sixth step: set configuration (only 1 supported)
beaglescout007 0:3dac1f1bc9e0 125 int config = 1;
beaglescout007 0:3dac1f1bc9e0 126 USB_TYPE res = controlWrite(dev, 0x00, SET_CONFIGURATION, config, 0, NULL, 0);
beaglescout007 0:3dac1f1bc9e0 127 if (res != USB_TYPE_OK) {
beaglescout007 0:3dac1f1bc9e0 128 USB_ERR("SET CONF FAILED");
beaglescout007 0:3dac1f1bc9e0 129 return res;
beaglescout007 0:3dac1f1bc9e0 130 }
beaglescout007 0:3dac1f1bc9e0 131 // Some devices may require this delay
beaglescout007 0:3dac1f1bc9e0 132 wait_ms(100);
beaglescout007 0:3dac1f1bc9e0 133 dev->setEnumerated();
beaglescout007 0:3dac1f1bc9e0 134 // Now the device is enumerated!
beaglescout007 0:3dac1f1bc9e0 135 USB_DBG("dev %p is enumerated", dev);
beaglescout007 0:3dac1f1bc9e0 136 }
beaglescout007 0:3dac1f1bc9e0 137 return USB_TYPE_OK;
beaglescout007 0:3dac1f1bc9e0 138 }
beaglescout007 0:3dac1f1bc9e0 139
beaglescout007 0:3dac1f1bc9e0 140 // this method fills the USBDeviceConnected object: class,.... . It also add endpoints found in the descriptor.
beaglescout007 0:3dac1f1bc9e0 141 void USBHost::parseConfDescr(USBDeviceConnected * dev, uint8_t * conf_descr, uint32_t len, IUSBEnumerator* pEnumerator)
beaglescout007 0:3dac1f1bc9e0 142 {
beaglescout007 0:3dac1f1bc9e0 143 uint32_t index = 0;
beaglescout007 0:3dac1f1bc9e0 144 uint32_t len_desc = 0;
beaglescout007 0:3dac1f1bc9e0 145 uint8_t id = 0;
beaglescout007 0:3dac1f1bc9e0 146 USBEndpoint * ep = NULL;
beaglescout007 0:3dac1f1bc9e0 147 uint8_t intf_nb = 0;
beaglescout007 0:3dac1f1bc9e0 148 bool parsing_intf = false;
beaglescout007 0:3dac1f1bc9e0 149 uint8_t current_intf = 0;
beaglescout007 0:3dac1f1bc9e0 150 EndpointDescriptor* ep_desc;
beaglescout007 0:3dac1f1bc9e0 151
beaglescout007 0:3dac1f1bc9e0 152 while (index < len) {
beaglescout007 0:3dac1f1bc9e0 153 len_desc = conf_descr[index];
beaglescout007 0:3dac1f1bc9e0 154 id = conf_descr[index+1];
beaglescout007 0:3dac1f1bc9e0 155 USB_DBG_HEX(conf_descr+index, len_desc);
beaglescout007 0:3dac1f1bc9e0 156 switch (id) {
beaglescout007 0:3dac1f1bc9e0 157 case CONFIGURATION_DESCRIPTOR:
beaglescout007 0:3dac1f1bc9e0 158 USB_DBG("dev: %p has %d intf", dev, conf_descr[4]);
beaglescout007 0:3dac1f1bc9e0 159 dev->setNbIntf(conf_descr[4]);
beaglescout007 0:3dac1f1bc9e0 160 break;
beaglescout007 0:3dac1f1bc9e0 161 case INTERFACE_DESCRIPTOR:
beaglescout007 0:3dac1f1bc9e0 162 if(pEnumerator->parseInterface(conf_descr[index + 2], conf_descr[index + 5], conf_descr[index + 6], conf_descr[index + 7])) {
beaglescout007 0:3dac1f1bc9e0 163 intf_nb++;
beaglescout007 0:3dac1f1bc9e0 164 current_intf = conf_descr[index + 2];
beaglescout007 0:3dac1f1bc9e0 165 dev->addInterface(current_intf, conf_descr[index + 5], conf_descr[index + 6], conf_descr[index + 7]);
beaglescout007 0:3dac1f1bc9e0 166 USB_DBG("ADD INTF %d on device %p: class: %d, subclass: %d, proto: %d", current_intf, dev, conf_descr[index + 5],conf_descr[index + 6],conf_descr[index + 7]);
beaglescout007 0:3dac1f1bc9e0 167 parsing_intf = true;
beaglescout007 0:3dac1f1bc9e0 168 } else {
beaglescout007 0:3dac1f1bc9e0 169 parsing_intf = false;
beaglescout007 0:3dac1f1bc9e0 170 }
beaglescout007 0:3dac1f1bc9e0 171 break;
beaglescout007 0:3dac1f1bc9e0 172 case ENDPOINT_DESCRIPTOR:
beaglescout007 0:3dac1f1bc9e0 173 ep_desc = reinterpret_cast<EndpointDescriptor*>(conf_descr+index);
beaglescout007 0:3dac1f1bc9e0 174 if (parsing_intf && (intf_nb <= MAX_INTF) ) {
beaglescout007 0:3dac1f1bc9e0 175 ENDPOINT_TYPE type = (ENDPOINT_TYPE)(ep_desc->bmAttributes & 0x03);
beaglescout007 0:3dac1f1bc9e0 176 ENDPOINT_DIRECTION dir = (ep_desc->bEndpointAddress & 0x80) ? IN : OUT;
beaglescout007 0:3dac1f1bc9e0 177 if(pEnumerator->useEndpoint(current_intf, type, dir)) {
beaglescout007 0:3dac1f1bc9e0 178 ep = new USBEndpoint(dev);
beaglescout007 0:3dac1f1bc9e0 179 ep->init(type, dir, ep_desc->wMaxPacketSize, ep_desc->bEndpointAddress);
beaglescout007 0:3dac1f1bc9e0 180 USB_DBG("ADD USBEndpoint %p, on interf %d on device %p", ep, current_intf, dev);
beaglescout007 0:3dac1f1bc9e0 181 dev->addEndpoint(current_intf, ep);
beaglescout007 0:3dac1f1bc9e0 182 }
beaglescout007 0:3dac1f1bc9e0 183 }
beaglescout007 0:3dac1f1bc9e0 184 break;
beaglescout007 0:3dac1f1bc9e0 185 case HID_DESCRIPTOR:
beaglescout007 0:3dac1f1bc9e0 186 //lenReportDescr = conf_descr[index + 7] | (conf_descr[index + 8] << 8);
beaglescout007 0:3dac1f1bc9e0 187 break;
beaglescout007 0:3dac1f1bc9e0 188 default:
beaglescout007 0:3dac1f1bc9e0 189 break;
beaglescout007 0:3dac1f1bc9e0 190 }
beaglescout007 0:3dac1f1bc9e0 191 index += len_desc;
beaglescout007 0:3dac1f1bc9e0 192 }
beaglescout007 0:3dac1f1bc9e0 193 }
beaglescout007 0:3dac1f1bc9e0 194
beaglescout007 0:3dac1f1bc9e0 195 USB_TYPE USBHost::controlRead(USBDeviceConnected* dev, uint8_t requestType, uint8_t request, uint32_t value, uint32_t index, uint8_t * buf, uint32_t len) {
beaglescout007 0:3dac1f1bc9e0 196 USBEndpoint* ep = dev->getEpCtl();
beaglescout007 0:3dac1f1bc9e0 197 SETUP_PACKET setup(requestType, request, value, index, len);
beaglescout007 0:3dac1f1bc9e0 198
beaglescout007 0:3dac1f1bc9e0 199 int result = token_setup(ep, &setup, len); // setup stage
beaglescout007 0:3dac1f1bc9e0 200 USB_TRACE1(result);
beaglescout007 0:3dac1f1bc9e0 201 if (result < 0) {
beaglescout007 0:3dac1f1bc9e0 202 return USB_TYPE_ERROR;
beaglescout007 0:3dac1f1bc9e0 203 }
beaglescout007 0:3dac1f1bc9e0 204
beaglescout007 0:3dac1f1bc9e0 205 int read_len = multi_token_in(ep, buf, len); // data stage
beaglescout007 0:3dac1f1bc9e0 206 USB_TRACE1(read_len);
beaglescout007 0:3dac1f1bc9e0 207 if (read_len < 0) {
beaglescout007 0:3dac1f1bc9e0 208 return USB_TYPE_ERROR;
beaglescout007 0:3dac1f1bc9e0 209 }
beaglescout007 0:3dac1f1bc9e0 210
beaglescout007 0:3dac1f1bc9e0 211 setToggle(ep, 1); // DATA1
beaglescout007 0:3dac1f1bc9e0 212 result = multi_token_out(ep); // status stage
beaglescout007 0:3dac1f1bc9e0 213 USB_TRACE1(result);
beaglescout007 0:3dac1f1bc9e0 214 if (result < 0) {
beaglescout007 0:3dac1f1bc9e0 215 return USB_TYPE_ERROR;
beaglescout007 0:3dac1f1bc9e0 216 }
beaglescout007 0:3dac1f1bc9e0 217 ep->setLengthTransferred(read_len);
beaglescout007 0:3dac1f1bc9e0 218 return USB_TYPE_OK;
beaglescout007 0:3dac1f1bc9e0 219 }
beaglescout007 0:3dac1f1bc9e0 220
beaglescout007 0:3dac1f1bc9e0 221 USB_TYPE USBHost::controlWrite(USBDeviceConnected* dev, uint8_t requestType, uint8_t request, uint32_t value, uint32_t index, uint8_t * buf, uint32_t len) {
beaglescout007 0:3dac1f1bc9e0 222 USBEndpoint* ep = dev->getEpCtl();
beaglescout007 0:3dac1f1bc9e0 223 SETUP_PACKET setup(requestType, request, value, index, len);
beaglescout007 0:3dac1f1bc9e0 224
beaglescout007 0:3dac1f1bc9e0 225 int result = token_setup(ep, &setup, len); // setup stage
beaglescout007 0:3dac1f1bc9e0 226 USB_TRACE1(result);
beaglescout007 0:3dac1f1bc9e0 227 if (result < 0) {
beaglescout007 0:3dac1f1bc9e0 228 return USB_TYPE_ERROR;
beaglescout007 0:3dac1f1bc9e0 229 }
beaglescout007 0:3dac1f1bc9e0 230 int write_len = 0;
beaglescout007 0:3dac1f1bc9e0 231 if (buf != NULL) {
beaglescout007 0:3dac1f1bc9e0 232 write_len = multi_token_out(ep, buf, len); // data stage
beaglescout007 0:3dac1f1bc9e0 233 USB_TRACE1(write_len);
beaglescout007 0:3dac1f1bc9e0 234 if (write_len < 0) {
beaglescout007 0:3dac1f1bc9e0 235 return USB_TYPE_ERROR;
beaglescout007 0:3dac1f1bc9e0 236 }
beaglescout007 0:3dac1f1bc9e0 237 }
beaglescout007 0:3dac1f1bc9e0 238
beaglescout007 0:3dac1f1bc9e0 239 setToggle(ep, 1); // DATA1
beaglescout007 0:3dac1f1bc9e0 240 result = multi_token_in(ep); // status stage
beaglescout007 0:3dac1f1bc9e0 241 USB_TRACE1(result);
beaglescout007 0:3dac1f1bc9e0 242 if (result < 0) {
beaglescout007 0:3dac1f1bc9e0 243 return USB_TYPE_ERROR;
beaglescout007 0:3dac1f1bc9e0 244 }
beaglescout007 0:3dac1f1bc9e0 245 ep->setLengthTransferred(write_len);
beaglescout007 0:3dac1f1bc9e0 246 return USB_TYPE_OK;
beaglescout007 0:3dac1f1bc9e0 247 }
beaglescout007 0:3dac1f1bc9e0 248
beaglescout007 0:3dac1f1bc9e0 249 USB_TYPE USBHost::bulkRead(USBDeviceConnected* dev, USBEndpoint* ep, uint8_t* buf, uint32_t len, bool blocking) {
beaglescout007 0:3dac1f1bc9e0 250 if (blocking == false) {
beaglescout007 0:3dac1f1bc9e0 251 ep->setBuffer(buf, len);
beaglescout007 0:3dac1f1bc9e0 252 ep_queue.push(ep);
beaglescout007 0:3dac1f1bc9e0 253 multi_token_inNB(ep, buf, len);
beaglescout007 0:3dac1f1bc9e0 254 return USB_TYPE_PROCESSING;
beaglescout007 0:3dac1f1bc9e0 255 }
beaglescout007 0:3dac1f1bc9e0 256 int result = multi_token_in(ep, buf, len);
beaglescout007 0:3dac1f1bc9e0 257 USB_TRACE1(result);
beaglescout007 0:3dac1f1bc9e0 258 if (result < 0) {
beaglescout007 0:3dac1f1bc9e0 259 return USB_TYPE_ERROR;
beaglescout007 0:3dac1f1bc9e0 260 }
beaglescout007 0:3dac1f1bc9e0 261 ep->setLengthTransferred(result);
beaglescout007 0:3dac1f1bc9e0 262 return USB_TYPE_OK;
beaglescout007 0:3dac1f1bc9e0 263 }
beaglescout007 0:3dac1f1bc9e0 264
beaglescout007 0:3dac1f1bc9e0 265 USB_TYPE USBHost::bulkWrite(USBDeviceConnected* dev, USBEndpoint* ep, uint8_t* buf, uint32_t len, bool blocking) {
beaglescout007 0:3dac1f1bc9e0 266 USB_TEST_ASSERT(blocking);
beaglescout007 0:3dac1f1bc9e0 267 int result = multi_token_out(ep, buf, len);
beaglescout007 0:3dac1f1bc9e0 268 USB_TRACE1(result);
beaglescout007 0:3dac1f1bc9e0 269 if (result < 0) {
beaglescout007 0:3dac1f1bc9e0 270 return USB_TYPE_ERROR;
beaglescout007 0:3dac1f1bc9e0 271 }
beaglescout007 0:3dac1f1bc9e0 272 ep->setLengthTransferred(result);
beaglescout007 0:3dac1f1bc9e0 273 return USB_TYPE_OK;
beaglescout007 0:3dac1f1bc9e0 274 }
beaglescout007 0:3dac1f1bc9e0 275
beaglescout007 0:3dac1f1bc9e0 276 USB_TYPE USBHost::interruptRead(USBDeviceConnected* dev, USBEndpoint* ep, uint8_t* buf, uint32_t len, bool blocking) {
beaglescout007 0:3dac1f1bc9e0 277 if (blocking == false) {
beaglescout007 0:3dac1f1bc9e0 278 ep->setBuffer(buf, len);
beaglescout007 0:3dac1f1bc9e0 279 ep_queue.push(ep);
beaglescout007 0:3dac1f1bc9e0 280 multi_token_inNB(ep, buf, len);
beaglescout007 0:3dac1f1bc9e0 281 return USB_TYPE_PROCESSING;
beaglescout007 0:3dac1f1bc9e0 282 }
beaglescout007 0:3dac1f1bc9e0 283 int result = multi_token_in(ep, buf, len);
beaglescout007 0:3dac1f1bc9e0 284 USB_TRACE1(result);
beaglescout007 0:3dac1f1bc9e0 285 if (result < 0) {
beaglescout007 0:3dac1f1bc9e0 286 return USB_TYPE_ERROR;
beaglescout007 0:3dac1f1bc9e0 287 }
beaglescout007 0:3dac1f1bc9e0 288 ep->setLengthTransferred(result);
beaglescout007 0:3dac1f1bc9e0 289 return USB_TYPE_OK;
beaglescout007 0:3dac1f1bc9e0 290 }
beaglescout007 0:3dac1f1bc9e0 291
beaglescout007 0:3dac1f1bc9e0 292 USB_TYPE USBHost::interruptWrite(USBDeviceConnected* dev, USBEndpoint* ep, uint8_t* buf, uint32_t len, bool blocking) {
beaglescout007 0:3dac1f1bc9e0 293 USB_TEST_ASSERT(blocking);
beaglescout007 0:3dac1f1bc9e0 294 int result = multi_token_out(ep, buf, len);
beaglescout007 0:3dac1f1bc9e0 295 USB_TRACE1(result);
beaglescout007 0:3dac1f1bc9e0 296 if (result < 0) {
beaglescout007 0:3dac1f1bc9e0 297 return USB_TYPE_ERROR;
beaglescout007 0:3dac1f1bc9e0 298 }
beaglescout007 0:3dac1f1bc9e0 299 ep->setLengthTransferred(result);
beaglescout007 0:3dac1f1bc9e0 300 return USB_TYPE_OK;
beaglescout007 0:3dac1f1bc9e0 301 }
beaglescout007 0:3dac1f1bc9e0 302
beaglescout007 0:3dac1f1bc9e0 303 USB_TYPE USBHost::isochronousRead(USBDeviceConnected* dev, USBEndpoint* ep, uint8_t* buf, uint32_t len, bool blocking) {
beaglescout007 0:3dac1f1bc9e0 304 USB_TEST_ASSERT(blocking);
beaglescout007 0:3dac1f1bc9e0 305 isochronousReadNB(ep, buf, len);
beaglescout007 0:3dac1f1bc9e0 306 return USB_TYPE_OK;
beaglescout007 0:3dac1f1bc9e0 307 }
beaglescout007 0:3dac1f1bc9e0 308
beaglescout007 0:3dac1f1bc9e0 309 int USBHost::interruptReadNB(USBEndpoint* ep, uint8_t* data, int size) {
beaglescout007 0:3dac1f1bc9e0 310 USB_TRACE1(size);
beaglescout007 0:3dac1f1bc9e0 311 if (ep->getState() != USB_TYPE_PROCESSING) {
beaglescout007 0:3dac1f1bc9e0 312 ep->setState(USB_TYPE_PROCESSING);
beaglescout007 0:3dac1f1bc9e0 313 ep->setBuffer(data, size);
beaglescout007 0:3dac1f1bc9e0 314 multi_token_inNB(ep, data, size);
beaglescout007 0:3dac1f1bc9e0 315 }
beaglescout007 0:3dac1f1bc9e0 316 if (multi_token_inNB_result(ep) != USB_TYPE_PROCESSING) {
beaglescout007 0:3dac1f1bc9e0 317 return ep->getLengthTransferred();
beaglescout007 0:3dac1f1bc9e0 318 }
beaglescout007 0:3dac1f1bc9e0 319 return -1;
beaglescout007 0:3dac1f1bc9e0 320 }
beaglescout007 0:3dac1f1bc9e0 321
beaglescout007 0:3dac1f1bc9e0 322 int USBHost::bulkReadNB(USBEndpoint* ep, uint8_t* data, int size) {
beaglescout007 0:3dac1f1bc9e0 323 USB_TRACE1(size);
beaglescout007 0:3dac1f1bc9e0 324 return interruptReadNB(ep, data, size);
beaglescout007 0:3dac1f1bc9e0 325 }
beaglescout007 0:3dac1f1bc9e0 326
beaglescout007 0:3dac1f1bc9e0 327 int USBHost::isochronousReadNB(USBEndpoint* ep, uint8_t* data, int size) {
beaglescout007 0:3dac1f1bc9e0 328 USB_TRACE1(size);
beaglescout007 0:3dac1f1bc9e0 329 int result = token_iso_in(ep, data, size);
beaglescout007 0:3dac1f1bc9e0 330 if (result >= 0) {
beaglescout007 0:3dac1f1bc9e0 331 ep->setLengthTransferred(result);
beaglescout007 0:3dac1f1bc9e0 332 }
beaglescout007 0:3dac1f1bc9e0 333 return result;
beaglescout007 0:3dac1f1bc9e0 334 }
beaglescout007 0:3dac1f1bc9e0 335
beaglescout007 0:3dac1f1bc9e0 336 void USBHost::task() {
beaglescout007 0:3dac1f1bc9e0 337 USBEndpoint* ep = ep_queue.pop();
beaglescout007 0:3dac1f1bc9e0 338 if (ep) {
beaglescout007 0:3dac1f1bc9e0 339 USB_TEST_ASSERT(ep->getDir() == IN);
beaglescout007 0:3dac1f1bc9e0 340 if (multi_token_inNB_result(ep) != USB_TYPE_PROCESSING) {
beaglescout007 0:3dac1f1bc9e0 341 ep->call();
beaglescout007 0:3dac1f1bc9e0 342 } else {
beaglescout007 0:3dac1f1bc9e0 343 ep_queue.push(ep);
beaglescout007 0:3dac1f1bc9e0 344 }
beaglescout007 0:3dac1f1bc9e0 345 }
beaglescout007 0:3dac1f1bc9e0 346 }
beaglescout007 0:3dac1f1bc9e0 347
beaglescout007 0:3dac1f1bc9e0 348 void usb_test_assert_internal(const char *expr, const char *file, int line){
beaglescout007 0:3dac1f1bc9e0 349 error("\n\n%s@%d %s ASSERT!\n\n", file, line, expr);
beaglescout007 0:3dac1f1bc9e0 350 }
beaglescout007 0:3dac1f1bc9e0 351
beaglescout007 0:3dac1f1bc9e0 352