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