src/usbwrap.h

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