src/usbwrap.h

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