2 * KOBIL USB Smart Card Terminal Driver
4 * Copyright (C) 2002 KOBIL Systems GmbH
5 * Author: Thomas Wahrenbruch
7 * Contact: linuxusb@kobil.de
9 * This program is largely derived from work by the linux-usb group
10 * and associated source files. Please see the usb/serial files for
11 * individual credits and copyrights.
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
18 * Thanks to Greg Kroah-Hartman (greg@kroah.com) for his help and
21 * Supported readers: USB TWIN, KAAN Standard Plus and SecOVID Reader Plus
22 * (Adapter K), B1 Professional and KAAN Professional (Adapter B)
25 * Fix bug with P'n'P readers
28 * Add support for KAAN SIM
38 #include <linux/kernel.h>
39 #include <linux/errno.h>
40 #include <linux/init.h>
41 #include <linux/slab.h>
42 #include <linux/tty.h>
43 #include <linux/tty_driver.h>
44 #include <linux/tty_flip.h>
45 #include <linux/module.h>
46 #include <linux/spinlock.h>
47 #include <linux/uaccess.h>
48 #include <linux/usb.h>
49 #include <linux/usb/serial.h>
50 #include <linux/ioctl.h>
51 #include "kobil_sct.h"
55 /* Version Information */
56 #define DRIVER_VERSION "21/05/2004"
57 #define DRIVER_AUTHOR "KOBIL Systems GmbH - http://www.kobil.com"
58 #define DRIVER_DESC "KOBIL USB Smart Card Terminal Driver (experimental)"
60 #define KOBIL_VENDOR_ID 0x0D46
61 #define KOBIL_ADAPTER_B_PRODUCT_ID 0x2011
62 #define KOBIL_ADAPTER_K_PRODUCT_ID 0x2012
63 #define KOBIL_USBTWIN_PRODUCT_ID 0x0078
64 #define KOBIL_KAAN_SIM_PRODUCT_ID 0x0081
66 #define KOBIL_TIMEOUT 500
67 #define KOBIL_BUF_LENGTH 300
70 /* Function prototypes */
71 static int kobil_startup(struct usb_serial
*serial
);
72 static void kobil_shutdown(struct usb_serial
*serial
);
73 static int kobil_open(struct tty_struct
*tty
,
74 struct usb_serial_port
*port
, struct file
*filp
);
75 static void kobil_close(struct tty_struct
*tty
, struct usb_serial_port
*port
,
77 static int kobil_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
78 const unsigned char *buf
, int count
);
79 static int kobil_write_room(struct tty_struct
*tty
);
80 static int kobil_ioctl(struct tty_struct
*tty
, struct file
*file
,
81 unsigned int cmd
, unsigned long arg
);
82 static int kobil_tiocmget(struct tty_struct
*tty
, struct file
*file
);
83 static int kobil_tiocmset(struct tty_struct
*tty
, struct file
*file
,
84 unsigned int set
, unsigned int clear
);
85 static void kobil_read_int_callback(struct urb
*urb
);
86 static void kobil_write_callback(struct urb
*purb
);
87 static void kobil_set_termios(struct tty_struct
*tty
,
88 struct usb_serial_port
*port
, struct ktermios
*old
);
91 static struct usb_device_id id_table
[] = {
92 { USB_DEVICE(KOBIL_VENDOR_ID
, KOBIL_ADAPTER_B_PRODUCT_ID
) },
93 { USB_DEVICE(KOBIL_VENDOR_ID
, KOBIL_ADAPTER_K_PRODUCT_ID
) },
94 { USB_DEVICE(KOBIL_VENDOR_ID
, KOBIL_USBTWIN_PRODUCT_ID
) },
95 { USB_DEVICE(KOBIL_VENDOR_ID
, KOBIL_KAAN_SIM_PRODUCT_ID
) },
96 { } /* Terminating entry */
100 MODULE_DEVICE_TABLE(usb
, id_table
);
102 static struct usb_driver kobil_driver
= {
104 .probe
= usb_serial_probe
,
105 .disconnect
= usb_serial_disconnect
,
106 .id_table
= id_table
,
111 static struct usb_serial_driver kobil_device
= {
113 .owner
= THIS_MODULE
,
116 .description
= "KOBIL USB smart card terminal",
117 .usb_driver
= &kobil_driver
,
118 .id_table
= id_table
,
120 .attach
= kobil_startup
,
121 .shutdown
= kobil_shutdown
,
122 .ioctl
= kobil_ioctl
,
123 .set_termios
= kobil_set_termios
,
124 .tiocmget
= kobil_tiocmget
,
125 .tiocmset
= kobil_tiocmset
,
127 .close
= kobil_close
,
128 .write
= kobil_write
,
129 .write_room
= kobil_write_room
,
130 .read_int_callback
= kobil_read_int_callback
,
134 struct kobil_private
{
135 int write_int_endpoint_address
;
136 int read_int_endpoint_address
;
137 unsigned char buf
[KOBIL_BUF_LENGTH
]; /* buffer for the APDU to send */
138 int filled
; /* index of the last char in buf */
139 int cur_pos
; /* index of the next char to send in buf */
144 static int kobil_startup(struct usb_serial
*serial
)
147 struct kobil_private
*priv
;
148 struct usb_device
*pdev
;
149 struct usb_host_config
*actconfig
;
150 struct usb_interface
*interface
;
151 struct usb_host_interface
*altsetting
;
152 struct usb_host_endpoint
*endpoint
;
154 priv
= kmalloc(sizeof(struct kobil_private
), GFP_KERNEL
);
160 priv
->device_type
= le16_to_cpu(serial
->dev
->descriptor
.idProduct
);
162 switch (priv
->device_type
) {
163 case KOBIL_ADAPTER_B_PRODUCT_ID
:
164 printk(KERN_DEBUG
"KOBIL B1 PRO / KAAN PRO detected\n");
166 case KOBIL_ADAPTER_K_PRODUCT_ID
:
168 "KOBIL KAAN Standard Plus / SecOVID Reader Plus detected\n");
170 case KOBIL_USBTWIN_PRODUCT_ID
:
171 printk(KERN_DEBUG
"KOBIL USBTWIN detected\n");
173 case KOBIL_KAAN_SIM_PRODUCT_ID
:
174 printk(KERN_DEBUG
"KOBIL KAAN SIM detected\n");
177 usb_set_serial_port_data(serial
->port
[0], priv
);
179 /* search for the necessary endpoints */
181 actconfig
= pdev
->actconfig
;
182 interface
= actconfig
->interface
[0];
183 altsetting
= interface
->cur_altsetting
;
184 endpoint
= altsetting
->endpoint
;
186 for (i
= 0; i
< altsetting
->desc
.bNumEndpoints
; i
++) {
187 endpoint
= &altsetting
->endpoint
[i
];
188 if (usb_endpoint_is_int_out(&endpoint
->desc
)) {
189 dbg("%s Found interrupt out endpoint. Address: %d",
190 __func__
, endpoint
->desc
.bEndpointAddress
);
191 priv
->write_int_endpoint_address
=
192 endpoint
->desc
.bEndpointAddress
;
194 if (usb_endpoint_is_int_in(&endpoint
->desc
)) {
195 dbg("%s Found interrupt in endpoint. Address: %d",
196 __func__
, endpoint
->desc
.bEndpointAddress
);
197 priv
->read_int_endpoint_address
=
198 endpoint
->desc
.bEndpointAddress
;
205 static void kobil_shutdown(struct usb_serial
*serial
)
208 dbg("%s - port %d", __func__
, serial
->port
[0]->number
);
210 for (i
= 0; i
< serial
->num_ports
; ++i
) {
211 while (serial
->port
[i
]->port
.count
> 0)
212 kobil_close(NULL
, serial
->port
[i
], NULL
);
213 kfree(usb_get_serial_port_data(serial
->port
[i
]));
214 usb_set_serial_port_data(serial
->port
[i
], NULL
);
219 static int kobil_open(struct tty_struct
*tty
,
220 struct usb_serial_port
*port
, struct file
*filp
)
223 struct kobil_private
*priv
;
224 unsigned char *transfer_buffer
;
225 int transfer_buffer_length
= 8;
226 int write_urb_transfer_buffer_length
= 8;
228 dbg("%s - port %d", __func__
, port
->number
);
229 priv
= usb_get_serial_port_data(port
);
231 /* someone sets the dev to 0 if the close method has been called */
232 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
236 /* Default to echo off and other sane device settings */
237 tty
->termios
->c_lflag
= 0;
238 tty
->termios
->c_lflag
&= ~(ISIG
| ICANON
| ECHO
| IEXTEN
|
240 tty
->termios
->c_iflag
= IGNBRK
| IGNPAR
| IXOFF
;
241 /* do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D) */
242 tty
->termios
->c_oflag
&= ~ONLCR
;
244 /* allocate memory for transfer buffer */
245 transfer_buffer
= kzalloc(transfer_buffer_length
, GFP_KERNEL
);
246 if (!transfer_buffer
)
249 /* allocate write_urb */
250 if (!port
->write_urb
) {
251 dbg("%s - port %d Allocating port->write_urb",
252 __func__
, port
->number
);
253 port
->write_urb
= usb_alloc_urb(0, GFP_KERNEL
);
254 if (!port
->write_urb
) {
255 dbg("%s - port %d usb_alloc_urb failed",
256 __func__
, port
->number
);
257 kfree(transfer_buffer
);
262 /* allocate memory for write_urb transfer buffer */
263 port
->write_urb
->transfer_buffer
=
264 kmalloc(write_urb_transfer_buffer_length
, GFP_KERNEL
);
265 if (!port
->write_urb
->transfer_buffer
) {
266 kfree(transfer_buffer
);
267 usb_free_urb(port
->write_urb
);
268 port
->write_urb
= NULL
;
272 /* get hardware version */
273 result
= usb_control_msg(port
->serial
->dev
,
274 usb_rcvctrlpipe(port
->serial
->dev
, 0),
275 SUSBCRequest_GetMisc
,
276 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_IN
,
277 SUSBCR_MSC_GetHWVersion
,
280 transfer_buffer_length
,
283 dbg("%s - port %d Send get_HW_version URB returns: %i",
284 __func__
, port
->number
, result
);
285 dbg("Harware version: %i.%i.%i",
286 transfer_buffer
[0], transfer_buffer
[1], transfer_buffer
[2]);
288 /* get firmware version */
289 result
= usb_control_msg(port
->serial
->dev
,
290 usb_rcvctrlpipe(port
->serial
->dev
, 0),
291 SUSBCRequest_GetMisc
,
292 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_IN
,
293 SUSBCR_MSC_GetFWVersion
,
296 transfer_buffer_length
,
299 dbg("%s - port %d Send get_FW_version URB returns: %i",
300 __func__
, port
->number
, result
);
301 dbg("Firmware version: %i.%i.%i",
302 transfer_buffer
[0], transfer_buffer
[1], transfer_buffer
[2]);
304 if (priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
||
305 priv
->device_type
== KOBIL_ADAPTER_K_PRODUCT_ID
) {
306 /* Setting Baudrate, Parity and Stopbits */
307 result
= usb_control_msg(port
->serial
->dev
,
308 usb_rcvctrlpipe(port
->serial
->dev
, 0),
309 SUSBCRequest_SetBaudRateParityAndStopBits
,
310 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
311 SUSBCR_SBR_9600
| SUSBCR_SPASB_EvenParity
|
312 SUSBCR_SPASB_1StopBit
,
318 dbg("%s - port %d Send set_baudrate URB returns: %i",
319 __func__
, port
->number
, result
);
321 /* reset all queues */
322 result
= usb_control_msg(port
->serial
->dev
,
323 usb_rcvctrlpipe(port
->serial
->dev
, 0),
325 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
326 SUSBCR_MSC_ResetAllQueues
,
332 dbg("%s - port %d Send reset_all_queues URB returns: %i",
333 __func__
, port
->number
, result
);
335 if (priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
||
336 priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
||
337 priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
) {
338 /* start reading (Adapter B 'cause PNP string) */
339 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
340 dbg("%s - port %d Send read URB returns: %i",
341 __func__
, port
->number
, result
);
344 kfree(transfer_buffer
);
349 static void kobil_close(struct tty_struct
*tty
,
350 struct usb_serial_port
*port
, struct file
*filp
)
352 dbg("%s - port %d", __func__
, port
->number
);
354 if (port
->write_urb
) {
355 usb_kill_urb(port
->write_urb
);
356 usb_free_urb(port
->write_urb
);
357 port
->write_urb
= NULL
;
359 usb_kill_urb(port
->interrupt_in_urb
);
363 static void kobil_read_int_callback(struct urb
*urb
)
366 struct usb_serial_port
*port
= urb
->context
;
367 struct tty_struct
*tty
;
368 unsigned char *data
= urb
->transfer_buffer
;
369 int status
= urb
->status
;
370 /* char *dbg_data; */
372 dbg("%s - port %d", __func__
, port
->number
);
375 dbg("%s - port %d Read int status not zero: %d",
376 __func__
, port
->number
, status
);
380 tty
= tty_port_tty_get(&port
->port
);
381 if (urb
->actual_length
) {
385 dbg_data = kzalloc((3 * purb->actual_length + 10)
386 * sizeof(char), GFP_KERNEL);
390 for (i = 0; i < purb->actual_length; i++) {
391 sprintf(dbg_data +3*i, "%02X ", data[i]);
393 dbg(" <-- %s", dbg_data);
398 tty_buffer_request_room(tty
, urb
->actual_length
);
399 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
400 tty_flip_buffer_push(tty
);
403 /* someone sets the dev to 0 if the close method has been called */
404 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
406 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
407 dbg("%s - port %d Send read URB returns: %i",
408 __func__
, port
->number
, result
);
412 static void kobil_write_callback(struct urb
*purb
)
417 static int kobil_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
418 const unsigned char *buf
, int count
)
423 struct kobil_private
*priv
;
426 dbg("%s - port %d write request of 0 bytes",
427 __func__
, port
->number
);
431 priv
= usb_get_serial_port_data(port
);
433 if (count
> (KOBIL_BUF_LENGTH
- priv
->filled
)) {
434 dbg("%s - port %d Error: write request bigger than buffer size", __func__
, port
->number
);
438 /* Copy data to buffer */
439 memcpy(priv
->buf
+ priv
->filled
, buf
, count
);
440 usb_serial_debug_data(debug
, &port
->dev
, __func__
, count
,
441 priv
->buf
+ priv
->filled
);
442 priv
->filled
= priv
->filled
+ count
;
444 /* only send complete block. TWIN, KAAN SIM and adapter K
445 use the same protocol. */
446 if (((priv
->device_type
!= KOBIL_ADAPTER_B_PRODUCT_ID
) && (priv
->filled
> 2) && (priv
->filled
>= (priv
->buf
[1] + 3))) ||
447 ((priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
) && (priv
->filled
> 3) && (priv
->filled
>= (priv
->buf
[2] + 4)))) {
448 /* stop reading (except TWIN and KAAN SIM) */
449 if ((priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
)
450 || (priv
->device_type
== KOBIL_ADAPTER_K_PRODUCT_ID
))
451 usb_kill_urb(port
->interrupt_in_urb
);
453 todo
= priv
->filled
- priv
->cur_pos
;
456 /* max 8 byte in one urb (endpoint size) */
457 length
= (todo
< 8) ? todo
: 8;
458 /* copy data to transfer buffer */
459 memcpy(port
->write_urb
->transfer_buffer
,
460 priv
->buf
+ priv
->cur_pos
, length
);
461 usb_fill_int_urb(port
->write_urb
,
463 usb_sndintpipe(port
->serial
->dev
,
464 priv
->write_int_endpoint_address
),
465 port
->write_urb
->transfer_buffer
,
467 kobil_write_callback
,
472 priv
->cur_pos
= priv
->cur_pos
+ length
;
473 result
= usb_submit_urb(port
->write_urb
, GFP_NOIO
);
474 dbg("%s - port %d Send write URB returns: %i",
475 __func__
, port
->number
, result
);
476 todo
= priv
->filled
- priv
->cur_pos
;
485 /* someone sets the dev to 0 if the close method
487 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
489 /* start reading (except TWIN and KAAN SIM) */
490 if (priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
||
491 priv
->device_type
== KOBIL_ADAPTER_K_PRODUCT_ID
) {
492 /* someone sets the dev to 0 if the close method has
494 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
496 result
= usb_submit_urb(port
->interrupt_in_urb
,
498 dbg("%s - port %d Send read URB returns: %i",
499 __func__
, port
->number
, result
);
506 static int kobil_write_room(struct tty_struct
*tty
)
508 /* dbg("%s - port %d", __func__, port->number); */
514 static int kobil_tiocmget(struct tty_struct
*tty
, struct file
*file
)
516 struct usb_serial_port
*port
= tty
->driver_data
;
517 struct kobil_private
*priv
;
519 unsigned char *transfer_buffer
;
520 int transfer_buffer_length
= 8;
522 priv
= usb_get_serial_port_data(port
);
523 if (priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
524 || priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
) {
525 /* This device doesn't support ioctl calls */
529 /* allocate memory for transfer buffer */
530 transfer_buffer
= kzalloc(transfer_buffer_length
, GFP_KERNEL
);
531 if (!transfer_buffer
)
534 result
= usb_control_msg(port
->serial
->dev
,
535 usb_rcvctrlpipe(port
->serial
->dev
, 0),
536 SUSBCRequest_GetStatusLineState
,
537 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_IN
,
541 transfer_buffer_length
,
544 dbg("%s - port %d Send get_status_line_state URB returns: %i. Statusline: %02x",
545 __func__
, port
->number
, result
, transfer_buffer
[0]);
548 if ((transfer_buffer
[0] & SUSBCR_GSL_DSR
) != 0)
550 kfree(transfer_buffer
);
554 static int kobil_tiocmset(struct tty_struct
*tty
, struct file
*file
,
555 unsigned int set
, unsigned int clear
)
557 struct usb_serial_port
*port
= tty
->driver_data
;
558 struct kobil_private
*priv
;
562 unsigned char *transfer_buffer
;
563 int transfer_buffer_length
= 8;
565 /* FIXME: locking ? */
566 priv
= usb_get_serial_port_data(port
);
567 if (priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
568 || priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
) {
569 /* This device doesn't support ioctl calls */
573 /* allocate memory for transfer buffer */
574 transfer_buffer
= kzalloc(transfer_buffer_length
, GFP_KERNEL
);
575 if (!transfer_buffer
)
582 if (clear
& TIOCM_RTS
)
584 if (clear
& TIOCM_DTR
)
587 if (priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
) {
589 dbg("%s - port %d Setting DTR",
590 __func__
, port
->number
);
592 dbg("%s - port %d Clearing DTR",
593 __func__
, port
->number
);
594 result
= usb_control_msg(port
->serial
->dev
,
595 usb_rcvctrlpipe(port
->serial
->dev
, 0),
596 SUSBCRequest_SetStatusLinesOrQueues
,
597 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
598 ((dtr
!= 0) ? SUSBCR_SSL_SETDTR
: SUSBCR_SSL_CLRDTR
),
605 dbg("%s - port %d Setting RTS",
606 __func__
, port
->number
);
608 dbg("%s - port %d Clearing RTS",
609 __func__
, port
->number
);
610 result
= usb_control_msg(port
->serial
->dev
,
611 usb_rcvctrlpipe(port
->serial
->dev
, 0),
612 SUSBCRequest_SetStatusLinesOrQueues
,
613 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
614 ((rts
!= 0) ? SUSBCR_SSL_SETRTS
: SUSBCR_SSL_CLRRTS
),
620 dbg("%s - port %d Send set_status_line URB returns: %i",
621 __func__
, port
->number
, result
);
622 kfree(transfer_buffer
);
623 return (result
< 0) ? result
: 0;
626 static void kobil_set_termios(struct tty_struct
*tty
,
627 struct usb_serial_port
*port
, struct ktermios
*old
)
629 struct kobil_private
*priv
;
631 unsigned short urb_val
= 0;
632 int c_cflag
= tty
->termios
->c_cflag
;
636 priv
= usb_get_serial_port_data(port
);
637 if (priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
||
638 priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
) {
639 /* This device doesn't support ioctl calls */
640 *tty
->termios
= *old
;
644 speed
= tty_get_baud_rate(tty
);
647 urb_val
= SUSBCR_SBR_1200
;
652 urb_val
= SUSBCR_SBR_9600
;
655 urb_val
|= (c_cflag
& CSTOPB
) ? SUSBCR_SPASB_2StopBits
:
656 SUSBCR_SPASB_1StopBit
;
658 settings
= kzalloc(50, GFP_KERNEL
);
662 sprintf(settings
, "%d ", speed
);
664 if (c_cflag
& PARENB
) {
665 if (c_cflag
& PARODD
) {
666 urb_val
|= SUSBCR_SPASB_OddParity
;
667 strcat(settings
, "Odd Parity");
669 urb_val
|= SUSBCR_SPASB_EvenParity
;
670 strcat(settings
, "Even Parity");
673 urb_val
|= SUSBCR_SPASB_NoParity
;
674 strcat(settings
, "No Parity");
676 tty
->termios
->c_cflag
&= ~CMSPAR
;
677 tty_encode_baud_rate(tty
, speed
, speed
);
679 result
= usb_control_msg(port
->serial
->dev
,
680 usb_rcvctrlpipe(port
->serial
->dev
, 0),
681 SUSBCRequest_SetBaudRateParityAndStopBits
,
682 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
692 static int kobil_ioctl(struct tty_struct
*tty
, struct file
*file
,
693 unsigned int cmd
, unsigned long arg
)
695 struct usb_serial_port
*port
= tty
->driver_data
;
696 struct kobil_private
*priv
= usb_get_serial_port_data(port
);
697 unsigned char *transfer_buffer
;
698 int transfer_buffer_length
= 8;
701 if (priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
||
702 priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
)
703 /* This device doesn't support ioctl calls */
708 transfer_buffer
= kmalloc(transfer_buffer_length
, GFP_KERNEL
);
709 if (!transfer_buffer
)
712 result
= usb_control_msg(port
->serial
->dev
,
713 usb_rcvctrlpipe(port
->serial
->dev
, 0),
715 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
716 SUSBCR_MSC_ResetAllQueues
,
718 NULL
, /* transfer_buffer, */
723 dbg("%s - port %d Send reset_all_queues (FLUSH) URB returns: %i", __func__
, port
->number
, result
);
724 kfree(transfer_buffer
);
725 return (result
< 0) ? -EIO
: 0;
731 static int __init
kobil_init(void)
734 retval
= usb_serial_register(&kobil_device
);
736 goto failed_usb_serial_register
;
737 retval
= usb_register(&kobil_driver
);
739 goto failed_usb_register
;
741 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_VERSION
":"
746 usb_serial_deregister(&kobil_device
);
747 failed_usb_serial_register
:
752 static void __exit
kobil_exit(void)
754 usb_deregister(&kobil_driver
);
755 usb_serial_deregister(&kobil_device
);
758 module_init(kobil_init
);
759 module_exit(kobil_exit
);
761 MODULE_AUTHOR(DRIVER_AUTHOR
);
762 MODULE_DESCRIPTION(DRIVER_DESC
);
763 MODULE_LICENSE("GPL");
765 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
766 MODULE_PARM_DESC(debug
, "Debug enabled or not");