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