Renesas / USBHost_AddIso

I added the Isochronous to USBHost library. The Isochronous code based on the following. http://developer.mbed.org/users/va009039/code/USBHostC270_example/

Dependencies:   FATFileSystem mbed-rtos

Fork of USBHost_AddIso by GR-PEACH_producer_meeting

USBHost/USBHost.cpp@30:2851a9b2bbfb, 2015-04-01 (annotated)

Committer:
dkato
Date:
Wed Apr 01 05:36:16 2015 +0000
Revision:
30:2851a9b2bbfb
Parent:
24:868cbfe611a7
Child:
31:271fcfd7cfc2
supported Isochronous

Who changed what in which revision?

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