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 #include "USBHost.h"
00018 
00019 #define USB_TRACE1(A) while(0)
00020 #undef USB_TEST_ASSERT
00021 void usb_test_assert_internal(const char *expr, const char *file, int line);
00022 #define USB_TEST_ASSERT(EXPR) while(!(EXPR)){usb_test_assert_internal(#EXPR,__FILE__,__LINE__);}
00023 
00024 USBHost* USBHost::inst_0 = NULL;
00025 USBHost* USBHost::inst_1 = NULL;
00026 
00027 USBHost* USBHost::getHostInst(int IF_Number) {
00028     if (IF_Number==0)
00029     {
00030     if (inst_0 == NULL) {
00031         inst_0 = new USBHost(IF_Number);
00032         inst_0->init();
00033     }
00034     return inst_0;
00035     }
00036     else
00037     {
00038     if (inst_1 == NULL) {
00039         inst_1 = new USBHost(IF_Number);
00040         inst_1->init();
00041     }
00042     return inst_1;
00043     }
00044 
00045 }
00046 
00047 void USBHost::poll()
00048 {
00049     if (inst_0) {
00050         inst_0->task();
00051     }
00052     if (inst_1) {
00053         inst_1->task();
00054     }
00055 }
00056 
00057 USBHost::USBHost(int InterfaceNumber):USBHALHost(InterfaceNumber) {
00058 
00059 }
00060 
00061 /* virtual */ bool USBHost::addDevice(USBDeviceConnected* parent, int port, bool lowSpeed) {
00062     USBDeviceConnected* dev = new USBDeviceConnected;
00063     USBEndpoint* ep = new USBEndpoint(dev);
00064     dev->init(0, port, lowSpeed);
00065     dev->setAddress(0);
00066     dev->setEpCtl(ep);
00067     uint8_t desc[18];
00068     wait_ms(100);
00069 
00070     int rc = controlRead(dev, 0x80, GET_DESCRIPTOR, 1<<8, 0, desc, 8);
00071     USB_TEST_ASSERT(rc == USB_TYPE_OK);
00072     if (rc != USB_TYPE_OK) {
00073         USB_ERR("ADD DEVICE FAILD");
00074     }
00075     USB_DBG_HEX(desc, 8);
00076     DeviceDescriptor* dev_desc = reinterpret_cast<DeviceDescriptor*>(desc);
00077     ep->setSize(dev_desc->bMaxPacketSize);
00078 
00079     int new_addr = USBDeviceConnected::getNewAddress();
00080     rc = controlWrite(dev, 0x00, SET_ADDRESS, new_addr, 0, NULL, 0);
00081     USB_TEST_ASSERT(rc == USB_TYPE_OK);
00082     dev->setAddress(new_addr);
00083     wait_ms(100);
00084 
00085     rc = controlRead(dev, 0x80, GET_DESCRIPTOR, 1<<8, 0, desc, sizeof(desc));
00086     USB_TEST_ASSERT(rc == USB_TYPE_OK);
00087     USB_DBG_HEX(desc, sizeof(desc));
00088 
00089     dev->setVid(dev_desc->idVendor);
00090     dev->setPid(dev_desc->idProduct);
00091     dev->setClass(dev_desc->bDeviceClass);
00092     USB_INFO("parent:%p port:%d speed:%s VID:%04x PID:%04x class:%02x addr:%d",
00093         parent, port, (lowSpeed ? "low " : "full"), dev->getVid(), dev->getPid(), dev->getClass(),
00094         dev->getAddress());
00095 
00096     DeviceLists.push_back(dev);
00097 
00098     if (dev->getClass() == HUB_CLASS) {
00099         const int config = 1;
00100         int rc = controlWrite(dev, 0x00, SET_CONFIGURATION, config, 0, NULL, 0);
00101         USB_TEST_ASSERT(rc == USB_TYPE_OK);
00102         wait_ms(100);
00103         Hub(dev);
00104     }
00105     return true;
00106 }
00107 
00108 // enumerate a device with the control USBEndpoint
00109 USB_TYPE USBHost::enumerate(USBDeviceConnected * dev, IUSBEnumerator* pEnumerator)
00110 {
00111     if (dev->getClass() == HUB_CLASS) { // skip hub class
00112         return USB_TYPE_OK;
00113     }
00114     uint8_t desc[18];
00115     USB_TYPE rc = controlRead(dev, 0x80, GET_DESCRIPTOR, 1<<8, 0, desc, sizeof(desc));
00116     USB_TEST_ASSERT(rc == USB_TYPE_OK);
00117     USB_DBG_HEX(desc, sizeof(desc));
00118     if (rc != USB_TYPE_OK) {
00119         return rc;
00120     }
00121     DeviceDescriptor* dev_desc = reinterpret_cast<DeviceDescriptor*>(desc);
00122     dev->setClass(dev_desc->bDeviceClass);
00123     pEnumerator->setVidPid(dev->getVid(), dev->getPid());
00124 
00125     rc = controlRead(dev, 0x80, GET_DESCRIPTOR, 2<<8, 0, desc, 4);
00126     USB_TEST_ASSERT(rc == USB_TYPE_OK);
00127     USB_DBG_HEX(desc, 4);
00128 
00129     int TotalLength = desc[2]|desc[3]<<8;
00130     uint8_t* buf = new uint8_t[TotalLength];
00131     rc = controlRead(dev, 0x80, GET_DESCRIPTOR, 2<<8, 0, buf, TotalLength);
00132     USB_TEST_ASSERT(rc == USB_TYPE_OK);
00133     //USB_DBG_HEX(buf, TotalLength);
00134 
00135     // Parse the configuration descriptor
00136     parseConfDescr(dev, buf, TotalLength, pEnumerator);
00137     delete[] buf;
00138     // only set configuration if not enumerated before
00139     if (!dev->isEnumerated()) {
00140         USB_DBG("Set configuration 1 on dev: %p", dev);
00141         // sixth step: set configuration (only 1 supported)
00142         int config = 1;
00143         USB_TYPE res = controlWrite(dev, 0x00, SET_CONFIGURATION, config, 0, NULL, 0);
00144         if (res != USB_TYPE_OK) {
00145             USB_ERR("SET CONF FAILED");
00146             return res;
00147         }
00148         // Some devices may require this delay
00149         wait_ms(100);
00150         dev->setEnumerated();
00151         // Now the device is enumerated!
00152         USB_DBG("dev %p is enumerated", dev);
00153     }
00154     return USB_TYPE_OK;
00155 }
00156 
00157 // this method fills the USBDeviceConnected object: class,.... . It also add endpoints found in the descriptor.
00158 void USBHost::parseConfDescr(USBDeviceConnected * dev, uint8_t * conf_descr, uint32_t len, IUSBEnumerator* pEnumerator)
00159 {
00160     uint32_t index = 0;
00161     uint32_t len_desc = 0;
00162     uint8_t id = 0;
00163     USBEndpoint * ep = NULL;
00164     uint8_t intf_nb = 0;
00165     bool parsing_intf = false;
00166     uint8_t current_intf = 0;
00167     EndpointDescriptor* ep_desc;
00168     int epsetup;
00169 
00170     while (index < len) {
00171         len_desc = conf_descr[index];
00172         id = conf_descr[index+1];
00173         USB_DBG_HEX(conf_descr+index, len_desc);
00174         switch (id) {
00175             case CONFIGURATION_DESCRIPTOR:
00176                 USB_DBG("dev: %p has %d intf", dev, conf_descr[4]);
00177                 dev->setNbIntf(conf_descr[4]);
00178                 break;
00179             case INTERFACE_DESCRIPTOR:
00180                 if(pEnumerator->parseInterface(conf_descr[index + 2], conf_descr[index + 5], conf_descr[index + 6], conf_descr[index + 7])) {
00181                     intf_nb++;
00182                     current_intf = conf_descr[index + 2];
00183                     dev->addInterface(current_intf, conf_descr[index + 5], conf_descr[index + 6], conf_descr[index + 7]);
00184                     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]);
00185                     parsing_intf = true;
00186                 } else {
00187                     parsing_intf = false;
00188                 }
00189                 break;
00190             case ENDPOINT_DESCRIPTOR:
00191                 ep_desc = reinterpret_cast<EndpointDescriptor*>(conf_descr+index);
00192                 if (parsing_intf && (intf_nb <= MAX_INTF) ) {
00193                     ENDPOINT_TYPE type = (ENDPOINT_TYPE)(ep_desc->bmAttributes & 0x03);
00194                     ENDPOINT_DIRECTION dir = (ep_desc->bEndpointAddress & 0x80) ? IN : OUT;
00195                     if(pEnumerator->useEndpoint(current_intf, type, dir)) {
00196                         ep = new USBEndpoint(dev);
00197                         ep->init(type, dir, ep_desc->wMaxPacketSize, ep_desc->bEndpointAddress);
00198                         USB_DBG("ADD USBEndpoint %p, on interf %d on device %p", ep, current_intf, dev);
00199                         dev->addEndpoint(current_intf, ep);
00200                         epsetup=epint_setup(ep);
00201                     }
00202                 }
00203                 break;
00204             case HID_DESCRIPTOR:
00205                 //lenReportDescr = conf_descr[index + 7] | (conf_descr[index + 8] << 8);
00206                 break;
00207             default:
00208                 break;
00209         }
00210         index += len_desc;
00211     }
00212 }
00213 
00214 USB_TYPE USBHost::controlRead(USBDeviceConnected* dev, uint8_t requestType, uint8_t request, uint32_t value, uint32_t index, uint8_t * buf, uint32_t len) {
00215     USBEndpoint* ep = dev->getEpCtl();
00216     SETUP_PACKET setup(requestType, request, value, index, len);
00217     wait_ms(100);
00218     int result = token_setup(ep, &setup, len); // setup stage
00219     USB_TRACE1(result);
00220     if (result < 0) {
00221         return USB_TYPE_ERROR;
00222     }
00223 
00224     int read_len = multi_token_in(ep, buf, len); // data stage
00225     USB_TRACE1(read_len);
00226     if (read_len < 0) {
00227         return USB_TYPE_ERROR;
00228     }
00229 
00230     setToggle(ep, 1); // DATA1
00231     result = multi_token_out(ep); // status stage
00232     USB_TRACE1(result);
00233     if (result < 0) {
00234         return USB_TYPE_ERROR;
00235     }
00236     ep->setLengthTransferred(read_len);
00237     return USB_TYPE_OK;
00238 }
00239 
00240 USB_TYPE USBHost::controlWrite(USBDeviceConnected* dev, uint8_t requestType, uint8_t request, uint32_t value, uint32_t index, uint8_t * buf, uint32_t len) {
00241     USBEndpoint* ep = dev->getEpCtl();
00242     SETUP_PACKET setup(requestType, request, value, index, len);
00243 
00244     int result = token_setup(ep, &setup, len); // setup stage
00245     USB_TRACE1(result);
00246     if (result < 0) {
00247         return USB_TYPE_ERROR;
00248     }
00249     int write_len = 0;
00250     if (buf != NULL) {
00251         write_len = multi_token_out(ep, buf, len); // data stage
00252         USB_TRACE1(write_len);
00253         if (write_len < 0) {
00254             return USB_TYPE_ERROR;
00255         }
00256     }
00257 
00258     setToggle(ep, 1); // DATA1
00259     result = multi_token_in(ep); // status stage
00260     USB_TRACE1(result);
00261     if (result < 0) {
00262         return USB_TYPE_ERROR;
00263     }
00264     ep->setLengthTransferred(write_len);
00265     return USB_TYPE_OK;
00266 }
00267 
00268 USB_TYPE USBHost::bulkRead(USBDeviceConnected* dev, USBEndpoint* ep, uint8_t* buf, uint32_t len, bool blocking) {
00269     if (blocking == false) {
00270         ep->setBuffer(buf, len);
00271         ep_queue.push(ep);
00272         multi_token_inNB(ep, buf, len);
00273         return USB_TYPE_PROCESSING;
00274     }
00275     int result = multi_token_in(ep, buf, len);
00276     USB_TRACE1(result);
00277     if (result < 0) {
00278         return USB_TYPE_ERROR;
00279     }
00280     ep->setLengthTransferred(result);
00281     return USB_TYPE_OK;
00282 }
00283 
00284 USB_TYPE USBHost::bulkWrite(USBDeviceConnected* dev, USBEndpoint* ep, uint8_t* buf, uint32_t len, bool blocking) {
00285     USB_TEST_ASSERT(blocking);
00286     int result = multi_token_out(ep, buf, len);
00287     USB_TRACE1(result);
00288     if (result < 0) {
00289         return USB_TYPE_ERROR;
00290     }
00291     ep->setLengthTransferred(result);
00292     return USB_TYPE_OK;
00293 }
00294 
00295 USB_TYPE USBHost::interruptRead(USBDeviceConnected* dev, USBEndpoint* ep, uint8_t* buf, uint32_t len, bool blocking) {
00296     if (blocking == false) {
00297         ep->setBuffer(buf, len);
00298         ep_queue.push(ep);
00299         multi_token_inNB(ep, buf, len);
00300         return USB_TYPE_PROCESSING;
00301     }
00302     int result = multi_token_in(ep, buf, len);
00303     USB_TRACE1(result);
00304     if (result < 0) {
00305         return USB_TYPE_ERROR;
00306     }
00307     ep->setLengthTransferred(result);
00308     return USB_TYPE_OK;
00309 }
00310 
00311 USB_TYPE USBHost::interruptWrite(USBDeviceConnected* dev, USBEndpoint* ep, uint8_t* buf, uint32_t len, bool blocking) {
00312     USB_TEST_ASSERT(blocking);
00313     int result = multi_token_out(ep, buf, len);
00314     USB_TRACE1(result);
00315     if (result < 0) {
00316         return USB_TYPE_ERROR;
00317     }
00318     ep->setLengthTransferred(result);
00319     return USB_TYPE_OK;
00320 }
00321 
00322 USB_TYPE USBHost::isochronousRead(USBDeviceConnected* dev, USBEndpoint* ep, uint8_t* buf, uint32_t len, bool blocking) {
00323     USB_TEST_ASSERT(blocking);
00324     isochronousReadNB(ep, buf, len);
00325     return USB_TYPE_OK;
00326 }
00327 
00328 int USBHost::interruptReadNB(USBEndpoint* ep, uint8_t* data, int size) {
00329     USB_TRACE1(size);
00330     if (ep->getState() != USB_TYPE_PROCESSING) {
00331         ep->setState(USB_TYPE_PROCESSING);
00332         ep->setBuffer(data, size);
00333         multi_token_inNB(ep, data, size);
00334     }
00335     if (multi_token_inNB_result(ep) != USB_TYPE_PROCESSING) {
00336         return ep->getLengthTransferred();
00337     }
00338     return -1;
00339 }
00340 
00341 int USBHost::bulkReadNB(USBEndpoint* ep, uint8_t* data, int size) {
00342     USB_TRACE1(size);
00343     return interruptReadNB(ep, data, size);
00344 }
00345 
00346 int USBHost::isochronousReadNB(USBEndpoint* ep, uint8_t* data, int size) {
00347     USB_TRACE1(size);
00348     int result = token_iso_in(ep, data, size);
00349     if (result >= 0) {
00350          ep->setLengthTransferred(result);
00351     }
00352     return result;
00353 }
00354 
00355 void USBHost::task() {
00356     USBEndpoint* ep = ep_queue.pop();
00357     if (ep) {
00358         USB_TEST_ASSERT(ep->getDir() == IN);
00359         if (multi_token_inNB_result(ep) != USB_TYPE_PROCESSING) {
00360             ep->call();
00361         } else {
00362             ep_queue.push(ep);
00363         }
00364     }
00365 }
00366 
00367 void usb_test_assert_internal(const char *expr, const char *file, int line){
00368     error("\n\n%s@%d %s ASSERT!\n\n", file, line, expr);
00369 }
00370