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

   1 #if defined(__GNUC__) && !defined(__STRICT_ANSI__)
   2
   3 #define _GNU_SOURCE 1
   4
   5 #if defined(RTLD_NEXT)
   6 #define REAL_LIBC RTLD_NEXT
   7 #else
   8 #define REAL_LIBC ((void *) -1L)
   9 #endif
  10
  11 #include <dlfcn.h>
  12 #include <stdarg.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <unistd.h>
  16 #include <fcntl.h>
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <sys/time.h>
  20 #include <stdio.h>
  21 #include <usb.h>
  22 #include <signal.h>
  23 #include "xilinx.h"
  24
  25 static int (*ioctl_func) (int, int, void *) = NULL;
  26 static int windrvrfd = 0;
  27 static struct usb_bus *busses = NULL;
  28 static struct usb_device *usbdevice;
  29 static usb_dev_handle *usb_devhandle = NULL;
  30 static unsigned long card_type;
  31 static int ints_enabled = 0;
  32
  33 #define NO_WINDRVR 1
  34
  35 void hexdump(unsigned char *buf, int len);
  36 void diff(unsigned char *buf1, unsigned char *buf2, int len);
  37
  38 //unique: 94, bytes: 276, options: 0
  39 //Vendor: 3fd
  40 //12 01 00 02 00 00 00 40 fd 03 08 00 00 00 01 02                              12 01 00 02 00 00 00 40 fd 03 08 00 00 00 01 02
  41 //00 01 00 00 00 00 00 00 40 00 00 00 00 00 00 00                              00 01 00 00 00 00 00 00 40 00 00 00 00 00 00 00
  42 //03 00 00 00 00 00 00 00 38 45 21 08 38 45 21 08                              03 00 00 00 00 00 00 00 38 45 21 08 38 45 21 08
  43 //4c 45 21 08 00 00 00 00 00 00 00 00 00 00 00 00                              4c 45 21 08 00 00 00 00 00 00 00 00 00 00 00 00
  44 //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  45 //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  46 //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  47 //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  48 //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  49 //00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00                              00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  50 //00 00 00 00 00 00 00 00 09 02 20 00 01 02 00 80                              00 00 00 00 00 00 00 00 09 02 20 00 01 02 00 80
  51 //8c 00 00 00 01 00 00 00 4c 45 21 08 58 45 21 08                              8c 00 00 00 01 00 00 00 4c 45 21 08 58 45 21 08
  52 //01 00 00 00 58 45 21 08 09 04 00 00 02 ff 00 00                              01 00 00 00 58 45 21 08 09 04 00 00 02 ff 00 00
  53 //00 00 00 00 6c 45 21 08 7c 45 21 08 07 05 02 02                              00 00 00 00 6c 45 21 08 7c 45 21 08 07 05 02 02
  54 //00 02 00 00 07 05 86 02 00 02 00 00 02 00 00 00                              00 02 00 00 07 05 86 02 00 02 00 00 02 00 00 00
  55 //00 02 00 00 02 00 00 00 02 00 00 00 00 00 00 00                              00 02 00 00 02 00 00 00 02 00 00 00 00 00 00 00
  56 //86 00 00 00 00 02 00 00 02 00 00 00 01 00 00 00                              86 00 00 00 00 02 00 00 02 00 00 00 01 00 00 00
  57 //00 00 00 00                                                                  00 00 00 00
  58 int usb_deviceinfo(unsigned char *buf) {
  59         int i,j,k,l;
  60         int len = 0;
  61         WDU_CONFIGURATION **pConfigs, **pActiveConfig;
  62         WDU_INTERFACE **pActiveInterface;
  63
  64         if (buf) {
  65                 struct usb_device_info *udi = (struct usb_device_info*)(buf+len);
  66
  67                 udi->Descriptor.bLength = sizeof(WDU_DEVICE_DESCRIPTOR);
  68                 udi->Descriptor.bDescriptorType = usbdevice->descriptor.bDescriptorType;
  69                 udi->Descriptor.bcdUSB = usbdevice->descriptor.bcdUSB;
  70                 udi->Descriptor.bDeviceClass = usbdevice->descriptor.bDeviceClass;
  71                 udi->Descriptor.bDeviceSubClass = usbdevice->descriptor.bDeviceSubClass;
  72                 udi->Descriptor.bDeviceProtocol = usbdevice->descriptor.bDeviceProtocol;
  73                 udi->Descriptor.bMaxPacketSize0 = usbdevice->descriptor.bMaxPacketSize0;
  74                 udi->Descriptor.idVendor = usbdevice->descriptor.idVendor;
  75                 udi->Descriptor.idProduct = usbdevice->descriptor.idProduct;
  76                 udi->Descriptor.bcdDevice = usbdevice->descriptor.bcdDevice;
  77                 udi->Descriptor.iManufacturer = usbdevice->descriptor.iManufacturer;
  78                 udi->Descriptor.iProduct = usbdevice->descriptor.iProduct;
  79                 udi->Descriptor.iSerialNumber = usbdevice->descriptor.iSerialNumber;
  80                 udi->Descriptor.bNumConfigurations = usbdevice->descriptor.bNumConfigurations;
  81
  82                 /* TODO: Fix Pipe0! */
  83                 udi->Pipe0.dwNumber = 0x00;
  84                 udi->Pipe0.dwMaximumPacketSize = usbdevice->descriptor.bMaxPacketSize0;
  85                 udi->Pipe0.type = 0;
  86                 udi->Pipe0.direction = 3;
  87                 udi->Pipe0.dwInterval = 0;
  88
  89                 pConfigs = &(udi->pConfigs);
  90                 pActiveConfig = &(udi->pActiveConfig);
  91                 pActiveInterface = &(udi->pActiveInterface[0]);
  92         }
  93
  94         len = sizeof(struct usb_device_info);
  95
  96         for (i=0; i<usbdevice->descriptor.bNumConfigurations; i++)
  97         {
  98                 struct usb_config_descriptor *conf_desc = &usbdevice->config[i];
  99                 WDU_INTERFACE **pInterfaces;
 100                 WDU_ALTERNATE_SETTING **pAlternateSettings[conf_desc->bNumInterfaces];
 101                 WDU_ALTERNATE_SETTING **pActiveAltSetting[conf_desc->bNumInterfaces];
 102
 103                 if (buf) {
 104                         WDU_CONFIGURATION *cfg = (WDU_CONFIGURATION*)(buf+len);
 105
 106                         *pConfigs = cfg;
 107                         *pActiveConfig = cfg;
 108
 109                         cfg->Descriptor.bLength = conf_desc->bLength;
 110                         cfg->Descriptor.bDescriptorType = conf_desc->bDescriptorType;
 111                         cfg->Descriptor.wTotalLength = conf_desc->wTotalLength;
 112                         cfg->Descriptor.bNumInterfaces = conf_desc->bNumInterfaces;
 113                         cfg->Descriptor.bConfigurationValue = conf_desc->bConfigurationValue;
 114                         cfg->Descriptor.iConfiguration = conf_desc->iConfiguration;
 115                         cfg->Descriptor.bmAttributes = conf_desc->bmAttributes;
 116                         cfg->Descriptor.MaxPower = conf_desc->MaxPower;
 117
 118                         cfg->dwNumInterfaces = conf_desc->bNumInterfaces;
 119
 120                         pInterfaces = &(cfg->pInterfaces);
 121                 }
 122                 len += sizeof(WDU_CONFIGURATION);
 123
 124                 if (buf) {
 125                         *pInterfaces = (WDU_INTERFACE*)(buf+len);
 126                         for (j=0; j<conf_desc->bNumInterfaces; j++) {
 127                                 WDU_INTERFACE *iface = (WDU_INTERFACE*)(buf+len);
 128
 129                                 pActiveInterface[j] = iface;
 130
 131                                 pAlternateSettings[j] = &(iface->pAlternateSettings);
 132                                 iface->dwNumAltSettings = usbdevice->config[i].interface[j].num_altsetting;
 133                                 pActiveAltSetting[j] = &(iface->pActiveAltSetting);
 134
 135                                 len += sizeof(WDU_INTERFACE);
 136                         }
 137                 } else {
 138                         len += sizeof(WDU_INTERFACE) * conf_desc->bNumInterfaces;
 139                 }
 140
 141                 for (j=0; j<conf_desc->bNumInterfaces; j++)
 142                 {
 143                         struct usb_interface *interface = &usbdevice->config[i].interface[j];
 144
 145                         if (buf) {
 146                                 *pAlternateSettings[j] = (WDU_ALTERNATE_SETTING*)(buf+len);
 147                                 /* FIXME: */
 148                                 *pActiveAltSetting[j] = (WDU_ALTERNATE_SETTING*)(buf+len);
 149                         }
 150
 151                         for(k=0; k<interface->num_altsetting; k++)
 152                         {
 153                                 unsigned char bNumEndpoints = interface->altsetting[k].bNumEndpoints;
 154                                 WDU_ENDPOINT_DESCRIPTOR **pEndpointDescriptors;
 155                                 WDU_PIPE_INFO **pPipes;
 156
 157                                 if (buf) {
 158                                         WDU_ALTERNATE_SETTING *altset = (WDU_ALTERNATE_SETTING*)(buf+len);
 159
 160                                         altset->Descriptor.bLength = interface->altsetting[k].bLength;
 161                                         altset->Descriptor.bDescriptorType = interface->altsetting[k].bDescriptorType;
 162                                         altset->Descriptor.bInterfaceNumber = interface->altsetting[k].bInterfaceNumber;
 163                                         altset->Descriptor.bAlternateSetting = interface->altsetting[k].bAlternateSetting;
 164                                         altset->Descriptor.bNumEndpoints = interface->altsetting[k].bNumEndpoints;
 165                                         altset->Descriptor.bInterfaceClass = interface->altsetting[k].bInterfaceClass;
 166                                         altset->Descriptor.bInterfaceSubClass = interface->altsetting[k].bInterfaceSubClass;
 167                                         altset->Descriptor.bInterfaceProtocol = interface->altsetting[k].bInterfaceProtocol;
 168                                         altset->Descriptor.iInterface = interface->altsetting[k].iInterface;
 169                                         pEndpointDescriptors = &(altset->pEndpointDescriptors);
 170                                         pPipes = &(altset->pPipes);
 171
 172                                 }
 173                                 len +=sizeof(WDU_ALTERNATE_SETTING);
 174
 175                                 if (buf) {
 176                                         *pEndpointDescriptors = (WDU_ENDPOINT_DESCRIPTOR*)(buf+len);
 177                                         for (l = 0; l < bNumEndpoints; l++) {
 178                                                 WDU_ENDPOINT_DESCRIPTOR *ed = (WDU_ENDPOINT_DESCRIPTOR*)(buf+len);
 179
 180                                                 ed->bLength = interface->altsetting[k].endpoint[l].bLength;
 181                                                 ed->bDescriptorType = interface->altsetting[k].endpoint[l].bDescriptorType;
 182                                                 ed->bEndpointAddress = interface->altsetting[k].endpoint[l].bEndpointAddress;
 183                                                 ed->bmAttributes = interface->altsetting[k].endpoint[l].bmAttributes;
 184                                                 ed->wMaxPacketSize = interface->altsetting[k].endpoint[l].wMaxPacketSize;
 185                                                 ed->bInterval = interface->altsetting[k].endpoint[l].bInterval;
 186
 187                                                 len += sizeof(WDU_ENDPOINT_DESCRIPTOR);
 188                                         }
 189
 190                                         *pPipes = (WDU_PIPE_INFO*)(buf+len);
 191                                         for (l = 0; l < bNumEndpoints; l++) {
 192                                                 WDU_PIPE_INFO *pi = (WDU_PIPE_INFO*)(buf+len);
 193
 194                                                 pi->dwNumber = interface->altsetting[k].endpoint[l].bEndpointAddress;
 195                                                 pi->dwMaximumPacketSize = WDU_GET_MAX_PACKET_SIZE(interface->altsetting[k].endpoint[l].wMaxPacketSize);
 196                                                 pi->type = interface->altsetting[k].endpoint[l].bmAttributes & USB_ENDPOINT_TYPE_MASK;
 197                                                 if (pi->type == PIPE_TYPE_CONTROL)
 198                                                         pi->direction = WDU_DIR_IN_OUT;
 199                                                 else
 200                                                 {
 201                                                         pi->direction = interface->altsetting[k].endpoint[l].bEndpointAddress & USB_ENDPOINT_DIR_MASK ?  WDU_DIR_IN : WDU_DIR_OUT;
 202                                                 }
 203
 204                                                 pi->dwInterval = interface->altsetting[k].endpoint[l].bInterval;
 205
 206                                                 len += sizeof(WDU_PIPE_INFO);
 207                                         }
 208                                 } else {
 209                                         len +=(sizeof(WDU_ENDPOINT_DESCRIPTOR)+sizeof(WDU_PIPE_INFO))*bNumEndpoints;
 210                                 }
 211                         }
 212                 }
 213         }
 214
 215         return len;
 216 }
 217
 218 int do_wdioctl(int fd, unsigned int request, unsigned char *wdioctl) {
 219         struct header_struct* wdheader = (struct header_struct*)wdioctl;
 220         struct version_struct *version;
 221         int ret = 0;
 222
 223         if (wdheader->magic != MAGIC) {
 224                 fprintf(stderr,"!!!ERROR: magic header does not match!!!\n");
 225                 return (*ioctl_func) (fd, request, wdioctl);
 226         }
 227
 228         fprintf(stderr,"PID %d: ",getpid());
 229         switch(request) {
 230                 case VERSION:
 231                         version = (struct version_struct*)(wdheader->data);
 232                         strcpy(version->version, "WinDriver no more");
 233                         version->versionul = 999;
 234                         fprintf(stderr,"faking VERSION\n");
 235                         break;
 236
 237                 case LICENSE:
 238                         fprintf(stderr,"faking LICENSE\n");
 239                         break;
 240
 241                 case CARD_REGISTER:
 242                         {
 243                                 //struct card_register* cr = (struct card_register*)(wdheader->data);
 244                                 /* Todo: LPT-Port already in use */
 245                         }
 246                         fprintf(stderr,"faking CARD_REGISTER\n");
 247                         break;
 248
 249                 case USB_TRANSFER:
 250                         fprintf(stderr,"in USB_TRANSFER");
 251                         {
 252                                 struct usb_transfer *ut = (struct usb_transfer*)(wdheader->data);
 253
 254                                 fprintf(stderr," unique: %lu, pipe: %lu, read: %lu, options: %lx, size: %lu, timeout: %lx\n", ut->dwUniqueID, ut->dwPipeNum, ut->fRead, ut->dwOptions, ut->dwBufferSize, ut->dwTimeout);
 255                                 fprintf(stderr,"setup packet: ");
 256                                 hexdump(ut->SetupPacket, 8);
 257                                 fprintf(stderr,"\n");
 258                                 if (!ut->fRead && ut->dwBufferSize)
 259                                 {
 260                                         hexdump(ut->pBuffer, ut->dwBufferSize);
 261                                         fprintf(stderr,"\n");
 262                                 }
 263
 264 #ifndef NO_WINDRVR
 265                                 ret = (*ioctl_func) (fd, request, wdioctl);
 266 #endif
 267
 268                                 fprintf(stderr,"Transferred: %lu (%s)\n",ut->dwBytesTransferred, (ut->fRead?"read":"write"));
 269                                 if (ut->fRead && ut->dwBytesTransferred)
 270                                 {
 271                                         fprintf(stderr,"Read: ");
 272                                         hexdump(ut->pBuffer, ut->dwBytesTransferred);
 273                                         fprintf(stderr,"\n");
 274                                 }
 275                         }
 276                         break;
 277
 278                 case INT_ENABLE:
 279                         fprintf(stderr,"INT_ENABLE\n");
 280                         {
 281                                 struct interrupt *it = (struct interrupt*)(wdheader->data);
 282
 283                                 hexdump(wdheader->data, wdheader->size);
 284                                 fprintf(stderr,"Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n", it->hInterrupt, it->dwOptions, it->dwCmds, it->fEnableOk, it->dwCounter, it->dwLost, it->fStopped);
 285
 286                                 it->fEnableOk = 1;
 287                                 ints_enabled = 1;
 288                                 //ret = (*ioctl_func) (fd, request, wdioctl);
 289                         }
 290
 291                         break;
 292
 293                 case INT_DISABLE:
 294                         fprintf(stderr,"INT_DISABLE\n");
 295                         {
 296                                 struct interrupt *it = (struct interrupt*)(wdheader->data);
 297
 298                                 fprintf(stderr,"Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n", it->hInterrupt, it->dwOptions, it->dwCmds, it->fEnableOk, it->dwCounter, it->dwLost, it->fStopped);
 299 #ifndef NO_WINDRVR
 300                                 ret = (*ioctl_func) (fd, request, wdioctl);
 301 #else
 302                                 it->dwCounter = 0;
 303                                 it->fStopped = 1;
 304                                 ints_enabled = 0;
 305 #endif
 306                                 fprintf(stderr,"Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n", it->hInterrupt, it->dwOptions, it->dwCmds, it->fEnableOk, it->dwCounter, it->dwLost, it->fStopped);
 307                         }
 308                         break;
 309
 310                 case USB_SET_INTERFACE:
 311                         fprintf(stderr,"USB_SET_INTERFACE\n");
 312                         {
 313                                 struct usb_set_interface *usi = (struct usb_set_interface*)(wdheader->data);
 314
 315                                 fprintf(stderr,"unique: %lu, interfacenum: %lu, alternatesetting: %lu, options: %lx\n", usi->dwUniqueID, usi->dwInterfaceNum, usi->dwAlternateSetting, usi->dwOptions);
 316 #ifndef NO_WINDRVR
 317                                 ret = (*ioctl_func) (fd, request, wdioctl);
 318 #else
 319                                 if (usbdevice) {
 320                                         int iface;
 321
 322                                         if (!usb_devhandle)
 323                                                 usb_devhandle = usb_open(usbdevice);
 324 //MGMG
 325                                         ret = usb_claim_interface(usb_devhandle, iface);
 326                                 }
 327 #endif
 328                                 fprintf(stderr,"unique: %lu, interfacenum: %lu, alternatesetting: %lu, options: %lx\n", usi->dwUniqueID, usi->dwInterfaceNum, usi->dwAlternateSetting, usi->dwOptions);
 329                         }
 330                         break;
 331
 332                 case USB_GET_DEVICE_DATA:
 333                         fprintf(stderr,"faking USB_GET_DEVICE_DATA\n");
 334                         {
 335                                 struct usb_get_device_data *ugdd = (struct usb_get_device_data*)(wdheader->data);
 336                                 int pSize;
 337
 338                                 fprintf(stderr, "unique: %lu, bytes: %lu, options: %lx\n", ugdd->dwUniqueID, ugdd->dwBytes, ugdd->dwOptions);
 339                                 pSize = ugdd->dwBytes;
 340                                 //ret = (*ioctl_func) (fd, request, wdioctl);
 341                                 if (!ugdd->dwBytes) {
 342                                         if (usbdevice) {
 343                                                 ugdd->dwBytes = usb_deviceinfo(NULL);
 344                                         }
 345                                 } else {
 346                                         usb_deviceinfo((unsigned char*)ugdd->pBuf);
 347                                 }
 348
 349                                 if (pSize) {
 350                                         struct usb_device_info *udi = (struct usb_device_info*)ugdd->pBuf;
 351
 352                                         fprintf(stderr, "Vendor: %x\n", udi->Descriptor.idVendor);
 353                                 }
 354                         }
 355                         break;
 356
 357                 case EVENT_REGISTER:
 358                         fprintf(stderr,"EVENT_REGISTER\n");
 359                         {
 360                                 struct event *e = (struct event*)(wdheader->data);
 361                                 struct usb_bus *bus;
 362                                 int i;
 363
 364                                 fprintf(stderr,"handle: %lu, action: %lu, status: %lu, eventid: %lu, cardtype: %lu, kplug: %lu, options: %lu, dev: %lx:%lx, unique: %lu, ver: %lu, nummatch: %lu\n", e->handle, e->dwAction, e->dwStatus, e->dwEventId, e->dwCardType, e->hKernelPlugIn, e->dwOptions, e->u.Usb.deviceId.dwVendorId, e->u.Usb.deviceId.dwProductId, e->u.Usb.dwUniqueID, e->dwEventVer, e->dwNumMatchTables);
 365                                 for (i = 0; i < e->dwNumMatchTables; i++) {
 366                                         fprintf(stderr,"match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n", e->matchTables[i].VendorId, e->matchTables[i].ProductId, e->matchTables[i].bDeviceClass, e->matchTables[i].bDeviceSubClass, e->matchTables[i].bInterfaceClass, e->matchTables[i].bInterfaceSubClass, e->matchTables[i].bInterfaceProtocol);
 367
 368                                         for (bus = busses; bus; bus = bus->next) {
 369                                                 struct usb_device *dev;
 370
 371                                                 for (dev = bus->devices; dev; dev = dev->next) {
 372                                                         struct usb_device_descriptor *desc = &(dev->descriptor);
 373
 374                                                         if((desc->idVendor == e->matchTables[i].VendorId) &&
 375                                                            (desc->idProduct == e->matchTables[i].ProductId) &&
 376                                                            (desc->bDeviceClass == e->matchTables[i].bDeviceClass) &&
 377                                                            (desc->bDeviceSubClass == e->matchTables[i].bDeviceSubClass)) {
 378                                                                    int ac;
 379                                                                    for (ac = 0; ac < desc->bNumConfigurations; ac++) {
 380                                                                            struct usb_interface *interface = dev->config[ac].interface;
 381                                                                            int ai;
 382
 383                                                                            for (ai = 0; ai < interface->num_altsetting; ai++) {
 384                                                                                    fprintf(stderr, "intclass: %x, intsubclass: %x, intproto: %x\n", interface->altsetting[i].bInterfaceClass, interface->altsetting[i].bInterfaceSubClass, interface->altsetting[i].bInterfaceProtocol);
 385                                                                                    if ((interface->altsetting[ai].bInterfaceSubClass == e->matchTables[i].bInterfaceSubClass) &&
 386                                                                                                    (interface->altsetting[ai].bInterfaceProtocol == e->matchTables[i].bInterfaceProtocol)){
 387                                                                                            /* TODO: check interfaceClass! */
 388                                                                                            fprintf(stderr,"!!!FOUND DEVICE WITH LIBUSB!!!\n");
 389                                                                                            usbdevice = dev;
 390                                                                                            card_type = e->dwCardType;
 391                                                                                    }
 392                                                                            }
 393                                                                    }
 394                                                         }
 395                                                 }
 396                                         }
 397                                 }
 398
 399 #ifndef NO_WINDRVR
 400                                 ret = (*ioctl_func) (fd, request, wdioctl);
 401 #else
 402 //handle: 0, action: 16371, status: 0, eventid: 0, cardtype: 4294967294, kplug: 0, options: 0, dev: 0:0, unique: 0, ver: 1, nummatch: 2
 403 //handle: 1, action: 16371, status: 0, eventid: 0, cardtype: 4294967294, kplug: 0, options: 0, dev: 0:0, unique: 0, ver: 1, nummatch: 2
 404                                 e->handle++;
 405 #endif
 406
 407                                 fprintf(stderr,"handle: %lu, action: %lu, status: %lu, eventid: %lu, cardtype: %lu, kplug: %lu, options: %lu, dev: %lx:%lx, unique: %lu, ver: %lu, nummatch: %lu\n", e->handle, e->dwAction, e->dwStatus, e->dwEventId, e->dwCardType, e->hKernelPlugIn, e->dwOptions, e->u.Usb.deviceId.dwVendorId, e->u.Usb.deviceId.dwProductId, e->u.Usb.dwUniqueID, e->dwEventVer, e->dwNumMatchTables);
 408                                 for (i = 0; i < e->dwNumMatchTables; i++)
 409                                         fprintf(stderr,"match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n", e->matchTables[i].VendorId, e->matchTables[i].ProductId, e->matchTables[i].bDeviceClass, e->matchTables[i].bDeviceSubClass, e->matchTables[i].bInterfaceClass, e->matchTables[i].bInterfaceSubClass, e->matchTables[i].bInterfaceProtocol);
 410                         }
 411                         break;
 412
 413                 case TRANSFER:
 414                         fprintf(stderr,"TRANSFER\n");
 415 #ifndef NO_WINDRVR
 416                         ret = (*ioctl_func) (fd, request, wdioctl);
 417 #endif
 418                         break;
 419
 420                 case EVENT_UNREGISTER:
 421                         fprintf(stderr,"EVENT_UNREGISTER\n");
 422 #ifndef NO_WINDRVR
 423                         ret = (*ioctl_func) (fd, request, wdioctl);
 424 #endif
 425                         break;
 426
 427                 case INT_WAIT:
 428                         fprintf(stderr,"INT_WAIT\n");
 429                         {
 430                                 struct interrupt *it = (struct interrupt*)(wdheader->data);
 431
 432                                 hexdump(wdheader->data, wdheader->size);
 433                                 fprintf(stderr,"Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n", it->hInterrupt, it->dwOptions, it->dwCmds, it->fEnableOk, it->dwCounter, it->dwLost, it->fStopped);
 434
 435 #ifndef NO_WINDRVR
 436                                 ret = (*ioctl_func) (fd, request, wdioctl);
 437 #else
 438                                 if (usbdevice) {
 439                                         if (it->dwCounter == 0) {
 440                                                 it->dwCounter = 1;
 441                                         } else {
 442                                                 //FIXME: signal durch FUTEX, overload futex!
 443                                                 while(ints_enabled) {sleep(1);}
 444                                         }
 445                                 } else {
 446                                         while(ints_enabled) {sleep(1);}
 447                                 }
 448 #endif
 449
 450                                 fprintf(stderr,"INT_WAIT_RETURN: Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n", it->hInterrupt, it->dwOptions, it->dwCmds, it->fEnableOk, it->dwCounter, it->dwLost, it->fStopped);
 451                         }
 452                         break;
 453
 454                 case CARD_UNREGISTER:
 455                         fprintf(stderr,"CARD_UNREGISTER\n");
 456 #ifndef NO_WINDRVR
 457                         ret = (*ioctl_func) (fd, request, wdioctl);
 458 #endif
 459                         break;
 460
 461                 case EVENT_PULL:
 462                         fprintf(stderr,"EVENT_PULL\n");
 463                         {
 464                                 struct event *e = (struct event*)(wdheader->data);
 465                                 int i;
 466
 467                                 fprintf(stderr,"handle: %lu, action: %lu, status: %lu, eventid: %lu, cardtype: %lx, kplug: %lu, options: %lu, dev: %lx:%lx, unique: %lu, ver: %lu, nummatch: %lu\n", e->handle, e->dwAction, e->dwStatus, e->dwEventId, e->dwCardType, e->hKernelPlugIn, e->dwOptions, e->u.Usb.deviceId.dwVendorId, e->u.Usb.deviceId.dwProductId, e->u.Usb.dwUniqueID, e->dwEventVer, e->dwNumMatchTables);
 468                                 for (i = 0; i < e->dwNumMatchTables; i++)
 469                                         fprintf(stderr,"match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n", e->matchTables[i].VendorId, e->matchTables[i].ProductId, e->matchTables[i].bDeviceClass, e->matchTables[i].bDeviceSubClass, e->matchTables[i].bInterfaceClass, e->matchTables[i].bInterfaceSubClass, e->matchTables[i].bInterfaceProtocol);
 470
 471 #ifndef NO_WINDRVR
 472                                 ret = (*ioctl_func) (fd, request, wdioctl);
 473 #else
 474 //EVENT_PULL
 475 //handle: 1, action: 0, status: 0, eventid: 0, cardtype: 0, kplug: 0, options: 0, dev: 0:0, unique: 0, ver: 1, nummatch: 1
 476 //match: dev: 0:0, class: 0, subclass: 0, intclass: 0, intsubclass: 0, intproto: 0
 477 //handle: 1, action: 1, status: 0, eventid: 109, cardtype: 4294967294, kplug: 0, options: 0, dev: 0:0, unique: 90, ver: 1, nummatch: 1
 478 //match: dev: 3fd:8, class: 0, subclass: 0, intclass: ff, intsubclass: 0, intproto: 0
 479                                 if (usbdevice) {
 480                                         struct usb_interface *interface = usbdevice->config->interface;
 481
 482                                         e->dwCardType = card_type;
 483                                         e->dwAction = 1;
 484                                         e->dwEventId = 109;
 485                                         e->u.Usb.dwUniqueID = 110;
 486                                         e->matchTables[0].VendorId = usbdevice->descriptor.idVendor;
 487                                         e->matchTables[0].ProductId = usbdevice->descriptor.idProduct;
 488                                         e->matchTables[0].bDeviceClass = usbdevice->descriptor.bDeviceClass;
 489                                         e->matchTables[0].bDeviceSubClass = usbdevice->descriptor.bDeviceSubClass;
 490                                         e->matchTables[0].bInterfaceClass = interface->altsetting[0].bInterfaceClass;
 491                                         e->matchTables[0].bInterfaceSubClass = interface->altsetting[0].bInterfaceSubClass;
 492                                         e->matchTables[0].bInterfaceProtocol = interface->altsetting[0].bInterfaceProtocol;
 493                                 }
 494 #endif
 495
 496                                 fprintf(stderr,"handle: %lu, action: %lu, status: %lu, eventid: %lu, cardtype: %lx, kplug: %lu, options: %lu, dev: %lx:%lx, unique: %lu, ver: %lu, nummatch: %lu\n", e->handle, e->dwAction, e->dwStatus, e->dwEventId, e->dwCardType, e->hKernelPlugIn, e->dwOptions, e->u.Usb.deviceId.dwVendorId, e->u.Usb.deviceId.dwProductId, e->u.Usb.dwUniqueID, e->dwEventVer, e->dwNumMatchTables);
 497                                 for (i = 0; i < e->dwNumMatchTables; i++)
 498                                         fprintf(stderr,"match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n", e->matchTables[i].VendorId, e->matchTables[i].ProductId, e->matchTables[i].bDeviceClass, e->matchTables[i].bDeviceSubClass, e->matchTables[i].bInterfaceClass, e->matchTables[i].bInterfaceSubClass, e->matchTables[i].bInterfaceProtocol);
 499
 500                         }
 501                         break;
 502
 503                 default:
 504                         fprintf(stderr,"!!!Unsupported IOCTL: %x!!!\n", request);
 505 #ifndef NO_WINDRVR
 506                         ret = (*ioctl_func) (fd, request, wdioctl);
 507 #endif
 508                         break;
 509         }
 510
 511         return ret;
 512 }
 513
 514
 515 typedef int (*open_funcptr_t) (const char *, int, mode_t);
 516
 517 int open (const char *pathname, int flags, ...)
 518 {
 519         static open_funcptr_t func = NULL;
 520         mode_t mode = 0;
 521         va_list args;
 522         int fd;
 523
 524         if (!func)
 525                 func = (open_funcptr_t) dlsym (REAL_LIBC, "open");
 526
 527         if (flags & O_CREAT) {
 528                 va_start(args, flags);
 529                 mode = va_arg(args, mode_t);
 530                 va_end(args);
 531         }
 532
 533         if (!strcmp (pathname, "/dev/windrvr6")) {
 534                 fprintf(stderr,"opening windrvr6\n");
 535 #ifdef NO_WINDRVR
 536                 windrvrfd = fd = (*func) ("/dev/null", flags, mode);
 537 #else
 538                 windrvrfd = fd = (*func) (pathname, flags, mode);
 539 #endif
 540                 if (!busses) {
 541                         usb_init();
 542                         usb_find_busses();
 543                         usb_find_devices();
 544
 545                         busses = usb_get_busses();
 546                 }
 547         } else {
 548                 fd = (*func) (pathname, flags, mode);
 549         }
 550
 551         return fd;
 552 }
 553
 554 void diff(unsigned char *buf1, unsigned char *buf2, int len) {
 555         int i;
 556
 557         for(i=0; i<len; i++) {
 558                 if (buf1[i] != buf2[i]) {
 559                         fprintf(stderr,"Diff at %d: %02x(%c)->%02x(%c)\n", i, buf1[i], ((buf1[i] >= 31 && buf1[i] <= 126)?buf1[i]:'.'), buf2[i], ((buf2[i] >= 31 && buf2[i] <= 126)?buf2[i]:'.'));
 560                 }
 561         }
 562 }
 563
 564 void hexdump(unsigned char *buf, int len) {
 565         int i;
 566
 567         for(i=0; i<len; i++) {
 568                 fprintf(stderr,"%02x ", buf[i]);
 569                 if ((i % 16) == 15)
 570                         fprintf(stderr,"\n");
 571         }
 572 }
 573
 574 int ioctl(int fd, int request, ...)
 575 {
 576         va_list args;
 577         void *argp;
 578         int ret;
 579
 580         if (!ioctl_func)
 581                 ioctl_func = (int (*) (int, int, void *)) dlsym (REAL_LIBC, "ioctl");
 582
 583         va_start (args, request);
 584         argp = va_arg (args, void *);
 585         va_end (args);
 586
 587         if (fd == windrvrfd)
 588                 ret = do_wdioctl(fd, request, argp);
 589         else
 590                 ret = (*ioctl_func) (fd, request, argp);
 591
 592         return ret;
 593 }
 594
 595 int futex(int *uaddr, int op, int val, const struct timespec *timeout, int *uaddr2, int val3) {
 596         static int (*func) (int*, int, int, const struct timespec*, int*, int) = NULL;
 597         int ret;
 598
 599         if (!func)
 600                 func = (int (*) (int*, int, int, const struct timespec*, int*, int)) dlsym(REAL_LIBC, "futex");
 601
 602         fprintf(stderr,"FUTEX: %x\n", (unsigned int)uaddr);
 603         ret = (*func) (uaddr, op, val, timeout, uaddr2, val3);
 604
 605         return ret;
 606 }
 607
 608
 609 #if 0
 610 void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset)
 611 {
 612         static void* (*func) (void *, size_t, int, int, int, off_t) = NULL;
 613         void *ret;
 614
 615         if (!func)
 616                 func = (void* (*) (void *, size_t, int, int, int, off_t)) dlsym (REAL_LIBC, "mmap");
 617
 618         ret = (*func) (start, length, prot, flags, fd, offset);
 619         fprintf(stderr,"MMAP: %x, %d, %d, %d, %d, %d -> %x\n", (unsigned int)start, length, prot, flags, fd, offset, (unsigned int)ret);
 620         mmapped = ret;
 621         mmapplen = length;
 622
 623         return ret;
 624 }
 625
 626 void *mmap64(void *start, size_t length, int prot, int flags, int fd, off64_t offset)
 627 {
 628         static void* (*func) (void *, size_t, int, int, int, off64_t) = NULL;
 629         void *ret;
 630
 631         if (!func)
 632                 func = (void* (*) (void *, size_t, int, int, int, off64_t)) dlsym (REAL_LIBC, "mmap64");
 633
 634         ret = (*func) (start, length, prot, flags, fd, offset);
 635         fprintf(stderr,"MMAP64: %x, %d, %d, %d, %d, %lld -> %x\n", (unsigned int)start, length, prot, flags, fd, offset, (unsigned int)ret);
 636         mmapped = ret;
 637         mmapplen = length;
 638
 639         return ret;
 640 }
 641
 642 void *mmap2(void *start, size_t length, int prot, int flags, int fd, off_t pgoffset)
 643 {
 644         static void* (*func) (void *, size_t, int, int, int, off_t) = NULL;
 645         void *ret;
 646
 647         if (!func)
 648                 func = (void* (*) (void *, size_t, int, int, int, off_t)) dlsym (REAL_LIBC, "mmap2");
 649
 650         ret = (*func) (start, length, prot, flags, fd, pgoffset);
 651         fprintf(stderr,"MMAP2: %x, %d, %d, %d, %d, %d -> %x\n", (unsigned int)start, length, prot, flags, fd, pgoffset, (unsigned int)ret);
 652         mmapped = ret;
 653         mmapplen = length;
 654
 655         return ret;
 656 }
 657
 658 void *malloc(size_t size)
 659 {
 660         static void* (*func) (size_t) = NULL;
 661         void *ret;
 662
 663         if (!func)
 664                 func = (void* (*) (size_t)) dlsym(REAL_LIBC, "malloc");
 665
 666         ret = (*func) (size);
 667
 668         //fprintf(stderr,"MALLOC: %d -> %x\n", size, (unsigned int) ret);
 669
 670         return ret;
 671 }
 672 #endif
 673
 674
 675 #endif