src/usbwrap.h

   1 ///
   2 /// \file       usbwrap.h
   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 #ifndef __SB_USBWRAP_H__
  24 #define __SB_USBWRAP_H__
  25
  26 #include "dll.h"
  27
  28 // On Windows systems, usb.h includes <windows.h> which defines min/max,
  29 // which causes trouble for other headers
  30 #include <usb.h>
  31 #undef min
  32 #undef max
  33
  34 #include <vector>
  35 #include <map>
  36 #include "error.h"
  37
  38 #define USBWRAP_DEFAULT_TIMEOUT 30000
  39
  40 namespace Barry { class Data; }
  41
  42 /// Namespace for the libusb-related wrapper classes.  This namespace
  43 /// may change in the future.
  44 namespace Usb {
  45
  46 /// \addtogroup exceptions
  47 /// @{
  48
  49 /// Thrown on low level USB errors.
  50 class BXEXPORT Error : public Barry::Error
  51 {
  52         int m_libusb_errcode;
  53
  54 public:
  55         Error(const std::string &str);
  56         Error(int libusb_errcode, const std::string &str);
  57
  58         // can return 0 in some case, if unknown error code
  59         int libusb_errcode() const { return m_libusb_errcode; }
  60 };
  61
  62 class BXEXPORT Timeout : public Error
  63 {
  64 public:
  65         Timeout(const std::string &str) : Error(str) {}
  66         Timeout(int libusb_errcode, const std::string &str)
  67                 : Error(libusb_errcode, str) {}
  68 };
  69
  70 /// @}
  71
  72 /// Typedefs used by the wrapper class, in the hope to make it
  73 /// easier to switch from libusb stable to devel and back.
  74 typedef struct usb_device*                      DeviceIDType;
  75 typedef struct usb_dev_handle*                  DeviceHandleType;
  76
  77 class BXEXPORT Match
  78 {
  79 private:
  80         struct usb_bus *m_busses;
  81         struct usb_device *m_dev;
  82         int m_vendor, m_product;
  83         int m_lasterror;
  84         const char *m_busname;
  85         const char *m_devname;
  86 protected:
  87         static bool ToNum(const char *str, long &num);
  88         static bool NameCompare(const char *n1, const char *n2);
  89 public:
  90         Match(int vendor, int product,
  91                 const char *busname = 0, const char *devname = 0);
  92         ~Match();
  93
  94         // searches for next match, and if found, fills devid with
  95         // something you can pass on to DeviceDiscover, etc
  96         // returns true if next is found, false if no more
  97         bool next_device(Usb::DeviceIDType *devid);
  98 };
  99
 100
 101 class BXEXPORT Device
 102 {
 103 private:
 104         Usb::DeviceIDType m_id;
 105         Usb::DeviceHandleType m_handle;
 106
 107         int m_timeout;
 108         int m_lasterror;
 109
 110 public:
 111         Device(Usb::DeviceIDType id, int timeout = USBWRAP_DEFAULT_TIMEOUT);
 112         ~Device();
 113
 114         /////////////////////////////
 115         // Data access
 116
 117         Usb::DeviceIDType GetID() const { return m_id; }
 118         Usb::DeviceHandleType GetHandle() const { return m_handle; }
 119         int GetLastError() const { return m_lasterror; } //< not thread safe...
 120                 //< use the error code stored in the exceptions to track
 121                 //< errors in threaded usage
 122
 123
 124         /////////////////////////////
 125         // Device manipulation
 126
 127         bool SetConfiguration(unsigned char cfg);
 128         bool ClearHalt(int ep);
 129         bool Reset();
 130
 131
 132         /////////////////////////////
 133         // IO functions
 134
 135         bool BulkRead(int ep, Barry::Data &data, int timeout = -1);
 136         bool BulkWrite(int ep, const Barry::Data &data, int timeout = -1);
 137         bool BulkWrite(int ep, const void *data, size_t size, int timeout = -1);
 138         bool InterruptRead(int ep, Barry::Data &data, int timeout = -1);
 139         bool InterruptWrite(int ep, const Barry::Data &data, int timeout = -1);
 140
 141         void BulkDrain(int ep, int timeout = 100);
 142
 143
 144         /////////////////////////////
 145         // Combo functions
 146
 147         bool GetConfiguration(unsigned char &cfg);
 148         bool SetAltInterface(int iface);
 149 };
 150
 151 class BXEXPORT Interface
 152 {
 153         Device &m_dev;
 154         int m_iface;
 155 public:
 156         Interface(Device &dev, int iface);
 157         ~Interface();
 158 };
 159
 160
 161
 162
 163 // Map of Endpoint numbers (not indexes) to endpoint descriptors
 164 struct BXEXPORT EndpointPair
 165 {
 166         unsigned char read;
 167         unsigned char write;
 168         unsigned char type;
 169
 170         EndpointPair() : read(0), write(0), type(0xff) {}
 171         bool IsTypeSet() const { return type != 0xff; }
 172         bool IsComplete() const { return read && write && IsTypeSet(); }
 173 };
 174
 175 class BXEXPORT EndpointDiscovery : public std::map<unsigned char, usb_endpoint_descriptor>
 176 {
 177         friend class InterfaceDiscovery;
 178
 179 public:
 180         typedef std::map<unsigned char, usb_endpoint_descriptor>base_type;
 181         typedef std::vector<EndpointPair>                       endpoint_array_type;
 182
 183 private:
 184         bool m_valid;
 185         endpoint_array_type m_endpoints;
 186
 187         BXLOCAL bool Discover(struct usb_interface_descriptor *interface, int epcount);
 188
 189 public:
 190         EndpointDiscovery() : m_valid(false) {}
 191
 192         bool IsValid() const { return m_valid; }
 193
 194         const endpoint_array_type & GetEndpointPairs() const { return m_endpoints; }
 195 };
 196
 197
 198
 199 // Map of Interface numbers (not indexes) to interface descriptors and endpoint map
 200 struct BXEXPORT InterfaceDesc
 201 {
 202         usb_interface_descriptor desc;
 203         EndpointDiscovery endpoints;
 204 };
 205
 206 class BXEXPORT InterfaceDiscovery : public std::map<int, InterfaceDesc>
 207 {
 208 public:
 209         typedef std::map<int, InterfaceDesc>                    base_type;
 210
 211 private:
 212         bool m_valid;
 213
 214         BXLOCAL bool DiscoverInterface(struct usb_interface *interface);
 215
 216 public:
 217         InterfaceDiscovery() : m_valid(false) {}
 218
 219         bool Discover(Usb::DeviceIDType devid, int cfgidx, int ifcount);
 220         bool IsValid() const { return m_valid; }
 221 };
 222
 223
 224
 225
 226 // Map of Config numbers (not indexes) to config descriptors and interface map
 227 struct BXEXPORT ConfigDesc
 228 {
 229         usb_config_descriptor desc;
 230         InterfaceDiscovery interfaces;
 231 };
 232
 233 class BXEXPORT ConfigDiscovery : public std::map<unsigned char, ConfigDesc>
 234 {
 235 public:
 236         typedef std::map<unsigned char, ConfigDesc>             base_type;
 237
 238 private:
 239         bool m_valid;
 240
 241 public:
 242         ConfigDiscovery() : m_valid(false) {}
 243
 244         bool Discover(Usb::DeviceIDType devid, int cfgcount);
 245         bool IsValid() const { return m_valid; }
 246 };
 247
 248
 249
 250 // Discovers all configurations, interfaces, and endpoints for a given device
 251 class BXEXPORT DeviceDiscovery
 252 {
 253         bool m_valid;
 254
 255 public:
 256         usb_device_descriptor desc;
 257         ConfigDiscovery configs;
 258
 259 public:
 260         DeviceDiscovery(Usb::DeviceIDType devid);
 261
 262         bool Discover(Usb::DeviceIDType devid);
 263         bool IsValid() const { return m_valid; }
 264 };
 265
 266 } // namespace Usb
 267
 268 #endif
 269