1 /* libusb connector for XILINX impact
3 * Copyright (c) 2007 Michael Gernoth <michael@gernoth.net>
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:
12 * The above copyright notice and this permission notice shall be included in
13 * all copies or substantial portions of the Software.
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
32 #include <sys/types.h>
41 #include "usb-driver.h"
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 uint32_t card_type
;
51 static int ints_enabled
= 0;
52 static pthread_mutex_t int_wait
= PTHREAD_MUTEX_INITIALIZER
;
58 #define DPRINTF(format, args...) fprintf(stderr, format, ##args)
59 void hexdump(unsigned char *buf
, int len
) {
62 for(i
=0; i
<len
; i
++) {
63 fprintf(stderr
,"%02x ", buf
[i
]);
70 #define DPRINTF(format, args...)
73 int usb_deviceinfo(unsigned char *buf
) {
76 WDU_CONFIGURATION
**pConfigs
, **pActiveConfig
;
77 WDU_INTERFACE
**pActiveInterface
;
80 struct usb_device_info
*udi
= (struct usb_device_info
*)(buf
+len
);
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
;
97 /* TODO: Fix Pipe0! */
98 udi
->Pipe0
.dwNumber
= 0x00;
99 udi
->Pipe0
.dwMaximumPacketSize
= usbdevice
->descriptor
.bMaxPacketSize0
;
101 udi
->Pipe0
.direction
= WDU_DIR_IN_OUT
;
102 udi
->Pipe0
.dwInterval
= 0;
104 pConfigs
= &(udi
->pConfigs
);
105 pActiveConfig
= &(udi
->pActiveConfig
);
106 pActiveInterface
= &(udi
->pActiveInterface
[0]);
109 len
= sizeof(struct usb_device_info
);
111 for (i
=0; i
<usbdevice
->descriptor
.bNumConfigurations
; i
++)
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
];
119 WDU_CONFIGURATION
*cfg
= (WDU_CONFIGURATION
*)(buf
+len
);
122 *pActiveConfig
= cfg
;
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
;
133 cfg
->dwNumInterfaces
= conf_desc
->bNumInterfaces
;
135 pInterfaces
= &(cfg
->pInterfaces
);
137 len
+= sizeof(WDU_CONFIGURATION
);
140 *pInterfaces
= (WDU_INTERFACE
*)(buf
+len
);
141 for (j
=0; j
<conf_desc
->bNumInterfaces
; j
++) {
142 WDU_INTERFACE
*iface
= (WDU_INTERFACE
*)(buf
+len
);
144 pActiveInterface
[j
] = iface
;
146 pAlternateSettings
[j
] = &(iface
->pAlternateSettings
);
147 iface
->dwNumAltSettings
= usbdevice
->config
[i
].interface
[j
].num_altsetting
;
148 pActiveAltSetting
[j
] = &(iface
->pActiveAltSetting
);
150 len
+= sizeof(WDU_INTERFACE
);
153 len
+= sizeof(WDU_INTERFACE
) * conf_desc
->bNumInterfaces
;
156 for (j
=0; j
<conf_desc
->bNumInterfaces
; j
++)
158 struct usb_interface
*interface
= &usbdevice
->config
[i
].interface
[j
];
161 *pAlternateSettings
[j
] = (WDU_ALTERNATE_SETTING
*)(buf
+len
);
163 *pActiveAltSetting
[j
] = (WDU_ALTERNATE_SETTING
*)(buf
+len
);
166 for(k
=0; k
<interface
->num_altsetting
; k
++)
168 unsigned char bNumEndpoints
= interface
->altsetting
[k
].bNumEndpoints
;
169 WDU_ENDPOINT_DESCRIPTOR
**pEndpointDescriptors
;
170 WDU_PIPE_INFO
**pPipes
;
173 WDU_ALTERNATE_SETTING
*altset
= (WDU_ALTERNATE_SETTING
*)(buf
+len
);
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
);
188 len
+=sizeof(WDU_ALTERNATE_SETTING
);
191 *pEndpointDescriptors
= (WDU_ENDPOINT_DESCRIPTOR
*)(buf
+len
);
192 for (l
= 0; l
< bNumEndpoints
; l
++) {
193 WDU_ENDPOINT_DESCRIPTOR
*ed
= (WDU_ENDPOINT_DESCRIPTOR
*)(buf
+len
);
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
;
202 len
+= sizeof(WDU_ENDPOINT_DESCRIPTOR
);
205 *pPipes
= (WDU_PIPE_INFO
*)(buf
+len
);
206 for (l
= 0; l
< bNumEndpoints
; l
++) {
207 WDU_PIPE_INFO
*pi
= (WDU_PIPE_INFO
*)(buf
+len
);
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
;
216 pi
->direction
= interface
->altsetting
[k
].endpoint
[l
].bEndpointAddress
& USB_ENDPOINT_DIR_MASK
? WDU_DIR_IN
: WDU_DIR_OUT
;
219 pi
->dwInterval
= interface
->altsetting
[k
].endpoint
[l
].bInterval
;
221 len
+= sizeof(WDU_PIPE_INFO
);
224 len
+=(sizeof(WDU_ENDPOINT_DESCRIPTOR
)+sizeof(WDU_PIPE_INFO
))*bNumEndpoints
;
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
;
238 if (wdheader
->magic
!= MAGIC
) {
239 fprintf(stderr
,"!!!ERROR: magic header does not match!!!\n");
240 return (*ioctl_func
) (fd
, request
, wdioctl
);
245 version
= (struct version_struct
*)(wdheader
->data
);
246 strcpy(version
->version
, "WinDriver no more");
247 version
->versionul
= 802;
248 DPRINTF("VERSION\n");
252 DPRINTF("LICENSE\n");
256 /* TODO: Implement for LPT-support */
259 struct card_register
* cr
= (struct card_register
*)(wdheader
->data
);
262 DPRINTF("CARD_REGISTER\n");
266 DPRINTF("in USB_TRANSFER");
268 struct usb_transfer
*ut
= (struct usb_transfer
*)(wdheader
->data
);
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);
277 if (!ut
->fRead
&& ut
->dwBufferSize
)
279 hexdump(ut
->pBuffer
, ut
->dwBufferSize
);
284 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
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
);
298 ret
= usb_bulk_read(usb_devhandle
, ut
->dwPipeNum
, ut
->pBuffer
, ut
->dwBufferSize
, ut
->dwTimeout
);
301 ret
= usb_bulk_write(usb_devhandle
, ut
->dwPipeNum
, ut
->pBuffer
, ut
->dwBufferSize
, ut
->dwTimeout
);
306 fprintf(stderr
, "usb_transfer: %d (%s)\n", ret
, usb_strerror());
308 ut
->dwBytesTransferred
= ret
;
314 DPRINTF("Transferred: %lu (%s)\n",ut
->dwBytesTransferred
, (ut
->fRead
?"read":"write"));
315 if (ut
->fRead
&& ut
->dwBytesTransferred
)
318 hexdump(ut
->pBuffer
, ut
->dwBytesTransferred
);
325 DPRINTF("INT_ENABLE\n");
327 struct interrupt
*it
= (struct interrupt
*)(wdheader
->data
);
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
);
337 pthread_mutex_trylock(&int_wait
);
343 DPRINTF("INT_DISABLE\n");
345 struct interrupt
*it
= (struct interrupt
*)(wdheader
->data
);
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
);
352 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
357 if (pthread_mutex_trylock(&int_wait
) == EBUSY
)
358 pthread_mutex_unlock(&int_wait
);
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
);
367 case USB_SET_INTERFACE
:
368 DPRINTF("USB_SET_INTERFACE\n");
370 struct usb_set_interface
*usi
= (struct usb_set_interface
*)(wdheader
->data
);
372 DPRINTF("unique: %lu, interfacenum: %lu, alternatesetting: %lu, options: %lx\n",
373 usi
->dwUniqueID
, usi
->dwInterfaceNum
,
374 usi
->dwAlternateSetting
, usi
->dwOptions
);
376 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
380 usb_devhandle
= usb_open(usbdevice
);
382 /* FIXME: Select right interface! */
383 ret
= usb_claim_interface(usb_devhandle
, usbdevice
->config
[0].interface
[usi
->dwInterfaceNum
].altsetting
[usi
->dwAlternateSetting
].bInterfaceNumber
);
386 ret
= usb_set_altinterface(usb_devhandle
, usi
->dwAlternateSetting
);
388 fprintf(stderr
, "usb_set_altinterface: %d\n", ret
);
390 fprintf(stderr
, "usb_set_configuration: %d (%s)\n", ret
, usb_strerror());
393 fprintf(stderr
, "usb_claim_interface: %d -> %d (%s)\n",
394 usbdevice
->config
[0].interface
[usi
->dwInterfaceNum
].altsetting
[usi
->dwAlternateSetting
].bInterfaceNumber
,
395 ret
, usb_strerror());
399 DPRINTF("unique: %lu, interfacenum: %lu, alternatesetting: %lu, options: %lx\n",
400 usi
->dwUniqueID
, usi
->dwInterfaceNum
,
401 usi
->dwAlternateSetting
, usi
->dwOptions
);
405 case USB_GET_DEVICE_DATA
:
406 DPRINTF("USB_GET_DEVICE_DATA\n");
408 struct usb_get_device_data
*ugdd
= (struct usb_get_device_data
*)(wdheader
->data
);
411 DPRINTF("unique: %lu, bytes: %lu, options: %lx\n",
412 ugdd
->dwUniqueID
, ugdd
->dwBytes
,
415 pSize
= ugdd
->dwBytes
;
416 if (!ugdd
->dwBytes
) {
418 ugdd
->dwBytes
= usb_deviceinfo(NULL
);
421 usb_deviceinfo((unsigned char*)ugdd
->pBuf
);
427 DPRINTF("EVENT_REGISTER\n");
429 struct event
*e
= (struct event
*)(wdheader
->data
);
433 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",
434 e
->handle
, e
->dwAction
,
435 e
->dwStatus
, e
->dwEventId
, e
->dwCardType
,
436 e
->hKernelPlugIn
, e
->dwOptions
,
437 e
->u
.Usb
.deviceId
.dwVendorId
,
438 e
->u
.Usb
.deviceId
.dwProductId
,
439 e
->u
.Usb
.dwUniqueID
, e
->dwEventVer
,
440 e
->dwNumMatchTables
);
442 for (i
= 0; i
< e
->dwNumMatchTables
; i
++) {
444 DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
445 e
->matchTables
[i
].VendorId
,
446 e
->matchTables
[i
].ProductId
,
447 e
->matchTables
[i
].bDeviceClass
,
448 e
->matchTables
[i
].bDeviceSubClass
,
449 e
->matchTables
[i
].bInterfaceClass
,
450 e
->matchTables
[i
].bInterfaceSubClass
,
451 e
->matchTables
[i
].bInterfaceProtocol
);
453 for (bus
= busses
; bus
; bus
= bus
->next
) {
454 struct usb_device
*dev
;
456 for (dev
= bus
->devices
; dev
; dev
= dev
->next
) {
457 struct usb_device_descriptor
*desc
= &(dev
->descriptor
);
459 if((desc
->idVendor
== e
->matchTables
[i
].VendorId
) &&
460 (desc
->idProduct
== e
->matchTables
[i
].ProductId
) &&
461 (desc
->bDeviceClass
== e
->matchTables
[i
].bDeviceClass
) &&
462 (desc
->bDeviceSubClass
== e
->matchTables
[i
].bDeviceSubClass
)) {
464 for (ac
= 0; ac
< desc
->bNumConfigurations
; ac
++) {
465 struct usb_interface
*interface
= dev
->config
[ac
].interface
;
468 for (ai
= 0; ai
< interface
->num_altsetting
; ai
++) {
470 DPRINTF("intclass: %x, intsubclass: %x, intproto: %x\n",
471 interface
->altsetting
[i
].bInterfaceClass
,
472 interface
->altsetting
[i
].bInterfaceSubClass
,
473 interface
->altsetting
[i
].bInterfaceProtocol
);
475 if ((interface
->altsetting
[ai
].bInterfaceSubClass
== e
->matchTables
[i
].bInterfaceSubClass
) &&
476 (interface
->altsetting
[ai
].bInterfaceProtocol
== e
->matchTables
[i
].bInterfaceProtocol
)){
477 /* TODO: check interfaceClass! */
478 DPRINTF("found device with libusb\n");
480 card_type
= e
->dwCardType
;
490 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
496 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",
497 e
->handle
, e
->dwAction
,
498 e
->dwStatus
, e
->dwEventId
, e
->dwCardType
,
499 e
->hKernelPlugIn
, e
->dwOptions
,
500 e
->u
.Usb
.deviceId
.dwVendorId
,
501 e
->u
.Usb
.deviceId
.dwProductId
,
502 e
->u
.Usb
.dwUniqueID
, e
->dwEventVer
,
503 e
->dwNumMatchTables
);
505 for (i
= 0; i
< e
->dwNumMatchTables
; i
++)
506 DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
507 e
->matchTables
[i
].VendorId
,
508 e
->matchTables
[i
].ProductId
,
509 e
->matchTables
[i
].bDeviceClass
,
510 e
->matchTables
[i
].bDeviceSubClass
,
511 e
->matchTables
[i
].bInterfaceClass
,
512 e
->matchTables
[i
].bInterfaceSubClass
,
513 e
->matchTables
[i
].bInterfaceProtocol
);
519 DPRINTF("TRANSFER\n");
521 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
525 case EVENT_UNREGISTER
:
526 DPRINTF("EVENT_UNREGISTER\n");
528 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
533 DPRINTF("INT_WAIT\n");
535 struct interrupt
*it
= (struct interrupt
*)(wdheader
->data
);
537 DPRINTF("Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n",
538 it
->hInterrupt
, it
->dwOptions
,
539 it
->dwCmds
, it
->fEnableOk
, it
->dwCounter
,
540 it
->dwLost
, it
->fStopped
);
543 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
546 if (it
->dwCounter
== 0) {
549 pthread_mutex_lock(&int_wait
);
550 pthread_mutex_unlock(&int_wait
);
553 pthread_mutex_lock(&int_wait
);
554 pthread_mutex_unlock(&int_wait
);
558 DPRINTF("INT_WAIT_RETURN: Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n",
559 it
->hInterrupt
, it
->dwOptions
, it
->dwCmds
,
560 it
->fEnableOk
, it
->dwCounter
, it
->dwLost
,
565 case CARD_UNREGISTER
:
566 DPRINTF("CARD_UNREGISTER\n");
568 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
573 DPRINTF("EVENT_PULL\n");
575 struct event
*e
= (struct event
*)(wdheader
->data
);
579 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",
580 e
->handle
, e
->dwAction
, e
->dwStatus
,
581 e
->dwEventId
, e
->dwCardType
, e
->hKernelPlugIn
,
582 e
->dwOptions
, e
->u
.Usb
.deviceId
.dwVendorId
,
583 e
->u
.Usb
.deviceId
.dwProductId
,
584 e
->u
.Usb
.dwUniqueID
, e
->dwEventVer
,
585 e
->dwNumMatchTables
);
587 for (i
= 0; i
< e
->dwNumMatchTables
; i
++)
588 DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
589 e
->matchTables
[i
].VendorId
,
590 e
->matchTables
[i
].ProductId
,
591 e
->matchTables
[i
].bDeviceClass
,
592 e
->matchTables
[i
].bDeviceSubClass
,
593 e
->matchTables
[i
].bInterfaceClass
,
594 e
->matchTables
[i
].bInterfaceSubClass
,
595 e
->matchTables
[i
].bInterfaceProtocol
);
599 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
602 struct usb_interface
*interface
= usbdevice
->config
->interface
;
604 e
->dwCardType
= card_type
;
607 e
->u
.Usb
.dwUniqueID
= 110;
608 e
->matchTables
[0].VendorId
= usbdevice
->descriptor
.idVendor
;
609 e
->matchTables
[0].ProductId
= usbdevice
->descriptor
.idProduct
;
610 e
->matchTables
[0].bDeviceClass
= usbdevice
->descriptor
.bDeviceClass
;
611 e
->matchTables
[0].bDeviceSubClass
= usbdevice
->descriptor
.bDeviceSubClass
;
612 e
->matchTables
[0].bInterfaceClass
= interface
->altsetting
[0].bInterfaceClass
;
613 e
->matchTables
[0].bInterfaceSubClass
= interface
->altsetting
[0].bInterfaceSubClass
;
614 e
->matchTables
[0].bInterfaceProtocol
= interface
->altsetting
[0].bInterfaceProtocol
;
619 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",
620 e
->handle
, e
->dwAction
, e
->dwStatus
,
621 e
->dwEventId
, e
->dwCardType
, e
->hKernelPlugIn
,
622 e
->dwOptions
, e
->u
.Usb
.deviceId
.dwVendorId
,
623 e
->u
.Usb
.deviceId
.dwProductId
,
624 e
->u
.Usb
.dwUniqueID
, e
->dwEventVer
,
625 e
->dwNumMatchTables
);
627 for (i
= 0; i
< e
->dwNumMatchTables
; i
++)
628 DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
629 e
->matchTables
[i
].VendorId
,
630 e
->matchTables
[i
].ProductId
,
631 e
->matchTables
[i
].bDeviceClass
,
632 e
->matchTables
[i
].bDeviceSubClass
,
633 e
->matchTables
[i
].bInterfaceClass
,
634 e
->matchTables
[i
].bInterfaceSubClass
,
635 e
->matchTables
[i
].bInterfaceProtocol
);
642 fprintf(stderr
,"!!!Unsupported IOCTL: %x!!!\n", request
);
644 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
652 int ioctl(int fd
, int request
, ...) {
658 ioctl_func
= (int (*) (int, int, void *)) dlsym (RTLD_NEXT
, "ioctl");
660 va_start (args
, request
);
661 argp
= va_arg (args
, void *);
665 ret
= do_wdioctl(fd
, request
, argp
);
667 ret
= (*ioctl_func
) (fd
, request
, argp
);
672 int open (const char *pathname
, int flags
, ...) {
673 static int (*func
) (const char *, int, mode_t
) = NULL
;
679 func
= (int (*) (const char *, int, mode_t
)) dlsym (RTLD_NEXT
, "open");
681 if (flags
& O_CREAT
) {
682 va_start(args
, flags
);
683 mode
= va_arg(args
, mode_t
);
687 if (!strcmp (pathname
, "/dev/windrvr6")) {
688 DPRINTF("opening windrvr6\n");
690 windrvrfd
= fd
= (*func
) ("/dev/null", flags
, mode
);
692 windrvrfd
= fd
= (*func
) (pathname
, flags
, mode
);
699 busses
= usb_get_busses();
705 return (*func
) (pathname
, flags
, mode
);
709 static int (*func
) (int) = NULL
;
712 func
= (int (*) (int)) dlsym(RTLD_NEXT
, "close");
714 if (fd
== windrvrfd
&& windrvrfd
>= 0) {
715 DPRINTF("close windrvrfd\n");
722 FILE *fopen(const char *path
, const char *mode
) {
724 static FILE* (*func
) (const char*, const char*) = NULL
;
727 func
= (FILE* (*) (const char*, const char*)) dlsym(RTLD_NEXT
, "fopen");
729 ret
= (*func
) (path
, mode
);
731 if (!strcmp (path
, "/proc/modules")) {
732 DPRINTF("opening /proc/modules\n");
742 char *fgets(char *s
, int size
, FILE *stream
) {
743 static char* (*func
) (char*, int, FILE*) = NULL
;
744 const char modules
[][256] = {"windrvr6 1 0 - Live 0xdeadbeef\n", "parport_pc 1 0 - Live 0xdeadbeef\n"};
749 func
= (char* (*) (char*, int, FILE*)) dlsym(RTLD_NEXT
, "fgets");
751 if (modulesfp
== stream
) {
752 if (modules_read
< sizeof(modules
)) {
753 strcpy(s
, modules
[modules_read
]);
758 ret
= (*func
)(s
,size
,stream
);
764 int fclose(FILE *fp
) {
765 static int (*func
) (FILE*) = NULL
;
768 func
= (int (*) (FILE*)) dlsym(RTLD_NEXT
, "fclose");
770 if (fp
== modulesfp
) {
777 int access(const char *pathname
, int mode
) {
778 static int (*func
) (const char*, int);
781 func
= (int (*) (const char*, int)) dlsym(RTLD_NEXT
, "access");
783 if (!strcmp(pathname
, "/dev/windrvr6")) {
786 return (*func
)(pathname
, mode
);