src/usbwrap.cc

   1 ///
   2 /// \file       usbwrap.cc
   3 ///             USB API wrapper
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2006, 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
  31 #define __DEBUG_MODE__
  32 #include "debug.h"
  33
  34 namespace Usb {
  35
  36 IO::IO(Device *dev, libusb_io_handle_t *handle)
  37         : m_dev(dev),
  38         m_handle(handle)
  39 {
  40         if( m_handle )
  41                 dout("IO::IO handle: " << m_handle);
  42 }
  43
  44 IO::IO(Device &dev, libusb_io_handle_t *handle)
  45         : m_dev(&dev),
  46         m_handle(handle)
  47 {
  48         if( m_handle )
  49                 dout("IO::IO handle: " << m_handle);
  50 }
  51
  52 IO::IO(const IO &other)
  53         : m_dev(other.m_dev),
  54         m_handle(0)
  55 {
  56         operator=(other);
  57 }
  58
  59 // only one IO object can ever hold a handle to an io operation
  60 IO& IO::operator=(const IO &other)
  61 {
  62         if( this == &other )
  63                 return *this;           // nothing to do
  64
  65         if( m_dev && m_dev != other.m_dev )
  66                 throw UsbError("Copying IO objects that are not "
  67                         "related to the same device.");
  68
  69         cleanup();
  70         m_handle = other.m_handle;
  71         other.m_handle = 0;
  72         return *this;
  73 }
  74
  75 // cleans up the io handle, making this IO object invalid
  76 void IO::cleanup()
  77 {
  78         if( IsValid() ) {
  79                 dout("IO::cleanup handle: " << m_handle);
  80
  81                 std::ostringstream oss;
  82                 oss << "cleanup: " << GetEndpoint() << " ";
  83                 if( !IsCompleted() ) {
  84                         // not complete yet, cancel
  85                         oss << " cancel ";
  86                         libusb_io_cancel(m_handle);
  87                 }
  88                 oss << " free";
  89                 dout(oss.str());
  90                 libusb_io_free(m_handle);
  91                 m_handle = 0;
  92         }
  93 }
  94
  95 // will cancel if not complete, and will always free if valid
  96 IO::~IO()
  97 {
  98         cleanup();
  99 }
 100
 101 // API wrappers
 102 bool IO::IsCompleted() const
 103 {
 104         if( !IsValid() )
 105                 return true;
 106
 107         return libusb_is_io_completed(m_handle) != 0;
 108 }
 109
 110 void IO::Wait()
 111 {
 112         if( !IsValid() )
 113                 return;                 // nothing to wait on
 114         libusb_io_wait(m_handle);
 115
 116 #ifdef __DEBUG_MODE__
 117         ddout("IO::Wait(): Endpoint " << GetEndpoint()
 118                 << " Status "
 119                 << std::setbase(10) << GetStatus() << std::setbase(16));
 120
 121         // only dump read endpoints that are successful
 122         if( (GetEndpoint() & USB_ENDPOINT_DIR_MASK) && GetStatus() >= 0 ) {
 123                 Data dump(GetData(), GetSize());
 124                 ddout(dump);
 125         }
 126 #endif
 127 }
 128
 129 void IO::Cancel()
 130 {
 131         if( !IsValid() )
 132                 return;
 133         if( !IsCompleted() ) {
 134                 // not complete yet, cancel
 135                 libusb_io_cancel(m_handle);
 136         }
 137 }
 138
 139 int IO::GetStatus() const
 140 {
 141         if( !IsValid() )
 142                 return -1;
 143         return libusb_io_comp_status(m_handle);
 144 }
 145
 146 int IO::GetSize() const
 147 {
 148         if( !IsValid() )
 149                 return 0;
 150         return libusb_io_xfer_size(m_handle);
 151 }
 152
 153 int IO::GetReqSize() const
 154 {
 155         if( !IsValid() )
 156                 return 0;
 157         return libusb_io_req_size(m_handle);
 158 }
 159
 160 int IO::GetEndpoint() const
 161 {
 162         if( !IsValid() )
 163                 return 0;
 164         return libusb_io_ep_addr(m_handle);
 165 }
 166
 167 unsigned char * IO::GetData()
 168 {
 169         if( !IsValid() )
 170                 return 0;
 171         return libusb_io_data(m_handle);
 172 }
 173
 174 const unsigned char * IO::GetData() const
 175 {
 176         if( !IsValid() )
 177                 return 0;
 178         return libusb_io_data(m_handle);
 179 }
 180
 181
 182
 183 ///////////////////////////////////////////////////////////////////////////////
 184 // Device
 185
 186 bool Device::SetConfiguration(unsigned char cfg)
 187 {
 188         m_lasterror = libusb_set_configuration(m_handle, cfg);
 189         return m_lasterror >= 0;
 190 }
 191
 192 bool Device::ClearHalt(int ep)
 193 {
 194         m_lasterror = libusb_clear_halt(m_handle, ep);
 195         return m_lasterror >= 0;
 196 }
 197
 198 bool Device::Reset()
 199 {
 200         m_lasterror = libusb_reset(m_handle);
 201         return m_lasterror == 0;
 202 }
 203
 204 void Device::TrackBulkRead(int ep, Data &data)
 205 {
 206         m_ios.push_back(ABulkRead(ep, data));
 207 }
 208
 209 void Device::TrackBulkWrite(int ep, const Data &data)
 210 {
 211         m_ios.push_back(ABulkWrite(ep, data));
 212 }
 213
 214 void Device::TrackInterruptRead(int ep, Data &data)
 215 {
 216         m_ios.push_back(AInterruptRead(ep, data));
 217 }
 218
 219 void Device::TrackInterruptWrite(int ep, const Data &data)
 220 {
 221         m_ios.push_back(AInterruptWrite(ep, data));
 222 }
 223
 224 // extracts the next completed IO handle, and returns it as an IO object
 225 // The Device object no longer tracks this handle, and if the IO object
 226 // goes out of scope, the handle will be freed.
 227 IO Device::PollCompletions()
 228 {
 229         // get next completed libusb IO handle
 230         libusb_io_handle_t *done = libusb_io_poll_completions();
 231         if( !done )
 232                 return IO::InvalidIO();
 233
 234         // search for it in our list
 235         io_list_type::iterator b = m_ios.begin();
 236         for( ; b != m_ios.end(); b++ ) {
 237                 if( *b == done ) {
 238                         IO io = *b;     // make copy to return
 239                         m_ios.erase(b); // remove forgotten placeholder
 240                         return io;      // return so user can deal with it
 241                 }
 242         }
 243
 244         // not found in our tracked list
 245         if( libusb_io_dev(done) == m_handle ) {
 246                 // this is an event for our device handle, so ok to return it
 247                 return IO(*this, done);
 248         }
 249         else {
 250                 // not our device, ignore it
 251                 return IO::InvalidIO();
 252         }
 253 }
 254
 255 void Device::ClearIO(int index)
 256 {
 257         m_ios.erase(m_ios.begin() + index);
 258 }
 259
 260 IO Device::ABulkRead(int ep, Data &data)
 261 {
 262         libusb_io_handle_t *rd = libusb_submit_bulk_read( GetHandle(), ep,
 263                 data.GetBuffer(), data.GetBufSize(), m_timeout, NULL);
 264         if( !rd )
 265                 throw UsbError("Error in libusb_submit_bulk_read");
 266
 267         return IO(*this, rd);
 268 }
 269
 270 IO Device::ABulkWrite(int ep, const Data &data)
 271 {
 272         ddout("ABulkWrite to endpoint " << ep << ":\n" << data);
 273         libusb_io_handle_t *wr = libusb_submit_bulk_write(GetHandle(), ep,
 274                 data.GetData(), data.GetSize(), m_timeout, NULL);
 275         if( !wr )
 276                 throw UsbError("Error in libusb_submit_bulk_write");
 277
 278         return IO(*this, wr);
 279 }
 280
 281 IO Device::ABulkWrite(int ep, const void *data, size_t size)
 282 {
 283 #ifdef __DEBUG_MODE__
 284         Data dump(data, size);
 285         ddout("ABulkWrite to endpoint " << ep << ":\n" << dump);
 286 #endif
 287
 288         libusb_io_handle_t *wr = libusb_submit_bulk_write(GetHandle(), ep,
 289                 data, size, m_timeout, NULL);
 290         if( !wr )
 291                 throw UsbError("Error in libusb_submit_bulk_write");
 292
 293         return IO(*this, wr);
 294 }
 295
 296 IO Device::AInterruptRead(int ep, Data &data)
 297 {
 298         libusb_io_handle_t *rd = libusb_submit_interrupt_read( GetHandle(), ep,
 299                 data.GetBuffer(), data.GetBufSize(), m_timeout, NULL);
 300         if( !rd )
 301                 throw UsbError("Error in libusb_submit_interrupt_read");
 302
 303         return IO(*this, rd);
 304 }
 305
 306 IO Device::AInterruptWrite(int ep, const Data &data)
 307 {
 308         ddout("AInterruptWrite to endpoint " << ep << ":\n" << data);
 309         libusb_io_handle_t *wr = libusb_submit_interrupt_write(GetHandle(), ep,
 310                 data.GetData(), data.GetSize(), m_timeout, NULL);
 311         if( !wr )
 312                 throw UsbError("Error in libusb_submit_interrupt_write");
 313
 314         return IO(*this, wr);
 315 }
 316
 317
 318
 319 ///////////////////////////////////////////////////////////////////////////////
 320 // EndpointDiscovery
 321
 322 bool EndpointDiscovery::Discover(libusb_device_id_t devid, int cfgidx, int ifcidx, int epcount)
 323 {
 324         // start fresh
 325         clear();
 326         m_valid = false;
 327
 328         EndpointPair pair;
 329
 330         for( int i = 0; i < epcount; i++ ) {
 331                 // load descriptor
 332                 usb_endpoint_desc desc;
 333                 if( libusb_get_endpoint_desc(devid, cfgidx, ifcidx, i, &desc) < 0 )
 334                         return false;
 335                 dout("      endpoint_desc #" << i << " loaded");
 336
 337                 // add to the map
 338                 (*this)[desc.bEndpointAddress] = desc;
 339                 dout("      endpoint added to map with bEndpointAddress: " << (unsigned int)desc.bEndpointAddress);
 340
 341                 // parse the endpoint into read/write sets, if possible,
 342                 // going in discovery order...
 343                 // Assumptions:
 344                 //      - endpoints of related utility will be grouped
 345                 //      - endpoints with same type will be grouped
 346                 //      - endpoints that do not meet the above assumptions
 347                 //              do not belong in a pair
 348                 unsigned char type = desc.bmAttributes & USB_ENDPOINT_TYPE_MASK;
 349                 if( desc.bEndpointAddress & USB_ENDPOINT_DIR_MASK ) {
 350                         // read endpoint
 351                         pair.read = desc.bEndpointAddress;
 352                         dout("        pair.read = " << (unsigned int)pair.read);
 353                         if( pair.IsTypeSet() && pair.type != type ) {
 354                                 // if type is already set, we must start over
 355                                 pair.write = 0;
 356                         }
 357                 }
 358                 else {
 359                         // write endpoint
 360                         pair.write = desc.bEndpointAddress;
 361                         dout("        pair.write = " << (unsigned int)pair.write);
 362                         if( pair.IsTypeSet() && pair.type != type ) {
 363                                 // if type is already set, we must start over
 364                                 pair.read = 0;
 365                         }
 366                 }
 367                 // save the type last
 368                 pair.type = type;
 369                 dout("        pair.type = " << (unsigned int)pair.type);
 370
 371                 // if pair is complete, add to array
 372                 if( pair.IsComplete() ) {
 373                         m_endpoints.push_back(pair);
 374                         dout("        pair added! ("
 375                                 << (unsigned int)pair.read << ","
 376                                 << (unsigned int)pair.write << ","
 377                                 << (unsigned int)pair.type << ")");
 378                         pair = EndpointPair();  // clear
 379                 }
 380         }
 381
 382         return m_valid = true;
 383 }
 384
 385
 386 ///////////////////////////////////////////////////////////////////////////////
 387 // InterfaceDiscovery
 388
 389 bool InterfaceDiscovery::Discover(libusb_device_id_t devid, int cfgidx, int ifcount)
 390 {
 391         // start fresh
 392         clear();
 393         m_valid = false;
 394
 395         for( int i = 0; i < ifcount; i++ ) {
 396                 // load descriptor
 397                 InterfaceDesc desc;
 398                 if( libusb_get_interface_desc(devid, cfgidx, i, &desc.desc) < 0 )
 399                         return false;
 400                 dout("    interface_desc #" << i << " loaded");
 401
 402                 // load all endpoints on this interface
 403                 if( !desc.endpoints.Discover(devid, cfgidx, i, desc.desc.bNumEndpoints) )
 404                         return false;
 405
 406                 // add to the map
 407                 (*this)[desc.desc.bInterfaceNumber] = desc;
 408                 dout("    interface added to map with bInterfaceNumber: " << (unsigned int)desc.desc.bInterfaceNumber);
 409         }
 410
 411         return m_valid = true;
 412 }
 413
 414
 415 ///////////////////////////////////////////////////////////////////////////////
 416 // ConfigDiscovery
 417
 418 bool ConfigDiscovery::Discover(libusb_device_id_t devid, int cfgcount)
 419 {
 420         // start fresh
 421         clear();
 422         m_valid = false;
 423
 424         for( int i = 0; i < cfgcount; i++ ) {
 425                 // load descriptor
 426                 ConfigDesc desc;
 427                 if( libusb_get_config_desc(devid, i, &desc.desc) < 0 )
 428                         return false;
 429                 dout("  config_desc #" << i << " loaded");
 430
 431                 // load all interfaces on this configuration
 432                 if( !desc.interfaces.Discover(devid, i, desc.desc.bNumInterfaces) )
 433                         return false;
 434
 435                 // add to the map
 436                 (*this)[desc.desc.bConfigurationValue] = desc;
 437                 dout("  config added to map with bConfigurationValue: " << (unsigned int)desc.desc.bConfigurationValue);
 438         }
 439
 440         return m_valid = true;
 441 }
 442
 443
 444 ///////////////////////////////////////////////////////////////////////////////
 445 // DeviceDiscovery
 446
 447 DeviceDiscovery::DeviceDiscovery(libusb_device_id_t devid)
 448         : m_valid(false)
 449 {
 450         Discover(devid);
 451 }
 452
 453 bool DeviceDiscovery::Discover(libusb_device_id_t devid)
 454 {
 455         // start fresh
 456         configs.clear();
 457         m_valid = false;
 458
 459         if( libusb_get_device_desc(devid, &desc) < 0 )
 460                 return false;
 461         dout("device_desc loaded");
 462
 463         m_valid = configs.Discover(devid, desc.bNumConfigurations);
 464         return m_valid;
 465 }
 466
 467 } // namespace Usb
 468