src/usbwrap.cc

   1 ///
   2 /// \file       usbwrap.cc
   3 ///             USB API wrapper
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2010, Chris Frey
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22
  23 #include "usbwrap.h"
  24 #include "data.h"
  25 #include "error.h"
  26 #include "debug.h"
  27
  28 #include <iomanip>
  29 #include <sstream>
  30 #include <errno.h>
  31 #include <string.h>
  32 #include <limits.h>
  33
  34 #ifndef __DEBUG_MODE__
  35 #define __DEBUG_MODE__
  36 #endif
  37 #include "debug.h"
  38
  39 namespace Usb {
  40
  41 ///////////////////////////////////////////////////////////////////////////////
  42 // Usb::Error exception class
  43
  44 static std::string GetErrorString(int libusb_errcode, const std::string &str)
  45 {
  46         std::ostringstream oss;
  47         oss << "(";
  48
  49         if( libusb_errcode ) {
  50                 oss << std::setbase(10) << libusb_errcode << ", ";
  51         }
  52
  53 //      oss << strerror(-libusb_errno) << "): "
  54         oss << usb_strerror() << "): ";
  55         oss << str;
  56         return oss.str();
  57 }
  58
  59 Error::Error(const std::string &str)
  60         : Barry::Error(GetErrorString(0, str))
  61         , m_libusb_errcode(0)
  62 {
  63 }
  64
  65 Error::Error(int libusb_errcode, const std::string &str)
  66         : Barry::Error(GetErrorString(libusb_errcode, str))
  67         , m_libusb_errcode(libusb_errcode)
  68 {
  69 }
  70
  71
  72 ///////////////////////////////////////////////////////////////////////////////
  73 // Match
  74
  75 Match::Match(int vendor, int product,
  76                 const char *busname, const char *devname)
  77         : m_busses(0)
  78         , m_dev(0)
  79         , m_vendor(vendor)
  80         , m_product(product)
  81         , m_busname(busname)
  82         , m_devname(devname)
  83 {
  84         usb_find_busses();
  85         usb_find_devices();
  86         m_busses = usb_get_busses();
  87 }
  88
  89 Match::~Match()
  90 {
  91 }
  92
  93 bool Match::ToNum(const char *str, long &num)
  94 {
  95         char *end = 0;
  96         num = strtol(str, &end, 10);
  97         return  num >= 0 &&                     // no negative numbers
  98                 num != LONG_MIN && num != LONG_MAX &&   // no overflow
  99                 str != end && *end == '\0';     // whole string valid
 100 }
 101
 102 //
 103 // Linux treats bus and device path names as numbers, sometimes left
 104 // padded with zeros.  Other platforms, such as Windows, use strings,
 105 // such as "bus-1" or similar.
 106 //
 107 // Here we try to convert each string to a number, and if successful,
 108 // compare them.  If unable to convert, then compare as strings.
 109 // This way, "3" == "003" and "bus-foobar" == "bus-foobar".
 110 //
 111 bool Match::NameCompare(const char *n1, const char *n2)
 112 {
 113         long l1, l2;
 114         if( ToNum(n1, l1) && ToNum(n2, l2) ) {
 115                 return l1 == l2;
 116         }
 117         else {
 118                 return strcmp(n1, n2) == 0;
 119         }
 120 }
 121
 122 bool Match::next_device(Usb::DeviceIDType *devid)
 123 {
 124         for( ; m_busses; m_busses = m_busses->next ) {
 125
 126                 // only search on given bus
 127                 if( m_busname && !NameCompare(m_busname, m_busses->dirname) )
 128                         continue;
 129
 130                 if( !m_dev )
 131                         m_dev = m_busses->devices;
 132
 133                 for( ; m_dev; m_dev = m_dev->next ) {
 134
 135                         // search for specific device
 136                         if( m_devname && !NameCompare(m_devname, m_dev->filename) )
 137                                 continue;
 138
 139                         // is there a match?
 140                         if( m_dev->descriptor.idVendor == m_vendor &&
 141                             m_dev->descriptor.idProduct == m_product ) {
 142                                 // found!
 143                                 *devid = m_dev;
 144
 145                                 // advance for next time
 146                                 m_dev = m_dev->next;
 147                                 if( !m_dev )
 148                                         m_busses = m_busses->next;
 149
 150                                 // done
 151                                 return true;
 152                         }
 153                 }
 154         }
 155         return false;
 156 }
 157
 158
 159 ///////////////////////////////////////////////////////////////////////////////
 160 // Device
 161
 162 Device::Device(Usb::DeviceIDType id, int timeout)
 163         : m_id(id),
 164         m_timeout(timeout)
 165 {
 166         dout("usb_open(" << std::dec << id << ")");
 167         m_handle = usb_open(id);
 168         if( !m_handle )
 169                 throw Error("open failed");
 170 }
 171
 172 Device::~Device()
 173 {
 174         dout("usb_close(" << std::dec << m_handle << ")");
 175         usb_close(m_handle);
 176 }
 177
 178 bool Device::SetConfiguration(unsigned char cfg)
 179 {
 180         dout("usb_set_configuration(" << std::dec << m_handle << ", 0x" << std::hex << (unsigned int) cfg << ")");
 181         int ret = usb_set_configuration(m_handle, cfg);
 182         m_lasterror = ret;
 183         return ret >= 0;
 184 }
 185
 186 bool Device::ClearHalt(int ep)
 187 {
 188         dout("usb_clear_halt(" << std::dec << m_handle << ", 0x" << std::hex << ep << ")");
 189         int ret = usb_clear_halt(m_handle, ep);
 190         m_lasterror = ret;
 191         return ret >= 0;
 192 }
 193
 194 bool Device::Reset()
 195 {
 196         dout("usb_reset(" << std::dec << m_handle << ")");
 197         int ret = usb_reset(m_handle);
 198         m_lasterror = ret;
 199         return ret == 0;
 200 }
 201
 202 bool Device::BulkRead(int ep, Barry::Data &data, int timeout)
 203 {
 204         int ret;
 205         do {
 206                 data.QuickZap();
 207                 ret = usb_bulk_read(m_handle, ep,
 208                         (char*) data.GetBuffer(), data.GetBufSize(),
 209                         timeout == -1 ? m_timeout : timeout);
 210                 if( ret < 0 && ret != -EINTR && ret != -EAGAIN ) {
 211                         m_lasterror = ret;
 212                         if( ret == -ETIMEDOUT )
 213                                 throw Timeout(ret, "Timeout in usb_bulk_read");
 214                         else
 215                                 throw Error(ret, "Error in usb_bulk_read");
 216                 }
 217                 else if( ret > 0 )
 218                         data.ReleaseBuffer(ret);
 219         } while( ret == -EINTR || ret == -EAGAIN );
 220
 221         return ret >= 0;
 222 }
 223
 224 bool Device::BulkWrite(int ep, const Barry::Data &data, int timeout)
 225 {
 226         ddout("BulkWrite to endpoint 0x" << std::hex << ep << ":\n" << data);
 227         int ret;
 228         do {
 229                 ret = usb_bulk_write(m_handle, ep,
 230                         (char*) data.GetData(), data.GetSize(),
 231                         timeout == -1 ? m_timeout : timeout);
 232                 if( ret < 0 && ret != -EINTR && ret != -EAGAIN ) {
 233                         m_lasterror = ret;
 234                         if( ret == -ETIMEDOUT )
 235                                 throw Timeout(ret, "Timeout in usb_bulk_write (1)");
 236                         else
 237                                 throw Error(ret, "Error in usb_bulk_write (1)");
 238                 }
 239         } while( ret == -EINTR || ret == -EAGAIN );
 240
 241         return ret >= 0;
 242 }
 243
 244 bool Device::BulkWrite(int ep, const void *data, size_t size, int timeout)
 245 {
 246 #ifdef __DEBUG_MODE__
 247         Barry::Data dump(data, size);
 248         ddout("BulkWrite to endpoint 0x" << std::hex << ep << ":\n" << dump);
 249 #endif
 250
 251         int ret;
 252         do {
 253                 ret = usb_bulk_write(m_handle, ep,
 254                         (char*) data, size,
 255                         timeout == -1 ? m_timeout : timeout);
 256                 if( ret < 0 && ret != -EINTR && ret != -EAGAIN ) {
 257                         m_lasterror = ret;
 258                         if( ret == -ETIMEDOUT )
 259                                 throw Timeout(ret, "Timeout in usb_bulk_write (2)");
 260                         else
 261                                 throw Error(ret, "Error in usb_bulk_write (2)");
 262                 }
 263         } while( ret == -EINTR || ret == -EAGAIN );
 264
 265         return ret >= 0;
 266 }
 267
 268 bool Device::InterruptRead(int ep, Barry::Data &data, int timeout)
 269 {
 270         int ret;
 271         do {
 272                 data.QuickZap();
 273                 ret = usb_interrupt_read(m_handle, ep,
 274                         (char*) data.GetBuffer(), data.GetBufSize(),
 275                         timeout == -1 ? m_timeout : timeout);
 276                 if( ret < 0 && ret != -EINTR && ret != -EAGAIN ) {
 277                         m_lasterror = ret;
 278                         if( ret == -ETIMEDOUT )
 279                                 throw Timeout(ret, "Timeout in usb_interrupt_read");
 280                         else
 281                                 throw Error(ret, "Error in usb_interrupt_read");
 282                 }
 283                 else if( ret > 0 )
 284                         data.ReleaseBuffer(ret);
 285         } while( ret == -EINTR || ret == -EAGAIN );
 286
 287         return ret >= 0;
 288 }
 289
 290 bool Device::InterruptWrite(int ep, const Barry::Data &data, int timeout)
 291 {
 292         ddout("InterruptWrite to endpoint 0x" << std::hex << ep << ":\n" << data);
 293
 294         int ret;
 295         do {
 296                 ret = usb_interrupt_write(m_handle, ep,
 297                         (char*) data.GetData(), data.GetSize(),
 298                         timeout == -1 ? m_timeout : timeout);
 299                 if( ret < 0 && ret != -EINTR && ret != -EAGAIN ) {
 300                         m_lasterror = ret;
 301                         if( ret == -ETIMEDOUT )
 302                                 throw Timeout(ret, "Timeout in usb_interrupt_write");
 303                         else
 304                                 throw Error(ret, "Error in usb_interrupt_write");
 305                 }
 306         } while( ret == -EINTR || ret == -EAGAIN );
 307
 308         return ret >= 0;
 309 }
 310
 311 //
 312 // BulkDrain
 313 //
 314 /// Reads anything available on the given endpoint, with a low timeout,
 315 /// in order to clear any pending reads.
 316 ///
 317 void Device::BulkDrain(int ep, int timeout)
 318 {
 319         try {
 320                 Barry::Data data;
 321                 while( BulkRead(ep, data, timeout) )
 322                 ;
 323         }
 324         catch( Usb::Error & ) {}
 325 }
 326
 327 //
 328 // GetConfiguration
 329 //
 330 /// Uses the GET_CONFIGURATION control message to determine the currently
 331 /// selected USB configuration, returning it in the cfg argument.
 332 /// If unsuccessful, returns false.
 333 ///
 334 bool Device::GetConfiguration(unsigned char &cfg)
 335 {
 336         int result = usb_control_msg(m_handle, 0x80, USB_REQ_GET_CONFIGURATION, 0, 0,
 337                 (char*) &cfg, 1, m_timeout);
 338         m_lasterror = result;
 339         return result >= 0;
 340 }
 341
 342 //
 343 // SetAltInterface
 344 //
 345 /// Uses the usb_set_altinterface() function to set the currently
 346 /// selected USB alternate setting of the current interface.
 347 /// The iface parameter passed in should be a value specified
 348 /// in the bAlternateSetting descriptor field.
 349 /// If unsuccessful, returns false.
 350 ///
 351 bool Device::SetAltInterface(int iface)
 352 {
 353         int result = usb_set_altinterface(m_handle, iface);
 354         m_lasterror = result;
 355         return result >= 0;
 356 }
 357
 358
 359
 360 ///////////////////////////////////////////////////////////////////////////////
 361 // Interface
 362
 363 Interface::Interface(Device &dev, int iface)
 364         : m_dev(dev), m_iface(iface)
 365 {
 366         dout("usb_claim_interface(" << dev.GetHandle() << ", 0x" << std::hex << iface << ")");
 367         int ret = usb_claim_interface(dev.GetHandle(), iface);
 368         if( ret < 0 )
 369                 throw Error(ret, "claim interface failed");
 370 }
 371
 372 Interface::~Interface()
 373 {
 374         dout("usb_release_interface(" << m_dev.GetHandle() << ", 0x" << std::hex << m_iface << ")");
 375         usb_release_interface(m_dev.GetHandle(), m_iface);
 376 }
 377
 378
 379
 380 ///////////////////////////////////////////////////////////////////////////////
 381 // EndpointDiscovery
 382
 383 bool EndpointDiscovery::Discover(struct usb_interface_descriptor *interface, int epcount)
 384 {
 385         // start fresh
 386         clear();
 387         m_valid = false;
 388
 389         EndpointPair pair;
 390
 391         if( !interface || !interface->endpoint ) {
 392                 dout("EndpointDiscovery::Discover: empty interface pointer");
 393                 return false;
 394         }
 395
 396         for( int i = 0; i < epcount; i++ ) {
 397                 // load descriptor
 398                 usb_endpoint_descriptor desc;
 399                 desc = interface->endpoint[i];
 400                 dout("      endpoint_desc #" << std::dec << i << " loaded"
 401                         << "\nbLength: " << std::dec << (unsigned ) desc.bLength
 402                         << "\nbDescriptorType: " << std::dec << (unsigned ) desc.bDescriptorType
 403                         << "\nbEndpointAddress: 0x" << std::hex << (unsigned ) desc.bEndpointAddress
 404                         << "\nbmAttributes: 0x" << std::hex << (unsigned ) desc.bmAttributes
 405                         << "\nwMaxPacketSize: " << std::dec << (unsigned ) desc.wMaxPacketSize
 406                         << "\nbInterval: " << std::dec << (unsigned ) desc.bInterval
 407                         << "\nbRefresh: " << std::dec << (unsigned ) desc.bRefresh
 408                         << "\nbSynchAddress: " << std::dec << (unsigned ) desc.bSynchAddress
 409                         << "\n"
 410                         );
 411
 412                 // add to the map
 413                 (*this)[desc.bEndpointAddress] = desc;
 414                 dout("      endpoint added to map with bEndpointAddress: 0x" << std::hex << (unsigned int)desc.bEndpointAddress);
 415
 416                 // parse the endpoint into read/write sets, if possible,
 417                 // going in discovery order...
 418                 // Assumptions:
 419                 //      - endpoints of related utility will be grouped
 420                 //      - endpoints with same type will be grouped
 421                 //      - endpoints that do not meet the above assumptions
 422                 //              do not belong in a pair
 423                 unsigned char type = desc.bmAttributes & USB_ENDPOINT_TYPE_MASK;
 424                 if( desc.bEndpointAddress & USB_ENDPOINT_DIR_MASK ) {
 425                         // read endpoint
 426                         pair.read = desc.bEndpointAddress;
 427                         dout("        pair.read = 0x" << std::hex << (unsigned int)pair.read);
 428                         if( pair.IsTypeSet() && pair.type != type ) {
 429                                 // if type is already set, we must start over
 430                                 pair.write = 0;
 431                         }
 432                 }
 433                 else {
 434                         // write endpoint
 435                         pair.write = desc.bEndpointAddress;
 436                         dout("        pair.write = 0x" << std::hex << (unsigned int)pair.write);
 437                         if( pair.IsTypeSet() && pair.type != type ) {
 438                                 // if type is already set, we must start over
 439                                 pair.read = 0;
 440                         }
 441                 }
 442                 // save the type last
 443                 pair.type = type;
 444                 dout("        pair.type = 0x" << std::hex << (unsigned int)pair.type);
 445
 446                 // if pair is complete, add to array
 447                 if( pair.IsComplete() ) {
 448                         m_endpoints.push_back(pair);
 449                         dout("        pair added! ("
 450                                 << "read: 0x" << std::hex << (unsigned int)pair.read << ","
 451                                 << "write: 0x" << std::hex << (unsigned int)pair.write << ","
 452                                 << "type: 0x" << std::hex << (unsigned int)pair.type << ")");
 453                         pair = EndpointPair();  // clear
 454                 }
 455         }
 456
 457         // just for debugging purposes, check for extra descriptors, and
 458         // dump them to dout if they exist
 459         if( interface->extra ) {
 460                 dout("while parsing endpoints, found a block of extra descriptors:");
 461                 Barry::Data data(interface->extra, interface->extralen);
 462                 dout(data);
 463         }
 464
 465         return m_valid = true;
 466 }
 467
 468
 469 ///////////////////////////////////////////////////////////////////////////////
 470 // InterfaceDiscovery
 471
 472 bool InterfaceDiscovery::DiscoverInterface(struct usb_interface *interface)
 473 {
 474         if( !interface->altsetting ) {
 475                 dout("InterfaceDiscovery::DiscoverIterface: empty altsetting");
 476                 // some devices are buggy and return a higher bNumInterfaces
 477                 // than the number of interfaces available... in this case
 478                 // we just skip and continue
 479                 return true;
 480         }
 481
 482         for( int i = 0; i < interface->num_altsetting; i++ ) {
 483                 // load descriptor
 484                 InterfaceDesc desc;
 485                 desc.desc = interface->altsetting[i];
 486                 dout("    interface_desc #" << std::dec << i << " loaded"
 487                         << "\nbLength: " << std::dec << (unsigned) desc.desc.bLength
 488                         << "\nbDescriptorType: " << std::dec << (unsigned) desc.desc.bDescriptorType
 489                         << "\nbInterfaceNumber: " << std::dec << (unsigned) desc.desc.bInterfaceNumber
 490                         << "\nbAlternateSetting: " << std::dec << (unsigned) desc.desc.bAlternateSetting
 491                         << "\nbNumEndpoints: " << std::dec << (unsigned) desc.desc.bNumEndpoints
 492                         << "\nbInterfaceClass: " << std::dec << (unsigned) desc.desc.bInterfaceClass
 493                         << "\nbInterfaceSubClass: " << std::dec << (unsigned) desc.desc.bInterfaceSubClass
 494                         << "\nbInterfaceProtocol: " << std::dec << (unsigned) desc.desc.bInterfaceProtocol
 495                         << "\niInterface: " << std::dec << (unsigned) desc.desc.iInterface
 496                         << "\n"
 497                         );
 498
 499                 // load all endpoints on this interface
 500                 if( !desc.endpoints.Discover(&desc.desc, desc.desc.bNumEndpoints) ) {
 501                         dout("    endpoint discovery failed for bInterfaceNumber: " << std::dec << (unsigned int)desc.desc.bInterfaceNumber << ", not added to map.");
 502                         return false;
 503                 }
 504
 505                 // add to the map
 506                 (*this)[desc.desc.bInterfaceNumber] = desc;
 507                 dout("    interface added to map with bInterfaceNumber: " << std::dec << (unsigned int)desc.desc.bInterfaceNumber);
 508         }
 509         return true;
 510 }
 511
 512 bool InterfaceDiscovery::Discover(Usb::DeviceIDType devid, int cfgidx, int ifcount)
 513 {
 514         // start fresh
 515         clear();
 516         m_valid = false;
 517
 518         if( !devid || !devid->config || !devid->config[cfgidx].interface ) {
 519                 dout("InterfaceDiscovery::Discover: empty devid/config/interface");
 520                 return false;
 521         }
 522
 523         for( int i = 0; i < ifcount; i++ ) {
 524                 if( !DiscoverInterface(&devid->config[cfgidx].interface[i]) )
 525                         return false;
 526         }
 527
 528         return m_valid = true;
 529 }
 530
 531
 532 ///////////////////////////////////////////////////////////////////////////////
 533 // ConfigDiscovery
 534
 535 bool ConfigDiscovery::Discover(Usb::DeviceIDType devid, int cfgcount)
 536 {
 537         // start fresh
 538         clear();
 539         m_valid = false;
 540
 541         for( int i = 0; i < cfgcount; i++ ) {
 542                 // load descriptor
 543                 ConfigDesc desc;
 544                 if( !devid || !devid->config ) {
 545                         dout("ConfigDiscovery::Discover: empty devid or config");
 546                         return false;
 547                 }
 548                 desc.desc = devid->config[i];
 549                 dout("  config_desc #" << std::dec << i << " loaded"
 550                         << "\nbLength: " << std::dec << (unsigned int) desc.desc.bLength
 551                         << "\nbDescriptorType: " << std::dec << (unsigned int) desc.desc.bDescriptorType
 552                         << "\nwTotalLength: " << std::dec << (unsigned int) desc.desc.wTotalLength
 553                         << "\nbNumInterfaces: " << std::dec << (unsigned int) desc.desc.bNumInterfaces
 554                         << "\nbConfigurationValue: " << std::dec << (unsigned int) desc.desc.bConfigurationValue
 555                         << "\niConfiguration: " << std::dec << (unsigned int) desc.desc.iConfiguration
 556                         << "\nbmAttributes: 0x" << std::hex << (unsigned int) desc.desc.bmAttributes
 557                         << "\nMaxPower: " << std::dec << (unsigned int) desc.desc.MaxPower
 558                         << "\n"
 559                         );
 560
 561                 // just for debugging purposes, check for extra descriptors, and
 562                 // dump them to dout if they exist
 563                 if( desc.desc.extra ) {
 564                         dout("while parsing config descriptor, found a block of extra descriptors:");
 565                         Barry::Data data(desc.desc.extra, desc.desc.extralen);
 566                         dout(data);
 567                 }
 568
 569                 // load all interfaces on this configuration
 570                 if( !desc.interfaces.Discover(devid, i, desc.desc.bNumInterfaces) ) {
 571                         dout("  config discovery failed for bConfigurationValue: " << std::dec << (unsigned int)desc.desc.bConfigurationValue << ", not added to map.");
 572                         return false;
 573                 }
 574
 575                 // add to the map
 576                 (*this)[desc.desc.bConfigurationValue] = desc;
 577                 dout("  config added to map with bConfigurationValue: " << std::dec << (unsigned int)desc.desc.bConfigurationValue);
 578         }
 579
 580         return m_valid = true;
 581 }
 582
 583
 584 ///////////////////////////////////////////////////////////////////////////////
 585 // DeviceDiscovery
 586
 587 DeviceDiscovery::DeviceDiscovery(Usb::DeviceIDType devid)
 588         : m_valid(false)
 589 {
 590         Discover(devid);
 591 }
 592
 593 bool DeviceDiscovery::Discover(Usb::DeviceIDType devid)
 594 {
 595         // start fresh
 596         configs.clear();
 597         m_valid = false;
 598
 599         // copy the descriptor over to our memory
 600         if( !devid ) {
 601                 dout("DeviceDiscovery::Discover: empty devid");
 602                 return false;
 603         }
 604
 605         desc = devid->descriptor;
 606         dout("device_desc loaded"
 607                 << "\nbLength: " << std::dec << (unsigned int) desc.bLength
 608                 << "\nbDescriptorType: " << std::dec << (unsigned int) desc.bDescriptorType
 609                 << "\nbcdUSB: 0x" << std::hex << (unsigned int) desc.bcdUSB
 610                 << "\nbDeviceClass: " << std::dec << (unsigned int) desc.bDeviceClass
 611                 << "\nbDeviceSubClass: " << std::dec << (unsigned int) desc.bDeviceSubClass
 612                 << "\nbDeviceProtocol: " << std::dec << (unsigned int) desc.bDeviceProtocol
 613                 << "\nbMaxPacketSize0: " << std::dec << (unsigned int) desc.bMaxPacketSize0
 614                 << "\nidVendor: 0x" << std::hex << (unsigned int) desc.idVendor
 615                 << "\nidProduct: 0x" << std::hex << (unsigned int) desc.idProduct
 616                 << "\nbcdDevice: 0x" << std::hex << (unsigned int) desc.bcdDevice
 617                 << "\niManufacturer: " << std::dec << (unsigned int) desc.iManufacturer
 618                 << "\niProduct: " << std::dec << (unsigned int) desc.iProduct
 619                 << "\niSerialNumber: " << std::dec << (unsigned int) desc.iSerialNumber
 620                 << "\nbNumConfigurations: " << std::dec << (unsigned int) desc.bNumConfigurations
 621                 << "\n"
 622         );
 623
 624         m_valid = configs.Discover(devid, desc.bNumConfigurations);
 625         return m_valid;
 626 }
 627
 628 } // namespace Usb
 629