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