Nathan Yonkee
init
Embed:
(wiki syntax)
Show/hide line numbers
USBHost.cpp
00001 /* mbed USBHost Library 00002 * Copyright (c) 2006-2013 ARM Limited 00003 * 00004 * Licensed under the Apache License, Version 2.0 (the "License"); 00005 * you may not use this file except in compliance with the License. 00006 * You may obtain a copy of the License at 00007 * 00008 * http://www.apache.org/licenses/LICENSE-2.0 00009 * 00010 * Unless required by applicable law or agreed to in writing, software 00011 * distributed under the License is distributed on an "AS IS" BASIS, 00012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00013 * See the License for the specific language governing permissions and 00014 * limitations under the License. 00015 */ 00016 00017 00018 #include "USBHost.h" 00019 #include "USBHostHub.h" 00020 00021 USBHost * USBHost::instHost = NULL; 00022 00023 #define DEVICE_CONNECTED_EVENT (1 << 0) 00024 #define DEVICE_DISCONNECTED_EVENT (1 << 1) 00025 #define TD_PROCESSED_EVENT (1 << 2) 00026 00027 #define MAX_TRY_ENUMERATE_HUB 3 00028 00029 #define MIN(a, b) ((a > b) ? b : a) 00030 00031 /** 00032 * How interrupts are processed: 00033 * - new device connected: 00034 * - a message is queued in queue_usb_event with the id DEVICE_CONNECTED_EVENT 00035 * - when the usb_thread receives the event, it: 00036 * - resets the device 00037 * - reads the device descriptor 00038 * - sets the address of the device 00039 * - if it is a hub, enumerates it 00040 * - device disconnected: 00041 * - a message is queued in queue_usb_event with the id DEVICE_DISCONNECTED_EVENT 00042 * - when the usb_thread receives the event, it: 00043 * - free the device and all its children (hub) 00044 * - td processed 00045 * - a message is queued in queue_usb_event with the id TD_PROCESSED_EVENT 00046 * - when the usb_thread receives the event, it: 00047 * - call the callback attached to the endpoint where the td is attached 00048 */ 00049 void USBHost::usb_process() 00050 { 00051 00052 bool controlListState; 00053 bool bulkListState; 00054 bool interruptListState; 00055 USBEndpoint * ep; 00056 uint8_t i, j, res, timeout_set_addr = 10; 00057 uint8_t buf[8]; 00058 bool too_many_hub; 00059 int idx; 00060 00061 #if DEBUG_TRANSFER 00062 uint8_t * buf_transfer; 00063 #endif 00064 00065 #if MAX_HUB_NB 00066 uint8_t k; 00067 #endif 00068 00069 while(1) { 00070 osEvent evt = mail_usb_event.get(); 00071 00072 if (evt.status == osEventMail) { 00073 00074 message_t * usb_msg = (message_t*)evt.value.p; 00075 00076 switch (usb_msg->event_id) { 00077 00078 // a new device has been connected 00079 case DEVICE_CONNECTED_EVENT: 00080 too_many_hub = false; 00081 buf[4] = 0; 00082 00083 do { 00084 Lock lock(this); 00085 bool hub_unplugged = true; 00086 00087 int idx = findDevice(usb_msg->hub, usb_msg->port, (USBHostHub *)(usb_msg->hub_parent)); 00088 /* check that hub is connected to root port */ 00089 if (usb_msg->hub_parent) { 00090 /* a hub device must be present */ 00091 #if MAX_HUB_NB 00092 00093 for (k = 0; k < MAX_HUB_NB; k++) { 00094 if ((&hubs[k] == usb_msg->hub_parent) && (hub_in_use[k])) { 00095 hub_unplugged=false; 00096 } 00097 } 00098 #endif 00099 } else { 00100 hub_unplugged = false; 00101 } 00102 00103 if (((idx!=-1) && deviceInUse[idx] ) || ((idx == -1) && hub_unplugged)) { 00104 break; 00105 } 00106 00107 for (i =0 ; i < MAX_DEVICE_CONNECTED; i++) { 00108 if (!deviceInUse[i]) { 00109 USB_DBG_EVENT("new device connected: %p\r\n", &devices[i]); 00110 devices[i].init(usb_msg->hub, usb_msg->port, usb_msg->lowSpeed); 00111 deviceReset[i] = false; 00112 deviceInited[i] = true; 00113 break; 00114 } 00115 } 00116 00117 if (i == MAX_DEVICE_CONNECTED) { 00118 USB_ERR("Too many device connected!!\r\n"); 00119 continue; 00120 } 00121 00122 if (!controlEndpointAllocated) { 00123 control = newEndpoint(CONTROL_ENDPOINT, OUT, 0x08, 0x00); 00124 addEndpoint(NULL, 0, (USBEndpoint*)control); 00125 controlEndpointAllocated = true; 00126 } 00127 00128 #if MAX_HUB_NB 00129 if (usb_msg->hub_parent) { 00130 devices[i].setHubParent((USBHostHub *)(usb_msg->hub_parent)); 00131 } 00132 #endif 00133 00134 for (j = 0; j < timeout_set_addr; j++) { 00135 00136 resetDevice(&devices[i]); 00137 00138 // set size of control endpoint 00139 devices[i].setSizeControlEndpoint(8); 00140 00141 devices[i].activeAddress(false); 00142 00143 // get first 8 bit of device descriptor 00144 // and check if we deal with a hub 00145 USB_DBG("usb_thread read device descriptor on dev: %p\r\n", &devices[i]); 00146 res = getDeviceDescriptor(&devices[i], buf, 8); 00147 00148 if (res != USB_TYPE_OK) { 00149 USB_ERR("usb_thread could not read dev descr"); 00150 continue; 00151 } 00152 00153 // set size of control endpoint 00154 devices[i].setSizeControlEndpoint(buf[7]); 00155 00156 // second step: set an address to the device 00157 res = setAddress(&devices[i], devices[i].getAddress()); 00158 00159 if (res != USB_TYPE_OK) { 00160 USB_ERR("SET ADDR FAILED"); 00161 continue; 00162 } 00163 devices[i].activeAddress(true); 00164 USB_DBG("Address of %p: %d", &devices[i], devices[i].getAddress()); 00165 00166 // try to read again the device descriptor to check if the device 00167 // answers to its new address 00168 res = getDeviceDescriptor(&devices[i], buf, 8); 00169 00170 if (res == USB_TYPE_OK) { 00171 break; 00172 } 00173 00174 Thread::wait(100); 00175 } 00176 00177 USB_INFO("New device connected: %p [hub: %d - port: %d]", &devices[i], usb_msg->hub, usb_msg->port); 00178 00179 #if MAX_HUB_NB 00180 if (buf[4] == HUB_CLASS) { 00181 for (k = 0; k < MAX_HUB_NB; k++) { 00182 if (hub_in_use[k] == false) { 00183 for (uint8_t j = 0; j < MAX_TRY_ENUMERATE_HUB; j++) { 00184 if (hubs[k].connect(&devices[i])) { 00185 devices[i].hub = &hubs[k]; 00186 hub_in_use[k] = true; 00187 break; 00188 } 00189 } 00190 if (hub_in_use[k] == true) { 00191 break; 00192 } 00193 } 00194 } 00195 00196 if (k == MAX_HUB_NB) { 00197 USB_ERR("Too many hubs connected!!\r\n"); 00198 too_many_hub = true; 00199 } 00200 } 00201 00202 if (usb_msg->hub_parent) { 00203 ((USBHostHub *)(usb_msg->hub_parent))->deviceConnected(&devices[i]); 00204 } 00205 #endif 00206 00207 if ((i < MAX_DEVICE_CONNECTED) && !too_many_hub) { 00208 deviceInUse[i] = true; 00209 } 00210 00211 } while(0); 00212 00213 break; 00214 00215 // a device has been disconnected 00216 case DEVICE_DISCONNECTED_EVENT: 00217 00218 do { 00219 Lock lock(this); 00220 00221 controlListState = disableList(CONTROL_ENDPOINT); 00222 bulkListState = disableList(BULK_ENDPOINT); 00223 interruptListState = disableList(INTERRUPT_ENDPOINT); 00224 00225 idx = findDevice(usb_msg->hub, usb_msg->port, (USBHostHub *)(usb_msg->hub_parent)); 00226 if (idx != -1) { 00227 freeDevice((USBDeviceConnected*)&devices[idx]); 00228 deviceInited[idx]=false; 00229 } 00230 00231 if (controlListState) { 00232 enableList(CONTROL_ENDPOINT); 00233 } 00234 if (bulkListState) { 00235 enableList(BULK_ENDPOINT); 00236 } 00237 if (interruptListState) { 00238 enableList(INTERRUPT_ENDPOINT); 00239 } 00240 00241 } while(0); 00242 00243 break; 00244 00245 // a td has been processed 00246 // call callback on the ed associated to the td 00247 // we are not in ISR -> users can use printf in their callback method 00248 case TD_PROCESSED_EVENT: 00249 ep = (USBEndpoint *) ((HCTD *)usb_msg->td_addr)->ep; 00250 if (usb_msg->td_state == USB_TYPE_IDLE) { 00251 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())); 00252 00253 #if DEBUG_TRANSFER 00254 if (ep->getDir() == IN) { 00255 buf_transfer = ep->getBufStart(); 00256 printf("READ SUCCESS [%d bytes transferred - td: 0x%08X] on ep: [%p - addr: %02X]: ", ep->getLengthTransferred(), usb_msg->td_addr, ep, ep->getAddress()); 00257 for (int i = 0; i < ep->getLengthTransferred(); i++) { 00258 printf("%02X ", buf_transfer[i]); 00259 } 00260 printf("\r\n\r\n"); 00261 } 00262 #endif 00263 ep->call(); 00264 } else { 00265 idx = findDevice(ep->dev); 00266 if (idx != -1) { 00267 if (deviceInUse[idx]) { 00268 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())); 00269 ep->setState(USB_TYPE_IDLE); 00270 /* as error, on interrupt endpoint can be 00271 * reported, call the call back registered , 00272 * if device still in use, this call back 00273 * shall ask again an interrupt request. 00274 */ 00275 ep->call(); 00276 } 00277 } 00278 } 00279 break; 00280 } 00281 00282 mail_usb_event.free(usb_msg); 00283 } 00284 } 00285 } 00286 00287 USBHost::USBHost() : usbThread(osPriorityNormal, USB_THREAD_STACK) 00288 { 00289 #ifndef USBHOST_OTHER 00290 headControlEndpoint = NULL; 00291 headBulkEndpoint = NULL; 00292 headInterruptEndpoint = NULL; 00293 tailControlEndpoint = NULL; 00294 tailBulkEndpoint = NULL; 00295 tailInterruptEndpoint = NULL; 00296 #endif 00297 lenReportDescr = 0; 00298 00299 controlEndpointAllocated = false; 00300 00301 for (uint8_t i = 0; i < MAX_DEVICE_CONNECTED; i++) { 00302 deviceInUse[i] = false; 00303 devices[i].setAddress(i + 1); 00304 deviceReset[i] = false; 00305 deviceInited[i] = false; 00306 for (uint8_t j = 0; j < MAX_INTF; j++) { 00307 deviceAttachedDriver[i][j] = false; 00308 } 00309 } 00310 00311 #if MAX_HUB_NB 00312 for (uint8_t i = 0; i < MAX_HUB_NB; i++) { 00313 hubs[i].setHost(this); 00314 hub_in_use[i] = false; 00315 } 00316 #endif 00317 00318 usbThread.start(callback(this, &USBHost::usb_process)); 00319 } 00320 00321 USBHost::Lock::Lock(USBHost* pHost) : m_pHost(pHost) 00322 { 00323 m_pHost->usb_mutex.lock(); 00324 } 00325 00326 USBHost::Lock::~Lock() 00327 { 00328 m_pHost->usb_mutex.unlock(); 00329 } 00330 00331 void USBHost::transferCompleted(volatile uint32_t addr) 00332 { 00333 uint8_t state; 00334 00335 if(addr == 0) { 00336 return; 00337 } 00338 00339 volatile HCTD* tdList = NULL; 00340 00341 //First we must reverse the list order and dequeue each TD 00342 do { 00343 volatile HCTD* td = (volatile HCTD*)addr; 00344 addr = (uint32_t)td->nextTD; //Dequeue from physical list 00345 td->nextTD = (hcTd*)tdList; //Enqueue into reversed list 00346 tdList = td; 00347 } while(addr); 00348 00349 while(tdList != NULL) { 00350 volatile HCTD* td = tdList; 00351 tdList = (volatile HCTD*)td->nextTD; //Dequeue element now as it could be modified below 00352 if (td->ep != NULL) { 00353 USBEndpoint * ep = (USBEndpoint *)(td->ep); 00354 00355 #ifdef USBHOST_OTHER 00356 state = ((HCTD *)td)->state; 00357 if (state == USB_TYPE_IDLE) { 00358 ep->setLengthTransferred((uint32_t)td->currBufPtr - (uint32_t)ep->getBufStart()); 00359 } 00360 00361 #else 00362 if (((HCTD *)td)->control >> 28) { 00363 state = ((HCTD *)td)->control >> 28; 00364 } else { 00365 if (td->currBufPtr) { 00366 ep->setLengthTransferred((uint32_t)td->currBufPtr - (uint32_t)ep->getBufStart()); 00367 } 00368 state = 16 /*USB_TYPE_IDLE*/; 00369 } 00370 #endif 00371 if (state == USB_TYPE_IDLE) { 00372 ep->setLengthTransferred((uint32_t)td->currBufPtr - (uint32_t)ep->getBufStart()); 00373 } 00374 00375 ep->unqueueTransfer(td); 00376 00377 if (ep->getType() != CONTROL_ENDPOINT) { 00378 // callback on the processed td will be called from the usb_thread (not in ISR) 00379 message_t * usb_msg = mail_usb_event.alloc(); 00380 usb_msg->event_id = TD_PROCESSED_EVENT; 00381 usb_msg->td_addr = (void *)td; 00382 usb_msg->td_state = state; 00383 mail_usb_event.put(usb_msg); 00384 } 00385 ep->setState((USB_TYPE)state); 00386 ep->ep_queue.put((uint8_t*)1); 00387 } 00388 } 00389 } 00390 00391 USBHost * USBHost::getHostInst() 00392 { 00393 if (instHost == NULL) { 00394 instHost = new USBHost(); 00395 instHost->init(); 00396 } 00397 return instHost; 00398 } 00399 00400 00401 /* 00402 * Called when a device has been connected 00403 * Called in ISR!!!! (no printf) 00404 */ 00405 /* virtual */ void USBHost::deviceConnected(int hub, int port, bool lowSpeed, USBHostHub * hub_parent) 00406 { 00407 // be sure that the new device connected is not already connected... 00408 int idx = findDevice(hub, port, hub_parent); 00409 if (idx != -1) { 00410 if (deviceInited[idx]) { 00411 return; 00412 } 00413 } 00414 00415 message_t * usb_msg = mail_usb_event.alloc(); 00416 usb_msg->event_id = DEVICE_CONNECTED_EVENT; 00417 usb_msg->hub = hub; 00418 usb_msg->port = port; 00419 usb_msg->lowSpeed = lowSpeed; 00420 usb_msg->hub_parent = hub_parent; 00421 mail_usb_event.put(usb_msg); 00422 } 00423 00424 /* 00425 * Called when a device has been disconnected 00426 * Called in ISR!!!! (no printf) 00427 */ 00428 /* virtual */ void USBHost::deviceDisconnected(int hub, int port, USBHostHub * hub_parent, volatile uint32_t addr) 00429 { 00430 // be sure that the device disconnected is connected... 00431 int idx = findDevice(hub, port, hub_parent); 00432 if (idx != -1) { 00433 if (!deviceInUse[idx]) { 00434 return; 00435 } 00436 } else { 00437 return; 00438 } 00439 00440 message_t * usb_msg = mail_usb_event.alloc(); 00441 usb_msg->event_id = DEVICE_DISCONNECTED_EVENT; 00442 usb_msg->hub = hub; 00443 usb_msg->port = port; 00444 usb_msg->hub_parent = hub_parent; 00445 mail_usb_event.put(usb_msg); 00446 } 00447 00448 void USBHost::freeDevice(USBDeviceConnected * dev) 00449 { 00450 USBEndpoint * ep = NULL; 00451 HCED * ed = NULL; 00452 00453 #if MAX_HUB_NB 00454 if (dev->getClass() == HUB_CLASS) { 00455 if (dev->hub == NULL) { 00456 USB_ERR("HUB NULL!!!!!\r\n"); 00457 } else { 00458 dev->hub->hubDisconnected(); 00459 for (uint8_t i = 0; i < MAX_HUB_NB; i++) { 00460 if (dev->hub == &hubs[i]) { 00461 hub_in_use[i] = false; 00462 break; 00463 } 00464 } 00465 } 00466 } 00467 00468 // notify hub parent that this device has been disconnected 00469 if (dev->getHubParent()) { 00470 dev->getHubParent()->deviceDisconnected(dev); 00471 } 00472 00473 #endif 00474 00475 int idx = findDevice(dev); 00476 if (idx != -1) { 00477 deviceInUse[idx] = false; 00478 deviceReset[idx] = false; 00479 00480 for (uint8_t j = 0; j < MAX_INTF; j++) { 00481 deviceAttachedDriver[idx][j] = false; 00482 if (dev->getInterface(j) != NULL) { 00483 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)); 00484 for (int i = 0; i < dev->getInterface(j)->nb_endpoint; i++) { 00485 if ((ep = dev->getEndpoint(j, i)) != NULL) { 00486 #ifndef USBHOST_OTHER 00487 ed = (HCED *)ep->getHCED(); 00488 ed->control |= (1 << 14); //sKip bit 00489 #endif 00490 unqueueEndpoint(ep); 00491 00492 freeTD((volatile uint8_t*)ep->getTDList()[0]); 00493 freeTD((volatile uint8_t*)ep->getTDList()[1]); 00494 00495 freeED((uint8_t *)ep->getHCED()); 00496 } 00497 printList(BULK_ENDPOINT); 00498 printList(INTERRUPT_ENDPOINT); 00499 } 00500 USB_INFO("Device disconnected [%p - %s - hub: %d - port: %d]", dev, dev->getName(j), dev->getHub(), dev->getPort()); 00501 } 00502 } 00503 dev->disconnect(); 00504 } 00505 } 00506 00507 00508 void USBHost::unqueueEndpoint(USBEndpoint * ep) 00509 { 00510 #ifdef USBHOST_OTHER 00511 ep->setState(USB_TYPE_FREE); 00512 #else 00513 USBEndpoint * prec = NULL; 00514 USBEndpoint * current = NULL; 00515 00516 for (int i = 0; i < 2; i++) { 00517 current = (i == 0) ? (USBEndpoint*)headBulkEndpoint : (USBEndpoint*)headInterruptEndpoint; 00518 prec = current; 00519 while (current != NULL) { 00520 if (current == ep) { 00521 if (current->nextEndpoint() != NULL) { 00522 prec->queueEndpoint(current->nextEndpoint()); 00523 if (current == headBulkEndpoint) { 00524 updateBulkHeadED((uint32_t)current->nextEndpoint()->getHCED()); 00525 headBulkEndpoint = current->nextEndpoint(); 00526 } else if (current == headInterruptEndpoint) { 00527 updateInterruptHeadED((uint32_t)current->nextEndpoint()->getHCED()); 00528 headInterruptEndpoint = current->nextEndpoint(); 00529 } 00530 } 00531 // here we are dequeuing the queue of ed 00532 // we need to update the tail pointer 00533 else { 00534 prec->queueEndpoint(NULL); 00535 if (current == headBulkEndpoint) { 00536 updateBulkHeadED(0); 00537 headBulkEndpoint = current->nextEndpoint(); 00538 } else if (current == headInterruptEndpoint) { 00539 updateInterruptHeadED(0); 00540 headInterruptEndpoint = current->nextEndpoint(); 00541 } 00542 00543 // modify tail 00544 switch (current->getType()) { 00545 case BULK_ENDPOINT: 00546 tailBulkEndpoint = prec; 00547 break; 00548 case INTERRUPT_ENDPOINT: 00549 tailInterruptEndpoint = prec; 00550 break; 00551 default: 00552 break; 00553 } 00554 } 00555 current->setState(USB_TYPE_FREE); 00556 return; 00557 } 00558 prec = current; 00559 current = current->nextEndpoint(); 00560 } 00561 } 00562 #endif 00563 } 00564 00565 00566 USBDeviceConnected * USBHost::getDevice(uint8_t index) 00567 { 00568 if ((index >= MAX_DEVICE_CONNECTED) || (!deviceInUse[index])) { 00569 return NULL; 00570 } 00571 return (USBDeviceConnected*)&devices[index]; 00572 } 00573 00574 // create an USBEndpoint descriptor. the USBEndpoint is not linked 00575 USBEndpoint * USBHost::newEndpoint(ENDPOINT_TYPE type, ENDPOINT_DIRECTION dir, uint32_t size, uint8_t addr) 00576 { 00577 int i = 0; 00578 HCED * ed = (HCED *)getED(); 00579 HCTD* td_list[2] = { (HCTD*)getTD(), (HCTD*)getTD() }; 00580 00581 memset((void *)td_list[0], 0x00, sizeof(HCTD)); 00582 memset((void *)td_list[1], 0x00, sizeof(HCTD)); 00583 00584 // search a free USBEndpoint 00585 for (i = 0; i < MAX_ENDPOINT; i++) { 00586 if (endpoints[i].getState() == USB_TYPE_FREE) { 00587 endpoints[i].init(ed, type, dir, size, addr, td_list); 00588 USB_DBG("USBEndpoint created (%p): type: %d, dir: %d, size: %d, addr: %d, state: %s", &endpoints[i], type, dir, size, addr, endpoints[i].getStateString()); 00589 return &endpoints[i]; 00590 } 00591 } 00592 USB_ERR("could not allocate more endpoints!!!!"); 00593 return NULL; 00594 } 00595 00596 00597 USB_TYPE USBHost::resetDevice(USBDeviceConnected * dev) 00598 { 00599 int index = findDevice(dev); 00600 if (index != -1) { 00601 USB_DBG("Resetting hub %d, port %d\n", dev->getHub(), dev->getPort()); 00602 Thread::wait(100); 00603 if (dev->getHub() == 0) { 00604 resetRootHub(); 00605 } 00606 #if MAX_HUB_NB 00607 else { 00608 dev->getHubParent()->portReset(dev->getPort()); 00609 } 00610 #endif 00611 Thread::wait(100); 00612 deviceReset[index] = true; 00613 return USB_TYPE_OK; 00614 } 00615 00616 return USB_TYPE_ERROR; 00617 } 00618 00619 // link the USBEndpoint to the linked list and attach an USBEndpoint to a device 00620 bool USBHost::addEndpoint(USBDeviceConnected * dev, uint8_t intf_nb, USBEndpoint * ep) 00621 { 00622 00623 if (ep == NULL) { 00624 return false; 00625 } 00626 00627 #ifndef USBHOST_OTHER 00628 HCED * prevEd; 00629 00630 #endif 00631 // set device address in the USBEndpoint descriptor 00632 if (dev == NULL) { 00633 ep->setDeviceAddress(0); 00634 } else { 00635 ep->setDeviceAddress(dev->getAddress()); 00636 } 00637 00638 if ((dev != NULL) && dev->getSpeed()) { 00639 ep->setSpeed(dev->getSpeed()); 00640 } 00641 00642 ep->setIntfNb(intf_nb); 00643 00644 #ifndef USBHOST_OTHER 00645 // queue the new USBEndpoint on the ED list 00646 switch (ep->getType()) { 00647 00648 case CONTROL_ENDPOINT: 00649 prevEd = ( HCED*) controlHeadED(); 00650 if (!prevEd) { 00651 updateControlHeadED((uint32_t) ep->getHCED()); 00652 USB_DBG_TRANSFER("First control USBEndpoint: %08X", (uint32_t) ep->getHCED()); 00653 headControlEndpoint = ep; 00654 tailControlEndpoint = ep; 00655 return true; 00656 } 00657 tailControlEndpoint->queueEndpoint(ep); 00658 tailControlEndpoint = ep; 00659 return true; 00660 00661 case BULK_ENDPOINT: 00662 prevEd = ( HCED*) bulkHeadED(); 00663 if (!prevEd) { 00664 updateBulkHeadED((uint32_t) ep->getHCED()); 00665 USB_DBG_TRANSFER("First bulk USBEndpoint: %08X\r\n", (uint32_t) ep->getHCED()); 00666 headBulkEndpoint = ep; 00667 tailBulkEndpoint = ep; 00668 break; 00669 } 00670 USB_DBG_TRANSFER("Queue BULK Ed %p after %p\r\n",ep->getHCED(), prevEd); 00671 tailBulkEndpoint->queueEndpoint(ep); 00672 tailBulkEndpoint = ep; 00673 break; 00674 00675 case INTERRUPT_ENDPOINT: 00676 prevEd = ( HCED*) interruptHeadED(); 00677 if (!prevEd) { 00678 updateInterruptHeadED((uint32_t) ep->getHCED()); 00679 USB_DBG_TRANSFER("First interrupt USBEndpoint: %08X\r\n", (uint32_t) ep->getHCED()); 00680 headInterruptEndpoint = ep; 00681 tailInterruptEndpoint = ep; 00682 break; 00683 } 00684 USB_DBG_TRANSFER("Queue INTERRUPT Ed %p after %p\r\n",ep->getHCED(), prevEd); 00685 tailInterruptEndpoint->queueEndpoint(ep); 00686 tailInterruptEndpoint = ep; 00687 break; 00688 default: 00689 return false; 00690 } 00691 00692 #endif 00693 ep->dev = dev; 00694 dev->addEndpoint(intf_nb, ep); 00695 00696 return true; 00697 } 00698 00699 00700 int USBHost::findDevice(USBDeviceConnected * dev) 00701 { 00702 for (int i = 0; i < MAX_DEVICE_CONNECTED; i++) { 00703 if (dev == &devices[i]) { 00704 return i; 00705 } 00706 } 00707 return -1; 00708 } 00709 00710 int USBHost::findDevice(uint8_t hub, uint8_t port, USBHostHub * hub_parent) 00711 { 00712 for (int i = 0; i < MAX_DEVICE_CONNECTED; i++) { 00713 if (devices[i].getHub() == hub && devices[i].getPort() == port) { 00714 if (hub_parent != NULL) { 00715 if (hub_parent == devices[i].getHubParent()) { 00716 return i; 00717 } 00718 } else { 00719 return i; 00720 } 00721 } 00722 } 00723 return -1; 00724 } 00725 00726 void USBHost::printList(ENDPOINT_TYPE type) 00727 { 00728 #if defined(DEBUG_EP_STATE) && !defined(USBHOST_OTHER) 00729 volatile HCED * hced; 00730 switch(type) { 00731 case CONTROL_ENDPOINT: 00732 hced = (HCED *)controlHeadED(); 00733 break; 00734 case BULK_ENDPOINT: 00735 hced = (HCED *)bulkHeadED(); 00736 break; 00737 case INTERRUPT_ENDPOINT: 00738 hced = (HCED *)interruptHeadED(); 00739 break; 00740 } 00741 volatile HCTD * hctd = NULL; 00742 const char * type_str = (type == BULK_ENDPOINT) ? "BULK" : 00743 ((type == INTERRUPT_ENDPOINT) ? "INTERRUPT" : 00744 ((type == CONTROL_ENDPOINT) ? "CONTROL" : "ISOCHRONOUS")); 00745 printf("State of %s:\r\n", type_str); 00746 while (hced != NULL) { 00747 uint8_t dir = ((hced->control & (3 << 11)) >> 11); 00748 printf("hced: %p [ADDR: %d, DIR: %s, EP_NB: 0x%X]\r\n", hced, 00749 hced->control & 0x7f, 00750 (dir == 1) ? "OUT" : ((dir == 0) ? "FROM_TD":"IN"), 00751 (hced->control & (0xf << 7)) >> 7); 00752 hctd = (HCTD *)((uint32_t)(hced->headTD) & ~(0xf)); 00753 while (hctd != hced->tailTD) { 00754 printf("\thctd: %p [DIR: %s]\r\n", hctd, ((hctd->control & (3 << 19)) >> 19) == 1 ? "OUT" : "IN"); 00755 hctd = hctd->nextTD; 00756 } 00757 printf("\thctd: %p\r\n", hctd); 00758 hced = hced->nextED; 00759 } 00760 printf("\r\n\r\n"); 00761 #endif 00762 } 00763 00764 00765 // add a transfer on the TD linked list 00766 USB_TYPE USBHost::addTransfer(USBEndpoint * ed, uint8_t * buf, uint32_t len) 00767 { 00768 USB_TYPE ret=USB_TYPE_PROCESSING; 00769 td_mutex.lock(); 00770 00771 // allocate a TD which will be freed in TDcompletion 00772 volatile HCTD * td = ed->getNextTD(); 00773 if (td == NULL) { 00774 return USB_TYPE_ERROR; 00775 } 00776 00777 #ifndef USBHOST_OTHER 00778 uint32_t token = (ed->isSetup() ? TD_SETUP : ( (ed->getDir() == IN) ? TD_IN : TD_OUT )); 00779 00780 uint32_t td_toggle; 00781 00782 if (ed->getType() == CONTROL_ENDPOINT) { 00783 if (ed->isSetup()) { 00784 td_toggle = TD_TOGGLE_0; 00785 } else { 00786 td_toggle = TD_TOGGLE_1; 00787 } 00788 } else { 00789 td_toggle = 0; 00790 } 00791 00792 td->control = (TD_ROUNDING | token | TD_DELAY_INT(0) | td_toggle | TD_CC); 00793 td->currBufPtr = buf; 00794 td->bufEnd = (buf + (len - 1)); 00795 00796 ENDPOINT_TYPE type = ed->getType(); 00797 00798 disableList(type); 00799 ed->queueTransfer(); 00800 printList(type); 00801 enableList(type); 00802 #else 00803 /* call method specific for endpoint */ 00804 td->currBufPtr = buf; 00805 td->size = len; 00806 ret = ed->queueTransfer(); 00807 #endif 00808 00809 td_mutex.unlock(); 00810 00811 return ret; 00812 } 00813 00814 00815 00816 USB_TYPE USBHost::getDeviceDescriptor(USBDeviceConnected * dev, uint8_t * buf, uint16_t max_len_buf, uint16_t * len_dev_descr) 00817 { 00818 USB_TYPE t = controlRead( dev, 00819 USB_DEVICE_TO_HOST | USB_RECIPIENT_DEVICE, 00820 GET_DESCRIPTOR, 00821 (DEVICE_DESCRIPTOR << 8) | (0), 00822 0, buf, MIN(DEVICE_DESCRIPTOR_LENGTH, max_len_buf)); 00823 if (len_dev_descr) { 00824 *len_dev_descr = MIN(DEVICE_DESCRIPTOR_LENGTH, max_len_buf); 00825 } 00826 00827 return t; 00828 } 00829 00830 USB_TYPE USBHost::getConfigurationDescriptor(USBDeviceConnected * dev, uint8_t * buf, uint16_t max_len_buf, uint16_t * len_conf_descr) 00831 { 00832 USB_TYPE res; 00833 uint16_t total_conf_descr_length = 0; 00834 00835 // fourth step: get the beginning of the configuration descriptor to have the total length of the conf descr 00836 res = controlRead( dev, 00837 USB_DEVICE_TO_HOST | USB_RECIPIENT_DEVICE, 00838 GET_DESCRIPTOR, 00839 (CONFIGURATION_DESCRIPTOR << 8) | (0), 00840 0, buf, CONFIGURATION_DESCRIPTOR_LENGTH); 00841 00842 if (res != USB_TYPE_OK) { 00843 USB_ERR("GET CONF 1 DESCR FAILED"); 00844 return res; 00845 } 00846 total_conf_descr_length = buf[2] | (buf[3] << 8); 00847 total_conf_descr_length = MIN(max_len_buf, total_conf_descr_length); 00848 00849 if (len_conf_descr) { 00850 *len_conf_descr = total_conf_descr_length; 00851 } 00852 00853 USB_DBG("TOTAL_LENGTH: %d \t NUM_INTERF: %d", total_conf_descr_length, buf[4]); 00854 00855 return controlRead( dev, 00856 USB_DEVICE_TO_HOST | USB_RECIPIENT_DEVICE, 00857 GET_DESCRIPTOR, 00858 (CONFIGURATION_DESCRIPTOR << 8) | (0), 00859 0, buf, total_conf_descr_length); 00860 } 00861 00862 00863 USB_TYPE USBHost::setAddress(USBDeviceConnected * dev, uint8_t address) 00864 { 00865 return controlWrite( dev, 00866 USB_HOST_TO_DEVICE | USB_RECIPIENT_DEVICE, 00867 SET_ADDRESS, 00868 address, 00869 0, NULL, 0); 00870 00871 } 00872 00873 USB_TYPE USBHost::setConfiguration(USBDeviceConnected * dev, uint8_t conf) 00874 { 00875 return controlWrite( dev, 00876 USB_HOST_TO_DEVICE | USB_RECIPIENT_DEVICE, 00877 SET_CONFIGURATION, 00878 conf, 00879 0, NULL, 0); 00880 } 00881 00882 uint8_t USBHost::numberDriverAttached(USBDeviceConnected * dev) 00883 { 00884 int index = findDevice(dev); 00885 uint8_t cnt = 0; 00886 if (index == -1) { 00887 return 0; 00888 } 00889 for (uint8_t i = 0; i < MAX_INTF; i++) { 00890 if (deviceAttachedDriver[index][i]) { 00891 cnt++; 00892 } 00893 } 00894 return cnt; 00895 } 00896 00897 // enumerate a device with the control USBEndpoint 00898 USB_TYPE USBHost::enumerate(USBDeviceConnected * dev, IUSBEnumerator* pEnumerator) 00899 { 00900 uint16_t total_conf_descr_length = 0; 00901 USB_TYPE res; 00902 00903 do { 00904 Lock lock(this); 00905 00906 // don't enumerate a device which all interfaces are registered to a specific driver 00907 int index = findDevice(dev); 00908 00909 if (index == -1) { 00910 return USB_TYPE_ERROR; 00911 } 00912 00913 uint8_t nb_intf_attached = numberDriverAttached(dev); 00914 USB_DBG("dev: %p nb_intf: %d", dev, dev->getNbIntf()); 00915 USB_DBG("dev: %p nb_intf_attached: %d", dev, nb_intf_attached); 00916 if ((nb_intf_attached != 0) && (dev->getNbIntf() == nb_intf_attached)) { 00917 USB_DBG("Don't enumerate dev: %p because all intf are registered with a driver", dev); 00918 return USB_TYPE_OK; 00919 } 00920 00921 USB_DBG("Enumerate dev: %p", dev); 00922 00923 // third step: get the whole device descriptor to see vid, pid 00924 res = getDeviceDescriptor(dev, data, DEVICE_DESCRIPTOR_LENGTH); 00925 00926 if (res != USB_TYPE_OK) { 00927 USB_DBG("GET DEV DESCR FAILED"); 00928 return res; 00929 } 00930 00931 dev->setClass(data[4]); 00932 dev->setSubClass(data[5]); 00933 dev->setProtocol(data[6]); 00934 dev->setVid(data[8] | (data[9] << 8)); 00935 dev->setPid(data[10] | (data[11] << 8)); 00936 USB_DBG("CLASS: %02X \t VID: %04X \t PID: %04X", data[4], data[8] | (data[9] << 8), data[10] | (data[11] << 8)); 00937 00938 pEnumerator->setVidPid( data[8] | (data[9] << 8), data[10] | (data[11] << 8) ); 00939 00940 res = getConfigurationDescriptor(dev, data, sizeof(data), &total_conf_descr_length); 00941 if (res != USB_TYPE_OK) { 00942 return res; 00943 } 00944 00945 #if (DEBUG > 3) 00946 USB_DBG("CONFIGURATION DESCRIPTOR:\r\n"); 00947 for (int i = 0; i < total_conf_descr_length; i++) { 00948 printf("%02X ", data[i]); 00949 } 00950 printf("\r\n\r\n"); 00951 #endif 00952 00953 // Parse the configuration descriptor 00954 parseConfDescr(dev, data, total_conf_descr_length, pEnumerator); 00955 00956 // only set configuration if not enumerated before 00957 if (!dev->isEnumerated()) { 00958 00959 USB_DBG("Set configuration 1 on dev: %p", dev); 00960 // sixth step: set configuration (only 1 supported) 00961 res = setConfiguration(dev, 1); 00962 00963 if (res != USB_TYPE_OK) { 00964 USB_DBG("SET CONF FAILED"); 00965 return res; 00966 } 00967 } 00968 00969 dev->setEnumerated(); 00970 00971 // Now the device is enumerated! 00972 USB_DBG("dev %p is enumerated\r\n", dev); 00973 00974 } while(0); 00975 00976 // Some devices may require this delay 00977 Thread::wait(100); 00978 00979 return USB_TYPE_OK; 00980 } 00981 // this method fills the USBDeviceConnected object: class,.... . It also add endpoints found in the descriptor. 00982 void USBHost::parseConfDescr(USBDeviceConnected * dev, uint8_t * conf_descr, uint32_t len, IUSBEnumerator* pEnumerator) 00983 { 00984 uint32_t index = 0; 00985 uint32_t len_desc = 0; 00986 uint8_t id = 0; 00987 int nb_endpoints_used = 0; 00988 USBEndpoint * ep = NULL; 00989 uint8_t intf_nb = 0; 00990 bool parsing_intf = false; 00991 uint8_t current_intf = 0; 00992 00993 while (index < len) { 00994 len_desc = conf_descr[index]; 00995 id = conf_descr[index+1]; 00996 switch (id) { 00997 case CONFIGURATION_DESCRIPTOR: 00998 USB_DBG("dev: %p has %d intf", dev, conf_descr[4]); 00999 dev->setNbIntf(conf_descr[4]); 01000 break; 01001 case INTERFACE_DESCRIPTOR: 01002 if(pEnumerator->parseInterface(conf_descr[index + 2], conf_descr[index + 5], conf_descr[index + 6], conf_descr[index + 7])) { 01003 if (intf_nb++ <= MAX_INTF) { 01004 current_intf = conf_descr[index + 2]; 01005 dev->addInterface(current_intf, conf_descr[index + 5], conf_descr[index + 6], conf_descr[index + 7]); 01006 nb_endpoints_used = 0; 01007 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]); 01008 } else { 01009 USB_DBG("Drop intf..."); 01010 } 01011 parsing_intf = true; 01012 } else { 01013 parsing_intf = false; 01014 } 01015 break; 01016 case ENDPOINT_DESCRIPTOR: 01017 if (parsing_intf && (intf_nb <= MAX_INTF) ) { 01018 if (nb_endpoints_used < MAX_ENDPOINT_PER_INTERFACE) { 01019 if( pEnumerator->useEndpoint(current_intf, (ENDPOINT_TYPE)(conf_descr[index + 3] & 0x03), (ENDPOINT_DIRECTION)((conf_descr[index + 2] >> 7) + 1)) ) { 01020 // if the USBEndpoint is isochronous -> skip it (TODO: fix this) 01021 if ((conf_descr[index + 3] & 0x03) != ISOCHRONOUS_ENDPOINT) { 01022 ep = newEndpoint((ENDPOINT_TYPE)(conf_descr[index+3] & 0x03), 01023 (ENDPOINT_DIRECTION)((conf_descr[index + 2] >> 7) + 1), 01024 conf_descr[index + 4] | (conf_descr[index + 5] << 8), 01025 conf_descr[index + 2] & 0x0f); 01026 USB_DBG("ADD USBEndpoint %p, on interf %d on device %p", ep, current_intf, dev); 01027 if (ep != NULL && dev != NULL) { 01028 addEndpoint(dev, current_intf, ep); 01029 } else { 01030 USB_DBG("EP NULL"); 01031 } 01032 nb_endpoints_used++; 01033 } else { 01034 USB_DBG("ISO USBEndpoint NOT SUPPORTED"); 01035 } 01036 } 01037 } 01038 } 01039 break; 01040 case HID_DESCRIPTOR: 01041 lenReportDescr = conf_descr[index + 7] | (conf_descr[index + 8] << 8); 01042 break; 01043 default: 01044 break; 01045 } 01046 index += len_desc; 01047 } 01048 } 01049 01050 01051 USB_TYPE USBHost::bulkWrite(USBDeviceConnected * dev, USBEndpoint * ep, uint8_t * buf, uint32_t len, bool blocking) 01052 { 01053 return generalTransfer(dev, ep, buf, len, blocking, BULK_ENDPOINT, true); 01054 } 01055 01056 USB_TYPE USBHost::bulkRead(USBDeviceConnected * dev, USBEndpoint * ep, uint8_t * buf, uint32_t len, bool blocking) 01057 { 01058 return generalTransfer(dev, ep, buf, len, blocking, BULK_ENDPOINT, false); 01059 } 01060 01061 USB_TYPE USBHost::interruptWrite(USBDeviceConnected * dev, USBEndpoint * ep, uint8_t * buf, uint32_t len, bool blocking) 01062 { 01063 return generalTransfer(dev, ep, buf, len, blocking, INTERRUPT_ENDPOINT, true); 01064 } 01065 01066 USB_TYPE USBHost::interruptRead(USBDeviceConnected * dev, USBEndpoint * ep, uint8_t * buf, uint32_t len, bool blocking) 01067 { 01068 return generalTransfer(dev, ep, buf, len, blocking, INTERRUPT_ENDPOINT, false); 01069 } 01070 01071 USB_TYPE USBHost::generalTransfer(USBDeviceConnected * dev, USBEndpoint * ep, uint8_t * buf, uint32_t len, bool blocking, ENDPOINT_TYPE type, bool write) 01072 { 01073 01074 #if DEBUG_TRANSFER 01075 const char * type_str = (type == BULK_ENDPOINT) ? "BULK" : ((type == INTERRUPT_ENDPOINT) ? "INTERRUPT" : "ISOCHRONOUS"); 01076 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()); 01077 #endif 01078 01079 Lock lock(this); 01080 01081 USB_TYPE res; 01082 ENDPOINT_DIRECTION dir = (write) ? OUT : IN; 01083 01084 if (dev == NULL) { 01085 USB_ERR("dev NULL"); 01086 return USB_TYPE_ERROR; 01087 } 01088 01089 if (ep == NULL) { 01090 USB_ERR("ep NULL"); 01091 return USB_TYPE_ERROR; 01092 } 01093 01094 if (ep->getState() != USB_TYPE_IDLE) { 01095 USB_WARN("[ep: %p - dev: %p - %s] NOT IDLE: %s", ep, ep->dev, ep->dev->getName(ep->getIntfNb()), ep->getStateString()); 01096 return ep->getState(); 01097 } 01098 01099 if ((ep->getDir() != dir) || (ep->getType() != type)) { 01100 USB_ERR("[ep: %p - dev: %p] wrong dir or bad USBEndpoint type", ep, ep->dev); 01101 return USB_TYPE_ERROR; 01102 } 01103 01104 if (dev->getAddress() != ep->getDeviceAddress()) { 01105 USB_ERR("[ep: %p - dev: %p] USBEndpoint addr and device addr don't match", ep, ep->dev); 01106 return USB_TYPE_ERROR; 01107 } 01108 01109 #if DEBUG_TRANSFER 01110 if (write) { 01111 USB_DBG_TRANSFER("%s WRITE buffer", type_str); 01112 for (int i = 0; i < ep->getLengthTransferred(); i++) { 01113 printf("%02X ", buf[i]); 01114 } 01115 printf("\r\n\r\n"); 01116 } 01117 #endif 01118 res = addTransfer(ep, buf, len); 01119 01120 if ((blocking)&& (res == USB_TYPE_PROCESSING)) { 01121 #ifdef USBHOST_OTHER 01122 osEvent event = ep->ep_queue.get(TD_TIMEOUT); 01123 if (event.status == osEventTimeout) { 01124 /* control endpoint is confusing for merge on b */ 01125 disableList(CONTROL_ENDPOINT); 01126 ep->setState(USB_TYPE_ERROR); 01127 ep->ep_queue.get(0); 01128 ep->unqueueTransfer(ep->getProcessedTD()); 01129 enableList(CONTROL_ENDPOINT); 01130 } 01131 #else 01132 ep->ep_queue.get(); 01133 #endif 01134 res = ep->getState(); 01135 01136 USB_DBG_TRANSFER("%s TRANSFER res: %s on ep: %p\r\n", type_str, ep->getStateString(), ep); 01137 01138 if (res != USB_TYPE_IDLE) { 01139 return res; 01140 } 01141 01142 return USB_TYPE_OK; 01143 } 01144 01145 return res; 01146 01147 } 01148 01149 01150 USB_TYPE USBHost::controlRead(USBDeviceConnected * dev, uint8_t requestType, uint8_t request, uint32_t value, uint32_t index, uint8_t * buf, uint32_t len) 01151 { 01152 return controlTransfer(dev, requestType, request, value, index, buf, len, false); 01153 } 01154 01155 USB_TYPE USBHost::controlWrite(USBDeviceConnected * dev, uint8_t requestType, uint8_t request, uint32_t value, uint32_t index, uint8_t * buf, uint32_t len) 01156 { 01157 return controlTransfer(dev, requestType, request, value, index, buf, len, true); 01158 } 01159 01160 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) 01161 { 01162 Lock lock(this); 01163 USB_DBG_TRANSFER("----- CONTROL %s [dev: %p - hub: %d - port: %d] ------", (write) ? "WRITE" : "READ", dev, dev->getHub(), dev->getPort()); 01164 01165 int length_transfer = len; 01166 USB_TYPE res; 01167 uint32_t token; 01168 01169 control->setSpeed(dev->getSpeed()); 01170 control->setSize(dev->getSizeControlEndpoint()); 01171 if (dev->isActiveAddress()) { 01172 control->setDeviceAddress(dev->getAddress()); 01173 } else { 01174 control->setDeviceAddress(0); 01175 } 01176 01177 USB_DBG_TRANSFER("Control transfer on device: %d\r\n", control->getDeviceAddress()); 01178 fillControlBuf(requestType, request, value, index, len); 01179 01180 #if DEBUG_TRANSFER 01181 USB_DBG_TRANSFER("SETUP PACKET: "); 01182 for (int i = 0; i < 8; i++) { 01183 printf("%01X ", setupPacket[i]); 01184 } 01185 printf("\r\n"); 01186 #endif 01187 01188 control->setNextToken(TD_SETUP); 01189 res = addTransfer(control, (uint8_t*)setupPacket, 8); 01190 01191 if (res == USB_TYPE_PROCESSING) 01192 #ifdef USBHOST_OTHER 01193 { 01194 osEvent event = control->ep_queue.get(TD_TIMEOUT_CTRL); 01195 if (event.status == osEventTimeout) { 01196 disableList(CONTROL_ENDPOINT); 01197 control->setState(USB_TYPE_ERROR); 01198 control->ep_queue.get(0); 01199 control->unqueueTransfer(control->getProcessedTD()); 01200 enableList(CONTROL_ENDPOINT); 01201 } 01202 } 01203 #else 01204 control->ep_queue.get(); 01205 #endif 01206 res = control->getState(); 01207 01208 USB_DBG_TRANSFER("CONTROL setup stage %s", control->getStateString()); 01209 01210 if (res != USB_TYPE_IDLE) { 01211 return res; 01212 } 01213 01214 if (length_transfer) { 01215 token = (write) ? TD_OUT : TD_IN; 01216 control->setNextToken(token); 01217 res = addTransfer(control, (uint8_t *)buf, length_transfer); 01218 01219 if (res == USB_TYPE_PROCESSING) 01220 #ifdef USBHOST_OTHER 01221 { 01222 osEvent event = control->ep_queue.get(TD_TIMEOUT_CTRL); 01223 if (event.status == osEventTimeout) { 01224 disableList(CONTROL_ENDPOINT); 01225 control->setState(USB_TYPE_ERROR); 01226 control->ep_queue.get(0); 01227 control->unqueueTransfer(control->getProcessedTD()); 01228 enableList(CONTROL_ENDPOINT); 01229 } 01230 } 01231 #else 01232 control->ep_queue.get(); 01233 #endif 01234 res = control->getState(); 01235 01236 #if DEBUG_TRANSFER 01237 USB_DBG_TRANSFER("CONTROL %s stage %s", (write) ? "WRITE" : "READ", control->getStateString()); 01238 if (write) { 01239 USB_DBG_TRANSFER("CONTROL WRITE buffer"); 01240 for (int i = 0; i < control->getLengthTransferred(); i++) { 01241 printf("%02X ", buf[i]); 01242 } 01243 printf("\r\n\r\n"); 01244 } else { 01245 USB_DBG_TRANSFER("CONTROL READ SUCCESS [%d bytes transferred]", control->getLengthTransferred()); 01246 for (int i = 0; i < control->getLengthTransferred(); i++) { 01247 printf("%02X ", buf[i]); 01248 } 01249 printf("\r\n\r\n"); 01250 } 01251 #endif 01252 01253 if (res != USB_TYPE_IDLE) { 01254 return res; 01255 } 01256 } 01257 01258 token = (write) ? TD_IN : TD_OUT; 01259 control->setNextToken(token); 01260 res = addTransfer(control, NULL, 0); 01261 if (res == USB_TYPE_PROCESSING) 01262 #ifdef USBHOST_OTHER 01263 { 01264 osEvent event = control->ep_queue.get(TD_TIMEOUT_CTRL); 01265 if (event.status == osEventTimeout) { 01266 disableList(CONTROL_ENDPOINT); 01267 control->setState(USB_TYPE_ERROR); 01268 control->ep_queue.get(0); 01269 control->unqueueTransfer(control->getProcessedTD()); 01270 enableList(CONTROL_ENDPOINT); 01271 } 01272 } 01273 #else 01274 control->ep_queue.get(); 01275 #endif 01276 res = control->getState(); 01277 01278 USB_DBG_TRANSFER("CONTROL ack stage %s", control->getStateString()); 01279 01280 if (res != USB_TYPE_IDLE) { 01281 return res; 01282 } 01283 01284 return USB_TYPE_OK; 01285 } 01286 01287 01288 void USBHost::fillControlBuf(uint8_t requestType, uint8_t request, uint16_t value, uint16_t index, int len) 01289 { 01290 setupPacket[0] = requestType; 01291 setupPacket[1] = request; 01292 setupPacket[2] = (uint8_t) value; 01293 setupPacket[3] = (uint8_t) (value >> 8); 01294 setupPacket[4] = (uint8_t) index; 01295 setupPacket[5] = (uint8_t) (index >> 8); 01296 setupPacket[6] = (uint8_t) len; 01297 setupPacket[7] = (uint8_t) (len >> 8); 01298 }
Generated on Tue Jul 12 2022 13:25:19 by
1.7.2