git.rot13.org Git - librfid/blob - src/libusb_dyn.c

   1 /* LIBUSB-WIN32, Generic Windows USB Library
   2  * Copyright (c) 2002-2005 Stephan Meyer <ste_meyer@web.de>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19
  20 #include <windows.h>
  21 #include <errno.h>
  22
  23 #include "libusb_dyn.h"
  24
  25 #define LIBUSB_DLL_NAME "libusb0.dll"
  26
  27 typedef usb_dev_handle * (*usb_open_t)(struct usb_device *dev);
  28 typedef int (*usb_close_t)(usb_dev_handle *dev);
  29 typedef int (*usb_get_string_t)(usb_dev_handle *dev, int index, int langid,
  30                                 char *buf, size_t buflen);
  31 typedef int (*usb_get_string_simple_t)(usb_dev_handle *dev, int index,
  32                                        char *buf, size_t buflen);
  33 typedef int (*usb_get_descriptor_by_endpoint_t)(usb_dev_handle *udev, int ep,
  34                                                 unsigned char type,
  35                                                 unsigned char index,
  36                                                 void *buf, int size);
  37 typedef int (*usb_get_descriptor_t)(usb_dev_handle *udev, unsigned char type,
  38                                     unsigned char index, void *buf, int size);
  39 typedef int (*usb_bulk_write_t)(usb_dev_handle *dev, int ep, char *bytes,
  40                                 int size, int timeout);
  41 typedef int (*usb_bulk_read_t)(usb_dev_handle *dev, int ep, char *bytes,
  42                                int size, int timeout);
  43 typedef int (*usb_interrupt_write_t)(usb_dev_handle *dev, int ep, char *bytes,
  44                                      int size, int timeout);
  45 typedef int (*usb_interrupt_read_t)(usb_dev_handle *dev, int ep, char *bytes,
  46                                     int size, int timeout);
  47 typedef int (*usb_control_msg_t)(usb_dev_handle *dev, int requesttype,
  48                                  int request, int value, int index,
  49                                  char *bytes, int size, int timeout);
  50 typedef int (*usb_set_configuration_t)(usb_dev_handle *dev, int configuration);
  51 typedef int (*usb_claim_interface_t)(usb_dev_handle *dev, int interface);
  52 typedef int (*usb_release_interface_t)(usb_dev_handle *dev, int interface);
  53 typedef int (*usb_set_altinterface_t)(usb_dev_handle *dev, int alternate);
  54 typedef int (*usb_resetep_t)(usb_dev_handle *dev, unsigned int ep);
  55 typedef int (*usb_clear_halt_t)(usb_dev_handle *dev, unsigned int ep);
  56 typedef int (*usb_reset_t)(usb_dev_handle *dev);
  57 typedef char * (*usb_strerror_t)(void);
  58 typedef void (*usb_init_t)(void);
  59 typedef void (*usb_set_debug_t)(int level);
  60 typedef int (*usb_find_busses_t)(void);
  61 typedef int (*usb_find_devices_t)(void);
  62 typedef struct usb_device * (*usb_device_t)(usb_dev_handle *dev);
  63 typedef struct usb_bus * (*usb_get_busses_t)(void);
  64 typedef int (*usb_install_service_np_t)(void);
  65 typedef int (*usb_uninstall_service_np_t)(void);
  66 typedef int (*usb_install_driver_np_t)(const char *inf_file);
  67 typedef const struct usb_version * (*usb_get_version_t)(void);
  68 typedef int (*usb_isochronous_setup_async_t)(usb_dev_handle *dev,
  69                                              void **context,
  70                                              unsigned char ep, int pktsize);
  71 typedef int (*usb_bulk_setup_async_t)(usb_dev_handle *dev, void **context,
  72                                       unsigned char ep);
  73 typedef int (*usb_interrupt_setup_async_t)(usb_dev_handle *dev, void **context,
  74                                            unsigned char ep);
  75 typedef int (*usb_submit_async_t)(void *context, char *bytes, int size);
  76 typedef int (*usb_reap_async_t)(void *context, int timeout);
  77 typedef int (*usb_free_async_t)(void **context);
  78
  79
  80 static usb_open_t _usb_open = NULL;
  81 static usb_close_t _usb_close = NULL;
  82 static usb_get_string_t _usb_get_string = NULL;
  83 static usb_get_string_simple_t _usb_get_string_simple = NULL;
  84 static usb_get_descriptor_by_endpoint_t _usb_get_descriptor_by_endpoint = NULL;
  85 static usb_get_descriptor_t _usb_get_descriptor = NULL;
  86 static usb_bulk_write_t _usb_bulk_write = NULL;
  87 static usb_bulk_read_t _usb_bulk_read = NULL;
  88 static usb_interrupt_write_t _usb_interrupt_write = NULL;
  89 static usb_interrupt_read_t _usb_interrupt_read = NULL;
  90 static usb_control_msg_t _usb_control_msg = NULL;
  91 static usb_set_configuration_t _usb_set_configuration = NULL;
  92 static usb_claim_interface_t _usb_claim_interface = NULL;
  93 static usb_release_interface_t _usb_release_interface = NULL;
  94 static usb_set_altinterface_t _usb_set_altinterface = NULL;
  95 static usb_resetep_t _usb_resetep = NULL;
  96 static usb_clear_halt_t _usb_clear_halt = NULL;
  97 static usb_reset_t _usb_reset = NULL;
  98 static usb_strerror_t _usb_strerror = NULL;
  99 static usb_init_t _usb_init = NULL;
 100 static usb_set_debug_t _usb_set_debug = NULL;
 101 static usb_find_busses_t _usb_find_busses = NULL;
 102 static usb_find_devices_t _usb_find_devices = NULL;
 103 static usb_device_t _usb_device = NULL;
 104 static usb_get_busses_t _usb_get_busses = NULL;
 105 static usb_install_service_np_t _usb_install_service_np = NULL;
 106 static usb_uninstall_service_np_t _usb_uninstall_service_np = NULL;
 107 static usb_install_driver_np_t _usb_install_driver_np = NULL;
 108 static usb_get_version_t _usb_get_version = NULL;
 109 static usb_isochronous_setup_async_t _usb_isochronous_setup_async = NULL;
 110 static usb_bulk_setup_async_t _usb_bulk_setup_async = NULL;
 111 static usb_interrupt_setup_async_t _usb_interrupt_setup_async = NULL;
 112 static usb_submit_async_t _usb_submit_async = NULL;
 113 static usb_reap_async_t _usb_reap_async = NULL;
 114 static usb_free_async_t _usb_free_async = NULL;
 115
 116
 117 void usb_init(void)
 118 {
 119   HINSTANCE libusb_dll  = LoadLibrary(LIBUSB_DLL_NAME);
 120
 121   if(!libusb_dll)
 122     return;
 123
 124   timeBeginPeriod(1);
 125
 126   _usb_open = (usb_open_t)
 127     GetProcAddress(libusb_dll, "usb_open");
 128   _usb_close = (usb_close_t)
 129     GetProcAddress(libusb_dll, "usb_close");
 130   _usb_get_string = (usb_get_string_t)
 131     GetProcAddress(libusb_dll, "usb_get_string");
 132   _usb_get_string_simple = (usb_get_string_simple_t)
 133     GetProcAddress(libusb_dll, "usb_get_string_simple");
 134   _usb_get_descriptor_by_endpoint = (usb_get_descriptor_by_endpoint_t)
 135     GetProcAddress(libusb_dll, "usb_get_descriptor_by_endpoint");
 136   _usb_get_descriptor = (usb_get_descriptor_t)
 137     GetProcAddress(libusb_dll, "usb_get_descriptor");
 138   _usb_bulk_write = (usb_bulk_write_t)
 139     GetProcAddress(libusb_dll, "usb_bulk_write");
 140   _usb_bulk_read = (usb_bulk_read_t)
 141     GetProcAddress(libusb_dll, "usb_bulk_read");
 142   _usb_interrupt_write = (usb_interrupt_write_t)
 143     GetProcAddress(libusb_dll, "usb_interrupt_write");
 144   _usb_interrupt_read = (usb_interrupt_read_t)
 145     GetProcAddress(libusb_dll, "usb_interrupt_read");
 146   _usb_control_msg = (usb_control_msg_t)
 147     GetProcAddress(libusb_dll, "usb_control_msg");
 148   _usb_set_configuration = (usb_set_configuration_t)
 149     GetProcAddress(libusb_dll, "usb_set_configuration");
 150   _usb_claim_interface = (usb_claim_interface_t)
 151     GetProcAddress(libusb_dll, "usb_claim_interface");
 152   _usb_release_interface = (usb_release_interface_t)
 153     GetProcAddress(libusb_dll, "usb_release_interface");
 154   _usb_set_altinterface = (usb_set_altinterface_t)
 155     GetProcAddress(libusb_dll, "usb_set_altinterface");
 156   _usb_resetep = (usb_resetep_t)
 157     GetProcAddress(libusb_dll, "usb_resetep");
 158   _usb_clear_halt = (usb_clear_halt_t)
 159     GetProcAddress(libusb_dll, "usb_clear_halt");
 160   _usb_reset = (usb_reset_t)
 161     GetProcAddress(libusb_dll, "usb_reset");
 162   _usb_strerror = (usb_strerror_t)
 163     GetProcAddress(libusb_dll, "usb_strerror");
 164   _usb_init = (usb_init_t)
 165     GetProcAddress(libusb_dll, "usb_init");
 166   _usb_set_debug = (usb_set_debug_t)
 167     GetProcAddress(libusb_dll, "usb_set_debug");
 168   _usb_find_busses = (usb_find_busses_t)
 169     GetProcAddress(libusb_dll, "usb_find_busses");
 170   _usb_find_devices = (usb_find_devices_t)
 171     GetProcAddress(libusb_dll, "usb_find_devices");
 172   _usb_device = (usb_device_t)
 173     GetProcAddress(libusb_dll, "usb_device");
 174   _usb_get_busses = (usb_get_busses_t)
 175     GetProcAddress(libusb_dll, "usb_get_busses");
 176   _usb_install_service_np = (usb_install_service_np_t)
 177     GetProcAddress(libusb_dll, "usb_install_service_np");
 178   _usb_uninstall_service_np = (usb_uninstall_service_np_t)
 179     GetProcAddress(libusb_dll, "usb_uninstall_service_np");
 180   _usb_install_driver_np = (usb_install_driver_np_t)
 181     GetProcAddress(libusb_dll, "usb_install_driver_np");
 182   _usb_get_version = (usb_get_version_t)
 183     GetProcAddress(libusb_dll, "usb_get_version");
 184   _usb_isochronous_setup_async = (usb_isochronous_setup_async_t)
 185     GetProcAddress(libusb_dll, "usb_isochronous_setup_async");
 186   _usb_bulk_setup_async = (usb_bulk_setup_async_t)
 187     GetProcAddress(libusb_dll, "usb_bulk_setup_async");
 188   _usb_interrupt_setup_async = (usb_interrupt_setup_async_t)
 189     GetProcAddress(libusb_dll, "usb_interrupt_setup_async");
 190   _usb_submit_async = (usb_submit_async_t)
 191     GetProcAddress(libusb_dll, "usb_submit_async");
 192   _usb_reap_async = (usb_reap_async_t)
 193     GetProcAddress(libusb_dll, "usb_reap_async");
 194   _usb_free_async = (usb_free_async_t)
 195     GetProcAddress(libusb_dll, "usb_free_async");
 196
 197   if(_usb_init)
 198     _usb_init();
 199 }
 200
 201 usb_dev_handle *usb_open(struct usb_device *dev)
 202 {
 203   if(_usb_open)
 204     return _usb_open(dev);
 205   else
 206     return NULL;
 207 }
 208
 209 int usb_close(usb_dev_handle *dev)
 210 {
 211   if(_usb_close)
 212     return _usb_close(dev);
 213   else
 214     return -ENOFILE;
 215 }
 216
 217 int usb_get_string(usb_dev_handle *dev, int index, int langid, char *buf,
 218                    size_t buflen)
 219 {
 220   if(_usb_get_string)
 221     return _usb_get_string(dev, index, langid, buf, buflen);
 222   else
 223     return -ENOFILE;
 224 }
 225
 226 int usb_get_string_simple(usb_dev_handle *dev, int index, char *buf,
 227                           size_t buflen)
 228 {
 229   if(_usb_get_string_simple)
 230     return _usb_get_string_simple(dev, index, buf, buflen);
 231   else
 232     return -ENOFILE;
 233 }
 234
 235 int usb_get_descriptor_by_endpoint(usb_dev_handle *udev, int ep,
 236                                    unsigned char type, unsigned char index,
 237                                    void *buf, int size)
 238 {
 239   if(_usb_get_descriptor_by_endpoint)
 240     return _usb_get_descriptor_by_endpoint(udev, ep, type, index, buf, size);
 241   else
 242     return -ENOFILE;
 243 }
 244
 245 int usb_get_descriptor(usb_dev_handle *udev, unsigned char type,
 246                        unsigned char index, void *buf, int size)
 247 {
 248   if(_usb_get_descriptor)
 249     return _usb_get_descriptor(udev, type, index, buf, size);
 250   else
 251     return -ENOFILE;
 252 }
 253
 254 int usb_bulk_write(usb_dev_handle *dev, int ep, char *bytes, int size,
 255                    int timeout)
 256 {
 257   if(_usb_bulk_write)
 258     return _usb_bulk_write(dev, ep, bytes, size, timeout);
 259   else
 260     return -ENOFILE;
 261 }
 262
 263 int usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size,
 264                   int timeout)
 265 {
 266   if(_usb_bulk_read)
 267     return _usb_bulk_read(dev, ep, bytes, size, timeout);
 268   else
 269     return -ENOFILE;
 270 }
 271
 272 int usb_interrupt_write(usb_dev_handle *dev, int ep, char *bytes, int size,
 273                         int timeout)
 274 {
 275   if(_usb_interrupt_write)
 276     return _usb_interrupt_write(dev, ep, bytes, size, timeout);
 277   else
 278     return -ENOFILE;
 279 }
 280
 281 int usb_interrupt_read(usb_dev_handle *dev, int ep, char *bytes, int size,
 282                        int timeout)
 283 {
 284   if(_usb_interrupt_read)
 285     return _usb_interrupt_read(dev, ep, bytes, size, timeout);
 286   else
 287     return -ENOFILE;
 288 }
 289
 290 int usb_control_msg(usb_dev_handle *dev, int requesttype, int request,
 291                     int value, int index, char *bytes, int size,
 292                     int timeout)
 293 {
 294   if(_usb_control_msg)
 295     return _usb_control_msg(dev, requesttype, request, value, index, bytes,
 296                             size, timeout);
 297   else
 298     return -ENOFILE;
 299 }
 300
 301 int usb_set_configuration(usb_dev_handle *dev, int configuration)
 302 {
 303   if(_usb_set_configuration)
 304     return _usb_set_configuration(dev, configuration);
 305   else
 306     return -ENOFILE;
 307 }
 308
 309 int usb_claim_interface(usb_dev_handle *dev, int interface)
 310 {
 311   if(_usb_claim_interface)
 312     return _usb_claim_interface(dev, interface);
 313   else
 314     return -ENOFILE;
 315 }
 316
 317 int usb_release_interface(usb_dev_handle *dev, int interface)
 318 {
 319   if(_usb_release_interface)
 320     return _usb_release_interface(dev, interface);
 321   else
 322     return -ENOFILE;
 323 }
 324
 325 int usb_set_altinterface(usb_dev_handle *dev, int alternate)
 326 {
 327   if(_usb_set_altinterface)
 328     return _usb_set_altinterface(dev, alternate);
 329   else
 330     return -ENOFILE;
 331 }
 332
 333 int usb_resetep(usb_dev_handle *dev, unsigned int ep)
 334 {
 335   if(_usb_resetep)
 336     return _usb_resetep(dev, ep);
 337   else
 338     return -ENOFILE;
 339 }
 340
 341 int usb_clear_halt(usb_dev_handle *dev, unsigned int ep)
 342 {
 343   if(_usb_clear_halt)
 344     return _usb_clear_halt(dev, ep);
 345   else
 346     return -ENOFILE;
 347 }
 348
 349 int usb_reset(usb_dev_handle *dev)
 350 {
 351   if(_usb_reset)
 352     return _usb_reset(dev);
 353   else
 354     return -ENOFILE;
 355 }
 356
 357 char *usb_strerror(void)
 358 {
 359   if(_usb_strerror)
 360     return _usb_strerror();
 361   else
 362     return NULL;
 363 }
 364
 365 void usb_set_debug(int level)
 366 {
 367   if(_usb_set_debug)
 368     return _usb_set_debug(level);
 369 }
 370
 371 int usb_find_busses(void)
 372 {
 373   if(_usb_find_busses)
 374     return _usb_find_busses();
 375   else
 376     return -ENOFILE;
 377 }
 378
 379 int usb_find_devices(void)
 380 {
 381   if(_usb_find_devices)
 382     return _usb_find_devices();
 383   else
 384     return -ENOFILE;
 385 }
 386
 387 struct usb_device *usb_device(usb_dev_handle *dev)
 388 {
 389   if(_usb_device)
 390     return _usb_device(dev);
 391   else
 392     return NULL;
 393 }
 394
 395 struct usb_bus *usb_get_busses(void)
 396 {
 397   if(_usb_get_busses)
 398     return _usb_get_busses();
 399   else
 400     return NULL;
 401 }
 402
 403 int usb_install_service_np(void)
 404 {
 405   if(_usb_install_service_np)
 406     return _usb_install_service_np();
 407   else
 408     return -ENOFILE;
 409 }
 410
 411 int usb_uninstall_service_np(void)
 412 {
 413   if(_usb_uninstall_service_np)
 414     return _usb_uninstall_service_np();
 415   else
 416     return -ENOFILE;
 417 }
 418
 419 int usb_install_driver_np(const char *inf_file)
 420 {
 421   if(_usb_install_driver_np)
 422     return _usb_install_driver_np(inf_file);
 423   else
 424     return -ENOFILE;
 425 }
 426
 427 const struct usb_version *usb_get_version(void)
 428 {
 429   if(_usb_get_version)
 430     return _usb_get_version();
 431   else
 432     return NULL;
 433 }
 434
 435 int usb_isochronous_setup_async(usb_dev_handle *dev, void **context,
 436                                 unsigned char ep, int pktsize)
 437 {
 438   if(_usb_isochronous_setup_async)
 439     return _usb_isochronous_setup_async(dev, context, ep, pktsize);
 440   else
 441     return -ENOFILE;
 442 }
 443
 444 int usb_bulk_setup_async(usb_dev_handle *dev, void **context,
 445                          unsigned char ep)
 446 {
 447   if(_usb_bulk_setup_async)
 448     return _usb_bulk_setup_async(dev, context, ep);
 449   else
 450     return -ENOFILE;
 451 }
 452
 453 int usb_interrupt_setup_async(usb_dev_handle *dev, void **context,
 454                               unsigned char ep)
 455 {
 456   if(_usb_interrupt_setup_async)
 457     return _usb_interrupt_setup_async(dev, context, ep);
 458   else
 459     return -ENOFILE;
 460 }
 461
 462 int usb_submit_async(void *context, char *bytes, int size)
 463 {
 464   if(_usb_submit_async)
 465     return _usb_submit_async(context, bytes, size);
 466   else
 467     return -ENOFILE;
 468 }
 469
 470 int usb_reap_async(void *context, int timeout)
 471 {
 472   if(_usb_reap_async)
 473     return _usb_reap_async(context, timeout);
 474   else
 475     return -ENOFILE;
 476 }
 477
 478 int usb_free_async(void **context)
 479 {
 480   if(_usb_free_async)
 481     return _usb_free_async(context);
 482   else
 483     return -ENOFILE;
 484 }