src/usbwrap_libusb.cc

   1 ///
   2 /// \file       usbwrap_libusb.cc
   3 ///             USB API wrapper for libusb version 0.1
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2012, Chris Frey
   8     Portions Copyright (C) 2011, RealVNC Ltd.
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18
  19     See the GNU General Public License in the COPYING file at the
  20     root directory of this project for more details.
  21 */
  22
  23 #include "usbwrap_libusb.h"
  24
  25 #include "debug.h"
  26 #include "data.h"
  27 #include <errno.h>
  28 #include <string.h>
  29 #include <iostream>
  30 #include <sstream>
  31 #include <algorithm>
  32
  33 #ifndef __DEBUG_MODE__
  34 #define __DEBUG_MODE__
  35 #endif
  36 #include "debug.h"
  37
  38 namespace Usb {
  39
  40 // helper function to make deleting pointers in maps and vectors easier
  41 template<typename T> static void deletePtr(T* ptr) {
  42         delete ptr;
  43 }
  44
  45 template<typename K, typename T> static void deleteMapPtr(std::pair<K,T*> ptr) {
  46         delete ptr.second;
  47 }
  48
  49 ///////////////////////////////////////////////////////////////////////////////
  50 // Static functions
  51
  52 std::string LibraryInterface::GetLastErrorString(int /*libusb_errcode*/)
  53 {
  54         // Errcode is unused by libusb, so just call the last error
  55         return std::string(usb_strerror());
  56 }
  57
  58 int LibraryInterface::TranslateErrcode(int libusb_errcode)
  59 {
  60         // libusb errcode == system errcode
  61         return libusb_errcode;
  62 }
  63
  64 bool LibraryInterface::Init(int *libusb_errno)
  65 {
  66         // if the environment variable USB_DEBUG is set, that
  67         // level value will be used instead of our 9 below...
  68         // if you need to *force* this to 9, call SetDataDump(true)
  69         // after Init()
  70         usb_init();
  71         // Can never fail, so return success
  72         return true;
  73 }
  74
  75 void LibraryInterface::Uninit()
  76 {
  77         // Nothing to do
  78 }
  79
  80 void LibraryInterface::SetDataDump(bool data_dump_mode)
  81 {
  82         if( data_dump_mode )
  83                 usb_set_debug(9);
  84         else
  85                 usb_set_debug(0);
  86 }
  87
  88 ///////////////////////////////////////////////////////////////////////////////
  89 // DeviceID
  90
  91 DeviceID::DeviceID(DeviceIDImpl* impl)
  92         : m_impl(impl)
  93 {
  94 }
  95
  96 DeviceID::~DeviceID()
  97 {
  98 }
  99
 100 const char* DeviceID::GetBusName() const
 101 {
 102         return m_impl->m_dev->bus->dirname;
 103 }
 104
 105 uint16_t DeviceID::GetNumber() const
 106 {
 107         return m_impl->m_dev->devnum;
 108 }
 109
 110 const char* DeviceID::GetFilename() const
 111 {
 112         return m_impl->m_dev->filename;
 113 }
 114
 115 uint16_t DeviceID::GetIdProduct() const
 116 {
 117         return m_impl->m_dev->descriptor.idProduct;
 118 }
 119
 120 std::string DeviceID::GetUsbName() const
 121 {
 122         // for libusb 0.1, we need both the bus name and the filename
 123         // and we stay away from the product ID, since that requires
 124         // communication with the device, which may not be possible
 125         // in error conditions.
 126         std::ostringstream oss;
 127         oss << GetBusName() << ":" << GetFilename();
 128         return oss.str();
 129 }
 130
 131 ///////////////////////////////////////////////////////////////////////////////
 132 // DeviceList
 133
 134 DeviceList::DeviceList()
 135         : m_impl(new DeviceListImpl())
 136 {
 137         // Work out what devices are on the bus at the moment
 138         usb_find_busses();
 139         usb_find_devices();
 140         struct usb_bus* busses = usb_get_busses();
 141         for( ; busses; busses = busses->next ) {
 142                 struct usb_device* dev = busses->devices;
 143                 for( ; dev; dev = dev->next ) {
 144                         // Add the device to the list of devices
 145                         std::auto_ptr<DeviceIDImpl> impl( new DeviceIDImpl() );
 146                         impl->m_dev = dev;
 147                         DeviceID devID(impl.release());
 148                         m_impl->m_devices.push_back(devID);
 149                 }
 150         }
 151 }
 152
 153 DeviceList::~DeviceList()
 154 {
 155 }
 156
 157
 158 static bool ToNum(const char *str, long &num)
 159 {
 160         char *end = 0;
 161         num = strtol(str, &end, 10);
 162         return  num >= 0 &&                     // no negative numbers
 163                 num != LONG_MIN && num != LONG_MAX &&   // no overflow
 164                 str != end && *end == '\0';     // whole string valid
 165 }
 166
 167 //
 168 // Linux treats bus and device path names as numbers, sometimes left
 169 // padded with zeros.  Other platforms, such as Windows, use strings,
 170 // such as "bus-1" or similar.
 171 //
 172 // Here we try to convert each string to a number, and if successful,
 173 // compare them.  If unable to convert, then compare as strings.
 174 // This way, "3" == "003" and "bus-foobar" == "bus-foobar".
 175 //
 176 static bool NameCompare(const char *n1, const char *n2)
 177 {
 178         long l1, l2;
 179         if( ToNum(n1, l1) && ToNum(n2, l2) ) {
 180                 return l1 == l2;
 181         }
 182         else {
 183                 return strcmp(n1, n2) == 0;
 184         }
 185 }
 186
 187 std::vector<DeviceID> DeviceList::MatchDevices(int vendor, int product,
 188                                             const char *busname, const char *devname)
 189 {
 190         std::vector<DeviceID> ret;
 191
 192         std::vector<DeviceID>::iterator iter = m_impl->m_devices.begin();
 193
 194         for( ; iter != m_impl->m_devices.end() ; ++iter ) {
 195                 struct usb_device* dev = iter->m_impl->m_dev;
 196
 197                 // only search on given bus
 198                 if( busname && !NameCompare(busname, dev->bus->dirname) )
 199                         continue;
 200
 201                 // search for specific device
 202                 if( devname && !NameCompare(devname, dev->filename) )
 203                         continue;
 204
 205                 // is there a match?
 206                 if( dev->descriptor.idVendor == vendor &&
 207                     ( dev->descriptor.idProduct == product ||
 208                       product == PRODUCT_ANY )) {
 209                         ret.push_back(*iter);
 210                 }
 211         }
 212
 213         return ret;
 214 }
 215
 216 ///////////////////////////////////////////////////////////////////////////////
 217 // Device
 218
 219 Device::Device(const Usb::DeviceID& id, int timeout)
 220         : m_id(id),
 221         m_timeout(timeout)
 222 {
 223         dout("usb_open(" << std::dec << id.m_impl.get() << ")");
 224         if( !id.m_impl.get() )
 225                 throw Error("invalid USB device ID");
 226         m_handle.reset(new DeviceHandle());
 227         m_handle->m_handle = usb_open(id.m_impl->m_dev);
 228         if( !m_handle->m_handle )
 229                 throw Error("Failed to open USB device.  Please check your system's USB device permissions.");
 230 }
 231
 232 Device::~Device()
 233 {
 234         dout("usb_close(" << std::dec << m_handle->m_handle << ")");
 235         usb_close(m_handle->m_handle);
 236 }
 237
 238 bool Device::SetConfiguration(unsigned char cfg)
 239 {
 240         dout("usb_set_configuration(" << std::dec << m_handle->m_handle << ", 0x" << std::hex << (unsigned int) cfg << ")");
 241         int ret = usb_set_configuration(m_handle->m_handle, cfg);
 242         m_lasterror = ret;
 243         return ret >= 0;
 244 }
 245
 246 bool Device::ClearHalt(int ep)
 247 {
 248         dout("usb_clear_halt(" << std::dec << m_handle->m_handle << ", 0x" << std::hex << ep << ")");
 249         int ret = usb_clear_halt(m_handle->m_handle, ep);
 250         m_lasterror = ret;
 251         return ret >= 0;
 252 }
 253
 254 bool Device::Reset()
 255 {
 256         dout("usb_reset(" << std::dec << m_handle->m_handle << ")");
 257         int ret = usb_reset(m_handle->m_handle);
 258         m_lasterror = ret;
 259         return ret == 0;
 260 }
 261
 262 bool Device::BulkRead(int ep, Barry::Data &data, int timeout)
 263 {
 264         int ret;
 265         do {
 266                 data.QuickZap();
 267                 ret = usb_bulk_read(m_handle->m_handle, ep,
 268                         (char*) data.GetBuffer(), data.GetBufSize(),
 269                         timeout == -1 ? m_timeout : timeout);
 270                 if( ret < 0 && ret != -EINTR && ret != -EAGAIN ) {
 271                         m_lasterror = ret;
 272                         if( ret == -ETIMEDOUT )
 273                                 throw Timeout(ret, "Timeout in usb_bulk_read");
 274                         else {
 275                                 std::ostringstream oss;
 276                                 oss << "Error in usb_bulk_read("
 277                                     << m_handle->m_handle << ", "
 278                                     << ep << ", buf, "
 279                                     << data.GetBufSize() << ")";
 280                                 throw Error(ret, oss.str());
 281                         }
 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::BulkWrite(int ep, const Barry::Data &data, int timeout)
 291 {
 292         ddout("BulkWrite to endpoint 0x" << std::hex << ep << ":\n" << data);
 293         int ret;
 294         do {
 295                 ret = usb_bulk_write(m_handle->m_handle, ep,
 296                         (char*) data.GetData(), data.GetSize(),
 297                         timeout == -1 ? m_timeout : timeout);
 298                 if( ret < 0 && ret != -EINTR && ret != -EAGAIN ) {
 299                         m_lasterror = ret;
 300                         if( ret == -ETIMEDOUT )
 301                                 throw Timeout(ret, "Timeout in usb_bulk_write (1)");
 302                         else
 303                                 throw Error(ret, "Error in usb_bulk_write (1)");
 304                 }
 305         } while( ret == -EINTR || ret == -EAGAIN );
 306
 307         return ret >= 0;
 308 }
 309
 310 bool Device::BulkWrite(int ep, const void *data, size_t size, int timeout)
 311 {
 312 #ifdef __DEBUG_MODE__
 313         Barry::Data dump(data, size);
 314         ddout("BulkWrite to endpoint 0x" << std::hex << ep << ":\n" << dump);
 315 #endif
 316
 317         int ret;
 318         do {
 319                 ret = usb_bulk_write(m_handle->m_handle, ep,
 320                         (char*) data, size,
 321                         timeout == -1 ? m_timeout : timeout);
 322                 if( ret < 0 && ret != -EINTR && ret != -EAGAIN ) {
 323                         m_lasterror = ret;
 324                         if( ret == -ETIMEDOUT )
 325                                 throw Timeout(ret, "Timeout in usb_bulk_write (2)");
 326                         else
 327                                 throw Error(ret, "Error in usb_bulk_write (2)");
 328                 }
 329         } while( ret == -EINTR || ret == -EAGAIN );
 330
 331         return ret >= 0;
 332 }
 333
 334 bool Device::InterruptRead(int ep, Barry::Data &data, int timeout)
 335 {
 336         int ret;
 337         do {
 338                 data.QuickZap();
 339                 ret = usb_interrupt_read(m_handle->m_handle, ep,
 340                         (char*) data.GetBuffer(), data.GetBufSize(),
 341                         timeout == -1 ? m_timeout : timeout);
 342                 if( ret < 0 && ret != -EINTR && ret != -EAGAIN ) {
 343                         m_lasterror = ret;
 344                         if( ret == -ETIMEDOUT )
 345                                 throw Timeout(ret, "Timeout in usb_interrupt_read");
 346                         else
 347                                 throw Error(ret, "Error in usb_interrupt_read");
 348                 }
 349                 else if( ret > 0 )
 350                         data.ReleaseBuffer(ret);
 351         } while( ret == -EINTR || ret == -EAGAIN );
 352
 353         return ret >= 0;
 354 }
 355
 356 bool Device::InterruptWrite(int ep, const Barry::Data &data, int timeout)
 357 {
 358         ddout("InterruptWrite to endpoint 0x" << std::hex << ep << ":\n" << data);
 359
 360         int ret;
 361         do {
 362                 ret = usb_interrupt_write(m_handle->m_handle, ep,
 363                         (char*) data.GetData(), data.GetSize(),
 364                         timeout == -1 ? m_timeout : timeout);
 365                 if( ret < 0 && ret != -EINTR && ret != -EAGAIN ) {
 366                         m_lasterror = ret;
 367                         if( ret == -ETIMEDOUT )
 368                                 throw Timeout(ret, "Timeout in usb_interrupt_write");
 369                         else
 370                                 throw Error(ret, "Error in usb_interrupt_write");
 371                 }
 372         } while( ret == -EINTR || ret == -EAGAIN );
 373
 374         return ret >= 0;
 375 }
 376
 377 //
 378 // BulkDrain
 379 //
 380 /// Reads anything available on the given endpoint, with a low timeout,
 381 /// in order to clear any pending reads.
 382 ///
 383 void Device::BulkDrain(int ep, int timeout)
 384 {
 385         try {
 386                 Barry::Data data;
 387                 while( BulkRead(ep, data, timeout) )
 388                 ;
 389         }
 390         catch( Usb::Error & ) {}
 391 }
 392
 393 //
 394 // GetConfiguration
 395 //
 396 /// Uses the GET_CONFIGURATION control message to determine the currently
 397 /// selected USB configuration, returning it in the cfg argument.
 398 /// If unsuccessful, returns false.
 399 ///
 400 bool Device::GetConfiguration(unsigned char &cfg)
 401 {
 402         int result = usb_control_msg(m_handle->m_handle, 0x80, USB_REQ_GET_CONFIGURATION, 0, 0,
 403                 (char*) &cfg, 1, m_timeout);
 404         m_lasterror = result;
 405         return result >= 0;
 406 }
 407
 408 // Returns the current power level of the device, or 0 if unknown
 409 int Device::GetPowerLevel()
 410 {
 411         if( !m_id.m_impl->m_dev->config ||
 412             !m_id.m_impl->m_dev->descriptor.bNumConfigurations < 1 )
 413                 return 0;
 414
 415         return m_id.m_impl->m_dev->config[0].MaxPower;
 416 }
 417
 418 bool Device::IsAttachKernelDriver(int iface)
 419 {
 420         int ret;
 421         char buffer[64];
 422
 423 #if LIBUSB_HAS_GET_DRIVER_NP
 424         ret = usb_get_driver_np(m_handle->m_handle, iface, buffer, sizeof(buffer));
 425         if (ret == 0) {
 426                 dout("interface (" << m_handle->m_handle << ", 0x" << std::hex << iface
 427                         << ") already claimed by driver \"" << buffer << "\"");
 428                 return true;
 429         }
 430         m_lasterror = ret;
 431 #else
 432         m_lasterror = -ENOSYS;
 433 #endif
 434
 435         return false;
 436 }
 437
 438 // Requests that the kernel driver is detached, returning false on failure
 439 bool Device::DetachKernelDriver(int iface)
 440 {
 441 #if LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP
 442         int result = usb_detach_kernel_driver_np(m_handle->m_handle, iface);
 443         m_lasterror = result;
 444         return result >= 0;
 445 #else
 446         m_lasterror = -ENOSYS;
 447         return false;
 448 #endif
 449 }
 450
 451 // Sends a control message to the device, returning false on failure
 452 bool Device::ControlMsg(int requesttype, int request, int value,
 453                         int index, char *bytes, int size, int timeout)
 454 {
 455         int result = usb_control_msg(m_handle->m_handle,
 456                                      requesttype, request, value, index,
 457                                      bytes, size, timeout);
 458         m_lasterror = result;
 459         return result >= 0;
 460 }
 461
 462
 463 int Device::FindInterface(int ifaceClass)
 464 {
 465         struct usb_config_descriptor *cfg = m_id.m_impl->m_dev->config;
 466
 467         if( cfg ) {
 468
 469                 for( unsigned i = 0; cfg->interface && i < cfg->bNumInterfaces; i++ ) {
 470                         struct usb_interface *iface = &cfg->interface[i];
 471                         for( int a = 0; iface->altsetting && a < iface->num_altsetting; a++ ) {
 472                                 struct usb_interface_descriptor *id = &iface->altsetting[a];
 473                                 if( id->bInterfaceClass == ifaceClass )
 474                                         return id->bInterfaceNumber;
 475                         }
 476                 }
 477         }
 478
 479         return -1;
 480 }
 481
 482
 483 ///////////////////////////////////////////////////////////////////////////////
 484 // Interface
 485
 486 Interface::Interface(Device &dev, int iface)
 487         : m_dev(dev), m_iface(iface)
 488 {
 489         dout("usb_claim_interface(" << dev.GetHandle()->m_handle << ", 0x" << std::hex << iface << ")");
 490         int ret = usb_claim_interface(dev.GetHandle()->m_handle, iface);
 491         if( ret < 0 )
 492                 throw Error(ret, "claim interface failed");
 493 }
 494
 495 Interface::~Interface()
 496 {
 497         dout("usb_release_interface(" << m_dev.GetHandle()->m_handle << ", 0x" << std::hex << m_iface << ")");
 498         usb_release_interface(m_dev.GetHandle()->m_handle, m_iface);
 499 }
 500
 501 //
 502 // SetAltInterface
 503 //
 504 /// Uses the usb_set_altinterface() function to set the currently
 505 /// selected USB alternate setting of the current interface.
 506 /// The iface parameter passed in should be a value specified
 507 /// in the bAlternateSetting descriptor field.
 508 /// If unsuccessful, returns false.
 509 ///
 510 bool Interface::SetAltInterface(int altSetting)
 511 {
 512         int result = usb_set_altinterface(m_dev.GetHandle()->m_handle, altSetting);
 513         m_dev.SetLastError(result);
 514         return result >= 0;
 515 }
 516
 517 //////////////////////////////////////////////////////////////////
 518 // DeviceDescriptor
 519
 520 DeviceDescriptor::DeviceDescriptor(DeviceID& devid)
 521         : m_impl(new DeviceDescriptorImpl())
 522 {
 523         if( !devid.m_impl.get() ) {
 524                 dout("DeviceDescriptor: empty devid");
 525                 return;
 526         }
 527         // Copy the descriptor over to our memory
 528         m_impl->m_dev = devid.m_impl->m_dev;
 529         m_impl->m_desc = devid.m_impl->m_dev->descriptor;
 530         dout("device_desc loaded"
 531              << "\nbLength: " << std::dec << (unsigned int) m_impl->m_desc.bLength
 532              << "\nbDescriptorType: " << std::dec << (unsigned int) m_impl->m_desc.bDescriptorType
 533              << "\nbcdUSB: 0x" << std::hex << (unsigned int) m_impl->m_desc.bcdUSB
 534              << "\nbDeviceClass: " << std::dec << (unsigned int) m_impl->m_desc.bDeviceClass
 535              << "\nbDeviceSubClass: " << std::dec << (unsigned int) m_impl->m_desc.bDeviceSubClass
 536              << "\nbDeviceProtocol: " << std::dec << (unsigned int) m_impl->m_desc.bDeviceProtocol
 537              << "\nbMaxPacketSize0: " << std::dec << (unsigned int) m_impl->m_desc.bMaxPacketSize0
 538              << "\nidVendor: 0x" << std::hex << (unsigned int) m_impl->m_desc.idVendor
 539              << "\nidProduct: 0x" << std::hex << (unsigned int) m_impl->m_desc.idProduct
 540              << "\nbcdDevice: 0x" << std::hex << (unsigned int) m_impl->m_desc.bcdDevice
 541              << "\niManufacturer: " << std::dec << (unsigned int) m_impl->m_desc.iManufacturer
 542              << "\niProduct: " << std::dec << (unsigned int) m_impl->m_desc.iProduct
 543              << "\niSerialNumber: " << std::dec << (unsigned int) m_impl->m_desc.iSerialNumber
 544              << "\nbNumConfigurations: " << std::dec << (unsigned int) m_impl->m_desc.bNumConfigurations
 545              << "\n"
 546         );
 547
 548         // Create all the configs
 549         for( int i = 0; i < m_impl->m_desc.bNumConfigurations; ++i ) {
 550                 std::auto_ptr<ConfigDescriptor> ptr(new ConfigDescriptor(*this, i));
 551                 (*this)[ptr->GetNumber()] = ptr.get();
 552                 ptr.release();
 553         }
 554 }
 555
 556 DeviceDescriptor::~DeviceDescriptor()
 557 {
 558         // Delete any pointers in the map
 559         std::for_each(begin(),
 560                       end(),
 561                       deleteMapPtr<int, ConfigDescriptor>);
 562 }
 563
 564 ///////////////////////////////////////////////////////////////////
 565 // ConfigDescriptor
 566
 567 ConfigDescriptor::ConfigDescriptor(DeviceDescriptor& dev, int cfgnumber)
 568         : m_impl(new ConfigDescriptorImpl())
 569 {
 570         // Copy the config descriptor locally
 571         m_impl->m_desc = dev.m_impl->m_dev->config[cfgnumber];
 572         dout("  config_desc #" << std::dec << cfgnumber << " loaded"
 573              << "\nbLength: " << std::dec << (unsigned int) m_impl->m_desc.bLength
 574              << "\nbDescriptorType: " << std::dec << (unsigned int) m_impl->m_desc.bDescriptorType
 575              << "\nwTotalLength: " << std::dec << (unsigned int) m_impl->m_desc.wTotalLength
 576              << "\nbNumInterfaces: " << std::dec << (unsigned int) m_impl->m_desc.bNumInterfaces
 577              << "\nbConfigurationValue: " << std::dec << (unsigned int) m_impl->m_desc.bConfigurationValue
 578              << "\niConfiguration: " << std::dec << (unsigned int) m_impl->m_desc.iConfiguration
 579              << "\nbmAttributes: 0x" << std::hex << (unsigned int) m_impl->m_desc.bmAttributes
 580              << "\nMaxPower: " << std::dec << (unsigned int) m_impl->m_desc.MaxPower
 581              << "\n"
 582                 );
 583
 584         // just for debugging purposes, check for extra descriptors, and
 585         // dump them to dout if they exist
 586         if( m_impl->m_desc.extra ) {
 587                 dout("while parsing config descriptor, found a block of extra descriptors:");
 588                 Barry::Data data(m_impl->m_desc.extra, m_impl->m_desc.extralen);
 589                 dout(data);
 590         }
 591
 592         // Create all the interfaces
 593         for( int i = 0; i < m_impl->m_desc.bNumInterfaces; ++i ) {
 594                 struct usb_interface* interface = &(m_impl->m_desc.interface[i]);
 595                 if( !interface->altsetting ) {
 596                         dout("ConfigDescriptor: empty altsetting");
 597                         // some devices are buggy and return a higher bNumInterfaces
 598                         // than the number of interfaces available... in this case
 599                         // we just skip and continue
 600                         continue;
 601                 }
 602                 for( int j = 0; j < interface->num_altsetting; ++j ) {
 603                         std::auto_ptr<InterfaceDescriptor> ptr(
 604                                 new InterfaceDescriptor(*this, i, j));
 605                         (*this)[ptr->GetNumber()] = ptr.get();
 606                         ptr.release();
 607                 }
 608         }
 609 }
 610
 611 ConfigDescriptor::~ConfigDescriptor()
 612 {
 613         // Delete any pointers in the map
 614         std::for_each(begin(),
 615                       end(),
 616                       deleteMapPtr<int, InterfaceDescriptor>);
 617 }
 618
 619 uint8_t ConfigDescriptor::GetNumber() const {
 620         return m_impl->m_desc.bConfigurationValue;
 621 }
 622
 623 /////////////////////////////////////////////////////////////////////////
 624 // InterfaceDescriptor
 625
 626 InterfaceDescriptor::InterfaceDescriptor(ConfigDescriptor& cfg,
 627                                          int interface, int altsetting)
 628         : m_impl(new InterfaceDescriptorImpl())
 629 {
 630         // Copy the descriptor
 631         m_impl->m_desc = cfg.m_impl->m_desc
 632                      .interface[interface]
 633                      .altsetting[altsetting];
 634         dout("    interface_desc #" << std::dec << interface << " loaded"
 635              << "\nbLength: " << std::dec << (unsigned) m_impl->m_desc.bLength
 636              << "\nbDescriptorType: " << std::dec << (unsigned) m_impl->m_desc.bDescriptorType
 637              << "\nbInterfaceNumber: " << std::dec << (unsigned) m_impl->m_desc.bInterfaceNumber
 638              << "\nbAlternateSetting: " << std::dec << (unsigned) m_impl->m_desc.bAlternateSetting
 639              << "\nbNumEndpoints: " << std::dec << (unsigned) m_impl->m_desc.bNumEndpoints
 640              << "\nbInterfaceClass: " << std::dec << (unsigned) m_impl->m_desc.bInterfaceClass
 641              << "\nbInterfaceSubClass: " << std::dec << (unsigned) m_impl->m_desc.bInterfaceSubClass
 642              << "\nbInterfaceProtocol: " << std::dec << (unsigned) m_impl->m_desc.bInterfaceProtocol
 643              << "\niInterface: " << std::dec << (unsigned) m_impl->m_desc.iInterface
 644              << "\n"
 645                 );
 646
 647         if( !m_impl->m_desc.endpoint ) {
 648                 dout("InterfaceDescriptor: empty interface pointer");
 649                 return;
 650         }
 651
 652         // Create all the endpoints
 653         for( int i = 0; i < m_impl->m_desc.bNumEndpoints; ++i ) {
 654                 std::auto_ptr<EndpointDescriptor> ptr (
 655                         new EndpointDescriptor(*this, i));
 656                 this->push_back(ptr.get());
 657                 ptr.release();
 658         }
 659
 660         // just for debugging purposes, check for extra descriptors, and
 661         // dump them to dout if they exist
 662         if( m_impl->m_desc.extra ) {
 663                 dout("while parsing interface descriptor, found a block of extra descriptors:");
 664                 Barry::Data data(m_impl->m_desc.extra, m_impl->m_desc.extralen);
 665                 dout(data);
 666         }
 667 }
 668
 669 InterfaceDescriptor::~InterfaceDescriptor()
 670 {
 671         // Delete any pointers in the vector
 672         std::for_each(begin(),
 673                       end(),
 674                       deletePtr<EndpointDescriptor>);
 675 }
 676
 677 uint8_t InterfaceDescriptor::GetClass() const
 678 {
 679         return m_impl->m_desc.bInterfaceClass;
 680 }
 681
 682 uint8_t InterfaceDescriptor::GetNumber() const
 683 {
 684         return m_impl->m_desc.bInterfaceNumber;
 685 }
 686
 687 uint8_t InterfaceDescriptor::GetAltSetting() const
 688 {
 689         return m_impl->m_desc.bAlternateSetting;
 690 }
 691
 692 /////////////////////////////////////////////////////////////////////////////////
 693 // EndpointDescriptor
 694
 695 EndpointDescriptor::EndpointDescriptor(InterfaceDescriptor& interface, int endpoint)
 696         : m_impl(new EndpointDescriptorImpl()),
 697           m_read(false),
 698           m_addr(0),
 699           m_type(InvalidType)
 700 {
 701         // Copy the descriptor
 702         m_impl->m_desc = interface.m_impl->m_desc.endpoint[endpoint];
 703         dout("      endpoint_desc #" << std::dec << endpoint << " loaded"
 704              << "\nbLength: " << std::dec << (unsigned ) m_impl->m_desc.bLength
 705              << "\nbDescriptorType: " << std::dec << (unsigned ) m_impl->m_desc.bDescriptorType
 706              << "\nbEndpointAddress: 0x" << std::hex << (unsigned ) m_impl->m_desc.bEndpointAddress
 707              << "\nbmAttributes: 0x" << std::hex << (unsigned ) m_impl->m_desc.bmAttributes
 708              << "\nwMaxPacketSize: " << std::dec << (unsigned ) m_impl->m_desc.wMaxPacketSize
 709              << "\nbInterval: " << std::dec << (unsigned ) m_impl->m_desc.bInterval
 710              << "\nbRefresh: " << std::dec << (unsigned ) m_impl->m_desc.bRefresh
 711              << "\nbSynchAddress: " << std::dec << (unsigned ) m_impl->m_desc.bSynchAddress
 712              << "\n"
 713                 );
 714         // Set up variables
 715         m_read = ((m_impl->m_desc.bEndpointAddress & USB_ENDPOINT_DIR_MASK) != 0);
 716         m_addr = (m_impl->m_desc.bEndpointAddress & USB_ENDPOINT_ADDRESS_MASK);
 717         int type = (m_impl->m_desc.bmAttributes & USB_ENDPOINT_TYPE_MASK);
 718         m_type = static_cast<Usb::EndpointDescriptor::EpType>(type);
 719
 720         // just for debugging purposes, check for extra descriptors, and
 721         // dump them to dout if they exist
 722         if( m_impl->m_desc.extra ) {
 723                 dout("while parsing endpoint descriptor, found a block of extra descriptors:");
 724                 Barry::Data data(m_impl->m_desc.extra, m_impl->m_desc.extralen);
 725                 dout(data);
 726         }
 727 }
 728
 729 EndpointDescriptor::~EndpointDescriptor()
 730 {
 731 }
 732
 733 } // namespace Usb
 734