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/config.h>
39 #include <linux/kernel.h>
40 #include <linux/errno.h>
41 #include <linux/init.h>
42 #include <linux/slab.h>
43 #include <linux/tty.h>
44 #include <linux/tty_driver.h>
45 #include <linux/tty_flip.h>
46 #include <linux/module.h>
47 #include <linux/spinlock.h>
48 #include <asm/uaccess.h>
49 #include <linux/usb.h>
50 #include <linux/ioctl.h>
51 #include "usb-serial.h"
52 #include "kobil_sct.h"
56 /* Version Information */
57 #define DRIVER_VERSION "21/05/2004"
58 #define DRIVER_AUTHOR "KOBIL Systems GmbH - http://www.kobil.com"
59 #define DRIVER_DESC "KOBIL USB Smart Card Terminal Driver (experimental)"
61 #define KOBIL_VENDOR_ID 0x0D46
62 #define KOBIL_ADAPTER_B_PRODUCT_ID 0x2011
63 #define KOBIL_ADAPTER_K_PRODUCT_ID 0x2012
64 #define KOBIL_USBTWIN_PRODUCT_ID 0x0078
65 #define KOBIL_KAAN_SIM_PRODUCT_ID 0x0081
67 #define KOBIL_TIMEOUT 500
68 #define KOBIL_BUF_LENGTH 300
71 /* Function prototypes */
72 static int kobil_startup (struct usb_serial
*serial
);
73 static void kobil_shutdown (struct usb_serial
*serial
);
74 static int kobil_open (struct usb_serial_port
*port
, struct file
*filp
);
75 static void kobil_close (struct usb_serial_port
*port
, struct file
*filp
);
76 static int kobil_write (struct usb_serial_port
*port
,
77 const unsigned char *buf
, int count
);
78 static int kobil_write_room(struct usb_serial_port
*port
);
79 static int kobil_ioctl(struct usb_serial_port
*port
, struct file
*file
,
80 unsigned int cmd
, unsigned long arg
);
81 static int kobil_tiocmget(struct usb_serial_port
*port
, struct file
*file
);
82 static int kobil_tiocmset(struct usb_serial_port
*port
, struct file
*file
,
83 unsigned int set
, unsigned int clear
);
84 static void kobil_read_int_callback( struct urb
*urb
, struct pt_regs
*regs
);
85 static void kobil_write_callback( struct urb
*purb
, struct pt_regs
*regs
);
88 static struct usb_device_id id_table
[] = {
89 { USB_DEVICE(KOBIL_VENDOR_ID
, KOBIL_ADAPTER_B_PRODUCT_ID
) },
90 { USB_DEVICE(KOBIL_VENDOR_ID
, KOBIL_ADAPTER_K_PRODUCT_ID
) },
91 { USB_DEVICE(KOBIL_VENDOR_ID
, KOBIL_USBTWIN_PRODUCT_ID
) },
92 { USB_DEVICE(KOBIL_VENDOR_ID
, KOBIL_KAAN_SIM_PRODUCT_ID
) },
93 { } /* Terminating entry */
97 MODULE_DEVICE_TABLE (usb
, id_table
);
99 static struct usb_driver kobil_driver
= {
100 .owner
= THIS_MODULE
,
102 .probe
= usb_serial_probe
,
103 .disconnect
= usb_serial_disconnect
,
104 .id_table
= id_table
,
109 static struct usb_serial_driver kobil_device
= {
111 .owner
= THIS_MODULE
,
114 .description
= "KOBIL USB smart card terminal",
115 .id_table
= id_table
,
116 .num_interrupt_in
= NUM_DONT_CARE
,
120 .attach
= kobil_startup
,
121 .shutdown
= kobil_shutdown
,
122 .ioctl
= kobil_ioctl
,
123 .tiocmget
= kobil_tiocmget
,
124 .tiocmset
= kobil_tiocmset
,
126 .close
= kobil_close
,
127 .write
= kobil_write
,
128 .write_room
= kobil_write_room
,
129 .read_int_callback
= kobil_read_int_callback
,
133 struct kobil_private
{
134 int write_int_endpoint_address
;
135 int read_int_endpoint_address
;
136 unsigned char buf
[KOBIL_BUF_LENGTH
]; // buffer for the APDU to send
137 int filled
; // index of the last char in buf
138 int cur_pos
; // index of the next char to send in buf
141 struct termios internal_termios
;
145 static int kobil_startup (struct usb_serial
*serial
)
148 struct kobil_private
*priv
;
149 struct usb_device
*pdev
;
150 struct usb_host_config
*actconfig
;
151 struct usb_interface
*interface
;
152 struct usb_host_interface
*altsetting
;
153 struct usb_host_endpoint
*endpoint
;
155 priv
= kmalloc(sizeof(struct kobil_private
), GFP_KERNEL
);
162 priv
->device_type
= le16_to_cpu(serial
->dev
->descriptor
.idProduct
);
163 priv
->line_state
= 0;
165 switch (priv
->device_type
){
166 case KOBIL_ADAPTER_B_PRODUCT_ID
:
167 printk(KERN_DEBUG
"KOBIL B1 PRO / KAAN PRO detected\n");
169 case KOBIL_ADAPTER_K_PRODUCT_ID
:
170 printk(KERN_DEBUG
"KOBIL KAAN Standard Plus / SecOVID Reader Plus detected\n");
172 case KOBIL_USBTWIN_PRODUCT_ID
:
173 printk(KERN_DEBUG
"KOBIL USBTWIN detected\n");
175 case KOBIL_KAAN_SIM_PRODUCT_ID
:
176 printk(KERN_DEBUG
"KOBIL KAAN SIM detected\n");
179 usb_set_serial_port_data(serial
->port
[0], priv
);
181 // search for the necessary endpoints
183 actconfig
= pdev
->actconfig
;
184 interface
= actconfig
->interface
[0];
185 altsetting
= interface
->cur_altsetting
;
186 endpoint
= altsetting
->endpoint
;
188 for (i
= 0; i
< altsetting
->desc
.bNumEndpoints
; i
++) {
189 endpoint
= &altsetting
->endpoint
[i
];
190 if (((endpoint
->desc
.bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) == USB_DIR_OUT
) &&
191 ((endpoint
->desc
.bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) == USB_ENDPOINT_XFER_INT
)) {
192 dbg("%s Found interrupt out endpoint. Address: %d", __FUNCTION__
, endpoint
->desc
.bEndpointAddress
);
193 priv
->write_int_endpoint_address
= endpoint
->desc
.bEndpointAddress
;
195 if (((endpoint
->desc
.bEndpointAddress
& USB_ENDPOINT_DIR_MASK
) == USB_DIR_IN
) &&
196 ((endpoint
->desc
.bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) == USB_ENDPOINT_XFER_INT
)) {
197 dbg("%s Found interrupt in endpoint. Address: %d", __FUNCTION__
, endpoint
->desc
.bEndpointAddress
);
198 priv
->read_int_endpoint_address
= endpoint
->desc
.bEndpointAddress
;
205 static void kobil_shutdown (struct usb_serial
*serial
)
208 dbg("%s - port %d", __FUNCTION__
, serial
->port
[0]->number
);
210 for (i
=0; i
< serial
->num_ports
; ++i
) {
211 while (serial
->port
[i
]->open_count
> 0) {
212 kobil_close (serial
->port
[i
], NULL
);
214 kfree(usb_get_serial_port_data(serial
->port
[i
]));
215 usb_set_serial_port_data(serial
->port
[i
], NULL
);
220 static int kobil_open (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", __FUNCTION__
, port
->number
);
229 priv
= usb_get_serial_port_data(port
);
230 priv
->line_state
= 0;
232 // someone sets the dev to 0 if the close method has been called
233 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
236 /* force low_latency on so that our tty_push actually forces
237 * the data through, otherwise it is scheduled, and with high
238 * data rates (like with OHCI) data can get lost.
240 port
->tty
->low_latency
= 1;
242 // without this, every push_tty_char is echoed :-(
243 port
->tty
->termios
->c_lflag
= 0;
244 port
->tty
->termios
->c_lflag
&= ~(ISIG
| ICANON
| ECHO
| IEXTEN
| XCASE
);
245 port
->tty
->termios
->c_iflag
= IGNBRK
| IGNPAR
| IXOFF
;
246 port
->tty
->termios
->c_oflag
&= ~ONLCR
; // do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D)
248 // set up internal termios structure
249 priv
->internal_termios
.c_iflag
= port
->tty
->termios
->c_iflag
;
250 priv
->internal_termios
.c_oflag
= port
->tty
->termios
->c_oflag
;
251 priv
->internal_termios
.c_cflag
= port
->tty
->termios
->c_cflag
;
252 priv
->internal_termios
.c_lflag
= port
->tty
->termios
->c_lflag
;
254 for (i
=0; i
<NCCS
; i
++) {
255 priv
->internal_termios
.c_cc
[i
] = port
->tty
->termios
->c_cc
[i
];
258 // allocate memory for transfer buffer
259 transfer_buffer
= (unsigned char *) kmalloc(transfer_buffer_length
, GFP_KERNEL
);
260 if (! transfer_buffer
) {
263 memset(transfer_buffer
, 0, transfer_buffer_length
);
266 // allocate write_urb
267 if (!port
->write_urb
) {
268 dbg("%s - port %d Allocating port->write_urb", __FUNCTION__
, port
->number
);
269 port
->write_urb
= usb_alloc_urb(0, GFP_KERNEL
);
270 if (!port
->write_urb
) {
271 dbg("%s - port %d usb_alloc_urb failed", __FUNCTION__
, port
->number
);
272 kfree(transfer_buffer
);
277 // allocate memory for write_urb transfer buffer
278 port
->write_urb
->transfer_buffer
= (unsigned char *) kmalloc(write_urb_transfer_buffer_length
, GFP_KERNEL
);
279 if (! port
->write_urb
->transfer_buffer
) {
280 kfree(transfer_buffer
);
281 usb_free_urb(port
->write_urb
);
282 port
->write_urb
= NULL
;
286 // get hardware version
287 result
= usb_control_msg( port
->serial
->dev
,
288 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
289 SUSBCRequest_GetMisc
,
290 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_IN
,
291 SUSBCR_MSC_GetHWVersion
,
294 transfer_buffer_length
,
297 dbg("%s - port %d Send get_HW_version URB returns: %i", __FUNCTION__
, port
->number
, result
);
298 dbg("Harware version: %i.%i.%i", transfer_buffer
[0], transfer_buffer
[1], transfer_buffer
[2] );
300 // get firmware version
301 result
= usb_control_msg( port
->serial
->dev
,
302 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
303 SUSBCRequest_GetMisc
,
304 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_IN
,
305 SUSBCR_MSC_GetFWVersion
,
308 transfer_buffer_length
,
311 dbg("%s - port %d Send get_FW_version URB returns: %i", __FUNCTION__
, port
->number
, result
);
312 dbg("Firmware version: %i.%i.%i", transfer_buffer
[0], transfer_buffer
[1], transfer_buffer
[2] );
314 if (priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
|| priv
->device_type
== KOBIL_ADAPTER_K_PRODUCT_ID
) {
315 // Setting Baudrate, Parity and Stopbits
316 result
= usb_control_msg( port
->serial
->dev
,
317 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
318 SUSBCRequest_SetBaudRateParityAndStopBits
,
319 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
320 SUSBCR_SBR_9600
| SUSBCR_SPASB_EvenParity
| SUSBCR_SPASB_1StopBit
,
326 dbg("%s - port %d Send set_baudrate URB returns: %i", __FUNCTION__
, port
->number
, result
);
329 result
= usb_control_msg( port
->serial
->dev
,
330 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
332 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
333 SUSBCR_MSC_ResetAllQueues
,
339 dbg("%s - port %d Send reset_all_queues URB returns: %i", __FUNCTION__
, port
->number
, result
);
341 if (priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
|| priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
||
342 priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
) {
343 // start reading (Adapter B 'cause PNP string)
344 result
= usb_submit_urb( port
->interrupt_in_urb
, GFP_ATOMIC
);
345 dbg("%s - port %d Send read URB returns: %i", __FUNCTION__
, port
->number
, result
);
348 kfree(transfer_buffer
);
353 static void kobil_close (struct usb_serial_port
*port
, struct file
*filp
)
355 dbg("%s - port %d", __FUNCTION__
, port
->number
);
357 if (port
->write_urb
) {
358 usb_kill_urb(port
->write_urb
);
359 usb_free_urb( port
->write_urb
);
360 port
->write_urb
= NULL
;
362 if (port
->interrupt_in_urb
)
363 usb_kill_urb(port
->interrupt_in_urb
);
367 static void kobil_read_int_callback( struct urb
*purb
, struct pt_regs
*regs
)
371 struct usb_serial_port
*port
= (struct usb_serial_port
*) purb
->context
;
372 struct tty_struct
*tty
;
373 unsigned char *data
= purb
->transfer_buffer
;
376 dbg("%s - port %d", __FUNCTION__
, port
->number
);
379 dbg("%s - port %d Read int status not zero: %d", __FUNCTION__
, port
->number
, purb
->status
);
384 if (purb
->actual_length
) {
388 dbg_data = (unsigned char *) kmalloc((3 * purb->actual_length + 10) * sizeof(char), GFP_KERNEL);
392 memset(dbg_data, 0, (3 * purb->actual_length + 10));
393 for (i = 0; i < purb->actual_length; i++) {
394 sprintf(dbg_data +3*i, "%02X ", data[i]);
396 dbg(" <-- %s", dbg_data );
401 for (i
= 0; i
< purb
->actual_length
; ++i
) {
402 // if we insert more than TTY_FLIPBUF_SIZE characters, we drop them.
403 if(tty
->flip
.count
>= TTY_FLIPBUF_SIZE
) {
404 tty_flip_buffer_push(tty
);
406 // this doesn't actually push the data through unless tty->low_latency is set
407 tty_insert_flip_char(tty
, data
[i
], 0);
409 tty_flip_buffer_push(tty
);
412 // someone sets the dev to 0 if the close method has been called
413 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
415 result
= usb_submit_urb( port
->interrupt_in_urb
, GFP_ATOMIC
);
416 dbg("%s - port %d Send read URB returns: %i", __FUNCTION__
, port
->number
, result
);
420 static void kobil_write_callback( struct urb
*purb
, struct pt_regs
*regs
)
425 static int kobil_write (struct usb_serial_port
*port
,
426 const unsigned char *buf
, int count
)
431 struct kobil_private
* priv
;
434 dbg("%s - port %d write request of 0 bytes", __FUNCTION__
, port
->number
);
438 priv
= usb_get_serial_port_data(port
);
440 if (count
> (KOBIL_BUF_LENGTH
- priv
->filled
)) {
441 dbg("%s - port %d Error: write request bigger than buffer size", __FUNCTION__
, port
->number
);
445 // Copy data to buffer
446 memcpy (priv
->buf
+ priv
->filled
, buf
, count
);
448 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, count
, priv
->buf
+ priv
->filled
);
450 priv
->filled
= priv
->filled
+ count
;
453 // only send complete block. TWIN, KAAN SIM and adapter K use the same protocol.
454 if ( ((priv
->device_type
!= KOBIL_ADAPTER_B_PRODUCT_ID
) && (priv
->filled
> 2) && (priv
->filled
>= (priv
->buf
[1] + 3))) ||
455 ((priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
) && (priv
->filled
> 3) && (priv
->filled
>= (priv
->buf
[2] + 4))) ) {
457 // stop reading (except TWIN and KAAN SIM)
458 if ( (priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
) || (priv
->device_type
== KOBIL_ADAPTER_K_PRODUCT_ID
) )
459 usb_kill_urb(port
->interrupt_in_urb
);
461 todo
= priv
->filled
- priv
->cur_pos
;
464 // max 8 byte in one urb (endpoint size)
465 length
= (todo
< 8) ? todo
: 8;
466 // copy data to transfer buffer
467 memcpy(port
->write_urb
->transfer_buffer
, priv
->buf
+ priv
->cur_pos
, length
);
468 usb_fill_int_urb( port
->write_urb
,
470 usb_sndintpipe(port
->serial
->dev
, priv
->write_int_endpoint_address
),
471 port
->write_urb
->transfer_buffer
,
473 kobil_write_callback
,
478 priv
->cur_pos
= priv
->cur_pos
+ length
;
479 result
= usb_submit_urb( port
->write_urb
, GFP_NOIO
);
480 dbg("%s - port %d Send write URB returns: %i", __FUNCTION__
, port
->number
, result
);
481 todo
= priv
->filled
- priv
->cur_pos
;
492 // someone sets the dev to 0 if the close method has been called
493 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
495 // start reading (except TWIN and KAAN SIM)
496 if ( (priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
) || (priv
->device_type
== KOBIL_ADAPTER_K_PRODUCT_ID
) ) {
497 // someone sets the dev to 0 if the close method has been called
498 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
500 result
= usb_submit_urb( port
->interrupt_in_urb
, GFP_NOIO
);
501 dbg("%s - port %d Send read URB returns: %i", __FUNCTION__
, port
->number
, result
);
508 static int kobil_write_room (struct usb_serial_port
*port
)
510 //dbg("%s - port %d", __FUNCTION__, port->number);
515 static int kobil_tiocmget(struct usb_serial_port
*port
, struct file
*file
)
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
) || (priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
)) {
524 // This device doesn't support ioctl calls
528 // allocate memory for transfer buffer
529 transfer_buffer
= (unsigned char *) kmalloc(transfer_buffer_length
, GFP_KERNEL
);
530 if (!transfer_buffer
) {
533 memset(transfer_buffer
, 0, transfer_buffer_length
);
535 result
= usb_control_msg( port
->serial
->dev
,
536 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
537 SUSBCRequest_GetStatusLineState
,
538 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_IN
,
542 transfer_buffer_length
,
545 dbg("%s - port %d Send get_status_line_state URB returns: %i. Statusline: %02x",
546 __FUNCTION__
, port
->number
, result
, transfer_buffer
[0]);
548 if ((transfer_buffer
[0] & SUSBCR_GSL_DSR
) != 0) {
549 priv
->line_state
|= TIOCM_DSR
;
551 priv
->line_state
&= ~TIOCM_DSR
;
554 kfree(transfer_buffer
);
555 return priv
->line_state
;
558 static int kobil_tiocmset(struct usb_serial_port
*port
, struct file
*file
,
559 unsigned int set
, unsigned int clear
)
561 struct kobil_private
* priv
;
565 unsigned char *transfer_buffer
;
566 int transfer_buffer_length
= 8;
568 priv
= usb_get_serial_port_data(port
);
569 if ((priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
) || (priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
)) {
570 // This device doesn't support ioctl calls
574 // allocate memory for transfer buffer
575 transfer_buffer
= (unsigned char *) kmalloc(transfer_buffer_length
, GFP_KERNEL
);
576 if (! transfer_buffer
) {
579 memset(transfer_buffer
, 0, transfer_buffer_length
);
585 if (clear
& TIOCM_RTS
)
587 if (clear
& TIOCM_DTR
)
590 if (priv
->device_type
== KOBIL_ADAPTER_B_PRODUCT_ID
) {
592 dbg("%s - port %d Setting DTR", __FUNCTION__
, port
->number
);
594 dbg("%s - port %d Clearing DTR", __FUNCTION__
, port
->number
);
595 result
= usb_control_msg( port
->serial
->dev
,
596 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
597 SUSBCRequest_SetStatusLinesOrQueues
,
598 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
599 ((dtr
!= 0) ? SUSBCR_SSL_SETDTR
: SUSBCR_SSL_CLRDTR
),
606 dbg("%s - port %d Setting RTS", __FUNCTION__
, port
->number
);
608 dbg("%s - port %d Clearing RTS", __FUNCTION__
, port
->number
);
609 result
= usb_control_msg( port
->serial
->dev
,
610 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
611 SUSBCRequest_SetStatusLinesOrQueues
,
612 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
613 ((rts
!= 0) ? SUSBCR_SSL_SETRTS
: SUSBCR_SSL_CLRRTS
),
619 dbg("%s - port %d Send set_status_line URB returns: %i", __FUNCTION__
, port
->number
, result
);
620 kfree(transfer_buffer
);
621 return (result
< 0) ? result
: 0;
625 static int kobil_ioctl(struct usb_serial_port
*port
, struct file
*file
,
626 unsigned int cmd
, unsigned long arg
)
628 struct kobil_private
* priv
;
630 unsigned short urb_val
= 0;
631 unsigned char *transfer_buffer
;
632 int transfer_buffer_length
= 8;
634 void __user
*user_arg
= (void __user
*)arg
;
636 priv
= usb_get_serial_port_data(port
);
637 if ((priv
->device_type
== KOBIL_USBTWIN_PRODUCT_ID
) || (priv
->device_type
== KOBIL_KAAN_SIM_PRODUCT_ID
)) {
638 // This device doesn't support ioctl calls
643 case TCGETS
: // 0x5401
644 if (!access_ok(VERIFY_WRITE
, user_arg
, sizeof(struct termios
))) {
645 dbg("%s - port %d Error in access_ok", __FUNCTION__
, port
->number
);
648 if (kernel_termios_to_user_termios((struct termios __user
*)arg
,
649 &priv
->internal_termios
))
653 case TCSETS
: // 0x5402
654 if (!(port
->tty
->termios
)) {
655 dbg("%s - port %d Error: port->tty->termios is NULL", __FUNCTION__
, port
->number
);
658 if (!access_ok(VERIFY_READ
, user_arg
, sizeof(struct termios
))) {
659 dbg("%s - port %d Error in access_ok", __FUNCTION__
, port
->number
);
662 if (user_termios_to_kernel_termios(&priv
->internal_termios
,
663 (struct termios __user
*)arg
))
666 settings
= (unsigned char *) kmalloc(50, GFP_KERNEL
);
670 memset(settings
, 0, 50);
672 switch (priv
->internal_termios
.c_cflag
& CBAUD
) {
674 urb_val
= SUSBCR_SBR_1200
;
675 strcat(settings
, "1200 ");
679 urb_val
= SUSBCR_SBR_9600
;
680 strcat(settings
, "9600 ");
684 urb_val
|= (priv
->internal_termios
.c_cflag
& CSTOPB
) ? SUSBCR_SPASB_2StopBits
: SUSBCR_SPASB_1StopBit
;
685 strcat(settings
, (priv
->internal_termios
.c_cflag
& CSTOPB
) ? "2 StopBits " : "1 StopBit ");
687 if (priv
->internal_termios
.c_cflag
& PARENB
) {
688 if (priv
->internal_termios
.c_cflag
& PARODD
) {
689 urb_val
|= SUSBCR_SPASB_OddParity
;
690 strcat(settings
, "Odd Parity");
692 urb_val
|= SUSBCR_SPASB_EvenParity
;
693 strcat(settings
, "Even Parity");
696 urb_val
|= SUSBCR_SPASB_NoParity
;
697 strcat(settings
, "No Parity");
699 dbg("%s - port %d setting port to: %s", __FUNCTION__
, port
->number
, settings
);
701 result
= usb_control_msg( port
->serial
->dev
,
702 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
703 SUSBCRequest_SetBaudRateParityAndStopBits
,
704 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
712 dbg("%s - port %d Send set_baudrate URB returns: %i", __FUNCTION__
, port
->number
, result
);
716 case TCFLSH
: // 0x540B
717 transfer_buffer
= (unsigned char *) kmalloc(transfer_buffer_length
, GFP_KERNEL
);
718 if (! transfer_buffer
) {
722 result
= usb_control_msg( port
->serial
->dev
,
723 usb_rcvctrlpipe(port
->serial
->dev
, 0 ),
725 USB_TYPE_VENDOR
| USB_RECIP_ENDPOINT
| USB_DIR_OUT
,
726 SUSBCR_MSC_ResetAllQueues
,
728 NULL
,//transfer_buffer,
733 dbg("%s - port %d Send reset_all_queues (FLUSH) URB returns: %i", __FUNCTION__
, port
->number
, result
);
735 kfree(transfer_buffer
);
736 return ((result
< 0) ? -EFAULT
: 0);
743 static int __init
kobil_init (void)
746 retval
= usb_serial_register(&kobil_device
);
748 goto failed_usb_serial_register
;
749 retval
= usb_register(&kobil_driver
);
751 goto failed_usb_register
;
753 info(DRIVER_VERSION
" " DRIVER_AUTHOR
);
758 usb_serial_deregister(&kobil_device
);
759 failed_usb_serial_register
:
764 static void __exit
kobil_exit (void)
766 usb_deregister (&kobil_driver
);
767 usb_serial_deregister (&kobil_device
);
770 module_init(kobil_init
);
771 module_exit(kobil_exit
);
773 MODULE_AUTHOR( DRIVER_AUTHOR
);
774 MODULE_DESCRIPTION( DRIVER_DESC
);
775 MODULE_LICENSE( "GPL" );
777 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
778 MODULE_PARM_DESC(debug
, "Debug enabled or not");