1 /* libusb/ppdev 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 <sys/ioctl.h>
42 #include <linux/parport.h>
43 #include <linux/ppdev.h>
44 #include "usb-driver.h"
46 static int (*ioctl_func
) (int, int, void *) = NULL
;
47 static int windrvrfd
= -1;
48 static int parportfd
= -1;
49 static int parportnum
= 0;
50 static unsigned long ppbase
= 0;
51 static unsigned long ecpbase
= 0;
52 FILE *modulesfp
= NULL
;
53 static int modules_read
= 0;
54 static struct usb_bus
*busses
= NULL
;
55 static struct usb_device
*usbdevice
;
56 static usb_dev_handle
*usb_devhandle
= NULL
;
57 static int usbinterface
= -1;
58 static unsigned long card_type
;
59 static int ints_enabled
= 0;
60 static pthread_mutex_t int_wait
= PTHREAD_MUTEX_INITIALIZER
;
65 #define DPRINTF(format, args...) fprintf(stderr, format, ##args)
66 void hexdump(unsigned char *buf
, int len
) {
69 for(i
=0; i
<len
; i
++) {
70 fprintf(stderr
,"%02x ", buf
[i
]);
77 #define DPRINTF(format, args...)
80 int usb_deviceinfo(unsigned char *buf
) {
83 WDU_CONFIGURATION
**pConfigs
, **pActiveConfig
;
84 WDU_INTERFACE
**pActiveInterface
;
87 struct usb_device_info
*udi
= (struct usb_device_info
*)(buf
+len
);
89 udi
->Descriptor
.bLength
= sizeof(WDU_DEVICE_DESCRIPTOR
);
90 udi
->Descriptor
.bDescriptorType
= usbdevice
->descriptor
.bDescriptorType
;
91 udi
->Descriptor
.bcdUSB
= usbdevice
->descriptor
.bcdUSB
;
92 udi
->Descriptor
.bDeviceClass
= usbdevice
->descriptor
.bDeviceClass
;
93 udi
->Descriptor
.bDeviceSubClass
= usbdevice
->descriptor
.bDeviceSubClass
;
94 udi
->Descriptor
.bDeviceProtocol
= usbdevice
->descriptor
.bDeviceProtocol
;
95 udi
->Descriptor
.bMaxPacketSize0
= usbdevice
->descriptor
.bMaxPacketSize0
;
96 udi
->Descriptor
.idVendor
= usbdevice
->descriptor
.idVendor
;
97 udi
->Descriptor
.idProduct
= usbdevice
->descriptor
.idProduct
;
98 udi
->Descriptor
.bcdDevice
= usbdevice
->descriptor
.bcdDevice
;
99 udi
->Descriptor
.iManufacturer
= usbdevice
->descriptor
.iManufacturer
;
100 udi
->Descriptor
.iProduct
= usbdevice
->descriptor
.iProduct
;
101 udi
->Descriptor
.iSerialNumber
= usbdevice
->descriptor
.iSerialNumber
;
102 udi
->Descriptor
.bNumConfigurations
= usbdevice
->descriptor
.bNumConfigurations
;
104 /* TODO: Fix Pipe0! */
105 udi
->Pipe0
.dwNumber
= 0x00;
106 udi
->Pipe0
.dwMaximumPacketSize
= usbdevice
->descriptor
.bMaxPacketSize0
;
108 udi
->Pipe0
.direction
= WDU_DIR_IN_OUT
;
109 udi
->Pipe0
.dwInterval
= 0;
111 pConfigs
= &(udi
->pConfigs
);
112 pActiveConfig
= &(udi
->pActiveConfig
);
113 pActiveInterface
= &(udi
->pActiveInterface
[0]);
116 len
= sizeof(struct usb_device_info
);
118 for (i
=0; i
<usbdevice
->descriptor
.bNumConfigurations
; i
++)
120 struct usb_config_descriptor
*conf_desc
= &usbdevice
->config
[i
];
121 WDU_INTERFACE
**pInterfaces
;
122 WDU_ALTERNATE_SETTING
**pAlternateSettings
[conf_desc
->bNumInterfaces
];
123 WDU_ALTERNATE_SETTING
**pActiveAltSetting
[conf_desc
->bNumInterfaces
];
126 WDU_CONFIGURATION
*cfg
= (WDU_CONFIGURATION
*)(buf
+len
);
129 *pActiveConfig
= cfg
;
131 cfg
->Descriptor
.bLength
= conf_desc
->bLength
;
132 cfg
->Descriptor
.bDescriptorType
= conf_desc
->bDescriptorType
;
133 cfg
->Descriptor
.wTotalLength
= conf_desc
->wTotalLength
;
134 cfg
->Descriptor
.bNumInterfaces
= conf_desc
->bNumInterfaces
;
135 cfg
->Descriptor
.bConfigurationValue
= conf_desc
->bConfigurationValue
;
136 cfg
->Descriptor
.iConfiguration
= conf_desc
->iConfiguration
;
137 cfg
->Descriptor
.bmAttributes
= conf_desc
->bmAttributes
;
138 cfg
->Descriptor
.MaxPower
= conf_desc
->MaxPower
;
140 cfg
->dwNumInterfaces
= conf_desc
->bNumInterfaces
;
142 pInterfaces
= &(cfg
->pInterfaces
);
144 len
+= sizeof(WDU_CONFIGURATION
);
147 *pInterfaces
= (WDU_INTERFACE
*)(buf
+len
);
148 for (j
=0; j
<conf_desc
->bNumInterfaces
; j
++) {
149 WDU_INTERFACE
*iface
= (WDU_INTERFACE
*)(buf
+len
);
151 pActiveInterface
[j
] = iface
;
153 pAlternateSettings
[j
] = &(iface
->pAlternateSettings
);
154 iface
->dwNumAltSettings
= usbdevice
->config
[i
].interface
[j
].num_altsetting
;
155 pActiveAltSetting
[j
] = &(iface
->pActiveAltSetting
);
157 len
+= sizeof(WDU_INTERFACE
);
160 len
+= sizeof(WDU_INTERFACE
) * conf_desc
->bNumInterfaces
;
163 for (j
=0; j
<conf_desc
->bNumInterfaces
; j
++)
165 struct usb_interface
*interface
= &usbdevice
->config
[i
].interface
[j
];
168 *pAlternateSettings
[j
] = (WDU_ALTERNATE_SETTING
*)(buf
+len
);
170 *pActiveAltSetting
[j
] = (WDU_ALTERNATE_SETTING
*)(buf
+len
);
173 for(k
=0; k
<interface
->num_altsetting
; k
++)
175 unsigned char bNumEndpoints
= interface
->altsetting
[k
].bNumEndpoints
;
176 WDU_ENDPOINT_DESCRIPTOR
**pEndpointDescriptors
;
177 WDU_PIPE_INFO
**pPipes
;
180 WDU_ALTERNATE_SETTING
*altset
= (WDU_ALTERNATE_SETTING
*)(buf
+len
);
182 altset
->Descriptor
.bLength
= interface
->altsetting
[k
].bLength
;
183 altset
->Descriptor
.bDescriptorType
= interface
->altsetting
[k
].bDescriptorType
;
184 altset
->Descriptor
.bInterfaceNumber
= interface
->altsetting
[k
].bInterfaceNumber
;
185 altset
->Descriptor
.bAlternateSetting
= interface
->altsetting
[k
].bAlternateSetting
;
186 altset
->Descriptor
.bNumEndpoints
= interface
->altsetting
[k
].bNumEndpoints
;
187 altset
->Descriptor
.bInterfaceClass
= interface
->altsetting
[k
].bInterfaceClass
;
188 altset
->Descriptor
.bInterfaceSubClass
= interface
->altsetting
[k
].bInterfaceSubClass
;
189 altset
->Descriptor
.bInterfaceProtocol
= interface
->altsetting
[k
].bInterfaceProtocol
;
190 altset
->Descriptor
.iInterface
= interface
->altsetting
[k
].iInterface
;
191 pEndpointDescriptors
= &(altset
->pEndpointDescriptors
);
192 pPipes
= &(altset
->pPipes
);
195 len
+=sizeof(WDU_ALTERNATE_SETTING
);
198 *pEndpointDescriptors
= (WDU_ENDPOINT_DESCRIPTOR
*)(buf
+len
);
199 for (l
= 0; l
< bNumEndpoints
; l
++) {
200 WDU_ENDPOINT_DESCRIPTOR
*ed
= (WDU_ENDPOINT_DESCRIPTOR
*)(buf
+len
);
202 ed
->bLength
= interface
->altsetting
[k
].endpoint
[l
].bLength
;
203 ed
->bDescriptorType
= interface
->altsetting
[k
].endpoint
[l
].bDescriptorType
;
204 ed
->bEndpointAddress
= interface
->altsetting
[k
].endpoint
[l
].bEndpointAddress
;
205 ed
->bmAttributes
= interface
->altsetting
[k
].endpoint
[l
].bmAttributes
;
206 ed
->wMaxPacketSize
= interface
->altsetting
[k
].endpoint
[l
].wMaxPacketSize
;
207 ed
->bInterval
= interface
->altsetting
[k
].endpoint
[l
].bInterval
;
209 len
+= sizeof(WDU_ENDPOINT_DESCRIPTOR
);
212 *pPipes
= (WDU_PIPE_INFO
*)(buf
+len
);
213 for (l
= 0; l
< bNumEndpoints
; l
++) {
214 WDU_PIPE_INFO
*pi
= (WDU_PIPE_INFO
*)(buf
+len
);
216 pi
->dwNumber
= interface
->altsetting
[k
].endpoint
[l
].bEndpointAddress
;
217 pi
->dwMaximumPacketSize
= WDU_GET_MAX_PACKET_SIZE(interface
->altsetting
[k
].endpoint
[l
].wMaxPacketSize
);
218 pi
->type
= interface
->altsetting
[k
].endpoint
[l
].bmAttributes
& USB_ENDPOINT_TYPE_MASK
;
219 if (pi
->type
== PIPE_TYPE_CONTROL
)
220 pi
->direction
= WDU_DIR_IN_OUT
;
223 pi
->direction
= interface
->altsetting
[k
].endpoint
[l
].bEndpointAddress
& USB_ENDPOINT_DIR_MASK
? WDU_DIR_IN
: WDU_DIR_OUT
;
226 pi
->dwInterval
= interface
->altsetting
[k
].endpoint
[l
].bInterval
;
228 len
+= sizeof(WDU_PIPE_INFO
);
231 len
+=(sizeof(WDU_ENDPOINT_DESCRIPTOR
)+sizeof(WDU_PIPE_INFO
))*bNumEndpoints
;
240 int pp_transfer(WD_TRANSFER
*tr
, int fd
, unsigned int request
, unsigned char *wdioctl
) {
244 DPRINTF("dwPort: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
245 (unsigned long)tr
->dwPort
, tr
->cmdTrans
, tr
->dwBytes
,
246 tr
->fAutoinc
, tr
->dwOptions
);
251 if (tr
->cmdTrans
== 13)
252 DPRINTF("write byte: %d\n", val
);
256 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
261 switch((unsigned long)tr
->dwPort
- ppbase
) {
263 DPRINTF("data port\n");
264 switch(tr
->cmdTrans
) {
266 ret
= 0; /* We don't support reading of the data port */
270 ret
= ioctl(parportfd
, PPWDATA
, &val
);
274 fprintf(stderr
,"!!!Unsupported TRANSFER command: %lu!!!\n", tr
->cmdTrans
);
281 DPRINTF("status port\n");
282 switch(tr
->cmdTrans
) {
284 ret
= ioctl(parportfd
, PPRSTATUS
, &val
);
288 ret
= 0; /* Status Port is readonly */
292 fprintf(stderr
,"!!!Unsupported TRANSFER command: %lu!!!\n", tr
->cmdTrans
);
299 DPRINTF("control port\n");
300 switch(tr
->cmdTrans
) {
302 ret
= ioctl(parportfd
, PPRCONTROL
, &val
);
306 ret
= ioctl(parportfd
, PPWCONTROL
, &val
);
310 fprintf(stderr
,"!!!Unsupported TRANSFER command: %lu!!!\n", tr
->cmdTrans
);
317 DPRINTF("access to unsupported address range (probably ECP)!\n");
325 DPRINTF("dwPortReturn: 0x%lx, cmdTrans: %lu, dwbytes: %ld, fautoinc: %ld, dwoptions: %ld\n",
326 (unsigned long)tr
->dwPort
, tr
->cmdTrans
, tr
->dwBytes
,
327 tr
->fAutoinc
, tr
->dwOptions
);
329 if (tr
->cmdTrans
== 10)
330 DPRINTF("read byte: %d\n", tr
->Data
.Byte
);
336 int do_wdioctl(int fd
, unsigned int request
, unsigned char *wdioctl
) {
337 struct header_struct
* wdheader
= (struct header_struct
*)wdioctl
;
338 struct version_struct
*version
;
341 if (wdheader
->magic
!= MAGIC
) {
342 fprintf(stderr
,"!!!ERROR: magic header does not match!!!\n");
343 return (*ioctl_func
) (fd
, request
, wdioctl
);
346 switch(request
& ~(0xc0000000)) {
348 version
= (struct version_struct
*)(wdheader
->data
);
349 strcpy(version
->version
, "WinDriver no more");
350 version
->versionul
= 802;
351 DPRINTF("VERSION\n");
355 DPRINTF("LICENSE\n");
358 case CARD_REGISTER_OLD
:
360 DPRINTF("CARD_REGISTER\n");
362 struct card_register
* cr
= (struct card_register
*)(wdheader
->data
);
365 DPRINTF("Items: %lu, Addr: 0x%lx, bytes: %lu, bar: %lu\n",
367 (unsigned long)cr
->Card
.Item
[0].I
.IO
.dwAddr
,
368 cr
->Card
.Item
[0].I
.IO
.dwBytes
,
369 cr
->Card
.Item
[0].I
.IO
.dwBar
);
371 DPRINTF("Items: %lu, Addr: 0x%lx, bytes: %lu, bar: %lu\n",
373 (unsigned long)cr
->Card
.Item
[1].I
.IO
.dwAddr
,
374 cr
->Card
.Item
[1].I
.IO
.dwBytes
,
375 cr
->Card
.Item
[1].I
.IO
.dwBar
);
377 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
380 snprintf(ppdev
, sizeof(ppdev
), "/dev/parport%d", parportnum
);
381 DPRINTF("opening %s\n", ppdev
);
382 parportfd
= open(ppdev
, O_RDWR
|O_EXCL
);
386 fprintf(stderr
,"Can't open %s: %s\n", ppdev
, strerror(errno
));
389 if (parportfd
>= 0) {
392 if (ioctl(parportfd
, PPCLAIM
) == -1)
396 pmode
= IEEE1284_MODE_COMPAT
;
397 if (ioctl(parportfd
, PPNEGOT
, &pmode
) == -1)
400 if (cr
->Card
.dwItems
> 1 && cr
->Card
.Item
[1].I
.IO
.dwBytes
) {
401 DPRINTF("ECP mode requested\n");
402 ecpbase
= cr
->Card
.Item
[1].I
.IO
.dwBytes
;
403 /* TODO: Implement ECP mode */
405 pmode
= IEEE1284_MODE_ECP
;
407 if (ioctl(parportfd
, PPNEGOT
, &pmode
) == -1) {
409 pmode
= IEEE1284_MODE_COMPAT
;
410 if (ioctl(parportfd
, PPNEGOT
, &pmode
) == -1)
416 cr
->hCard
= parportfd
;
417 ppbase
= (unsigned long)cr
->Card
.Item
[0].I
.IO
.dwAddr
;
420 DPRINTF("hCard: %lu\n", cr
->hCard
);
425 DPRINTF("in USB_TRANSFER");
427 struct usb_transfer
*ut
= (struct usb_transfer
*)(wdheader
->data
);
430 DPRINTF(" unique: %lu, pipe: %lu, read: %lu, options: %lx, size: %lu, timeout: %lx\n",
431 ut
->dwUniqueID
, ut
->dwPipeNum
, ut
->fRead
,
432 ut
->dwOptions
, ut
->dwBufferSize
, ut
->dwTimeout
);
433 DPRINTF("setup packet: ");
434 hexdump(ut
->SetupPacket
, 8);
436 if (!ut
->fRead
&& ut
->dwBufferSize
)
438 hexdump(ut
->pBuffer
, ut
->dwBufferSize
);
443 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
445 /* http://www.jungo.com/support/documentation/windriver/802/wdusb_man_mhtml/node55.html#SECTION001213000000000000000 */
446 if (ut
->dwPipeNum
== 0) { /* control pipe */
447 int requesttype
, request
, value
, index
, size
;
448 requesttype
= ut
->SetupPacket
[0];
449 request
= ut
->SetupPacket
[1];
450 value
= ut
->SetupPacket
[2] | (ut
->SetupPacket
[3] << 8);
451 index
= ut
->SetupPacket
[4] | (ut
->SetupPacket
[5] << 8);
452 size
= ut
->SetupPacket
[6] | (ut
->SetupPacket
[7] << 8);
453 DPRINTF("requesttype: %x, request: %x, value: %u, index: %u, size: %u\n", requesttype
, request
, value
, index
, size
);
454 ret
= usb_control_msg(usb_devhandle
, requesttype
, request
, value
, index
, ut
->pBuffer
, size
, ut
->dwTimeout
);
457 ret
= usb_bulk_read(usb_devhandle
, ut
->dwPipeNum
, ut
->pBuffer
, ut
->dwBufferSize
, ut
->dwTimeout
);
460 ret
= usb_bulk_write(usb_devhandle
, ut
->dwPipeNum
, ut
->pBuffer
, ut
->dwBufferSize
, ut
->dwTimeout
);
465 fprintf(stderr
, "usb_transfer: %d (%s)\n", ret
, usb_strerror());
467 ut
->dwBytesTransferred
= ret
;
473 DPRINTF("Transferred: %lu (%s)\n",ut
->dwBytesTransferred
, (ut
->fRead
?"read":"write"));
474 if (ut
->fRead
&& ut
->dwBytesTransferred
)
477 hexdump(ut
->pBuffer
, ut
->dwBytesTransferred
);
485 DPRINTF("INT_ENABLE\n");
487 struct interrupt
*it
= (struct interrupt
*)(wdheader
->data
);
489 DPRINTF("Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n",
490 it
->hInterrupt
, it
->dwOptions
,
491 it
->dwCmds
, it
->fEnableOk
, it
->dwCounter
,
492 it
->dwLost
, it
->fStopped
);
497 pthread_mutex_trylock(&int_wait
);
503 DPRINTF("INT_DISABLE\n");
505 struct interrupt
*it
= (struct interrupt
*)(wdheader
->data
);
507 DPRINTF("Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n",
508 it
->hInterrupt
, it
->dwOptions
,
509 it
->dwCmds
, it
->fEnableOk
, it
->dwCounter
,
510 it
->dwLost
, it
->fStopped
);
512 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
517 if (pthread_mutex_trylock(&int_wait
) == EBUSY
)
518 pthread_mutex_unlock(&int_wait
);
520 DPRINTF("Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n",
521 it
->hInterrupt
, it
->dwOptions
,
522 it
->dwCmds
, it
->fEnableOk
, it
->dwCounter
,
523 it
->dwLost
, it
->fStopped
);
527 case USB_SET_INTERFACE
:
528 DPRINTF("USB_SET_INTERFACE\n");
530 struct usb_set_interface
*usi
= (struct usb_set_interface
*)(wdheader
->data
);
532 DPRINTF("unique: %lu, interfacenum: %lu, alternatesetting: %lu, options: %lx\n",
533 usi
->dwUniqueID
, usi
->dwInterfaceNum
,
534 usi
->dwAlternateSetting
, usi
->dwOptions
);
536 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
540 usb_devhandle
= usb_open(usbdevice
);
542 /* FIXME: Select right interface! */
543 ret
= usb_claim_interface(usb_devhandle
, usbdevice
->config
[0].interface
[usi
->dwInterfaceNum
].altsetting
[usi
->dwAlternateSetting
].bInterfaceNumber
);
546 usbinterface
= usbdevice
->config
[0].interface
[usi
->dwInterfaceNum
].altsetting
[usi
->dwAlternateSetting
].bInterfaceNumber
;
547 ret
= usb_set_altinterface(usb_devhandle
, usi
->dwAlternateSetting
);
549 fprintf(stderr
, "usb_set_altinterface: %d\n", ret
);
551 fprintf(stderr
, "usb_set_configuration: %d (%s)\n", ret
, usb_strerror());
554 fprintf(stderr
, "usb_claim_interface: %d -> %d (%s)\n",
555 usbdevice
->config
[0].interface
[usi
->dwInterfaceNum
].altsetting
[usi
->dwAlternateSetting
].bInterfaceNumber
,
556 ret
, usb_strerror());
560 DPRINTF("unique: %lu, interfacenum: %lu, alternatesetting: %lu, options: %lx\n",
561 usi
->dwUniqueID
, usi
->dwInterfaceNum
,
562 usi
->dwAlternateSetting
, usi
->dwOptions
);
566 case USB_GET_DEVICE_DATA_OLD
:
567 case USB_GET_DEVICE_DATA
:
568 DPRINTF("USB_GET_DEVICE_DATA\n");
570 struct usb_get_device_data
*ugdd
= (struct usb_get_device_data
*)(wdheader
->data
);
573 DPRINTF("unique: %lu, bytes: %lu, options: %lx\n",
574 ugdd
->dwUniqueID
, ugdd
->dwBytes
,
577 pSize
= ugdd
->dwBytes
;
578 if (!ugdd
->dwBytes
) {
580 ugdd
->dwBytes
= usb_deviceinfo(NULL
);
583 usb_deviceinfo((unsigned char*)ugdd
->pBuf
);
588 case EVENT_REGISTER_OLD
:
590 DPRINTF("EVENT_REGISTER\n");
592 struct event
*e
= (struct event
*)(wdheader
->data
);
596 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",
597 e
->handle
, e
->dwAction
,
598 e
->dwStatus
, e
->dwEventId
, e
->dwCardType
,
599 e
->hKernelPlugIn
, e
->dwOptions
,
600 e
->u
.Usb
.deviceId
.dwVendorId
,
601 e
->u
.Usb
.deviceId
.dwProductId
,
602 e
->u
.Usb
.dwUniqueID
, e
->dwEventVer
,
603 e
->dwNumMatchTables
);
605 for (i
= 0; i
< e
->dwNumMatchTables
; i
++) {
607 DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
608 e
->matchTables
[i
].VendorId
,
609 e
->matchTables
[i
].ProductId
,
610 e
->matchTables
[i
].bDeviceClass
,
611 e
->matchTables
[i
].bDeviceSubClass
,
612 e
->matchTables
[i
].bInterfaceClass
,
613 e
->matchTables
[i
].bInterfaceSubClass
,
614 e
->matchTables
[i
].bInterfaceProtocol
);
616 for (bus
= busses
; bus
; bus
= bus
->next
) {
617 struct usb_device
*dev
;
619 for (dev
= bus
->devices
; dev
; dev
= dev
->next
) {
620 struct usb_device_descriptor
*desc
= &(dev
->descriptor
);
622 if((desc
->idVendor
== e
->matchTables
[i
].VendorId
) &&
623 (desc
->idProduct
== e
->matchTables
[i
].ProductId
) &&
624 (desc
->bDeviceClass
== e
->matchTables
[i
].bDeviceClass
) &&
625 (desc
->bDeviceSubClass
== e
->matchTables
[i
].bDeviceSubClass
)) {
627 for (ac
= 0; ac
< desc
->bNumConfigurations
; ac
++) {
628 struct usb_interface
*interface
= dev
->config
[ac
].interface
;
631 for (ai
= 0; ai
< interface
->num_altsetting
; ai
++) {
633 DPRINTF("intclass: %x, intsubclass: %x, intproto: %x\n",
634 interface
->altsetting
[i
].bInterfaceClass
,
635 interface
->altsetting
[i
].bInterfaceSubClass
,
636 interface
->altsetting
[i
].bInterfaceProtocol
);
638 if ((interface
->altsetting
[ai
].bInterfaceSubClass
== e
->matchTables
[i
].bInterfaceSubClass
) &&
639 (interface
->altsetting
[ai
].bInterfaceProtocol
== e
->matchTables
[i
].bInterfaceProtocol
)){
640 /* TODO: check interfaceClass! */
641 DPRINTF("found device with libusb\n");
643 card_type
= e
->dwCardType
;
653 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
659 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",
660 e
->handle
, e
->dwAction
,
661 e
->dwStatus
, e
->dwEventId
, e
->dwCardType
,
662 e
->hKernelPlugIn
, e
->dwOptions
,
663 e
->u
.Usb
.deviceId
.dwVendorId
,
664 e
->u
.Usb
.deviceId
.dwProductId
,
665 e
->u
.Usb
.dwUniqueID
, e
->dwEventVer
,
666 e
->dwNumMatchTables
);
668 for (i
= 0; i
< e
->dwNumMatchTables
; i
++)
669 DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
670 e
->matchTables
[i
].VendorId
,
671 e
->matchTables
[i
].ProductId
,
672 e
->matchTables
[i
].bDeviceClass
,
673 e
->matchTables
[i
].bDeviceSubClass
,
674 e
->matchTables
[i
].bInterfaceClass
,
675 e
->matchTables
[i
].bInterfaceSubClass
,
676 e
->matchTables
[i
].bInterfaceProtocol
);
683 DPRINTF("TRANSFER\n");
685 WD_TRANSFER
*tr
= (WD_TRANSFER
*)(wdheader
->data
);
687 ret
= pp_transfer(tr
, fd
, request
, wdioctl
);
691 case MULTI_TRANSFER_OLD
:
693 DPRINTF("MULTI_TRANSFER\n");
695 WD_TRANSFER
*tr
= (WD_TRANSFER
*)(wdheader
->data
);
696 unsigned long num
= wdheader
->size
/sizeof(WD_TRANSFER
);
700 for (i
= 0; i
< num
; i
++) {
701 DPRINTF("Transfer %d:\n", i
+1);
703 wdheader
->size
= sizeof(WD_TRANSFER
);
705 wdheader
->data
= tr
+ i
;
707 ret
= pp_transfer(tr
+ i
, fd
, request
, wdioctl
);
718 case EVENT_UNREGISTER
:
719 DPRINTF("EVENT_UNREGISTER\n");
721 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
726 DPRINTF("INT_WAIT\n");
728 struct interrupt
*it
= (struct interrupt
*)(wdheader
->data
);
730 DPRINTF("Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n",
731 it
->hInterrupt
, it
->dwOptions
,
732 it
->dwCmds
, it
->fEnableOk
, it
->dwCounter
,
733 it
->dwLost
, it
->fStopped
);
736 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
739 if (it
->dwCounter
== 0) {
742 pthread_mutex_lock(&int_wait
);
743 pthread_mutex_unlock(&int_wait
);
746 pthread_mutex_lock(&int_wait
);
747 pthread_mutex_unlock(&int_wait
);
751 DPRINTF("INT_WAIT_RETURN: Handle: %lu, Options: %lx, ncmds: %lu, enableok: %lu, count: %lu, lost: %lu, stopped: %lu\n",
752 it
->hInterrupt
, it
->dwOptions
, it
->dwCmds
,
753 it
->fEnableOk
, it
->dwCounter
, it
->dwLost
,
758 case CARD_UNREGISTER
:
759 DPRINTF("CARD_UNREGISTER\n");
761 struct card_register
* cr
= (struct card_register
*)(wdheader
->data
);
763 DPRINTF("Addr: 0x%lx, bytes: %lu, bar: %lu\n",
764 (unsigned long)cr
->Card
.Item
[0].I
.IO
.dwAddr
,
765 cr
->Card
.Item
[0].I
.IO
.dwBytes
,
766 cr
->Card
.Item
[0].I
.IO
.dwBar
);
768 DPRINTF("hCard: %lu\n", cr
->hCard
);
771 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
773 if (parportfd
== cr
->hCard
&& parportfd
>= 0) {
774 ioctl(parportfd
, PPRELEASE
);
784 DPRINTF("EVENT_PULL\n");
786 struct event
*e
= (struct event
*)(wdheader
->data
);
790 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",
791 e
->handle
, e
->dwAction
, e
->dwStatus
,
792 e
->dwEventId
, e
->dwCardType
, e
->hKernelPlugIn
,
793 e
->dwOptions
, e
->u
.Usb
.deviceId
.dwVendorId
,
794 e
->u
.Usb
.deviceId
.dwProductId
,
795 e
->u
.Usb
.dwUniqueID
, e
->dwEventVer
,
796 e
->dwNumMatchTables
);
798 for (i
= 0; i
< e
->dwNumMatchTables
; i
++)
799 DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
800 e
->matchTables
[i
].VendorId
,
801 e
->matchTables
[i
].ProductId
,
802 e
->matchTables
[i
].bDeviceClass
,
803 e
->matchTables
[i
].bDeviceSubClass
,
804 e
->matchTables
[i
].bInterfaceClass
,
805 e
->matchTables
[i
].bInterfaceSubClass
,
806 e
->matchTables
[i
].bInterfaceProtocol
);
810 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
813 struct usb_interface
*interface
= usbdevice
->config
->interface
;
815 e
->dwCardType
= card_type
;
818 e
->u
.Usb
.dwUniqueID
= 110;
819 e
->matchTables
[0].VendorId
= usbdevice
->descriptor
.idVendor
;
820 e
->matchTables
[0].ProductId
= usbdevice
->descriptor
.idProduct
;
821 e
->matchTables
[0].bDeviceClass
= usbdevice
->descriptor
.bDeviceClass
;
822 e
->matchTables
[0].bDeviceSubClass
= usbdevice
->descriptor
.bDeviceSubClass
;
823 e
->matchTables
[0].bInterfaceClass
= interface
->altsetting
[0].bInterfaceClass
;
824 e
->matchTables
[0].bInterfaceSubClass
= interface
->altsetting
[0].bInterfaceSubClass
;
825 e
->matchTables
[0].bInterfaceProtocol
= interface
->altsetting
[0].bInterfaceProtocol
;
830 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",
831 e
->handle
, e
->dwAction
, e
->dwStatus
,
832 e
->dwEventId
, e
->dwCardType
, e
->hKernelPlugIn
,
833 e
->dwOptions
, e
->u
.Usb
.deviceId
.dwVendorId
,
834 e
->u
.Usb
.deviceId
.dwProductId
,
835 e
->u
.Usb
.dwUniqueID
, e
->dwEventVer
,
836 e
->dwNumMatchTables
);
838 for (i
= 0; i
< e
->dwNumMatchTables
; i
++)
839 DPRINTF("match: dev: %04x:%04x, class: %x, subclass: %x, intclass: %x, intsubclass: %x, intproto: %x\n",
840 e
->matchTables
[i
].VendorId
,
841 e
->matchTables
[i
].ProductId
,
842 e
->matchTables
[i
].bDeviceClass
,
843 e
->matchTables
[i
].bDeviceSubClass
,
844 e
->matchTables
[i
].bInterfaceClass
,
845 e
->matchTables
[i
].bInterfaceSubClass
,
846 e
->matchTables
[i
].bInterfaceProtocol
);
853 fprintf(stderr
,"!!!Unsupported IOCTL: %x!!!\n", request
);
855 ret
= (*ioctl_func
) (fd
, request
, wdioctl
);
863 int ioctl(int fd
, unsigned long int request
, ...) {
869 ioctl_func
= (int (*) (int, int, void *)) dlsym (RTLD_NEXT
, "ioctl");
871 va_start (args
, request
);
872 argp
= va_arg (args
, void *);
876 ret
= do_wdioctl(fd
, request
, argp
);
878 ret
= (*ioctl_func
) (fd
, request
, argp
);
883 int open (const char *pathname
, int flags
, ...) {
884 static int (*func
) (const char *, int, mode_t
) = NULL
;
890 func
= (int (*) (const char *, int, mode_t
)) dlsym (RTLD_NEXT
, "open");
892 if (flags
& O_CREAT
) {
893 va_start(args
, flags
);
894 mode
= va_arg(args
, mode_t
);
898 if (!strcmp (pathname
, "/dev/windrvr6")) {
899 DPRINTF("opening windrvr6\n");
901 windrvrfd
= fd
= (*func
) ("/dev/null", flags
, mode
);
903 windrvrfd
= fd
= (*func
) (pathname
, flags
, mode
);
910 busses
= usb_get_busses();
916 return (*func
) (pathname
, flags
, mode
);
920 static int (*func
) (int) = NULL
;
923 func
= (int (*) (int)) dlsym(RTLD_NEXT
, "close");
925 if (fd
== windrvrfd
&& windrvrfd
>= 0) {
926 DPRINTF("close windrvrfd\n");
927 if (usbinterface
>= 0)
928 usb_release_interface(usb_devhandle
, usbinterface
);
931 usb_close(usb_devhandle
);
933 usb_devhandle
= NULL
;
941 FILE *fopen(const char *path
, const char *mode
) {
943 static FILE* (*func
) (const char*, const char*) = NULL
;
946 func
= (FILE* (*) (const char*, const char*)) dlsym(RTLD_NEXT
, "fopen");
948 ret
= (*func
) (path
, mode
);
950 if (!strcmp (path
, "/proc/modules")) {
951 DPRINTF("opening /proc/modules\n");
961 char *fgets(char *s
, int size
, FILE *stream
) {
962 static char* (*func
) (char*, int, FILE*) = NULL
;
963 const char modules
[][256] = {"windrvr6 1 0 - Live 0xdeadbeef\n", "parport_pc 1 0 - Live 0xdeadbeef\n"};
968 func
= (char* (*) (char*, int, FILE*)) dlsym(RTLD_NEXT
, "fgets");
970 if (modulesfp
== stream
) {
971 if (modules_read
< sizeof(modules
) / sizeof(modules
[0])) {
972 strcpy(s
, modules
[modules_read
]);
977 ret
= (*func
)(s
,size
,stream
);
983 int fclose(FILE *fp
) {
984 static int (*func
) (FILE*) = NULL
;
987 func
= (int (*) (FILE*)) dlsym(RTLD_NEXT
, "fclose");
989 if (fp
== modulesfp
) {
996 int access(const char *pathname
, int mode
) {
997 static int (*func
) (const char*, int);
1000 func
= (int (*) (const char*, int)) dlsym(RTLD_NEXT
, "access");
1002 if (!strcmp(pathname
, "/dev/windrvr6")) {
1005 return (*func
)(pathname
, mode
);