git.zerfleddert.de Git - usb-driver/blob - usb-driver.c

   1 /* libusb connector for XILINX impact
   2  *
   3  * Copyright (c) 2007 Michael Gernoth <michael@gernoth.net>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy
   6  * of this software and associated documentation files (the "Software"), to
   7  * deal in the Software without restriction, including without limitation the
   8  * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
   9  * sell copies of the Software, and to permit persons to whom the Software is
  10  * furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice shall be included in
  13  * all copies or substantial portions of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  18  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  */
  23
  24 #define _GNU_SOURCE 1
  25
  26 #include <dlfcn.h>
  27 #include <stdarg.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31 #include <fcntl.h>
  32 #include <sys/types.h>
  33 #include <sys/stat.h>
  34 #include <sys/time.h>
  35 #include <stdio.h>
  36 #include <usb.h>
  37 #include <signal.h>
  38 #include <pthread.h>
  39 #include <errno.h>
  40 #include <inttypes.h>
  41 #include "usb-driver.h"
  42
  43 static int (*ioctl_func) (int, int, void *) = NULL;
  44 static int windrvrfd = -1;
  45 FILE *modulesfp = NULL;
  46 static int modules_read = 0;
  47 static struct usb_bus *busses = NULL;
  48 static struct usb_device *usbdevice;
  49 static usb_dev_handle *usb_devhandle = NULL;
  50 static int usbinterface = -1;
  51 static unsigned long card_type;
  52 static int ints_enabled = 0;
  53 static pthread_mutex_t int_wait = PTHREAD_MUTEX_INITIALIZER;
  54
  55 #define NO_WINDRVR 1
  56
  57 #ifdef DEBUG
  58 #define DPRINTF(format, args...) fprintf(stderr, format, ##args)
  59 void hexdump(unsigned char *buf, int len) {
  60         int i;
  61
  62         for(i=0; i<len; i++) {
  63                 fprintf(stderr,"%02x ", buf[i]);
  64                 if ((i % 16) == 15)
  65                         fprintf(stderr,"\n");
  66         }
  67         fprintf(stderr,"\n");
  68 }
  69 #else
  70 #define DPRINTF(format, args...)
  71 #endif
  72
  73 int usb_deviceinfo(unsigned char *buf) {
  74         int i,j,k,l;
  75         int len = 0;
  76         WDU_CONFIGURATION **pConfigs, **pActiveConfig;
  77         WDU_INTERFACE **pActiveInterface;
  78
  79         if (buf) {
  80                 struct usb_device_info *udi = (struct usb_device_info*)(buf+len);
  81
  82                 udi->Descriptor.bLength = sizeof(WDU_DEVICE_DESCRIPTOR);
  83                 udi->Descriptor.bDescriptorType = usbdevice->descriptor.bDescriptorType;
  84                 udi->Descriptor.bcdUSB = usbdevice->descriptor.bcdUSB;
  85                 udi->Descriptor.bDeviceClass = usbdevice->descriptor.bDeviceClass;
  86                 udi->Descriptor.bDeviceSubClass = usbdevice->descriptor.bDeviceSubClass;
  87                 udi->Descriptor.bDeviceProtocol = usbdevice->descriptor.bDeviceProtocol;
  88                 udi->Descriptor.bMaxPacketSize0 = usbdevice->descriptor.bMaxPacketSize0;
  89                 udi->Descriptor.idVendor = usbdevice->descriptor.idVendor;
  90                 udi->Descriptor.idProduct = usbdevice->descriptor.idProduct;
  91                 udi->Descriptor.bcdDevice = usbdevice->descriptor.bcdDevice;
  92                 udi->Descriptor.iManufacturer = usbdevice->descriptor.iManufacturer;
  93                 udi->Descriptor.iProduct = usbdevice->descriptor.iProduct;
  94                 udi->Descriptor.iSerialNumber = usbdevice->descriptor.iSerialNumber;
  95                 udi->Descriptor.bNumConfigurations = usbdevice->descriptor.bNumConfigurations;
  96
  97                 /* TODO: Fix Pipe0! */
  98                 udi->Pipe0.dwNumber = 0x00;
  99                 udi->Pipe0.dwMaximumPacketSize = usbdevice->descriptor.bMaxPacketSize0;
 100                 udi->Pipe0.type = 0;
 101                 udi->Pipe0.direction = WDU_DIR_IN_OUT;
 102                 udi->Pipe0.dwInterval = 0;
 103
 104                 pConfigs = &(udi->pConfigs);
 105                 pActiveConfig = &(udi->pActiveConfig);
 106                 pActiveInterface = &(udi->pActiveInterface[0]);
 107         }
 108
 109         len = sizeof(struct usb_device_info);
 110
 111         for (i=0; i<usbdevice->descriptor.bNumConfigurations; i++)
 112         {
 113                 struct usb_config_descriptor *conf_desc = &usbdevice->config[i];
 114                 WDU_INTERFACE **pInterfaces;
 115                 WDU_ALTERNATE_SETTING **pAlternateSettings[conf_desc->bNumInterfaces];
 116                 WDU_ALTERNATE_SETTING **pActiveAltSetting[conf_desc->bNumInterfaces];
 117
 118                 if (buf) {
 119                         WDU_CONFIGURATION *cfg = (WDU_CONFIGURATION*)(buf+len);
 120
 121                         *pConfigs = cfg;
 122                         *pActiveConfig = cfg;
 123
 124                         cfg->Descriptor.bLength = conf_desc->bLength;
 125                         cfg->Descriptor.bDescriptorType = conf_desc->bDescriptorType;
 126                         cfg->Descriptor.wTotalLength = conf_desc->wTotalLength;
 127                         cfg->Descriptor.bNumInterfaces = conf_desc->bNumInterfaces;
 128                         cfg->Descriptor.bConfigurationValue = conf_desc->bConfigurationValue;
 129                         cfg->Descriptor.iConfiguration = conf_desc->iConfiguration;
 130                         cfg->Descriptor.bmAttributes = conf_desc->bmAttributes;
 131                         cfg->Descriptor.MaxPower = conf_desc->MaxPower;
 132
 133                         cfg->dwNumInterfaces = conf_desc->bNumInterfaces;
 134
 135                         pInterfaces = &(cfg->pInterfaces);
 136                 }
 137                 len += sizeof(WDU_CONFIGURATION);
 138
 139                 if (buf) {
 140                         *pInterfaces = (WDU_INTERFACE*)(buf+len);
 141                         for (j=0; j<conf_desc->bNumInterfaces; j++) {
 142                                 WDU_INTERFACE *iface = (WDU_INTERFACE*)(buf+len);
 143
 144                                 pActiveInterface[j] = iface;
 145
 146                                 pAlternateSettings[j] = &(iface->pAlternateSettings);
 147                                 iface->dwNumAltSettings = usbdevice->config[i].interface[j].num_altsetting;
 148                                 pActiveAltSetting[j] = &(iface->pActiveAltSetting);
 149
 150                                 len += sizeof(WDU_INTERFACE);
 151                         }
 152                 } else {
 153                         len += sizeof(WDU_INTERFACE) * conf_desc->bNumInterfaces;
 154                 }
 155
 156                 for (j=0; j<conf_desc->bNumInterfaces; j++)
 157                 {
 158                         struct usb_interface *interface = &usbdevice->config[i].interface[j];
 159
 160                         if (buf) {
 161                                 *pAlternateSettings[j] = (WDU_ALTERNATE_SETTING*)(buf+len);
 162                                 /* FIXME: */
 163                                 *pActiveAltSetting[j] = (WDU_ALTERNATE_SETTING*)(buf+len);
 164                         }
 165
 166                         for(k=0; k<interface->num_altsetting; k++)
 167                         {
 168                                 unsigned char bNumEndpoints = interface->altsetting[k].bNumEndpoints;
 169                                 WDU_ENDPOINT_DESCRIPTOR **pEndpointDescriptors;
 170                                 WDU_PIPE_INFO **pPipes;
 171
 172                                 if (buf) {
 173                                         WDU_ALTERNATE_SETTING *altset = (WDU_ALTERNATE_SETTING*)(buf+len);
 174
 175                                         altset->Descriptor.bLength = interface->altsetting[k].bLength;
 176                                         altset->Descriptor.bDescriptorType = interface->altsetting[k].bDescriptorType;
 177                                         altset->Descriptor.bInterfaceNumber = interface->altsetting[k].bInterfaceNumber;
 178                                         altset->Descriptor.bAlternateSetting = interface->altsetting[k].bAlternateSetting;
 179                                         altset->Descriptor.bNumEndpoints = interface->altsetting[k].bNumEndpoints;
 180                                         altset->Descriptor.bInterfaceClass = interface->altsetting[k].bInterfaceClass;
 181                                         altset->Descriptor.bInterfaceSubClass = interface->altsetting[k].bInterfaceSubClass;
 182                                         altset->Descriptor.bInterfaceProtocol = interface->altsetting[k].bInterfaceProtocol;
 183                                         altset->Descriptor.iInterface = interface->altsetting[k].iInterface;
 184                                         pEndpointDescriptors = &(altset->pEndpointDescriptors);
 185                                         pPipes = &(altset->pPipes);
 186
 187                                 }
 188                                 len +=sizeof(WDU_ALTERNATE_SETTING);
 189
 190                                 if (buf) {
 191                                         *pEndpointDescriptors = (WDU_ENDPOINT_DESCRIPTOR*)(buf+len);
 192                                         for (l = 0; l < bNumEndpoints; l++) {
 193                                                 WDU_ENDPOINT_DESCRIPTOR *ed = (WDU_ENDPOINT_DESCRIPTOR*)(buf+len);
 194
 195                                                 ed->bLength = interface->altsetting[k].endpoint[l].bLength;
 196                                                 ed->bDescriptorType = interface->altsetting[k].endpoint[l].bDescriptorType;
 197                                                 ed->bEndpointAddress = interface->altsetting[k].endpoint[l].bEndpointAddress;
 198                                                 ed->bmAttributes = interface->altsetting[k].endpoint[l].bmAttributes;
 199                                                 ed->wMaxPacketSize = interface->altsetting[k].endpoint[l].wMaxPacketSize;
 200                                                 ed->bInterval = interface->altsetting[k].endpoint[l].bInterval;
 201
 202                                                 len += sizeof(WDU_ENDPOINT_DESCRIPTOR);
 203                                         }
 204
 205                                         *pPipes = (WDU_PIPE_INFO*)(buf+len);
 206                                         for (l = 0; l < bNumEndpoints; l++) {
 207                                                 WDU_PIPE_INFO *pi = (WDU_PIPE_INFO*)(buf+len);
 208
 209                                                 pi->dwNumber = interface->altsetting[k].endpoint[l].bEndpointAddress;
 210                                                 pi->dwMaximumPacketSize = WDU_GET_MAX_PACKET_SIZE(interface->altsetting[k].endpoint[l].wMaxPacketSize);
 211                                                 pi->type = interface->altsetting[k].endpoint[l].bmAttributes & USB_ENDPOINT_TYPE_MASK;
 212                                                 if (pi->type == PIPE_TYPE_CONTROL)
 213                                                         pi->direction = WDU_DIR_IN_OUT;
 214                                                 else
 215                                                 {
 216                                                         pi->direction = interface->altsetting[k].endpoint[l].bEndpointAddress & USB_ENDPOINT_DIR_MASK ?  WDU_DIR_IN : WDU_DIR_OUT;
 217                                                 }
 218
 219                                                 pi->dwInterval = interface->altsetting[k].endpoint[l].bInterval;
 220
 221                                                 len += sizeof(WDU_PIPE_INFO);
 222                                         }
 223                                 } else {
 224                                         len +=(sizeof(WDU_ENDPOINT_DESCRIPTOR)+sizeof(WDU_PIPE_INFO))*bNumEndpoints;
 225                                 }
 226                         }
 227                 }
 228         }
 229
 230         return len;
 231 }
 232
 233 int do_wdioctl(int fd, unsigned int request, unsigned char *wdioctl) {
 234         struct header_struct* wdheader = (struct header_struct*)wdioctl;
 235         struct version_struct *version;
 236         int ret = 0;
 237
 238         if (wdheader->magic != MAGIC) {
 239                 fprintf(stderr,"!!!ERROR: magic header does not match!!!\n");
 240                 return (*ioctl_func) (fd, request, wdioctl);
 241         }
 242
 243         switch(request) {
 244                 case VERSION:
 245                         version = (struct version_struct*)(wdheader->data);
 246                         strcpy(version->version, "WinDriver no more");
 247                         version->versionul = 802;
 248                         DPRINTF("VERSION\n");
 249                         break;
 250
 251                 case LICENSE:
 252                         DPRINTF("LICENSE\n");
 253                         break;
 254
 255                 case CARD_REGISTER:
 256                         /* TODO: Implement for LPT-support */
 257 #if 0
 258                         {
 259                                 struct card_register* cr = (struct card_register*)(wdheader->data);
 260                         }
 261 #endif
 262                         DPRINTF("CARD_REGISTER\n");
 263                         break;
 264
 265                 case USB_TRANSFER:
 266                         DPRINTF("in USB_TRANSFER");
 267                         {
 268                                 struct usb_transfer *ut = (struct usb_transfer*)(wdheader->data);
 269
 270 #ifdef DEBUG
 271                                 DPRINTF(" unique: %lu, pipe: %lu, read: %lu, options: %lx, size: %lu, timeout: %lx\n",
 272                                 ut->dwUniqueID, ut->dwPipeNum, ut->fRead,
 273                                 ut->dwOptions, ut->dwBufferSize, ut->dwTimeout);
 274                                 DPRINTF("setup packet: ");
 275                                 hexdump(ut->SetupPacket, 8);
 276
 277                                 if (!ut->fRead && ut->dwBufferSize)
 278                                 {
 279                                         hexdump(ut->pBuffer, ut->dwBufferSize);
 280                                 }
 281 #endif
 282
 283 #ifndef NO_WINDRVR
 284                                 ret = (*ioctl_func) (fd, request, wdioctl);
 285 #else
 286                                 /* http://www.jungo.com/support/documentation/windriver/802/wdusb_man_mhtml/node55.html#SECTION001213000000000000000 */
 287                                 if (ut->dwPipeNum == 0) { /* control pipe */
 288                                         int requesttype, request, value, index, size;
 289                                         requesttype = ut->SetupPacket[0];
 290                                         request = ut->SetupPacket[1];
 291                                         value = ut->SetupPacket[2] | (ut->SetupPacket[3] << 8);
 292                                         index = ut->SetupPacket[4] | (ut->SetupPacket[5] << 8);
 293                                         size = ut->SetupPacket[6] | (ut->SetupPacket[7] << 8);
 294                                         DPRINTF("requesttype: %x, request: %x, value: %u, index: %u, size: %u\n", requesttype, request, value, index, size);
 295                                         ret = usb_control_msg(usb_devhandle, requesttype, request, value, index, ut->pBuffer, size, ut->dwTimeout);
 296                                 } else {
 297                                         if (ut->fRead) {
 298                                                 ret = usb_bulk_read(usb_devhandle, ut->dwPipeNum, ut->pBuffer, ut->dwBufferSize, ut->dwTimeout);
 299
 300                                         } else {
 301                                                 ret = usb_bulk_write(usb_devhandle, ut->dwPipeNum, ut->pBuffer, ut->dwBufferSize, ut->dwTimeout);
 302                                         }
 303                                 }
 304
 305                                 if (ret < 0) {
 306                                         fprintf(stderr, "usb_transfer: %d (%s)\n", ret, usb_strerror());
 307                                 } else {
 308                                         ut->dwBytesTransferred = ret;
 309                                         ret = 0;
 310                                 }
 311 #endif
 312
 313 #ifdef DEBUG
 314                                 DPRINTF("Transferred: %lu (%s)\n",ut->dwBytesTransferred, (ut->fRead?"read":"write"));
 315                                 if (ut->fRead && ut->dwBytesTransferred)
 316                                 {
 317                                         DPRINTF("Read: ");
 318                                         hexdump(ut->pBuffer, ut->dwBytesTransferred);
 319                                 }
 320 #endif
 321                         }
 322                         break;
 323
 324                 case INT_ENABLE:
 325                         DPRINTF("INT_ENABLE\n");
 326                         {
 327                                 struct interrupt *it = (struct interrupt*)(wdheader->data);
 328
 329                                 DPRINTF("Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n",
 330                                 it->hInterrupt, it->dwOptions,
 331                                 it->dwCmds, it->fEnableOk, it->dwCounter,
 332                                 it->dwLost, it->fStopped);
 333
 334                                 it->fEnableOk = 1;
 335                                 it->fStopped = 0;
 336                                 ints_enabled = 1;
 337                                 pthread_mutex_trylock(&int_wait);
 338                         }
 339
 340                         break;
 341
 342                 case INT_DISABLE:
 343                         DPRINTF("INT_DISABLE\n");
 344                         {
 345                                 struct interrupt *it = (struct interrupt*)(wdheader->data);
 346
 347                                 DPRINTF("Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n",
 348                                 it->hInterrupt, it->dwOptions,
 349                                 it->dwCmds, it->fEnableOk, it->dwCounter,
 350                                 it->dwLost, it->fStopped);
 351 #ifndef NO_WINDRVR
 352                                 ret = (*ioctl_func) (fd, request, wdioctl);
 353 #else
 354                                 it->dwCounter = 0;
 355                                 it->fStopped = 1;
 356                                 ints_enabled = 0;
 357                                 if (pthread_mutex_trylock(&int_wait) == EBUSY)
 358                                         pthread_mutex_unlock(&int_wait);
 359 #endif
 360                                 DPRINTF("Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n",
 361                                 it->hInterrupt, it->dwOptions,
 362                                 it->dwCmds, it->fEnableOk, it->dwCounter,
 363                                 it->dwLost, it->fStopped);
 364                         }
 365                         break;
 366
 367                 case USB_SET_INTERFACE:
 368                         DPRINTF("USB_SET_INTERFACE\n");
 369                         {
 370                                 struct usb_set_interface *usi = (struct usb_set_interface*)(wdheader->data);
 371
 372                                 DPRINTF("unique: %lu, interfacenum: %lu, alternatesetting: %lu, options: %lx\n",
 373                                 usi->dwUniqueID, usi->dwInterfaceNum,
 374                                 usi->dwAlternateSetting, usi->dwOptions);
 375 #ifndef NO_WINDRVR
 376                                 ret = (*ioctl_func) (fd, request, wdioctl);
 377 #else
 378                                 if (usbdevice) {
 379                                         if (!usb_devhandle)
 380                                                 usb_devhandle = usb_open(usbdevice);
 381
 382                                         /* FIXME: Select right interface! */
 383                                         ret = usb_claim_interface(usb_devhandle, usbdevice->config[0].interface[usi->dwInterfaceNum].altsetting[usi->dwAlternateSetting].bInterfaceNumber);
 384                                         if (!ret) {
 385                                                 if(!ret) {
 386                                                         usbinterface = usbdevice->config[0].interface[usi->dwInterfaceNum].altsetting[usi->dwAlternateSetting].bInterfaceNumber;
 387                                                         ret = usb_set_altinterface(usb_devhandle, usi->dwAlternateSetting);
 388                                                         if (ret)
 389                                                                 fprintf(stderr, "usb_set_altinterface: %d\n", ret);
 390                                                 } else {
 391                                                         fprintf(stderr, "usb_set_configuration: %d (%s)\n", ret, usb_strerror());
 392                                                 }
 393                                         } else {
 394                                                 fprintf(stderr, "usb_claim_interface: %d -> %d (%s)\n",
 395                                                 usbdevice->config[0].interface[usi->dwInterfaceNum].altsetting[usi->dwAlternateSetting].bInterfaceNumber,
 396                                                 ret, usb_strerror());
 397                                         }
 398                                 }
 399 #endif
 400                                 DPRINTF("unique: %lu, interfacenum: %lu, alternatesetting: %lu, options: %lx\n",
 401                                 usi->dwUniqueID, usi->dwInterfaceNum,
 402                                 usi->dwAlternateSetting, usi->dwOptions);
 403                         }
 404                         break;
 405
 406                 case USB_GET_DEVICE_DATA:
 407                         DPRINTF("USB_GET_DEVICE_DATA\n");
 408                         {
 409                                 struct usb_get_device_data *ugdd = (struct usb_get_device_data*)(wdheader->data);
 410                                 int pSize;
 411
 412                                 DPRINTF("unique: %lu, bytes: %lu, options: %lx\n",
 413                                 ugdd->dwUniqueID, ugdd->dwBytes,
 414                                 ugdd->dwOptions);
 415
 416                                 pSize = ugdd->dwBytes;
 417                                 if (!ugdd->dwBytes) {
 418                                         if (usbdevice) {
 419                                                 ugdd->dwBytes = usb_deviceinfo(NULL);
 420                                         }
 421                                 } else {
 422                                         usb_deviceinfo((unsigned char*)ugdd->pBuf);
 423                                 }
 424                         }
 425                         break;
 426
 427                 case EVENT_REGISTER:
 428                         DPRINTF("EVENT_REGISTER\n");
 429                         {
 430                                 struct event *e = (struct event*)(wdheader->data);
 431                                 struct usb_bus *bus;
 432                                 int i;
 433
 434                                 DPRINTF("handle: %lu, action: %lu, status: %lu, eventid: %lu, cardtype: %lu, kplug: %lu, options: %lu, dev: %lx:%lx, unique: %lu, ver: %lu, nummatch: %lu\n",
 435                                 e->handle, e->dwAction,
 436                                 e->dwStatus, e->dwEventId, e->dwCardType,
 437                                 e->hKernelPlugIn, e->dwOptions,
 438                                 e->u.Usb.deviceId.dwVendorId,
 439                                 e->u.Usb.deviceId.dwProductId,
 440                                 e->u.Usb.dwUniqueID, e->dwEventVer,
 441                                 e->dwNumMatchTables);
 442
 443                                 for (i = 0; i < e->dwNumMatchTables; i++) {
 444
 445                                         DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
 446                                         e->matchTables[i].VendorId,
 447                                         e->matchTables[i].ProductId,
 448                                         e->matchTables[i].bDeviceClass,
 449                                         e->matchTables[i].bDeviceSubClass,
 450                                         e->matchTables[i].bInterfaceClass,
 451                                         e->matchTables[i].bInterfaceSubClass,
 452                                         e->matchTables[i].bInterfaceProtocol);
 453
 454                                         for (bus = busses; bus; bus = bus->next) {
 455                                                 struct usb_device *dev;
 456
 457                                                 for (dev = bus->devices; dev; dev = dev->next) {
 458                                                         struct usb_device_descriptor *desc = &(dev->descriptor);
 459
 460                                                         if((desc->idVendor == e->matchTables[i].VendorId) &&
 461                                                            (desc->idProduct == e->matchTables[i].ProductId) &&
 462                                                            (desc->bDeviceClass == e->matchTables[i].bDeviceClass) &&
 463                                                            (desc->bDeviceSubClass == e->matchTables[i].bDeviceSubClass)) {
 464                                                                    int ac;
 465                                                                    for (ac = 0; ac < desc->bNumConfigurations; ac++) {
 466                                                                            struct usb_interface *interface = dev->config[ac].interface;
 467                                                                            int ai;
 468
 469                                                                            for (ai = 0; ai < interface->num_altsetting; ai++) {
 470
 471                                                                                    DPRINTF("intclass: %x, intsubclass: %x, intproto: %x\n",
 472                                                                                    interface->altsetting[i].bInterfaceClass,
 473                                                                                    interface->altsetting[i].bInterfaceSubClass,
 474                                                                                    interface->altsetting[i].bInterfaceProtocol);
 475
 476                                                                                    if ((interface->altsetting[ai].bInterfaceSubClass == e->matchTables[i].bInterfaceSubClass) &&
 477                                                                                                    (interface->altsetting[ai].bInterfaceProtocol == e->matchTables[i].bInterfaceProtocol)){
 478                                                                                            /* TODO: check interfaceClass! */
 479                                                                                            DPRINTF("found device with libusb\n");
 480                                                                                            usbdevice = dev;
 481                                                                                            card_type = e->dwCardType;
 482                                                                                    }
 483                                                                            }
 484                                                                    }
 485                                                         }
 486                                                 }
 487                                         }
 488                                 }
 489
 490 #ifndef NO_WINDRVR
 491                                 ret = (*ioctl_func) (fd, request, wdioctl);
 492 #else
 493                                 e->handle++;
 494 #endif
 495
 496 #ifdef DEBUG
 497                                 DPRINTF("handle: %lu, action: %lu, status: %lu, eventid: %lu, cardtype: %lu, kplug: %lu, options: %lu, dev: %lx:%lx, unique: %lu, ver: %lu, nummatch: %lu\n",
 498                                 e->handle, e->dwAction,
 499                                 e->dwStatus, e->dwEventId, e->dwCardType,
 500                                 e->hKernelPlugIn, e->dwOptions,
 501                                 e->u.Usb.deviceId.dwVendorId,
 502                                 e->u.Usb.deviceId.dwProductId,
 503                                 e->u.Usb.dwUniqueID, e->dwEventVer,
 504                                 e->dwNumMatchTables);
 505
 506                                 for (i = 0; i < e->dwNumMatchTables; i++)
 507                                         DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
 508                                         e->matchTables[i].VendorId,
 509                                         e->matchTables[i].ProductId,
 510                                         e->matchTables[i].bDeviceClass,
 511                                         e->matchTables[i].bDeviceSubClass,
 512                                         e->matchTables[i].bInterfaceClass,
 513                                         e->matchTables[i].bInterfaceSubClass,
 514                                         e->matchTables[i].bInterfaceProtocol);
 515 #endif
 516                         }
 517                         break;
 518
 519                 case TRANSFER:
 520                         DPRINTF("TRANSFER\n");
 521 #ifndef NO_WINDRVR
 522                         ret = (*ioctl_func) (fd, request, wdioctl);
 523 #endif
 524                         break;
 525
 526                 case EVENT_UNREGISTER:
 527                         DPRINTF("EVENT_UNREGISTER\n");
 528 #ifndef NO_WINDRVR
 529                         ret = (*ioctl_func) (fd, request, wdioctl);
 530 #endif
 531                         break;
 532
 533                 case INT_WAIT:
 534                         DPRINTF("INT_WAIT\n");
 535                         {
 536                                 struct interrupt *it = (struct interrupt*)(wdheader->data);
 537
 538                                 DPRINTF("Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n",
 539                                 it->hInterrupt, it->dwOptions,
 540                                 it->dwCmds, it->fEnableOk, it->dwCounter,
 541                                 it->dwLost, it->fStopped);
 542
 543 #ifndef NO_WINDRVR
 544                                 ret = (*ioctl_func) (fd, request, wdioctl);
 545 #else
 546                                 if (usbdevice) {
 547                                         if (it->dwCounter == 0) {
 548                                                 it->dwCounter = 1;
 549                                         } else {
 550                                                 pthread_mutex_lock(&int_wait);
 551                                                 pthread_mutex_unlock(&int_wait);
 552                                         }
 553                                 } else {
 554                                         pthread_mutex_lock(&int_wait);
 555                                         pthread_mutex_unlock(&int_wait);
 556                                 }
 557 #endif
 558
 559                                 DPRINTF("INT_WAIT_RETURN: Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n",
 560                                 it->hInterrupt, it->dwOptions, it->dwCmds,
 561                                 it->fEnableOk, it->dwCounter, it->dwLost,
 562                                 it->fStopped);
 563                         }
 564                         break;
 565
 566                 case CARD_UNREGISTER:
 567                         DPRINTF("CARD_UNREGISTER\n");
 568 #ifndef NO_WINDRVR
 569                         ret = (*ioctl_func) (fd, request, wdioctl);
 570 #endif
 571                         break;
 572
 573                 case EVENT_PULL:
 574                         DPRINTF("EVENT_PULL\n");
 575                         {
 576                                 struct event *e = (struct event*)(wdheader->data);
 577 #ifdef DEBUG
 578                                 int i;
 579
 580                                 DPRINTF("handle: %lu, action: %lu, status: %lu, eventid: %lu, cardtype: %lx, kplug: %lu, options: %lu, dev: %lx:%lx, unique: %lu, ver: %lu, nummatch: %lu\n",
 581                                 e->handle, e->dwAction, e->dwStatus,
 582                                 e->dwEventId, e->dwCardType, e->hKernelPlugIn,
 583                                 e->dwOptions, e->u.Usb.deviceId.dwVendorId,
 584                                 e->u.Usb.deviceId.dwProductId,
 585                                 e->u.Usb.dwUniqueID, e->dwEventVer,
 586                                 e->dwNumMatchTables);
 587
 588                                 for (i = 0; i < e->dwNumMatchTables; i++)
 589                                         DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
 590                                         e->matchTables[i].VendorId,
 591                                         e->matchTables[i].ProductId,
 592                                         e->matchTables[i].bDeviceClass,
 593                                         e->matchTables[i].bDeviceSubClass,
 594                                         e->matchTables[i].bInterfaceClass,
 595                                         e->matchTables[i].bInterfaceSubClass,
 596                                         e->matchTables[i].bInterfaceProtocol);
 597 #endif
 598
 599 #ifndef NO_WINDRVR
 600                                 ret = (*ioctl_func) (fd, request, wdioctl);
 601 #else
 602                                 if (usbdevice) {
 603                                         struct usb_interface *interface = usbdevice->config->interface;
 604
 605                                         e->dwCardType = card_type;
 606                                         e->dwAction = 1;
 607                                         e->dwEventId = 109;
 608                                         e->u.Usb.dwUniqueID = 110;
 609                                         e->matchTables[0].VendorId = usbdevice->descriptor.idVendor;
 610                                         e->matchTables[0].ProductId = usbdevice->descriptor.idProduct;
 611                                         e->matchTables[0].bDeviceClass = usbdevice->descriptor.bDeviceClass;
 612                                         e->matchTables[0].bDeviceSubClass = usbdevice->descriptor.bDeviceSubClass;
 613                                         e->matchTables[0].bInterfaceClass = interface->altsetting[0].bInterfaceClass;
 614                                         e->matchTables[0].bInterfaceSubClass = interface->altsetting[0].bInterfaceSubClass;
 615                                         e->matchTables[0].bInterfaceProtocol = interface->altsetting[0].bInterfaceProtocol;
 616                                 }
 617 #endif
 618
 619 #ifdef DEBUG
 620                                 DPRINTF("handle: %lu, action: %lu, status: %lu, eventid: %lu, cardtype: %lx, kplug: %lu, options: %lu, dev: %lx:%lx, unique: %lu, ver: %lu, nummatch: %lu\n",
 621                                 e->handle, e->dwAction, e->dwStatus,
 622                                 e->dwEventId, e->dwCardType, e->hKernelPlugIn,
 623                                 e->dwOptions, e->u.Usb.deviceId.dwVendorId,
 624                                 e->u.Usb.deviceId.dwProductId,
 625                                 e->u.Usb.dwUniqueID, e->dwEventVer,
 626                                 e->dwNumMatchTables);
 627
 628                                 for (i = 0; i < e->dwNumMatchTables; i++)
 629                                         DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
 630                                         e->matchTables[i].VendorId,
 631                                         e->matchTables[i].ProductId,
 632                                         e->matchTables[i].bDeviceClass,
 633                                         e->matchTables[i].bDeviceSubClass,
 634                                         e->matchTables[i].bInterfaceClass,
 635                                         e->matchTables[i].bInterfaceSubClass,
 636                                         e->matchTables[i].bInterfaceProtocol);
 637 #endif
 638
 639                         }
 640                         break;
 641
 642                 default:
 643                         fprintf(stderr,"!!!Unsupported IOCTL: %x!!!\n", request);
 644 #ifndef NO_WINDRVR
 645                         ret = (*ioctl_func) (fd, request, wdioctl);
 646 #endif
 647                         break;
 648         }
 649
 650         return ret;
 651 }
 652
 653 int ioctl(int fd, int request, ...) {
 654         va_list args;
 655         void *argp;
 656         int ret;
 657
 658         if (!ioctl_func)
 659                 ioctl_func = (int (*) (int, int, void *)) dlsym (RTLD_NEXT, "ioctl");
 660
 661         va_start (args, request);
 662         argp = va_arg (args, void *);
 663         va_end (args);
 664
 665         if (fd == windrvrfd)
 666                 ret = do_wdioctl(fd, request, argp);
 667         else
 668                 ret = (*ioctl_func) (fd, request, argp);
 669
 670         return ret;
 671 }
 672
 673 int open (const char *pathname, int flags, ...) {
 674         static int (*func) (const char *, int, mode_t) = NULL;
 675         mode_t mode = 0;
 676         va_list args;
 677         int fd;
 678
 679         if (!func)
 680                 func = (int (*) (const char *, int, mode_t)) dlsym (RTLD_NEXT, "open");
 681
 682         if (flags & O_CREAT) {
 683                 va_start(args, flags);
 684                 mode = va_arg(args, mode_t);
 685                 va_end(args);
 686         }
 687
 688         if (!strcmp (pathname, "/dev/windrvr6")) {
 689                 DPRINTF("opening windrvr6\n");
 690 #ifdef NO_WINDRVR
 691                 windrvrfd = fd = (*func) ("/dev/null", flags, mode);
 692 #else
 693                 windrvrfd = fd = (*func) (pathname, flags, mode);
 694 #endif
 695                 if (!busses) {
 696                         usb_init();
 697                         usb_find_busses();
 698                         usb_find_devices();
 699
 700                         busses = usb_get_busses();
 701                 }
 702
 703                 return fd;
 704         }
 705
 706         return (*func) (pathname, flags, mode);
 707 }
 708
 709 int close(int fd) {
 710         static int (*func) (int) = NULL;
 711
 712         if (!func)
 713                 func = (int (*) (int)) dlsym(RTLD_NEXT, "close");
 714
 715         if (fd == windrvrfd && windrvrfd >= 0) {
 716                 DPRINTF("close windrvrfd\n");
 717                 if (usbinterface >= 0)
 718                         usb_release_interface(usb_devhandle, usbinterface);
 719
 720                 if (usb_devhandle)
 721                         usb_close(usb_devhandle);
 722
 723                 usb_devhandle = NULL;
 724                 usbinterface = -1;
 725                 windrvrfd = -1;
 726         }
 727
 728         return (*func) (fd);
 729 }
 730
 731 FILE *fopen(const char *path, const char *mode) {
 732         FILE *ret;
 733         static FILE* (*func) (const char*, const char*) = NULL;
 734
 735         if (!func)
 736                 func = (FILE* (*) (const char*, const char*)) dlsym(RTLD_NEXT, "fopen");
 737
 738         ret = (*func) (path, mode);
 739
 740         if (!strcmp (path, "/proc/modules")) {
 741                 DPRINTF("opening /proc/modules\n");
 742 #ifdef NO_WINDRVR
 743                 modulesfp = ret;
 744                 modules_read = 0;
 745 #endif
 746         }
 747
 748         return ret;
 749 }
 750
 751 char *fgets(char *s, int size, FILE *stream) {
 752         static char* (*func) (char*, int, FILE*) = NULL;
 753         const char modules[][256] = {"windrvr6 1 0 - Live 0xdeadbeef\n", "parport_pc 1 0 - Live 0xdeadbeef\n"};
 754         char *ret = NULL;
 755
 756
 757         if (!func)
 758                 func = (char* (*) (char*, int, FILE*)) dlsym(RTLD_NEXT, "fgets");
 759
 760         if (modulesfp == stream) {
 761                 if (modules_read < sizeof(modules)) {
 762                         strcpy(s, modules[modules_read]);
 763                         ret = s;
 764                         modules_read++;
 765                 }
 766         } else {
 767                 ret = (*func)(s,size,stream);
 768         }
 769
 770         return ret;
 771 }
 772
 773 int fclose(FILE *fp) {
 774         static int (*func) (FILE*) = NULL;
 775
 776         if (!func)
 777                 func = (int (*) (FILE*)) dlsym(RTLD_NEXT, "fclose");
 778
 779         if (fp == modulesfp) {
 780                 modulesfp = NULL;
 781         }
 782
 783         return (*func)(fp);
 784 }
 785
 786 int access(const char *pathname, int mode) {
 787         static int (*func) (const char*, int);
 788
 789         if (!func)
 790                 func = (int (*) (const char*, int)) dlsym(RTLD_NEXT, "access");
 791
 792         if (!strcmp(pathname, "/dev/windrvr6")) {
 793                 return 0;
 794         } else {
 795                 return (*func)(pathname, mode);
 796         }
 797 }