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 <asm/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
);
161 priv
->device_type
= le16_to_cpu(serial
->dev
->descriptor
.idProduct
);
163 switch (priv
->device_type
){
164 case KOBIL_ADAPTER_B_PRODUCT_ID
:
165 printk(KERN_DEBUG
"KOBIL B1 PRO / KAAN PRO detected\n");
167 case KOBIL_ADAPTER_K_PRODUCT_ID
:
168 printk(KERN_DEBUG
"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", __func__
, endpoint
->desc
.bEndpointAddress
);
190 priv
->write_int_endpoint_address
= endpoint
->desc
.bEndpointAddress
;
192 if (usb_endpoint_is_int_in(&endpoint
->desc
)) {
193 dbg("%s Found interrupt in endpoint. Address: %d", __func__
, endpoint
->desc
.bEndpointAddress
);
194 priv
->read_int_endpoint_address
= endpoint
->desc
.bEndpointAddress
;
201 static void kobil_shutdown (struct usb_serial
*serial
)
204 dbg("%s - port %d", __func__
, serial
->port
[0]->number
);
206 for (i
=0; i
< serial
->num_ports
; ++i
) {
207 while (serial
->port
[i
]->port
.count
> 0) {
208 kobil_close (NULL
, serial
->port
[i
], NULL
);
210 kfree(usb_get_serial_port_data(serial
->port
[i
]));
211 usb_set_serial_port_data(serial
->port
[i
], NULL
);
216 static int kobil_open(struct tty_struct
*tty
,
217 struct usb_serial_port
*port
, struct file
*filp
)
220 struct kobil_private
*priv
;
221 unsigned char *transfer_buffer
;
222 int transfer_buffer_length
= 8;
223 int write_urb_transfer_buffer_length
= 8;
225 dbg("%s - port %d", __func__
, port
->number
);
226 priv
= usb_get_serial_port_data(port
);
228 // someone sets the dev to 0 if the close method has been called
229 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
232 /* force low_latency on so that our tty_push actually forces
233 * the data through, otherwise it is scheduled, and with high
234 * data rates (like with OHCI) data can get lost.
237 tty
->low_latency
= 1;
239 /* Default to echo off and other sane device settings */
240 tty
->termios
->c_lflag
= 0;
241 tty
->termios
->c_lflag
&= ~(ISIG
| ICANON
| ECHO
| IEXTEN
| XCASE
);
242 tty
->termios
->c_iflag
= IGNBRK
| IGNPAR
| IXOFF
;
243 tty
->termios
->c_oflag
&= ~ONLCR
; // do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D)
245 // allocate memory for transfer buffer
246 transfer_buffer
= kzalloc(transfer_buffer_length
, GFP_KERNEL
);
247 if (! transfer_buffer
) {
251 // allocate write_urb
252 if (!port
->write_urb
) {
253 dbg("%s - port %d Allocating port->write_urb", __func__
, port
->number
);
254 port
->write_urb
= usb_alloc_urb(0, GFP_KERNEL
);
255 if (!port
->write_urb
) {
256 dbg("%s - port %d usb_alloc_urb failed", __func__
, port
->number
);
257 kfree(transfer_buffer
);
262 // allocate memory for write_urb transfer buffer
263 port
->write_urb
->transfer_buffer
= kmalloc(write_urb_transfer_buffer_length
, GFP_KERNEL
);
264 if (! port
->write_urb
->transfer_buffer
) {
265 kfree(transfer_buffer
);
266 usb_free_urb(port
->write_urb
);
267 port
->write_urb
= NULL
;
271 // get hardware version
272 result
= usb_control_msg( port
->serial
->dev
,
273 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
274 SUSBCRequest_GetMisc
,
275 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_IN
,
276 SUSBCR_MSC_GetHWVersion
,
279 transfer_buffer_length
,
282 dbg("%s - port %d Send get_HW_version URB returns: %i", __func__
, port
->number
, result
);
283 dbg("Harware version: %i.%i.%i", transfer_buffer
[0], transfer_buffer
[1], transfer_buffer
[2] );
285 // get firmware version
286 result
= usb_control_msg( port
->serial
->dev
,
287 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
288 SUSBCRequest_GetMisc
,
289 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_IN
,
290 SUSBCR_MSC_GetFWVersion
,
293 transfer_buffer_length
,
296 dbg("%s - port %d Send get_FW_version URB returns: %i", __func__
, port
->number
, result
);
297 dbg("Firmware version: %i.%i.%i", transfer_buffer
[0], transfer_buffer
[1], transfer_buffer
[2] );
299 if (priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
|| priv
->device_type
== KOBIL_ADAPTER_K_PRODUCT_ID
) {
300 // Setting Baudrate, Parity and Stopbits
301 result
= usb_control_msg( port
->serial
->dev
,
302 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
303 SUSBCRequest_SetBaudRateParityAndStopBits
,
304 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
305 SUSBCR_SBR_9600
| SUSBCR_SPASB_EvenParity
| SUSBCR_SPASB_1StopBit
,
311 dbg("%s - port %d Send set_baudrate URB returns: %i", __func__
, port
->number
, result
);
314 result
= usb_control_msg( port
->serial
->dev
,
315 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
317 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
318 SUSBCR_MSC_ResetAllQueues
,
324 dbg("%s - port %d Send reset_all_queues URB returns: %i", __func__
, port
->number
, result
);
326 if (priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
|| priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
||
327 priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
) {
328 // start reading (Adapter B 'cause PNP string)
329 result
= usb_submit_urb( port
->interrupt_in_urb
, GFP_ATOMIC
);
330 dbg("%s - port %d Send read URB returns: %i", __func__
, port
->number
, result
);
333 kfree(transfer_buffer
);
338 static void kobil_close(struct tty_struct
*tty
,
339 struct usb_serial_port
*port
, struct file
*filp
)
341 dbg("%s - port %d", __func__
, port
->number
);
343 if (port
->write_urb
) {
344 usb_kill_urb(port
->write_urb
);
345 usb_free_urb( port
->write_urb
);
346 port
->write_urb
= NULL
;
348 usb_kill_urb(port
->interrupt_in_urb
);
352 static void kobil_read_int_callback(struct urb
*urb
)
355 struct usb_serial_port
*port
= urb
->context
;
356 struct tty_struct
*tty
;
357 unsigned char *data
= urb
->transfer_buffer
;
358 int status
= urb
->status
;
361 dbg("%s - port %d", __func__
, port
->number
);
364 dbg("%s - port %d Read int status not zero: %d",
365 __func__
, port
->number
, status
);
369 tty
= port
->port
.tty
;
370 if (urb
->actual_length
) {
374 dbg_data = kzalloc((3 * purb->actual_length + 10) * sizeof(char), GFP_KERNEL);
378 for (i = 0; i < purb->actual_length; i++) {
379 sprintf(dbg_data +3*i, "%02X ", data[i]);
381 dbg(" <-- %s", dbg_data );
386 tty_buffer_request_room(tty
, urb
->actual_length
);
387 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
388 tty_flip_buffer_push(tty
);
391 // someone sets the dev to 0 if the close method has been called
392 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
394 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
395 dbg("%s - port %d Send read URB returns: %i", __func__
, port
->number
, result
);
399 static void kobil_write_callback( struct urb
*purb
)
404 static int kobil_write (struct tty_struct
*tty
, struct usb_serial_port
*port
,
405 const unsigned char *buf
, int count
)
410 struct kobil_private
* priv
;
413 dbg("%s - port %d write request of 0 bytes", __func__
, port
->number
);
417 priv
= usb_get_serial_port_data(port
);
419 if (count
> (KOBIL_BUF_LENGTH
- priv
->filled
)) {
420 dbg("%s - port %d Error: write request bigger than buffer size", __func__
, port
->number
);
424 // Copy data to buffer
425 memcpy (priv
->buf
+ priv
->filled
, buf
, count
);
426 usb_serial_debug_data(debug
, &port
->dev
, __func__
, count
, priv
->buf
+ priv
->filled
);
427 priv
->filled
= priv
->filled
+ count
;
429 // only send complete block. TWIN, KAAN SIM and adapter K use the same protocol.
430 if ( ((priv
->device_type
!= KOBIL_ADAPTER_B_PRODUCT_ID
) && (priv
->filled
> 2) && (priv
->filled
>= (priv
->buf
[1] + 3))) ||
431 ((priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
) && (priv
->filled
> 3) && (priv
->filled
>= (priv
->buf
[2] + 4))) ) {
433 // stop reading (except TWIN and KAAN SIM)
434 if ( (priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
) || (priv
->device_type
== KOBIL_ADAPTER_K_PRODUCT_ID
) )
435 usb_kill_urb(port
->interrupt_in_urb
);
437 todo
= priv
->filled
- priv
->cur_pos
;
440 // max 8 byte in one urb (endpoint size)
441 length
= (todo
< 8) ? todo
: 8;
442 // copy data to transfer buffer
443 memcpy(port
->write_urb
->transfer_buffer
, priv
->buf
+ priv
->cur_pos
, length
);
444 usb_fill_int_urb( port
->write_urb
,
446 usb_sndintpipe(port
->serial
->dev
, priv
->write_int_endpoint_address
),
447 port
->write_urb
->transfer_buffer
,
449 kobil_write_callback
,
454 priv
->cur_pos
= priv
->cur_pos
+ length
;
455 result
= usb_submit_urb( port
->write_urb
, GFP_NOIO
);
456 dbg("%s - port %d Send write URB returns: %i", __func__
, port
->number
, result
);
457 todo
= priv
->filled
- priv
->cur_pos
;
468 // someone sets the dev to 0 if the close method has been called
469 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
471 // start reading (except TWIN and KAAN SIM)
472 if ( (priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
) || (priv
->device_type
== KOBIL_ADAPTER_K_PRODUCT_ID
) ) {
473 // someone sets the dev to 0 if the close method has been called
474 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
476 result
= usb_submit_urb( port
->interrupt_in_urb
, GFP_NOIO
);
477 dbg("%s - port %d Send read URB returns: %i", __func__
, port
->number
, result
);
484 static int kobil_write_room (struct tty_struct
*tty
)
486 //dbg("%s - port %d", __func__, port->number);
492 static int kobil_tiocmget(struct tty_struct
*tty
, struct file
*file
)
494 struct usb_serial_port
*port
= tty
->driver_data
;
495 struct kobil_private
* priv
;
497 unsigned char *transfer_buffer
;
498 int transfer_buffer_length
= 8;
500 priv
= usb_get_serial_port_data(port
);
501 if ((priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
) || (priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
)) {
502 // This device doesn't support ioctl calls
506 // allocate memory for transfer buffer
507 transfer_buffer
= kzalloc(transfer_buffer_length
, GFP_KERNEL
);
508 if (!transfer_buffer
) {
512 result
= usb_control_msg( port
->serial
->dev
,
513 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
514 SUSBCRequest_GetStatusLineState
,
515 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_IN
,
519 transfer_buffer_length
,
522 dbg("%s - port %d Send get_status_line_state URB returns: %i. Statusline: %02x",
523 __func__
, port
->number
, result
, transfer_buffer
[0]);
526 if ((transfer_buffer
[0] & SUSBCR_GSL_DSR
) != 0)
528 kfree(transfer_buffer
);
532 static int kobil_tiocmset(struct tty_struct
*tty
, struct file
*file
,
533 unsigned int set
, unsigned int clear
)
535 struct usb_serial_port
*port
= tty
->driver_data
;
536 struct kobil_private
* priv
;
540 unsigned char *transfer_buffer
;
541 int transfer_buffer_length
= 8;
543 /* FIXME: locking ? */
544 priv
= usb_get_serial_port_data(port
);
545 if ((priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
) || (priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
)) {
546 // This device doesn't support ioctl calls
550 // allocate memory for transfer buffer
551 transfer_buffer
= kzalloc(transfer_buffer_length
, GFP_KERNEL
);
552 if (! transfer_buffer
) {
560 if (clear
& TIOCM_RTS
)
562 if (clear
& TIOCM_DTR
)
565 if (priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
) {
567 dbg("%s - port %d Setting DTR", __func__
, port
->number
);
569 dbg("%s - port %d Clearing DTR", __func__
, port
->number
);
570 result
= usb_control_msg( port
->serial
->dev
,
571 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
572 SUSBCRequest_SetStatusLinesOrQueues
,
573 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
574 ((dtr
!= 0) ? SUSBCR_SSL_SETDTR
: SUSBCR_SSL_CLRDTR
),
581 dbg("%s - port %d Setting RTS", __func__
, port
->number
);
583 dbg("%s - port %d Clearing RTS", __func__
, port
->number
);
584 result
= usb_control_msg( port
->serial
->dev
,
585 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
586 SUSBCRequest_SetStatusLinesOrQueues
,
587 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
588 ((rts
!= 0) ? SUSBCR_SSL_SETRTS
: SUSBCR_SSL_CLRRTS
),
594 dbg("%s - port %d Send set_status_line URB returns: %i", __func__
, port
->number
, result
);
595 kfree(transfer_buffer
);
596 return (result
< 0) ? result
: 0;
599 static void kobil_set_termios(struct tty_struct
*tty
,
600 struct usb_serial_port
*port
, struct ktermios
*old
)
602 struct kobil_private
* priv
;
604 unsigned short urb_val
= 0;
605 int c_cflag
= tty
->termios
->c_cflag
;
609 priv
= usb_get_serial_port_data(port
);
610 if (priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
|| priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
)
611 // This device doesn't support ioctl calls
614 switch (speed
= tty_get_baud_rate(tty
)) {
616 urb_val
= SUSBCR_SBR_1200
;
621 urb_val
= SUSBCR_SBR_9600
;
624 urb_val
|= (c_cflag
& CSTOPB
) ? SUSBCR_SPASB_2StopBits
: SUSBCR_SPASB_1StopBit
;
626 settings
= kzalloc(50, GFP_KERNEL
);
630 sprintf(settings
, "%d ", speed
);
632 if (c_cflag
& PARENB
) {
633 if (c_cflag
& PARODD
) {
634 urb_val
|= SUSBCR_SPASB_OddParity
;
635 strcat(settings
, "Odd Parity");
637 urb_val
|= SUSBCR_SPASB_EvenParity
;
638 strcat(settings
, "Even Parity");
641 urb_val
|= SUSBCR_SPASB_NoParity
;
642 strcat(settings
, "No Parity");
644 tty
->termios
->c_cflag
&= ~CMSPAR
;
645 tty_encode_baud_rate(tty
, speed
, speed
);
647 result
= usb_control_msg( port
->serial
->dev
,
648 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
649 SUSBCRequest_SetBaudRateParityAndStopBits
,
650 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
660 static int kobil_ioctl(struct tty_struct
*tty
, struct file
* file
, unsigned int cmd
, unsigned long arg
)
662 struct usb_serial_port
*port
= tty
->driver_data
;
663 struct kobil_private
* priv
= usb_get_serial_port_data(port
);
664 unsigned char *transfer_buffer
;
665 int transfer_buffer_length
= 8;
668 if (priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
|| priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
)
669 // This device doesn't support ioctl calls
674 transfer_buffer
= kmalloc(transfer_buffer_length
, GFP_KERNEL
);
675 if (! transfer_buffer
)
678 result
= usb_control_msg( port
->serial
->dev
,
679 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
681 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
682 SUSBCR_MSC_ResetAllQueues
,
684 NULL
,//transfer_buffer,
689 dbg("%s - port %d Send reset_all_queues (FLUSH) URB returns: %i", __func__
, port
->number
, result
);
690 kfree(transfer_buffer
);
691 return (result
< 0) ? -EIO
: 0;
697 static int __init
kobil_init (void)
700 retval
= usb_serial_register(&kobil_device
);
702 goto failed_usb_serial_register
;
703 retval
= usb_register(&kobil_driver
);
705 goto failed_usb_register
;
707 info(DRIVER_VERSION
" " DRIVER_AUTHOR
);
712 usb_serial_deregister(&kobil_device
);
713 failed_usb_serial_register
:
718 static void __exit
kobil_exit (void)
720 usb_deregister (&kobil_driver
);
721 usb_serial_deregister (&kobil_device
);
724 module_init(kobil_init
);
725 module_exit(kobil_exit
);
727 MODULE_AUTHOR( DRIVER_AUTHOR
);
728 MODULE_DESCRIPTION( DRIVER_DESC
);
729 MODULE_LICENSE( "GPL" );
731 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
732 MODULE_PARM_DESC(debug
, "Debug enabled or not");