the do / gr-peach-opencv-project

Opencv 3.1 project on GR-PEACH board

Fork of gr-peach-opencv-project by the do

USBHost_custom/USBHost/USBHost.cpp@170:54ff26da7eb6, 2017-07-04 (annotated)

Committer:
thedo
Date:
Tue Jul 04 06:23:13 2017 +0000
Revision:
170:54ff26da7eb6
Parent:
166:3a9487d57a5c 
project opencv 3.1 on GR PEACH board, no use SD card.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
thedo 166:3a9487d57a5c 1 /* mbed USBHost Library
thedo 166:3a9487d57a5c 2 * Copyright (c) 2006-2013 ARM Limited
thedo 166:3a9487d57a5c 3 *
thedo 166:3a9487d57a5c 4 * Licensed under the Apache License, Version 2.0 (the "License");
thedo 166:3a9487d57a5c 5 * you may not use this file except in compliance with the License.
thedo 166:3a9487d57a5c 6 * You may obtain a copy of the License at
thedo 166:3a9487d57a5c 7 *
thedo 166:3a9487d57a5c 8 * http://www.apache.org/licenses/LICENSE-2.0
thedo 166:3a9487d57a5c 9 *
thedo 166:3a9487d57a5c 10 * Unless required by applicable law or agreed to in writing, software
thedo 166:3a9487d57a5c 11 * distributed under the License is distributed on an "AS IS" BASIS,
thedo 166:3a9487d57a5c 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
thedo 166:3a9487d57a5c 13 * See the License for the specific language governing permissions and
thedo 166:3a9487d57a5c 14 * limitations under the License.
thedo 166:3a9487d57a5c 15 */
thedo 166:3a9487d57a5c 16
thedo 166:3a9487d57a5c 17
thedo 166:3a9487d57a5c 18 #include "USBHost.h"
thedo 166:3a9487d57a5c 19 #include "USBHostHub.h"
thedo 166:3a9487d57a5c 20
thedo 166:3a9487d57a5c 21 USBHost * USBHost::instHost = NULL;
thedo 166:3a9487d57a5c 22
thedo 166:3a9487d57a5c 23 #define DEVICE_CONNECTED_EVENT (1 << 0)
thedo 166:3a9487d57a5c 24 #define DEVICE_DISCONNECTED_EVENT (1 << 1)
thedo 166:3a9487d57a5c 25 #define TD_PROCESSED_EVENT (1 << 2)
thedo 166:3a9487d57a5c 26
thedo 166:3a9487d57a5c 27 #define MAX_TRY_ENUMERATE_HUB 3
thedo 166:3a9487d57a5c 28
thedo 166:3a9487d57a5c 29 #define MIN(a, b) ((a > b) ? b : a)
thedo 166:3a9487d57a5c 30
thedo 166:3a9487d57a5c 31 /**
thedo 166:3a9487d57a5c 32 * How interrupts are processed:
thedo 166:3a9487d57a5c 33 * - new device connected:
thedo 166:3a9487d57a5c 34 * - a message is queued in queue_usb_event with the id DEVICE_CONNECTED_EVENT
thedo 166:3a9487d57a5c 35 * - when the usb_thread receives the event, it:
thedo 166:3a9487d57a5c 36 * - resets the device
thedo 166:3a9487d57a5c 37 * - reads the device descriptor
thedo 166:3a9487d57a5c 38 * - sets the address of the device
thedo 166:3a9487d57a5c 39 * - if it is a hub, enumerates it
thedo 166:3a9487d57a5c 40 * - device disconnected:
thedo 166:3a9487d57a5c 41 * - a message is queued in queue_usb_event with the id DEVICE_DISCONNECTED_EVENT
thedo 166:3a9487d57a5c 42 * - when the usb_thread receives the event, it:
thedo 166:3a9487d57a5c 43 * - free the device and all its children (hub)
thedo 166:3a9487d57a5c 44 * - td processed
thedo 166:3a9487d57a5c 45 * - a message is queued in queue_usb_event with the id TD_PROCESSED_EVENT
thedo 166:3a9487d57a5c 46 * - when the usb_thread receives the event, it:
thedo 166:3a9487d57a5c 47 * - call the callback attached to the endpoint where the td is attached
thedo 166:3a9487d57a5c 48 */
thedo 166:3a9487d57a5c 49 void USBHost::usb_process() {
thedo 166:3a9487d57a5c 50
thedo 166:3a9487d57a5c 51 bool controlListState;
thedo 166:3a9487d57a5c 52 bool bulkListState;
thedo 166:3a9487d57a5c 53 bool interruptListState;
thedo 166:3a9487d57a5c 54 USBEndpoint * ep;
thedo 166:3a9487d57a5c 55 uint8_t i, j, res, timeout_set_addr = 10;
thedo 166:3a9487d57a5c 56 uint8_t buf[8];
thedo 166:3a9487d57a5c 57 bool too_many_hub;
thedo 166:3a9487d57a5c 58 int idx;
thedo 166:3a9487d57a5c 59
thedo 166:3a9487d57a5c 60 #if DEBUG_TRANSFER
thedo 166:3a9487d57a5c 61 uint8_t * buf_transfer;
thedo 166:3a9487d57a5c 62 #endif
thedo 166:3a9487d57a5c 63
thedo 166:3a9487d57a5c 64 #if MAX_HUB_NB
thedo 166:3a9487d57a5c 65 uint8_t k;
thedo 166:3a9487d57a5c 66 #endif
thedo 166:3a9487d57a5c 67
thedo 166:3a9487d57a5c 68 while(1) {
thedo 166:3a9487d57a5c 69 osEvent evt = mail_usb_event.get();
thedo 166:3a9487d57a5c 70
thedo 166:3a9487d57a5c 71 if (evt.status == osEventMail) {
thedo 166:3a9487d57a5c 72
thedo 166:3a9487d57a5c 73 message_t * usb_msg = (message_t*)evt.value.p;
thedo 166:3a9487d57a5c 74
thedo 166:3a9487d57a5c 75 switch (usb_msg->event_id) {
thedo 166:3a9487d57a5c 76
thedo 166:3a9487d57a5c 77 // a new device has been connected
thedo 166:3a9487d57a5c 78 case DEVICE_CONNECTED_EVENT:
thedo 166:3a9487d57a5c 79 too_many_hub = false;
thedo 166:3a9487d57a5c 80 buf[4] = 0;
thedo 166:3a9487d57a5c 81
thedo 166:3a9487d57a5c 82 do
thedo 166:3a9487d57a5c 83 {
thedo 166:3a9487d57a5c 84 Lock lock(this);
thedo 166:3a9487d57a5c 85
thedo 166:3a9487d57a5c 86 for (i = 0; i < MAX_DEVICE_CONNECTED; i++) {
thedo 166:3a9487d57a5c 87 if (!deviceInUse[i]) {
thedo 166:3a9487d57a5c 88 USB_DBG_EVENT("new device connected: %p\r\n", &devices[i]);
thedo 166:3a9487d57a5c 89 devices[i].init(usb_msg->hub, usb_msg->port, usb_msg->lowSpeed);
thedo 166:3a9487d57a5c 90 deviceReset[i] = false;
thedo 166:3a9487d57a5c 91 deviceInited[i] = true;
thedo 166:3a9487d57a5c 92 break;
thedo 166:3a9487d57a5c 93 }
thedo 166:3a9487d57a5c 94 }
thedo 166:3a9487d57a5c 95
thedo 166:3a9487d57a5c 96 if (i == MAX_DEVICE_CONNECTED) {
thedo 166:3a9487d57a5c 97 USB_ERR("Too many device connected!!\r\n");
thedo 166:3a9487d57a5c 98 continue;
thedo 166:3a9487d57a5c 99 }
thedo 166:3a9487d57a5c 100
thedo 166:3a9487d57a5c 101 if (!controlEndpointAllocated) {
thedo 166:3a9487d57a5c 102 control = newEndpoint(CONTROL_ENDPOINT, OUT, 0x08, 0x00);
thedo 166:3a9487d57a5c 103 addEndpoint(NULL, 0, (USBEndpoint*)control);
thedo 166:3a9487d57a5c 104 controlEndpointAllocated = true;
thedo 166:3a9487d57a5c 105 }
thedo 166:3a9487d57a5c 106
thedo 166:3a9487d57a5c 107 #if MAX_HUB_NB
thedo 166:3a9487d57a5c 108 if (usb_msg->hub_parent)
thedo 166:3a9487d57a5c 109 devices[i].setHubParent((USBHostHub *)(usb_msg->hub_parent));
thedo 166:3a9487d57a5c 110 #endif
thedo 166:3a9487d57a5c 111
thedo 166:3a9487d57a5c 112 for (j = 0; j < timeout_set_addr; j++) {
thedo 166:3a9487d57a5c 113
thedo 166:3a9487d57a5c 114 resetDevice(&devices[i]);
thedo 166:3a9487d57a5c 115
thedo 166:3a9487d57a5c 116 // set size of control endpoint
thedo 166:3a9487d57a5c 117 devices[i].setSizeControlEndpoint(8);
thedo 166:3a9487d57a5c 118
thedo 166:3a9487d57a5c 119 devices[i].activeAddress(false);
thedo 166:3a9487d57a5c 120
thedo 166:3a9487d57a5c 121 // get first 8 bit of device descriptor
thedo 166:3a9487d57a5c 122 // and check if we deal with a hub
thedo 166:3a9487d57a5c 123 USB_DBG("usb_thread read device descriptor on dev: %p\r\n", &devices[i]);
thedo 166:3a9487d57a5c 124 res = getDeviceDescriptor(&devices[i], buf, 8);
thedo 166:3a9487d57a5c 125
thedo 166:3a9487d57a5c 126 if (res != USB_TYPE_OK) {
thedo 166:3a9487d57a5c 127 USB_ERR("usb_thread could not read dev descr");
thedo 166:3a9487d57a5c 128 continue;
thedo 166:3a9487d57a5c 129 }
thedo 166:3a9487d57a5c 130
thedo 166:3a9487d57a5c 131 // set size of control endpoint
thedo 166:3a9487d57a5c 132 devices[i].setSizeControlEndpoint(buf[7]);
thedo 166:3a9487d57a5c 133
thedo 166:3a9487d57a5c 134 // second step: set an address to the device
thedo 166:3a9487d57a5c 135 res = setAddress(&devices[i], devices[i].getAddress());
thedo 166:3a9487d57a5c 136
thedo 166:3a9487d57a5c 137 if (res != USB_TYPE_OK) {
thedo 166:3a9487d57a5c 138 USB_ERR("SET ADDR FAILED");
thedo 166:3a9487d57a5c 139 continue;
thedo 166:3a9487d57a5c 140 }
thedo 166:3a9487d57a5c 141 devices[i].activeAddress(true);
thedo 166:3a9487d57a5c 142 USB_DBG("Address of %p: %d", &devices[i], devices[i].getAddress());
thedo 166:3a9487d57a5c 143
thedo 166:3a9487d57a5c 144 // try to read again the device descriptor to check if the device
thedo 166:3a9487d57a5c 145 // answers to its new address
thedo 166:3a9487d57a5c 146 res = getDeviceDescriptor(&devices[i], buf, 8);
thedo 166:3a9487d57a5c 147
thedo 166:3a9487d57a5c 148 if (res == USB_TYPE_OK) {
thedo 166:3a9487d57a5c 149 break;
thedo 166:3a9487d57a5c 150 }
thedo 166:3a9487d57a5c 151
thedo 166:3a9487d57a5c 152 Thread::wait(100);
thedo 166:3a9487d57a5c 153 }
thedo 166:3a9487d57a5c 154
thedo 166:3a9487d57a5c 155 USB_INFO("New device connected: %p [hub: %d - port: %d]", &devices[i], usb_msg->hub, usb_msg->port);
thedo 166:3a9487d57a5c 156
thedo 166:3a9487d57a5c 157 #if MAX_HUB_NB
thedo 166:3a9487d57a5c 158 if (buf[4] == HUB_CLASS) {
thedo 166:3a9487d57a5c 159 for (k = 0; k < MAX_HUB_NB; k++) {
thedo 166:3a9487d57a5c 160 if (hub_in_use[k] == false) {
thedo 166:3a9487d57a5c 161 for (uint8_t j = 0; j < MAX_TRY_ENUMERATE_HUB; j++) {
thedo 166:3a9487d57a5c 162 if (hubs[k].connect(&devices[i])) {
thedo 166:3a9487d57a5c 163 devices[i].hub = &hubs[k];
thedo 166:3a9487d57a5c 164 hub_in_use[k] = true;
thedo 166:3a9487d57a5c 165 break;
thedo 166:3a9487d57a5c 166 }
thedo 166:3a9487d57a5c 167 }
thedo 166:3a9487d57a5c 168 if (hub_in_use[k] == true)
thedo 166:3a9487d57a5c 169 break;
thedo 166:3a9487d57a5c 170 }
thedo 166:3a9487d57a5c 171 }
thedo 166:3a9487d57a5c 172
thedo 166:3a9487d57a5c 173 if (k == MAX_HUB_NB) {
thedo 166:3a9487d57a5c 174 USB_ERR("Too many hubs connected!!\r\n");
thedo 166:3a9487d57a5c 175 too_many_hub = true;
thedo 166:3a9487d57a5c 176 }
thedo 166:3a9487d57a5c 177 }
thedo 166:3a9487d57a5c 178
thedo 166:3a9487d57a5c 179 if (usb_msg->hub_parent)
thedo 166:3a9487d57a5c 180 ((USBHostHub *)(usb_msg->hub_parent))->deviceConnected(&devices[i]);
thedo 166:3a9487d57a5c 181 #endif
thedo 166:3a9487d57a5c 182
thedo 166:3a9487d57a5c 183 if ((i < MAX_DEVICE_CONNECTED) && !too_many_hub) {
thedo 166:3a9487d57a5c 184 deviceInUse[i] = true;
thedo 166:3a9487d57a5c 185 }
thedo 166:3a9487d57a5c 186
thedo 166:3a9487d57a5c 187 } while(0);
thedo 166:3a9487d57a5c 188
thedo 166:3a9487d57a5c 189 break;
thedo 166:3a9487d57a5c 190
thedo 166:3a9487d57a5c 191 // a device has been disconnected
thedo 166:3a9487d57a5c 192 case DEVICE_DISCONNECTED_EVENT:
thedo 166:3a9487d57a5c 193
thedo 166:3a9487d57a5c 194 do
thedo 166:3a9487d57a5c 195 {
thedo 166:3a9487d57a5c 196 Lock lock(this);
thedo 166:3a9487d57a5c 197
thedo 166:3a9487d57a5c 198 controlListState = disableList(CONTROL_ENDPOINT);
thedo 166:3a9487d57a5c 199 bulkListState = disableList(BULK_ENDPOINT);
thedo 166:3a9487d57a5c 200 interruptListState = disableList(INTERRUPT_ENDPOINT);
thedo 166:3a9487d57a5c 201
thedo 166:3a9487d57a5c 202 idx = findDevice(usb_msg->hub, usb_msg->port, (USBHostHub *)(usb_msg->hub_parent));
thedo 166:3a9487d57a5c 203 if (idx != -1) {
thedo 166:3a9487d57a5c 204 freeDevice((USBDeviceConnected*)&devices[idx]);
thedo 166:3a9487d57a5c 205 }
thedo 166:3a9487d57a5c 206
thedo 166:3a9487d57a5c 207 if (controlListState) enableList(CONTROL_ENDPOINT);
thedo 166:3a9487d57a5c 208 if (bulkListState) enableList(BULK_ENDPOINT);
thedo 166:3a9487d57a5c 209 if (interruptListState) enableList(INTERRUPT_ENDPOINT);
thedo 166:3a9487d57a5c 210
thedo 166:3a9487d57a5c 211 } while(0);
thedo 166:3a9487d57a5c 212
thedo 166:3a9487d57a5c 213 break;
thedo 166:3a9487d57a5c 214
thedo 166:3a9487d57a5c 215 // a td has been processed
thedo 166:3a9487d57a5c 216 // call callback on the ed associated to the td
thedo 166:3a9487d57a5c 217 // we are not in ISR -> users can use printf in their callback method
thedo 166:3a9487d57a5c 218 case TD_PROCESSED_EVENT:
thedo 166:3a9487d57a5c 219 ep = (USBEndpoint *) ((HCTD *)usb_msg->td_addr)->ep;
thedo 166:3a9487d57a5c 220 if (usb_msg->td_state == USB_TYPE_IDLE) {
thedo 166:3a9487d57a5c 221 USB_DBG_EVENT("call callback on td %p [ep: %p state: %s - dev: %p - %s]", usb_msg->td_addr, ep, ep->getStateString(), ep->dev, ep->dev->getName(ep->getIntfNb()));
thedo 166:3a9487d57a5c 222
thedo 166:3a9487d57a5c 223 #if DEBUG_TRANSFER
thedo 166:3a9487d57a5c 224 if (ep->getDir() == IN) {
thedo 166:3a9487d57a5c 225 buf_transfer = ep->getBufStart();
thedo 166:3a9487d57a5c 226 printf("READ SUCCESS [%d bytes transferred - td: 0x%08X] on ep: [%p - addr: %02X]: ", ep->getLengthTransferred(), usb_msg->td_addr, ep, ep->getAddress());
thedo 166:3a9487d57a5c 227 for (int i = 0; i < ep->getLengthTransferred(); i++)
thedo 166:3a9487d57a5c 228 printf("%02X ", buf_transfer[i]);
thedo 166:3a9487d57a5c 229 printf("\r\n\r\n");
thedo 166:3a9487d57a5c 230 }
thedo 166:3a9487d57a5c 231 #endif
thedo 166:3a9487d57a5c 232 ep->call();
thedo 166:3a9487d57a5c 233 } else {
thedo 166:3a9487d57a5c 234 idx = findDevice(ep->dev);
thedo 166:3a9487d57a5c 235 if (idx != -1) {
thedo 166:3a9487d57a5c 236 if (deviceInUse[idx]) {
thedo 166:3a9487d57a5c 237 USB_WARN("td %p processed but not in idle state: %s [ep: %p - dev: %p - %s]", usb_msg->td_addr, ep->getStateString(), ep, ep->dev, ep->dev->getName(ep->getIntfNb()));
thedo 166:3a9487d57a5c 238 ep->setState(USB_TYPE_IDLE);
thedo 166:3a9487d57a5c 239 }
thedo 166:3a9487d57a5c 240 }
thedo 166:3a9487d57a5c 241 }
thedo 166:3a9487d57a5c 242 break;
thedo 166:3a9487d57a5c 243 }
thedo 166:3a9487d57a5c 244
thedo 166:3a9487d57a5c 245 mail_usb_event.free(usb_msg);
thedo 166:3a9487d57a5c 246 }
thedo 166:3a9487d57a5c 247 }
thedo 166:3a9487d57a5c 248 }
thedo 166:3a9487d57a5c 249
thedo 166:3a9487d57a5c 250 /* static */void USBHost::usb_process_static(void const * arg) {
thedo 166:3a9487d57a5c 251 ((USBHost *)arg)->usb_process();
thedo 166:3a9487d57a5c 252 }
thedo 166:3a9487d57a5c 253
thedo 166:3a9487d57a5c 254 USBHost::USBHost() : usbThread(USBHost::usb_process_static, (void *)this, osPriorityNormal, USB_THREAD_STACK)
thedo 166:3a9487d57a5c 255 {
thedo 166:3a9487d57a5c 256 headControlEndpoint = NULL;
thedo 166:3a9487d57a5c 257 headBulkEndpoint = NULL;
thedo 166:3a9487d57a5c 258 headInterruptEndpoint = NULL;
thedo 166:3a9487d57a5c 259 tailControlEndpoint = NULL;
thedo 166:3a9487d57a5c 260 tailBulkEndpoint = NULL;
thedo 166:3a9487d57a5c 261 tailInterruptEndpoint = NULL;
thedo 166:3a9487d57a5c 262
thedo 166:3a9487d57a5c 263 lenReportDescr = 0;
thedo 166:3a9487d57a5c 264
thedo 166:3a9487d57a5c 265 controlEndpointAllocated = false;
thedo 166:3a9487d57a5c 266
thedo 166:3a9487d57a5c 267 for (uint8_t i = 0; i < MAX_DEVICE_CONNECTED; i++) {
thedo 166:3a9487d57a5c 268 deviceInUse[i] = false;
thedo 166:3a9487d57a5c 269 devices[i].setAddress(i + 1);
thedo 166:3a9487d57a5c 270 deviceReset[i] = false;
thedo 166:3a9487d57a5c 271 deviceInited[i] = false;
thedo 166:3a9487d57a5c 272 for (uint8_t j = 0; j < MAX_INTF; j++)
thedo 166:3a9487d57a5c 273 deviceAttachedDriver[i][j] = false;
thedo 166:3a9487d57a5c 274 }
thedo 166:3a9487d57a5c 275
thedo 166:3a9487d57a5c 276 #if MAX_HUB_NB
thedo 166:3a9487d57a5c 277 for (uint8_t i = 0; i < MAX_HUB_NB; i++) {
thedo 166:3a9487d57a5c 278 hubs[i].setHost(this);
thedo 166:3a9487d57a5c 279 hub_in_use[i] = false;
thedo 166:3a9487d57a5c 280 }
thedo 166:3a9487d57a5c 281 #endif
thedo 166:3a9487d57a5c 282 }
thedo 166:3a9487d57a5c 283
thedo 166:3a9487d57a5c 284 USBHost::Lock::Lock(USBHost* pHost) : m_pHost(pHost)
thedo 166:3a9487d57a5c 285 {
thedo 166:3a9487d57a5c 286 m_pHost->usb_mutex.lock();
thedo 166:3a9487d57a5c 287 }
thedo 166:3a9487d57a5c 288
thedo 166:3a9487d57a5c 289 USBHost::Lock::~Lock()
thedo 166:3a9487d57a5c 290 {
thedo 166:3a9487d57a5c 291 m_pHost->usb_mutex.unlock();
thedo 166:3a9487d57a5c 292 }
thedo 166:3a9487d57a5c 293
thedo 166:3a9487d57a5c 294 void USBHost::transferCompleted(volatile uint32_t addr)
thedo 166:3a9487d57a5c 295 {
thedo 166:3a9487d57a5c 296 uint8_t state;
thedo 166:3a9487d57a5c 297
thedo 166:3a9487d57a5c 298 if(addr == 0)
thedo 166:3a9487d57a5c 299 return;
thedo 166:3a9487d57a5c 300
thedo 166:3a9487d57a5c 301 volatile HCTD* tdList = NULL;
thedo 166:3a9487d57a5c 302
thedo 166:3a9487d57a5c 303 //First we must reverse the list order and dequeue each TD
thedo 166:3a9487d57a5c 304 do {
thedo 166:3a9487d57a5c 305 volatile HCTD* td = (volatile HCTD*)addr;
thedo 166:3a9487d57a5c 306 addr = (uint32_t)td->nextTD; //Dequeue from physical list
thedo 166:3a9487d57a5c 307 td->nextTD = (hcTd*)tdList; //Enqueue into reversed list
thedo 166:3a9487d57a5c 308 tdList = td;
thedo 166:3a9487d57a5c 309 } while(addr);
thedo 166:3a9487d57a5c 310
thedo 166:3a9487d57a5c 311 while(tdList != NULL) {
thedo 166:3a9487d57a5c 312 volatile HCTD* td = tdList;
thedo 166:3a9487d57a5c 313 tdList = (volatile HCTD*)td->nextTD; //Dequeue element now as it could be modified below
thedo 166:3a9487d57a5c 314 if (td->ep != NULL) {
thedo 166:3a9487d57a5c 315 USBEndpoint * ep = (USBEndpoint *)(td->ep);
thedo 166:3a9487d57a5c 316
thedo 166:3a9487d57a5c 317 if (((HCTD *)td)->control >> 28) {
thedo 166:3a9487d57a5c 318 state = ((HCTD *)td)->control >> 28;
thedo 166:3a9487d57a5c 319 } else {
thedo 166:3a9487d57a5c 320 if (td->currBufPtr)
thedo 166:3a9487d57a5c 321 ep->setLengthTransferred((uint32_t)td->currBufPtr - (uint32_t)ep->getBufStart());
thedo 166:3a9487d57a5c 322 state = 16 /*USB_TYPE_IDLE*/;
thedo 166:3a9487d57a5c 323 }
thedo 166:3a9487d57a5c 324
thedo 166:3a9487d57a5c 325 ep->unqueueTransfer(td);
thedo 166:3a9487d57a5c 326
thedo 166:3a9487d57a5c 327 if (ep->getType() != CONTROL_ENDPOINT) {
thedo 166:3a9487d57a5c 328 // callback on the processed td will be called from the usb_thread (not in ISR)
thedo 166:3a9487d57a5c 329 message_t * usb_msg = mail_usb_event.alloc();
thedo 166:3a9487d57a5c 330 usb_msg->event_id = TD_PROCESSED_EVENT;
thedo 166:3a9487d57a5c 331 usb_msg->td_addr = (void *)td;
thedo 166:3a9487d57a5c 332 usb_msg->td_state = state;
thedo 166:3a9487d57a5c 333 mail_usb_event.put(usb_msg);
thedo 166:3a9487d57a5c 334 }
thedo 166:3a9487d57a5c 335 ep->setState(state);
thedo 166:3a9487d57a5c 336 ep->ep_queue.put((uint8_t*)1);
thedo 166:3a9487d57a5c 337 }
thedo 166:3a9487d57a5c 338 }
thedo 166:3a9487d57a5c 339 }
thedo 166:3a9487d57a5c 340
thedo 166:3a9487d57a5c 341 USBHost * USBHost::getHostInst()
thedo 166:3a9487d57a5c 342 {
thedo 166:3a9487d57a5c 343 if (instHost == NULL) {
thedo 166:3a9487d57a5c 344 instHost = new USBHost();
thedo 166:3a9487d57a5c 345 instHost->init();
thedo 166:3a9487d57a5c 346 }
thedo 166:3a9487d57a5c 347 return instHost;
thedo 166:3a9487d57a5c 348 }
thedo 166:3a9487d57a5c 349
thedo 166:3a9487d57a5c 350
thedo 166:3a9487d57a5c 351 /*
thedo 166:3a9487d57a5c 352 * Called when a device has been connected
thedo 166:3a9487d57a5c 353 * Called in ISR!!!! (no printf)
thedo 166:3a9487d57a5c 354 */
thedo 166:3a9487d57a5c 355 /* virtual */ void USBHost::deviceConnected(int hub, int port, bool lowSpeed, USBHostHub * hub_parent)
thedo 166:3a9487d57a5c 356 {
thedo 166:3a9487d57a5c 357 // be sure that the new device connected is not already connected...
thedo 166:3a9487d57a5c 358 int idx = findDevice(hub, port, hub_parent);
thedo 166:3a9487d57a5c 359 if (idx != -1) {
thedo 166:3a9487d57a5c 360 if (deviceInited[idx])
thedo 166:3a9487d57a5c 361 return;
thedo 166:3a9487d57a5c 362 }
thedo 166:3a9487d57a5c 363
thedo 166:3a9487d57a5c 364 message_t * usb_msg = mail_usb_event.alloc();
thedo 166:3a9487d57a5c 365 usb_msg->event_id = DEVICE_CONNECTED_EVENT;
thedo 166:3a9487d57a5c 366 usb_msg->hub = hub;
thedo 166:3a9487d57a5c 367 usb_msg->port = port;
thedo 166:3a9487d57a5c 368 usb_msg->lowSpeed = lowSpeed;
thedo 166:3a9487d57a5c 369 usb_msg->hub_parent = hub_parent;
thedo 166:3a9487d57a5c 370 mail_usb_event.put(usb_msg);
thedo 166:3a9487d57a5c 371 }
thedo 166:3a9487d57a5c 372
thedo 166:3a9487d57a5c 373 /*
thedo 166:3a9487d57a5c 374 * Called when a device has been disconnected
thedo 166:3a9487d57a5c 375 * Called in ISR!!!! (no printf)
thedo 166:3a9487d57a5c 376 */
thedo 166:3a9487d57a5c 377 /* virtual */ void USBHost::deviceDisconnected(int hub, int port, USBHostHub * hub_parent, volatile uint32_t addr)
thedo 166:3a9487d57a5c 378 {
thedo 166:3a9487d57a5c 379 // be sure that the device disconnected is connected...
thedo 166:3a9487d57a5c 380 int idx = findDevice(hub, port, hub_parent);
thedo 166:3a9487d57a5c 381 if (idx != -1) {
thedo 166:3a9487d57a5c 382 if (!deviceInUse[idx])
thedo 166:3a9487d57a5c 383 return;
thedo 166:3a9487d57a5c 384 } else {
thedo 166:3a9487d57a5c 385 return;
thedo 166:3a9487d57a5c 386 }
thedo 166:3a9487d57a5c 387
thedo 166:3a9487d57a5c 388 message_t * usb_msg = mail_usb_event.alloc();
thedo 166:3a9487d57a5c 389 usb_msg->event_id = DEVICE_DISCONNECTED_EVENT;
thedo 166:3a9487d57a5c 390 usb_msg->hub = hub;
thedo 166:3a9487d57a5c 391 usb_msg->port = port;
thedo 166:3a9487d57a5c 392 usb_msg->hub_parent = hub_parent;
thedo 166:3a9487d57a5c 393 mail_usb_event.put(usb_msg);
thedo 166:3a9487d57a5c 394 }
thedo 166:3a9487d57a5c 395
thedo 166:3a9487d57a5c 396 void USBHost::freeDevice(USBDeviceConnected * dev)
thedo 166:3a9487d57a5c 397 {
thedo 166:3a9487d57a5c 398 USBEndpoint * ep = NULL;
thedo 166:3a9487d57a5c 399 HCED * ed = NULL;
thedo 166:3a9487d57a5c 400
thedo 166:3a9487d57a5c 401 #if MAX_HUB_NB
thedo 166:3a9487d57a5c 402 if (dev->getClass() == HUB_CLASS) {
thedo 166:3a9487d57a5c 403 if (dev->hub == NULL) {
thedo 166:3a9487d57a5c 404 USB_ERR("HUB NULL!!!!!\r\n");
thedo 166:3a9487d57a5c 405 } else {
thedo 166:3a9487d57a5c 406 dev->hub->hubDisconnected();
thedo 166:3a9487d57a5c 407 for (uint8_t i = 0; i < MAX_HUB_NB; i++) {
thedo 166:3a9487d57a5c 408 if (dev->hub == &hubs[i]) {
thedo 166:3a9487d57a5c 409 hub_in_use[i] = false;
thedo 166:3a9487d57a5c 410 break;
thedo 166:3a9487d57a5c 411 }
thedo 166:3a9487d57a5c 412 }
thedo 166:3a9487d57a5c 413 }
thedo 166:3a9487d57a5c 414 }
thedo 166:3a9487d57a5c 415
thedo 166:3a9487d57a5c 416 // notify hub parent that this device has been disconnected
thedo 166:3a9487d57a5c 417 if (dev->getHubParent())
thedo 166:3a9487d57a5c 418 dev->getHubParent()->deviceDisconnected(dev);
thedo 166:3a9487d57a5c 419
thedo 166:3a9487d57a5c 420 #endif
thedo 166:3a9487d57a5c 421
thedo 166:3a9487d57a5c 422 int idx = findDevice(dev);
thedo 166:3a9487d57a5c 423 if (idx != -1) {
thedo 166:3a9487d57a5c 424 deviceInUse[idx] = false;
thedo 166:3a9487d57a5c 425 deviceReset[idx] = false;
thedo 166:3a9487d57a5c 426
thedo 166:3a9487d57a5c 427 for (uint8_t j = 0; j < MAX_INTF; j++) {
thedo 166:3a9487d57a5c 428 deviceAttachedDriver[idx][j] = false;
thedo 166:3a9487d57a5c 429 if (dev->getInterface(j) != NULL) {
thedo 166:3a9487d57a5c 430 USB_DBG("FREE INTF %d on dev: %p, %p, nb_endpot: %d, %s", j, (void *)dev->getInterface(j), dev, dev->getInterface(j)->nb_endpoint, dev->getName(j));
thedo 166:3a9487d57a5c 431 for (int i = 0; i < dev->getInterface(j)->nb_endpoint; i++) {
thedo 166:3a9487d57a5c 432 if ((ep = dev->getEndpoint(j, i)) != NULL) {
thedo 166:3a9487d57a5c 433 ed = (HCED *)ep->getHCED();
thedo 166:3a9487d57a5c 434 ed->control |= (1 << 14); //sKip bit
thedo 166:3a9487d57a5c 435 unqueueEndpoint(ep);
thedo 166:3a9487d57a5c 436
thedo 166:3a9487d57a5c 437 freeTD((volatile uint8_t*)ep->getTDList()[0]);
thedo 166:3a9487d57a5c 438 freeTD((volatile uint8_t*)ep->getTDList()[1]);
thedo 166:3a9487d57a5c 439
thedo 166:3a9487d57a5c 440 freeED((uint8_t *)ep->getHCED());
thedo 166:3a9487d57a5c 441 }
thedo 166:3a9487d57a5c 442 printList(BULK_ENDPOINT);
thedo 166:3a9487d57a5c 443 printList(INTERRUPT_ENDPOINT);
thedo 166:3a9487d57a5c 444 }
thedo 166:3a9487d57a5c 445 USB_INFO("Device disconnected [%p - %s - hub: %d - port: %d]", dev, dev->getName(j), dev->getHub(), dev->getPort());
thedo 166:3a9487d57a5c 446 }
thedo 166:3a9487d57a5c 447 }
thedo 166:3a9487d57a5c 448 dev->disconnect();
thedo 166:3a9487d57a5c 449 }
thedo 166:3a9487d57a5c 450 }
thedo 166:3a9487d57a5c 451
thedo 166:3a9487d57a5c 452
thedo 166:3a9487d57a5c 453 void USBHost::unqueueEndpoint(USBEndpoint * ep)
thedo 166:3a9487d57a5c 454 {
thedo 166:3a9487d57a5c 455 USBEndpoint * prec = NULL;
thedo 166:3a9487d57a5c 456 USBEndpoint * current = NULL;
thedo 166:3a9487d57a5c 457
thedo 166:3a9487d57a5c 458 for (int i = 0; i < 2; i++) {
thedo 166:3a9487d57a5c 459 current = (i == 0) ? (USBEndpoint*)headBulkEndpoint : (USBEndpoint*)headInterruptEndpoint;
thedo 166:3a9487d57a5c 460 prec = current;
thedo 166:3a9487d57a5c 461 while (current != NULL) {
thedo 166:3a9487d57a5c 462 if (current == ep) {
thedo 166:3a9487d57a5c 463 if (current->nextEndpoint() != NULL) {
thedo 166:3a9487d57a5c 464 prec->queueEndpoint(current->nextEndpoint());
thedo 166:3a9487d57a5c 465 if (current == headBulkEndpoint) {
thedo 166:3a9487d57a5c 466 updateBulkHeadED((uint32_t)current->nextEndpoint()->getHCED());
thedo 166:3a9487d57a5c 467 headBulkEndpoint = current->nextEndpoint();
thedo 166:3a9487d57a5c 468 } else if (current == headInterruptEndpoint) {
thedo 166:3a9487d57a5c 469 updateInterruptHeadED((uint32_t)current->nextEndpoint()->getHCED());
thedo 166:3a9487d57a5c 470 headInterruptEndpoint = current->nextEndpoint();
thedo 166:3a9487d57a5c 471 }
thedo 166:3a9487d57a5c 472 }
thedo 166:3a9487d57a5c 473 // here we are dequeuing the queue of ed
thedo 166:3a9487d57a5c 474 // we need to update the tail pointer
thedo 166:3a9487d57a5c 475 else {
thedo 166:3a9487d57a5c 476 prec->queueEndpoint(NULL);
thedo 166:3a9487d57a5c 477 if (current == headBulkEndpoint) {
thedo 166:3a9487d57a5c 478 updateBulkHeadED(0);
thedo 166:3a9487d57a5c 479 headBulkEndpoint = current->nextEndpoint();
thedo 166:3a9487d57a5c 480 } else if (current == headInterruptEndpoint) {
thedo 166:3a9487d57a5c 481 updateInterruptHeadED(0);
thedo 166:3a9487d57a5c 482 headInterruptEndpoint = current->nextEndpoint();
thedo 166:3a9487d57a5c 483 }
thedo 166:3a9487d57a5c 484
thedo 166:3a9487d57a5c 485 // modify tail
thedo 166:3a9487d57a5c 486 switch (current->getType()) {
thedo 166:3a9487d57a5c 487 case BULK_ENDPOINT:
thedo 166:3a9487d57a5c 488 tailBulkEndpoint = prec;
thedo 166:3a9487d57a5c 489 break;
thedo 166:3a9487d57a5c 490 case INTERRUPT_ENDPOINT:
thedo 166:3a9487d57a5c 491 tailInterruptEndpoint = prec;
thedo 166:3a9487d57a5c 492 break;
thedo 166:3a9487d57a5c 493 default:
thedo 166:3a9487d57a5c 494 break;
thedo 166:3a9487d57a5c 495 }
thedo 166:3a9487d57a5c 496 }
thedo 166:3a9487d57a5c 497 current->setState(USB_TYPE_FREE);
thedo 166:3a9487d57a5c 498 return;
thedo 166:3a9487d57a5c 499 }
thedo 166:3a9487d57a5c 500 prec = current;
thedo 166:3a9487d57a5c 501 current = current->nextEndpoint();
thedo 166:3a9487d57a5c 502 }
thedo 166:3a9487d57a5c 503 }
thedo 166:3a9487d57a5c 504 }
thedo 166:3a9487d57a5c 505
thedo 166:3a9487d57a5c 506
thedo 166:3a9487d57a5c 507 USBDeviceConnected * USBHost::getDevice(uint8_t index)
thedo 166:3a9487d57a5c 508 {
thedo 166:3a9487d57a5c 509 if ((index >= MAX_DEVICE_CONNECTED) || (!deviceInUse[index])) {
thedo 166:3a9487d57a5c 510 return NULL;
thedo 166:3a9487d57a5c 511 }
thedo 166:3a9487d57a5c 512 return (USBDeviceConnected*)&devices[index];
thedo 166:3a9487d57a5c 513 }
thedo 166:3a9487d57a5c 514
thedo 166:3a9487d57a5c 515 // create an USBEndpoint descriptor. the USBEndpoint is not linked
thedo 166:3a9487d57a5c 516 USBEndpoint * USBHost::newEndpoint(ENDPOINT_TYPE type, ENDPOINT_DIRECTION dir, uint32_t size, uint8_t addr)
thedo 166:3a9487d57a5c 517 {
thedo 166:3a9487d57a5c 518 int i = 0;
thedo 166:3a9487d57a5c 519 HCED * ed = (HCED *)getED();
thedo 166:3a9487d57a5c 520 HCTD* td_list[2] = { (HCTD*)getTD(), (HCTD*)getTD() };
thedo 166:3a9487d57a5c 521
thedo 166:3a9487d57a5c 522 memset((void *)td_list[0], 0x00, sizeof(HCTD));
thedo 166:3a9487d57a5c 523 memset((void *)td_list[1], 0x00, sizeof(HCTD));
thedo 166:3a9487d57a5c 524
thedo 166:3a9487d57a5c 525 // search a free USBEndpoint
thedo 166:3a9487d57a5c 526 for (i = 0; i < MAX_ENDPOINT; i++) {
thedo 166:3a9487d57a5c 527 if (endpoints[i].getState() == USB_TYPE_FREE) {
thedo 166:3a9487d57a5c 528 endpoints[i].init(ed, type, dir, size, addr, td_list);
thedo 166:3a9487d57a5c 529 USB_DBG("USBEndpoint created (%p): type: %d, dir: %d, size: %d, addr: %d, state: %s", &endpoints[i], type, dir, size, addr, endpoints[i].getStateString());
thedo 166:3a9487d57a5c 530 return &endpoints[i];
thedo 166:3a9487d57a5c 531 }
thedo 166:3a9487d57a5c 532 }
thedo 166:3a9487d57a5c 533 USB_ERR("could not allocate more endpoints!!!!");
thedo 166:3a9487d57a5c 534 return NULL;
thedo 166:3a9487d57a5c 535 }
thedo 166:3a9487d57a5c 536
thedo 166:3a9487d57a5c 537
thedo 166:3a9487d57a5c 538 USB_TYPE USBHost::resetDevice(USBDeviceConnected * dev)
thedo 166:3a9487d57a5c 539 {
thedo 166:3a9487d57a5c 540 int index = findDevice(dev);
thedo 166:3a9487d57a5c 541 if (index != -1) {
thedo 166:3a9487d57a5c 542 USB_DBG("Resetting hub %d, port %d\n", dev->getHub(), dev->getPort());
thedo 166:3a9487d57a5c 543 Thread::wait(100);
thedo 166:3a9487d57a5c 544 if (dev->getHub() == 0) {
thedo 166:3a9487d57a5c 545 resetRootHub();
thedo 166:3a9487d57a5c 546 }
thedo 166:3a9487d57a5c 547 #if MAX_HUB_NB
thedo 166:3a9487d57a5c 548 else {
thedo 166:3a9487d57a5c 549 dev->getHubParent()->portReset(dev->getPort());
thedo 166:3a9487d57a5c 550 }
thedo 166:3a9487d57a5c 551 #endif
thedo 166:3a9487d57a5c 552 Thread::wait(100);
thedo 166:3a9487d57a5c 553 deviceReset[index] = true;
thedo 166:3a9487d57a5c 554 return USB_TYPE_OK;
thedo 166:3a9487d57a5c 555 }
thedo 166:3a9487d57a5c 556
thedo 166:3a9487d57a5c 557 return USB_TYPE_ERROR;
thedo 166:3a9487d57a5c 558 }
thedo 166:3a9487d57a5c 559
thedo 166:3a9487d57a5c 560 // link the USBEndpoint to the linked list and attach an USBEndpoint to a device
thedo 166:3a9487d57a5c 561 bool USBHost::addEndpoint(USBDeviceConnected * dev, uint8_t intf_nb, USBEndpoint * ep)
thedo 166:3a9487d57a5c 562 {
thedo 166:3a9487d57a5c 563
thedo 166:3a9487d57a5c 564 if (ep == NULL) {
thedo 166:3a9487d57a5c 565 return false;
thedo 166:3a9487d57a5c 566 }
thedo 166:3a9487d57a5c 567
thedo 166:3a9487d57a5c 568 HCED * prevEd;
thedo 166:3a9487d57a5c 569
thedo 166:3a9487d57a5c 570 // set device address in the USBEndpoint descriptor
thedo 166:3a9487d57a5c 571 if (dev == NULL) {
thedo 166:3a9487d57a5c 572 ep->setDeviceAddress(0);
thedo 166:3a9487d57a5c 573 } else {
thedo 166:3a9487d57a5c 574 ep->setDeviceAddress(dev->getAddress());
thedo 166:3a9487d57a5c 575 }
thedo 166:3a9487d57a5c 576
thedo 166:3a9487d57a5c 577 if ((dev != NULL) && dev->getSpeed()) {
thedo 166:3a9487d57a5c 578 ep->setSpeed(dev->getSpeed());
thedo 166:3a9487d57a5c 579 }
thedo 166:3a9487d57a5c 580
thedo 166:3a9487d57a5c 581 ep->setIntfNb(intf_nb);
thedo 166:3a9487d57a5c 582
thedo 166:3a9487d57a5c 583 // queue the new USBEndpoint on the ED list
thedo 166:3a9487d57a5c 584 switch (ep->getType()) {
thedo 166:3a9487d57a5c 585
thedo 166:3a9487d57a5c 586 case CONTROL_ENDPOINT:
thedo 166:3a9487d57a5c 587 prevEd = ( HCED*) controlHeadED();
thedo 166:3a9487d57a5c 588 if (!prevEd) {
thedo 166:3a9487d57a5c 589 updateControlHeadED((uint32_t) ep->getHCED());
thedo 166:3a9487d57a5c 590 USB_DBG_TRANSFER("First control USBEndpoint: %08X", (uint32_t) ep->getHCED());
thedo 166:3a9487d57a5c 591 headControlEndpoint = ep;
thedo 166:3a9487d57a5c 592 tailControlEndpoint = ep;
thedo 166:3a9487d57a5c 593 return true;
thedo 166:3a9487d57a5c 594 }
thedo 166:3a9487d57a5c 595 tailControlEndpoint->queueEndpoint(ep);
thedo 166:3a9487d57a5c 596 tailControlEndpoint = ep;
thedo 166:3a9487d57a5c 597 return true;
thedo 166:3a9487d57a5c 598
thedo 166:3a9487d57a5c 599 case BULK_ENDPOINT:
thedo 166:3a9487d57a5c 600 prevEd = ( HCED*) bulkHeadED();
thedo 166:3a9487d57a5c 601 if (!prevEd) {
thedo 166:3a9487d57a5c 602 updateBulkHeadED((uint32_t) ep->getHCED());
thedo 166:3a9487d57a5c 603 USB_DBG_TRANSFER("First bulk USBEndpoint: %08X\r\n", (uint32_t) ep->getHCED());
thedo 166:3a9487d57a5c 604 headBulkEndpoint = ep;
thedo 166:3a9487d57a5c 605 tailBulkEndpoint = ep;
thedo 166:3a9487d57a5c 606 break;
thedo 166:3a9487d57a5c 607 }
thedo 166:3a9487d57a5c 608 USB_DBG_TRANSFER("Queue BULK Ed %p after %p\r\n",ep->getHCED(), prevEd);
thedo 166:3a9487d57a5c 609 tailBulkEndpoint->queueEndpoint(ep);
thedo 166:3a9487d57a5c 610 tailBulkEndpoint = ep;
thedo 166:3a9487d57a5c 611 break;
thedo 166:3a9487d57a5c 612
thedo 166:3a9487d57a5c 613 case INTERRUPT_ENDPOINT:
thedo 166:3a9487d57a5c 614 prevEd = ( HCED*) interruptHeadED();
thedo 166:3a9487d57a5c 615 if (!prevEd) {
thedo 166:3a9487d57a5c 616 updateInterruptHeadED((uint32_t) ep->getHCED());
thedo 166:3a9487d57a5c 617 USB_DBG_TRANSFER("First interrupt USBEndpoint: %08X\r\n", (uint32_t) ep->getHCED());
thedo 166:3a9487d57a5c 618 headInterruptEndpoint = ep;
thedo 166:3a9487d57a5c 619 tailInterruptEndpoint = ep;
thedo 166:3a9487d57a5c 620 break;
thedo 166:3a9487d57a5c 621 }
thedo 166:3a9487d57a5c 622 USB_DBG_TRANSFER("Queue INTERRUPT Ed %p after %p\r\n",ep->getHCED(), prevEd);
thedo 166:3a9487d57a5c 623 tailInterruptEndpoint->queueEndpoint(ep);
thedo 166:3a9487d57a5c 624 tailInterruptEndpoint = ep;
thedo 166:3a9487d57a5c 625 break;
thedo 166:3a9487d57a5c 626 default:
thedo 166:3a9487d57a5c 627 return false;
thedo 166:3a9487d57a5c 628 }
thedo 166:3a9487d57a5c 629
thedo 166:3a9487d57a5c 630 ep->dev = dev;
thedo 166:3a9487d57a5c 631 dev->addEndpoint(intf_nb, ep);
thedo 166:3a9487d57a5c 632
thedo 166:3a9487d57a5c 633 return true;
thedo 166:3a9487d57a5c 634 }
thedo 166:3a9487d57a5c 635
thedo 166:3a9487d57a5c 636
thedo 166:3a9487d57a5c 637 int USBHost::findDevice(USBDeviceConnected * dev)
thedo 166:3a9487d57a5c 638 {
thedo 166:3a9487d57a5c 639 for (int i = 0; i < MAX_DEVICE_CONNECTED; i++) {
thedo 166:3a9487d57a5c 640 if (dev == &devices[i]) {
thedo 166:3a9487d57a5c 641 return i;
thedo 166:3a9487d57a5c 642 }
thedo 166:3a9487d57a5c 643 }
thedo 166:3a9487d57a5c 644 return -1;
thedo 166:3a9487d57a5c 645 }
thedo 166:3a9487d57a5c 646
thedo 166:3a9487d57a5c 647 int USBHost::findDevice(uint8_t hub, uint8_t port, USBHostHub * hub_parent)
thedo 166:3a9487d57a5c 648 {
thedo 166:3a9487d57a5c 649 for (int i = 0; i < MAX_DEVICE_CONNECTED; i++) {
thedo 166:3a9487d57a5c 650 if (devices[i].getHub() == hub && devices[i].getPort() == port) {
thedo 166:3a9487d57a5c 651 if (hub_parent != NULL) {
thedo 166:3a9487d57a5c 652 if (hub_parent == devices[i].getHubParent())
thedo 166:3a9487d57a5c 653 return i;
thedo 166:3a9487d57a5c 654 } else {
thedo 166:3a9487d57a5c 655 return i;
thedo 166:3a9487d57a5c 656 }
thedo 166:3a9487d57a5c 657 }
thedo 166:3a9487d57a5c 658 }
thedo 166:3a9487d57a5c 659 return -1;
thedo 166:3a9487d57a5c 660 }
thedo 166:3a9487d57a5c 661
thedo 166:3a9487d57a5c 662 void USBHost::printList(ENDPOINT_TYPE type)
thedo 166:3a9487d57a5c 663 {
thedo 166:3a9487d57a5c 664 #if DEBUG_EP_STATE
thedo 166:3a9487d57a5c 665 volatile HCED * hced;
thedo 166:3a9487d57a5c 666 switch(type) {
thedo 166:3a9487d57a5c 667 case CONTROL_ENDPOINT:
thedo 166:3a9487d57a5c 668 hced = (HCED *)controlHeadED();
thedo 166:3a9487d57a5c 669 break;
thedo 166:3a9487d57a5c 670 case BULK_ENDPOINT:
thedo 166:3a9487d57a5c 671 hced = (HCED *)bulkHeadED();
thedo 166:3a9487d57a5c 672 break;
thedo 166:3a9487d57a5c 673 case INTERRUPT_ENDPOINT:
thedo 166:3a9487d57a5c 674 hced = (HCED *)interruptHeadED();
thedo 166:3a9487d57a5c 675 break;
thedo 166:3a9487d57a5c 676 }
thedo 166:3a9487d57a5c 677 volatile HCTD * hctd = NULL;
thedo 166:3a9487d57a5c 678 const char * type_str = (type == BULK_ENDPOINT) ? "BULK" :
thedo 166:3a9487d57a5c 679 ((type == INTERRUPT_ENDPOINT) ? "INTERRUPT" :
thedo 166:3a9487d57a5c 680 ((type == CONTROL_ENDPOINT) ? "CONTROL" : "ISOCHRONOUS"));
thedo 166:3a9487d57a5c 681 printf("State of %s:\r\n", type_str);
thedo 166:3a9487d57a5c 682 while (hced != NULL) {
thedo 166:3a9487d57a5c 683 uint8_t dir = ((hced->control & (3 << 11)) >> 11);
thedo 166:3a9487d57a5c 684 printf("hced: %p [ADDR: %d, DIR: %s, EP_NB: 0x%X]\r\n", hced,
thedo 166:3a9487d57a5c 685 hced->control & 0x7f,
thedo 166:3a9487d57a5c 686 (dir == 1) ? "OUT" : ((dir == 0) ? "FROM_TD":"IN"),
thedo 166:3a9487d57a5c 687 (hced->control & (0xf << 7)) >> 7);
thedo 166:3a9487d57a5c 688 hctd = (HCTD *)((uint32_t)(hced->headTD) & ~(0xf));
thedo 166:3a9487d57a5c 689 while (hctd != hced->tailTD) {
thedo 166:3a9487d57a5c 690 printf("\thctd: %p [DIR: %s]\r\n", hctd, ((hctd->control & (3 << 19)) >> 19) == 1 ? "OUT" : "IN");
thedo 166:3a9487d57a5c 691 hctd = hctd->nextTD;
thedo 166:3a9487d57a5c 692 }
thedo 166:3a9487d57a5c 693 printf("\thctd: %p\r\n", hctd);
thedo 166:3a9487d57a5c 694 hced = hced->nextED;
thedo 166:3a9487d57a5c 695 }
thedo 166:3a9487d57a5c 696 printf("\r\n\r\n");
thedo 166:3a9487d57a5c 697 #endif
thedo 166:3a9487d57a5c 698 }
thedo 166:3a9487d57a5c 699
thedo 166:3a9487d57a5c 700
thedo 166:3a9487d57a5c 701 // add a transfer on the TD linked list
thedo 166:3a9487d57a5c 702 USB_TYPE USBHost::addTransfer(USBEndpoint * ed, uint8_t * buf, uint32_t len)
thedo 166:3a9487d57a5c 703 {
thedo 166:3a9487d57a5c 704 td_mutex.lock();
thedo 166:3a9487d57a5c 705
thedo 166:3a9487d57a5c 706 // allocate a TD which will be freed in TDcompletion
thedo 166:3a9487d57a5c 707 volatile HCTD * td = ed->getNextTD();
thedo 166:3a9487d57a5c 708 if (td == NULL) {
thedo 166:3a9487d57a5c 709 return USB_TYPE_ERROR;
thedo 166:3a9487d57a5c 710 }
thedo 166:3a9487d57a5c 711
thedo 166:3a9487d57a5c 712 uint32_t token = (ed->isSetup() ? TD_SETUP : ( (ed->getDir() == IN) ? TD_IN : TD_OUT ));
thedo 166:3a9487d57a5c 713
thedo 166:3a9487d57a5c 714 uint32_t td_toggle;
thedo 166:3a9487d57a5c 715
thedo 166:3a9487d57a5c 716 if (ed->getType() == CONTROL_ENDPOINT) {
thedo 166:3a9487d57a5c 717 if (ed->isSetup()) {
thedo 166:3a9487d57a5c 718 td_toggle = TD_TOGGLE_0;
thedo 166:3a9487d57a5c 719 } else {
thedo 166:3a9487d57a5c 720 td_toggle = TD_TOGGLE_1;
thedo 166:3a9487d57a5c 721 }
thedo 166:3a9487d57a5c 722 } else {
thedo 166:3a9487d57a5c 723 td_toggle = 0;
thedo 166:3a9487d57a5c 724 }
thedo 166:3a9487d57a5c 725
thedo 166:3a9487d57a5c 726 td->control = (TD_ROUNDING | token | TD_DELAY_INT(0) | td_toggle | TD_CC);
thedo 166:3a9487d57a5c 727 td->currBufPtr = buf;
thedo 166:3a9487d57a5c 728 td->bufEnd = (buf + (len - 1));
thedo 166:3a9487d57a5c 729
thedo 166:3a9487d57a5c 730 ENDPOINT_TYPE type = ed->getType();
thedo 166:3a9487d57a5c 731
thedo 166:3a9487d57a5c 732 disableList(type);
thedo 166:3a9487d57a5c 733 ed->queueTransfer();
thedo 166:3a9487d57a5c 734 printList(type);
thedo 166:3a9487d57a5c 735 enableList(type);
thedo 166:3a9487d57a5c 736
thedo 166:3a9487d57a5c 737 td_mutex.unlock();
thedo 166:3a9487d57a5c 738
thedo 166:3a9487d57a5c 739 return USB_TYPE_PROCESSING;
thedo 166:3a9487d57a5c 740 }
thedo 166:3a9487d57a5c 741
thedo 166:3a9487d57a5c 742
thedo 166:3a9487d57a5c 743
thedo 166:3a9487d57a5c 744 USB_TYPE USBHost::getDeviceDescriptor(USBDeviceConnected * dev, uint8_t * buf, uint16_t max_len_buf, uint16_t * len_dev_descr)
thedo 166:3a9487d57a5c 745 {
thedo 166:3a9487d57a5c 746 USB_TYPE t = controlRead( dev,
thedo 166:3a9487d57a5c 747 USB_DEVICE_TO_HOST | USB_RECIPIENT_DEVICE,
thedo 166:3a9487d57a5c 748 GET_DESCRIPTOR,
thedo 166:3a9487d57a5c 749 (DEVICE_DESCRIPTOR << 8) | (0),
thedo 166:3a9487d57a5c 750 0, buf, MIN(DEVICE_DESCRIPTOR_LENGTH, max_len_buf));
thedo 166:3a9487d57a5c 751 if (len_dev_descr)
thedo 166:3a9487d57a5c 752 *len_dev_descr = MIN(DEVICE_DESCRIPTOR_LENGTH, max_len_buf);
thedo 166:3a9487d57a5c 753
thedo 166:3a9487d57a5c 754 return t;
thedo 166:3a9487d57a5c 755 }
thedo 166:3a9487d57a5c 756
thedo 166:3a9487d57a5c 757 USB_TYPE USBHost::getConfigurationDescriptor(USBDeviceConnected * dev, uint8_t * buf, uint16_t max_len_buf, uint16_t * len_conf_descr)
thedo 166:3a9487d57a5c 758 {
thedo 166:3a9487d57a5c 759 USB_TYPE res;
thedo 166:3a9487d57a5c 760 uint16_t total_conf_descr_length = 0;
thedo 166:3a9487d57a5c 761
thedo 166:3a9487d57a5c 762 // fourth step: get the beginning of the configuration descriptor to have the total length of the conf descr
thedo 166:3a9487d57a5c 763 res = controlRead( dev,
thedo 166:3a9487d57a5c 764 USB_DEVICE_TO_HOST | USB_RECIPIENT_DEVICE,
thedo 166:3a9487d57a5c 765 GET_DESCRIPTOR,
thedo 166:3a9487d57a5c 766 (CONFIGURATION_DESCRIPTOR << 8) | (0),
thedo 166:3a9487d57a5c 767 0, buf, CONFIGURATION_DESCRIPTOR_LENGTH);
thedo 166:3a9487d57a5c 768
thedo 166:3a9487d57a5c 769 if (res != USB_TYPE_OK) {
thedo 166:3a9487d57a5c 770 USB_ERR("GET CONF 1 DESCR FAILED");
thedo 166:3a9487d57a5c 771 return res;
thedo 166:3a9487d57a5c 772 }
thedo 166:3a9487d57a5c 773 total_conf_descr_length = buf[2] | (buf[3] << 8);
thedo 166:3a9487d57a5c 774 total_conf_descr_length = MIN(max_len_buf, total_conf_descr_length);
thedo 166:3a9487d57a5c 775
thedo 166:3a9487d57a5c 776 if (len_conf_descr)
thedo 166:3a9487d57a5c 777 *len_conf_descr = total_conf_descr_length;
thedo 166:3a9487d57a5c 778
thedo 166:3a9487d57a5c 779 USB_DBG("TOTAL_LENGTH: %d \t NUM_INTERF: %d", total_conf_descr_length, buf[4]);
thedo 166:3a9487d57a5c 780
thedo 166:3a9487d57a5c 781 return controlRead( dev,
thedo 166:3a9487d57a5c 782 USB_DEVICE_TO_HOST | USB_RECIPIENT_DEVICE,
thedo 166:3a9487d57a5c 783 GET_DESCRIPTOR,
thedo 166:3a9487d57a5c 784 (CONFIGURATION_DESCRIPTOR << 8) | (0),
thedo 166:3a9487d57a5c 785 0, buf, total_conf_descr_length);
thedo 166:3a9487d57a5c 786 }
thedo 166:3a9487d57a5c 787
thedo 166:3a9487d57a5c 788
thedo 166:3a9487d57a5c 789 USB_TYPE USBHost::setAddress(USBDeviceConnected * dev, uint8_t address) {
thedo 166:3a9487d57a5c 790 return controlWrite( dev,
thedo 166:3a9487d57a5c 791 USB_HOST_TO_DEVICE | USB_RECIPIENT_DEVICE,
thedo 166:3a9487d57a5c 792 SET_ADDRESS,
thedo 166:3a9487d57a5c 793 address,
thedo 166:3a9487d57a5c 794 0, NULL, 0);
thedo 166:3a9487d57a5c 795
thedo 166:3a9487d57a5c 796 }
thedo 166:3a9487d57a5c 797
thedo 166:3a9487d57a5c 798 USB_TYPE USBHost::setConfiguration(USBDeviceConnected * dev, uint8_t conf)
thedo 166:3a9487d57a5c 799 {
thedo 166:3a9487d57a5c 800 return controlWrite( dev,
thedo 166:3a9487d57a5c 801 USB_HOST_TO_DEVICE | USB_RECIPIENT_DEVICE,
thedo 166:3a9487d57a5c 802 SET_CONFIGURATION,
thedo 166:3a9487d57a5c 803 conf,
thedo 166:3a9487d57a5c 804 0, NULL, 0);
thedo 166:3a9487d57a5c 805 }
thedo 166:3a9487d57a5c 806
thedo 166:3a9487d57a5c 807 uint8_t USBHost::numberDriverAttached(USBDeviceConnected * dev) {
thedo 166:3a9487d57a5c 808 int index = findDevice(dev);
thedo 166:3a9487d57a5c 809 uint8_t cnt = 0;
thedo 166:3a9487d57a5c 810 if (index == -1)
thedo 166:3a9487d57a5c 811 return 0;
thedo 166:3a9487d57a5c 812 for (uint8_t i = 0; i < MAX_INTF; i++) {
thedo 166:3a9487d57a5c 813 if (deviceAttachedDriver[index][i])
thedo 166:3a9487d57a5c 814 cnt++;
thedo 166:3a9487d57a5c 815 }
thedo 166:3a9487d57a5c 816 return cnt;
thedo 166:3a9487d57a5c 817 }
thedo 166:3a9487d57a5c 818
thedo 166:3a9487d57a5c 819 // enumerate a device with the control USBEndpoint
thedo 166:3a9487d57a5c 820 USB_TYPE USBHost::enumerate(USBDeviceConnected * dev, IUSBEnumerator* pEnumerator)
thedo 166:3a9487d57a5c 821 {
thedo 166:3a9487d57a5c 822 uint16_t total_conf_descr_length = 0;
thedo 166:3a9487d57a5c 823 USB_TYPE res;
thedo 166:3a9487d57a5c 824
thedo 166:3a9487d57a5c 825 do
thedo 166:3a9487d57a5c 826 {
thedo 166:3a9487d57a5c 827 Lock lock(this);
thedo 166:3a9487d57a5c 828
thedo 166:3a9487d57a5c 829 // don't enumerate a device which all interfaces are registered to a specific driver
thedo 166:3a9487d57a5c 830 int index = findDevice(dev);
thedo 166:3a9487d57a5c 831
thedo 166:3a9487d57a5c 832 if (index == -1) {
thedo 166:3a9487d57a5c 833 return USB_TYPE_ERROR;
thedo 166:3a9487d57a5c 834 }
thedo 166:3a9487d57a5c 835
thedo 166:3a9487d57a5c 836 uint8_t nb_intf_attached = numberDriverAttached(dev);
thedo 166:3a9487d57a5c 837 USB_DBG("dev: %p nb_intf: %d", dev, dev->getNbIntf());
thedo 166:3a9487d57a5c 838 USB_DBG("dev: %p nb_intf_attached: %d", dev, nb_intf_attached);
thedo 166:3a9487d57a5c 839 if ((nb_intf_attached != 0) && (dev->getNbIntf() == nb_intf_attached)) {
thedo 166:3a9487d57a5c 840 USB_DBG("Don't enumerate dev: %p because all intf are registered with a driver", dev);
thedo 166:3a9487d57a5c 841 return USB_TYPE_OK;
thedo 166:3a9487d57a5c 842 }
thedo 166:3a9487d57a5c 843
thedo 166:3a9487d57a5c 844 USB_DBG("Enumerate dev: %p", dev);
thedo 166:3a9487d57a5c 845
thedo 166:3a9487d57a5c 846 // third step: get the whole device descriptor to see vid, pid
thedo 166:3a9487d57a5c 847 res = getDeviceDescriptor(dev, data, DEVICE_DESCRIPTOR_LENGTH);
thedo 166:3a9487d57a5c 848
thedo 166:3a9487d57a5c 849 if (res != USB_TYPE_OK) {
thedo 166:3a9487d57a5c 850 USB_DBG("GET DEV DESCR FAILED");
thedo 166:3a9487d57a5c 851 return res;
thedo 166:3a9487d57a5c 852 }
thedo 166:3a9487d57a5c 853
thedo 166:3a9487d57a5c 854 dev->setClass(data[4]);
thedo 166:3a9487d57a5c 855 dev->setSubClass(data[5]);
thedo 166:3a9487d57a5c 856 dev->setProtocol(data[6]);
thedo 166:3a9487d57a5c 857 dev->setVid(data[8] | (data[9] << 8));
thedo 166:3a9487d57a5c 858 dev->setPid(data[10] | (data[11] << 8));
thedo 166:3a9487d57a5c 859 USB_DBG("CLASS: %02X \t VID: %04X \t PID: %04X", data[4], data[8] | (data[9] << 8), data[10] | (data[11] << 8));
thedo 166:3a9487d57a5c 860
thedo 166:3a9487d57a5c 861 pEnumerator->setVidPid( data[8] | (data[9] << 8), data[10] | (data[11] << 8) );
thedo 166:3a9487d57a5c 862
thedo 166:3a9487d57a5c 863 res = getConfigurationDescriptor(dev, data, sizeof(data), &total_conf_descr_length);
thedo 166:3a9487d57a5c 864 if (res != USB_TYPE_OK) {
thedo 166:3a9487d57a5c 865 return res;
thedo 166:3a9487d57a5c 866 }
thedo 166:3a9487d57a5c 867
thedo 166:3a9487d57a5c 868 #if (DEBUG > 3)
thedo 166:3a9487d57a5c 869 USB_DBG("CONFIGURATION DESCRIPTOR:\r\n");
thedo 166:3a9487d57a5c 870 for (int i = 0; i < total_conf_descr_length; i++)
thedo 166:3a9487d57a5c 871 printf("%02X ", data[i]);
thedo 166:3a9487d57a5c 872 printf("\r\n\r\n");
thedo 166:3a9487d57a5c 873 #endif
thedo 166:3a9487d57a5c 874
thedo 166:3a9487d57a5c 875 // Parse the configuration descriptor
thedo 166:3a9487d57a5c 876 parseConfDescr(dev, data, total_conf_descr_length, pEnumerator);
thedo 166:3a9487d57a5c 877
thedo 166:3a9487d57a5c 878 // only set configuration if not enumerated before
thedo 166:3a9487d57a5c 879 if (!dev->isEnumerated()) {
thedo 166:3a9487d57a5c 880
thedo 166:3a9487d57a5c 881 USB_DBG("Set configuration 1 on dev: %p", dev);
thedo 166:3a9487d57a5c 882 // sixth step: set configuration (only 1 supported)
thedo 166:3a9487d57a5c 883 res = setConfiguration(dev, 1);
thedo 166:3a9487d57a5c 884
thedo 166:3a9487d57a5c 885 if (res != USB_TYPE_OK) {
thedo 166:3a9487d57a5c 886 USB_DBG("SET CONF FAILED");
thedo 166:3a9487d57a5c 887 return res;
thedo 166:3a9487d57a5c 888 }
thedo 166:3a9487d57a5c 889 }
thedo 166:3a9487d57a5c 890
thedo 166:3a9487d57a5c 891 dev->setEnumerated();
thedo 166:3a9487d57a5c 892
thedo 166:3a9487d57a5c 893 // Now the device is enumerated!
thedo 166:3a9487d57a5c 894 USB_DBG("dev %p is enumerated\r\n", dev);
thedo 166:3a9487d57a5c 895
thedo 166:3a9487d57a5c 896 } while(0);
thedo 166:3a9487d57a5c 897
thedo 166:3a9487d57a5c 898 // Some devices may require this delay
thedo 166:3a9487d57a5c 899 Thread::wait(100);
thedo 166:3a9487d57a5c 900
thedo 166:3a9487d57a5c 901 return USB_TYPE_OK;
thedo 166:3a9487d57a5c 902 }
thedo 166:3a9487d57a5c 903 // this method fills the USBDeviceConnected object: class,.... . It also add endpoints found in the descriptor.
thedo 166:3a9487d57a5c 904 void USBHost::parseConfDescr(USBDeviceConnected * dev, uint8_t * conf_descr, uint32_t len, IUSBEnumerator* pEnumerator)
thedo 166:3a9487d57a5c 905 {
thedo 166:3a9487d57a5c 906 uint32_t index = 0;
thedo 166:3a9487d57a5c 907 uint32_t len_desc = 0;
thedo 166:3a9487d57a5c 908 uint8_t id = 0;
thedo 166:3a9487d57a5c 909 int nb_endpoints_used = 0;
thedo 166:3a9487d57a5c 910 USBEndpoint * ep = NULL;
thedo 166:3a9487d57a5c 911 uint8_t intf_nb = 0;
thedo 166:3a9487d57a5c 912 bool parsing_intf = false;
thedo 166:3a9487d57a5c 913 uint8_t current_intf = 0;
thedo 166:3a9487d57a5c 914
thedo 166:3a9487d57a5c 915 while (index < len) {
thedo 166:3a9487d57a5c 916 len_desc = conf_descr[index];
thedo 166:3a9487d57a5c 917 id = conf_descr[index+1];
thedo 166:3a9487d57a5c 918 switch (id) {
thedo 166:3a9487d57a5c 919 case CONFIGURATION_DESCRIPTOR:
thedo 166:3a9487d57a5c 920 USB_DBG("dev: %p has %d intf", dev, conf_descr[4]);
thedo 166:3a9487d57a5c 921 dev->setNbIntf(conf_descr[4]);
thedo 166:3a9487d57a5c 922 break;
thedo 166:3a9487d57a5c 923 case INTERFACE_DESCRIPTOR:
thedo 166:3a9487d57a5c 924 if(pEnumerator->parseInterface(conf_descr[index + 2], conf_descr[index + 5], conf_descr[index + 6], conf_descr[index + 7])) {
thedo 166:3a9487d57a5c 925 if (intf_nb++ <= MAX_INTF) {
thedo 166:3a9487d57a5c 926 current_intf = conf_descr[index + 2];
thedo 166:3a9487d57a5c 927 dev->addInterface(current_intf, conf_descr[index + 5], conf_descr[index + 6], conf_descr[index + 7]);
thedo 166:3a9487d57a5c 928 nb_endpoints_used = 0;
thedo 166:3a9487d57a5c 929 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]);
thedo 166:3a9487d57a5c 930 } else {
thedo 166:3a9487d57a5c 931 USB_DBG("Drop intf...");
thedo 166:3a9487d57a5c 932 }
thedo 166:3a9487d57a5c 933 parsing_intf = true;
thedo 166:3a9487d57a5c 934 } else {
thedo 166:3a9487d57a5c 935 parsing_intf = false;
thedo 166:3a9487d57a5c 936 }
thedo 166:3a9487d57a5c 937 break;
thedo 166:3a9487d57a5c 938 case ENDPOINT_DESCRIPTOR:
thedo 166:3a9487d57a5c 939 if (parsing_intf && (intf_nb <= MAX_INTF) ) {
thedo 166:3a9487d57a5c 940 if (nb_endpoints_used < MAX_ENDPOINT_PER_INTERFACE) {
thedo 166:3a9487d57a5c 941 if( pEnumerator->useEndpoint(current_intf, (ENDPOINT_TYPE)(conf_descr[index + 3] & 0x03), (ENDPOINT_DIRECTION)((conf_descr[index + 2] >> 7) + 1)) ) {
thedo 166:3a9487d57a5c 942 // if the USBEndpoint is isochronous -> skip it (TODO: fix this)
thedo 166:3a9487d57a5c 943 if ((conf_descr[index + 3] & 0x03) != ISOCHRONOUS_ENDPOINT) {
thedo 166:3a9487d57a5c 944 ep = newEndpoint((ENDPOINT_TYPE)(conf_descr[index+3] & 0x03),
thedo 166:3a9487d57a5c 945 (ENDPOINT_DIRECTION)((conf_descr[index + 2] >> 7) + 1),
thedo 166:3a9487d57a5c 946 conf_descr[index + 4] | (conf_descr[index + 5] << 8),
thedo 166:3a9487d57a5c 947 conf_descr[index + 2] & 0x0f);
thedo 166:3a9487d57a5c 948 USB_DBG("ADD USBEndpoint %p, on interf %d on device %p", ep, current_intf, dev);
thedo 166:3a9487d57a5c 949 if (ep != NULL && dev != NULL) {
thedo 166:3a9487d57a5c 950 addEndpoint(dev, current_intf, ep);
thedo 166:3a9487d57a5c 951 } else {
thedo 166:3a9487d57a5c 952 USB_DBG("EP NULL");
thedo 166:3a9487d57a5c 953 }
thedo 166:3a9487d57a5c 954 nb_endpoints_used++;
thedo 166:3a9487d57a5c 955 } else {
thedo 166:3a9487d57a5c 956 USB_DBG("ISO USBEndpoint NOT SUPPORTED");
thedo 166:3a9487d57a5c 957 }
thedo 166:3a9487d57a5c 958 }
thedo 166:3a9487d57a5c 959 }
thedo 166:3a9487d57a5c 960 }
thedo 166:3a9487d57a5c 961 break;
thedo 166:3a9487d57a5c 962 case HID_DESCRIPTOR:
thedo 166:3a9487d57a5c 963 lenReportDescr = conf_descr[index + 7] | (conf_descr[index + 8] << 8);
thedo 166:3a9487d57a5c 964 break;
thedo 166:3a9487d57a5c 965 default:
thedo 166:3a9487d57a5c 966 break;
thedo 166:3a9487d57a5c 967 }
thedo 166:3a9487d57a5c 968 index += len_desc;
thedo 166:3a9487d57a5c 969 }
thedo 166:3a9487d57a5c 970 }
thedo 166:3a9487d57a5c 971
thedo 166:3a9487d57a5c 972
thedo 166:3a9487d57a5c 973 USB_TYPE USBHost::bulkWrite(USBDeviceConnected * dev, USBEndpoint * ep, uint8_t * buf, uint32_t len, bool blocking)
thedo 166:3a9487d57a5c 974 {
thedo 166:3a9487d57a5c 975 return generalTransfer(dev, ep, buf, len, blocking, BULK_ENDPOINT, true);
thedo 166:3a9487d57a5c 976 }
thedo 166:3a9487d57a5c 977
thedo 166:3a9487d57a5c 978 USB_TYPE USBHost::bulkRead(USBDeviceConnected * dev, USBEndpoint * ep, uint8_t * buf, uint32_t len, bool blocking)
thedo 166:3a9487d57a5c 979 {
thedo 166:3a9487d57a5c 980 return generalTransfer(dev, ep, buf, len, blocking, BULK_ENDPOINT, false);
thedo 166:3a9487d57a5c 981 }
thedo 166:3a9487d57a5c 982
thedo 166:3a9487d57a5c 983 USB_TYPE USBHost::interruptWrite(USBDeviceConnected * dev, USBEndpoint * ep, uint8_t * buf, uint32_t len, bool blocking)
thedo 166:3a9487d57a5c 984 {
thedo 166:3a9487d57a5c 985 return generalTransfer(dev, ep, buf, len, blocking, INTERRUPT_ENDPOINT, true);
thedo 166:3a9487d57a5c 986 }
thedo 166:3a9487d57a5c 987
thedo 166:3a9487d57a5c 988 USB_TYPE USBHost::interruptRead(USBDeviceConnected * dev, USBEndpoint * ep, uint8_t * buf, uint32_t len, bool blocking)
thedo 166:3a9487d57a5c 989 {
thedo 166:3a9487d57a5c 990 return generalTransfer(dev, ep, buf, len, blocking, INTERRUPT_ENDPOINT, false);
thedo 166:3a9487d57a5c 991 }
thedo 166:3a9487d57a5c 992
thedo 166:3a9487d57a5c 993 USB_TYPE USBHost::generalTransfer(USBDeviceConnected * dev, USBEndpoint * ep, uint8_t * buf, uint32_t len, bool blocking, ENDPOINT_TYPE type, bool write) {
thedo 166:3a9487d57a5c 994
thedo 166:3a9487d57a5c 995 #if DEBUG_TRANSFER
thedo 166:3a9487d57a5c 996 const char * type_str = (type == BULK_ENDPOINT) ? "BULK" : ((type == INTERRUPT_ENDPOINT) ? "INTERRUPT" : "ISOCHRONOUS");
thedo 166:3a9487d57a5c 997 USB_DBG_TRANSFER("----- %s %s [dev: %p - %s - hub: %d - port: %d - addr: %d - ep: %02X]------", type_str, (write) ? "WRITE" : "READ", dev, dev->getName(ep->getIntfNb()), dev->getHub(), dev->getPort(), dev->getAddress(), ep->getAddress());
thedo 166:3a9487d57a5c 998 #endif
thedo 166:3a9487d57a5c 999
thedo 166:3a9487d57a5c 1000 Lock lock(this);
thedo 166:3a9487d57a5c 1001
thedo 166:3a9487d57a5c 1002 USB_TYPE res;
thedo 166:3a9487d57a5c 1003 ENDPOINT_DIRECTION dir = (write) ? OUT : IN;
thedo 166:3a9487d57a5c 1004
thedo 166:3a9487d57a5c 1005 if (dev == NULL) {
thedo 166:3a9487d57a5c 1006 USB_ERR("dev NULL");
thedo 166:3a9487d57a5c 1007 return USB_TYPE_ERROR;
thedo 166:3a9487d57a5c 1008 }
thedo 166:3a9487d57a5c 1009
thedo 166:3a9487d57a5c 1010 if (ep == NULL) {
thedo 166:3a9487d57a5c 1011 USB_ERR("ep NULL");
thedo 166:3a9487d57a5c 1012 return USB_TYPE_ERROR;
thedo 166:3a9487d57a5c 1013 }
thedo 166:3a9487d57a5c 1014
thedo 166:3a9487d57a5c 1015 if (ep->getState() != USB_TYPE_IDLE) {
thedo 166:3a9487d57a5c 1016 USB_WARN("[ep: %p - dev: %p - %s] NOT IDLE: %s", ep, ep->dev, ep->dev->getName(ep->getIntfNb()), ep->getStateString());
thedo 166:3a9487d57a5c 1017 return ep->getState();
thedo 166:3a9487d57a5c 1018 }
thedo 166:3a9487d57a5c 1019
thedo 166:3a9487d57a5c 1020 if ((ep->getDir() != dir) || (ep->getType() != type)) {
thedo 166:3a9487d57a5c 1021 USB_ERR("[ep: %p - dev: %p] wrong dir or bad USBEndpoint type", ep, ep->dev);
thedo 166:3a9487d57a5c 1022 return USB_TYPE_ERROR;
thedo 166:3a9487d57a5c 1023 }
thedo 166:3a9487d57a5c 1024
thedo 166:3a9487d57a5c 1025 if (dev->getAddress() != ep->getDeviceAddress()) {
thedo 166:3a9487d57a5c 1026 USB_ERR("[ep: %p - dev: %p] USBEndpoint addr and device addr don't match", ep, ep->dev);
thedo 166:3a9487d57a5c 1027 return USB_TYPE_ERROR;
thedo 166:3a9487d57a5c 1028 }
thedo 166:3a9487d57a5c 1029
thedo 166:3a9487d57a5c 1030 #if DEBUG_TRANSFER
thedo 166:3a9487d57a5c 1031 if (write) {
thedo 166:3a9487d57a5c 1032 USB_DBG_TRANSFER("%s WRITE buffer", type_str);
thedo 166:3a9487d57a5c 1033 for (int i = 0; i < ep->getLengthTransferred(); i++)
thedo 166:3a9487d57a5c 1034 printf("%02X ", buf[i]);
thedo 166:3a9487d57a5c 1035 printf("\r\n\r\n");
thedo 166:3a9487d57a5c 1036 }
thedo 166:3a9487d57a5c 1037 #endif
thedo 166:3a9487d57a5c 1038 addTransfer(ep, buf, len);
thedo 166:3a9487d57a5c 1039
thedo 166:3a9487d57a5c 1040 if (blocking) {
thedo 166:3a9487d57a5c 1041
thedo 166:3a9487d57a5c 1042 ep->ep_queue.get();
thedo 166:3a9487d57a5c 1043 res = ep->getState();
thedo 166:3a9487d57a5c 1044
thedo 166:3a9487d57a5c 1045 USB_DBG_TRANSFER("%s TRANSFER res: %s on ep: %p\r\n", type_str, ep->getStateString(), ep);
thedo 166:3a9487d57a5c 1046
thedo 166:3a9487d57a5c 1047 if (res != USB_TYPE_IDLE) {
thedo 166:3a9487d57a5c 1048 return res;
thedo 166:3a9487d57a5c 1049 }
thedo 166:3a9487d57a5c 1050
thedo 166:3a9487d57a5c 1051 return USB_TYPE_OK;
thedo 166:3a9487d57a5c 1052 }
thedo 166:3a9487d57a5c 1053
thedo 166:3a9487d57a5c 1054 return USB_TYPE_PROCESSING;
thedo 166:3a9487d57a5c 1055
thedo 166:3a9487d57a5c 1056 }
thedo 166:3a9487d57a5c 1057
thedo 166:3a9487d57a5c 1058
thedo 166:3a9487d57a5c 1059 USB_TYPE USBHost::controlRead(USBDeviceConnected * dev, uint8_t requestType, uint8_t request, uint32_t value, uint32_t index, uint8_t * buf, uint32_t len) {
thedo 166:3a9487d57a5c 1060 return controlTransfer(dev, requestType, request, value, index, buf, len, false);
thedo 166:3a9487d57a5c 1061 }
thedo 166:3a9487d57a5c 1062
thedo 166:3a9487d57a5c 1063 USB_TYPE USBHost::controlWrite(USBDeviceConnected * dev, uint8_t requestType, uint8_t request, uint32_t value, uint32_t index, uint8_t * buf, uint32_t len) {
thedo 166:3a9487d57a5c 1064 return controlTransfer(dev, requestType, request, value, index, buf, len, true);
thedo 166:3a9487d57a5c 1065 }
thedo 166:3a9487d57a5c 1066
thedo 166:3a9487d57a5c 1067 USB_TYPE USBHost::controlTransfer(USBDeviceConnected * dev, uint8_t requestType, uint8_t request, uint32_t value, uint32_t index, uint8_t * buf, uint32_t len, bool write)
thedo 166:3a9487d57a5c 1068 {
thedo 166:3a9487d57a5c 1069 Lock lock(this);
thedo 166:3a9487d57a5c 1070 USB_DBG_TRANSFER("----- CONTROL %s [dev: %p - hub: %d - port: %d] ------", (write) ? "WRITE" : "READ", dev, dev->getHub(), dev->getPort());
thedo 166:3a9487d57a5c 1071
thedo 166:3a9487d57a5c 1072 int length_transfer = len;
thedo 166:3a9487d57a5c 1073 USB_TYPE res;
thedo 166:3a9487d57a5c 1074 uint32_t token;
thedo 166:3a9487d57a5c 1075
thedo 166:3a9487d57a5c 1076 control->setSpeed(dev->getSpeed());
thedo 166:3a9487d57a5c 1077 control->setSize(dev->getSizeControlEndpoint());
thedo 166:3a9487d57a5c 1078 if (dev->isActiveAddress()) {
thedo 166:3a9487d57a5c 1079 control->setDeviceAddress(dev->getAddress());
thedo 166:3a9487d57a5c 1080 } else {
thedo 166:3a9487d57a5c 1081 control->setDeviceAddress(0);
thedo 166:3a9487d57a5c 1082 }
thedo 166:3a9487d57a5c 1083
thedo 166:3a9487d57a5c 1084 USB_DBG_TRANSFER("Control transfer on device: %d\r\n", control->getDeviceAddress());
thedo 166:3a9487d57a5c 1085 fillControlBuf(requestType, request, value, index, len);
thedo 166:3a9487d57a5c 1086
thedo 166:3a9487d57a5c 1087 #if DEBUG_TRANSFER
thedo 166:3a9487d57a5c 1088 USB_DBG_TRANSFER("SETUP PACKET: ");
thedo 166:3a9487d57a5c 1089 for (int i = 0; i < 8; i++)
thedo 166:3a9487d57a5c 1090 printf("%01X ", setupPacket[i]);
thedo 166:3a9487d57a5c 1091 printf("\r\n");
thedo 166:3a9487d57a5c 1092 #endif
thedo 166:3a9487d57a5c 1093
thedo 166:3a9487d57a5c 1094 control->setNextToken(TD_SETUP);
thedo 166:3a9487d57a5c 1095 addTransfer(control, (uint8_t*)setupPacket, 8);
thedo 166:3a9487d57a5c 1096
thedo 166:3a9487d57a5c 1097 control->ep_queue.get();
thedo 166:3a9487d57a5c 1098 res = control->getState();
thedo 166:3a9487d57a5c 1099
thedo 166:3a9487d57a5c 1100 USB_DBG_TRANSFER("CONTROL setup stage %s", control->getStateString());
thedo 166:3a9487d57a5c 1101
thedo 166:3a9487d57a5c 1102 if (res != USB_TYPE_IDLE) {
thedo 166:3a9487d57a5c 1103 return res;
thedo 166:3a9487d57a5c 1104 }
thedo 166:3a9487d57a5c 1105
thedo 166:3a9487d57a5c 1106 if (length_transfer) {
thedo 166:3a9487d57a5c 1107 token = (write) ? TD_OUT : TD_IN;
thedo 166:3a9487d57a5c 1108 control->setNextToken(token);
thedo 166:3a9487d57a5c 1109 addTransfer(control, (uint8_t *)buf, length_transfer);
thedo 166:3a9487d57a5c 1110
thedo 166:3a9487d57a5c 1111 control->ep_queue.get();
thedo 166:3a9487d57a5c 1112 res = control->getState();
thedo 166:3a9487d57a5c 1113
thedo 166:3a9487d57a5c 1114 #if DEBUG_TRANSFER
thedo 166:3a9487d57a5c 1115 USB_DBG_TRANSFER("CONTROL %s stage %s", (write) ? "WRITE" : "READ", control->getStateString());
thedo 166:3a9487d57a5c 1116 if (write) {
thedo 166:3a9487d57a5c 1117 USB_DBG_TRANSFER("CONTROL WRITE buffer");
thedo 166:3a9487d57a5c 1118 for (int i = 0; i < control->getLengthTransferred(); i++)
thedo 166:3a9487d57a5c 1119 printf("%02X ", buf[i]);
thedo 166:3a9487d57a5c 1120 printf("\r\n\r\n");
thedo 166:3a9487d57a5c 1121 } else {
thedo 166:3a9487d57a5c 1122 USB_DBG_TRANSFER("CONTROL READ SUCCESS [%d bytes transferred]", control->getLengthTransferred());
thedo 166:3a9487d57a5c 1123 for (int i = 0; i < control->getLengthTransferred(); i++)
thedo 166:3a9487d57a5c 1124 printf("%02X ", buf[i]);
thedo 166:3a9487d57a5c 1125 printf("\r\n\r\n");
thedo 166:3a9487d57a5c 1126 }
thedo 166:3a9487d57a5c 1127 #endif
thedo 166:3a9487d57a5c 1128
thedo 166:3a9487d57a5c 1129 if (res != USB_TYPE_IDLE) {
thedo 166:3a9487d57a5c 1130 return res;
thedo 166:3a9487d57a5c 1131 }
thedo 166:3a9487d57a5c 1132 }
thedo 166:3a9487d57a5c 1133
thedo 166:3a9487d57a5c 1134 token = (write) ? TD_IN : TD_OUT;
thedo 166:3a9487d57a5c 1135 control->setNextToken(token);
thedo 166:3a9487d57a5c 1136 addTransfer(control, NULL, 0);
thedo 166:3a9487d57a5c 1137
thedo 166:3a9487d57a5c 1138 control->ep_queue.get();
thedo 166:3a9487d57a5c 1139 res = control->getState();
thedo 166:3a9487d57a5c 1140
thedo 166:3a9487d57a5c 1141 USB_DBG_TRANSFER("CONTROL ack stage %s", control->getStateString());
thedo 166:3a9487d57a5c 1142
thedo 166:3a9487d57a5c 1143 if (res != USB_TYPE_IDLE)
thedo 166:3a9487d57a5c 1144 return res;
thedo 166:3a9487d57a5c 1145
thedo 166:3a9487d57a5c 1146 return USB_TYPE_OK;
thedo 166:3a9487d57a5c 1147 }
thedo 166:3a9487d57a5c 1148
thedo 166:3a9487d57a5c 1149
thedo 166:3a9487d57a5c 1150 void USBHost::fillControlBuf(uint8_t requestType, uint8_t request, uint16_t value, uint16_t index, int len)
thedo 166:3a9487d57a5c 1151 {
thedo 166:3a9487d57a5c 1152 setupPacket[0] = requestType;
thedo 166:3a9487d57a5c 1153 setupPacket[1] = request;
thedo 166:3a9487d57a5c 1154 setupPacket[2] = (uint8_t) value;
thedo 166:3a9487d57a5c 1155 setupPacket[3] = (uint8_t) (value >> 8);
thedo 166:3a9487d57a5c 1156 setupPacket[4] = (uint8_t) index;
thedo 166:3a9487d57a5c 1157 setupPacket[5] = (uint8_t) (index >> 8);
thedo 166:3a9487d57a5c 1158 setupPacket[6] = (uint8_t) len;
thedo 166:3a9487d57a5c 1159 setupPacket[7] = (uint8_t) (len >> 8);
thedo 166:3a9487d57a5c 1160 }