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