?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usb-serial: fix crash when sub-driver updates firmware
[linux-2.6/mini2440.git] / drivers / usb / serial / kobil_sct.c
blob6286baad9392a7c13dbb9a40d4d770156cee7cb0
1 /*
2 * KOBIL USB Smart Card Terminal Driver
3 *
4 * Copyright (C) 2002 KOBIL Systems GmbH
5 * Author: Thomas Wahrenbruch
6 *
7 * Contact: linuxusb@kobil.de
8 *
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.
12 *
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.
17 *
18 * Thanks to Greg Kroah-Hartman (greg@kroah.com) for his help and
19 * patience.
20 *
21 * Supported readers: USB TWIN, KAAN Standard Plus and SecOVID Reader Plus
22 * (Adapter K), B1 Professional and KAAN Professional (Adapter B)
23 *
24 * (21/05/2004) tw
25 * Fix bug with P'n'P readers
26 *
27 * (28/05/2003) tw
28 * Add support for KAAN SIM
29 *
30 * (12/09/2002) tw
31 * Adapted to 2.5.
32 *
33 * (11/08/2002) tw
34 * Initial version.
35 */
36
37
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"
52
53 static int debug;
54
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)"
59
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
65
66 #define KOBIL_TIMEOUT 500
67 #define KOBIL_BUF_LENGTH 300
68
69
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,
76 struct file *filp);
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);
89
90
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 */
97 };
98
99
100 MODULE_DEVICE_TABLE(usb, id_table);
101
102 static struct usb_driver kobil_driver = {
103 .name = "kobil",
104 .probe = usb_serial_probe,
105 .disconnect = usb_serial_disconnect,
106 .id_table = id_table,
107 .no_dynamic_id = 1,
108 };
109
110
111 static struct usb_serial_driver kobil_device = {
112 .driver = {
113 .owner = THIS_MODULE,
114 .name = "kobil",
115 },
116 .description = "KOBIL USB smart card terminal",
117 .usb_driver = &kobil_driver,
118 .id_table = id_table,
119 .num_ports = 1,
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,
126 .open = kobil_open,
127 .close = kobil_close,
128 .write = kobil_write,
129 .write_room = kobil_write_room,
130 .read_int_callback = kobil_read_int_callback,
131 };
132
133
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 */
140 __u16 device_type;
141 };
142
143
144 static int kobil_startup(struct usb_serial *serial)
145 {
146 int i;
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;
153
154 priv = kmalloc(sizeof(struct kobil_private), GFP_KERNEL);
155 if (!priv)
156 return -ENOMEM;
157
158 priv->filled = 0;
159 priv->cur_pos = 0;
160 priv->device_type = le16_to_cpu(serial->dev->descriptor.idProduct);
161
162 switch (priv->device_type) {
163 case KOBIL_ADAPTER_B_PRODUCT_ID:
164 printk(KERN_DEBUG "KOBIL B1 PRO / KAAN PRO detected\n");
165 break;
166 case KOBIL_ADAPTER_K_PRODUCT_ID:
167 printk(KERN_DEBUG
168 "KOBIL KAAN Standard Plus / SecOVID Reader Plus detected\n");
169 break;
170 case KOBIL_USBTWIN_PRODUCT_ID:
171 printk(KERN_DEBUG "KOBIL USBTWIN detected\n");
172 break;
173 case KOBIL_KAAN_SIM_PRODUCT_ID:
174 printk(KERN_DEBUG "KOBIL KAAN SIM detected\n");
175 break;
176 }
177 usb_set_serial_port_data(serial->port[0], priv);
178
179 /* search for the necessary endpoints */
180 pdev = serial->dev;
181 actconfig = pdev->actconfig;
182 interface = actconfig->interface[0];
183 altsetting = interface->cur_altsetting;
184 endpoint = altsetting->endpoint;
185
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;
193 }
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;
199 }
200 }
201 return 0;
202 }
203
204
205 static void kobil_shutdown(struct usb_serial *serial)
206 {
207 int i;
208 dbg("%s - port %d", __func__, serial->port[0]->number);
209
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);
215 }
216 }
217
218
219 static int kobil_open(struct tty_struct *tty,
220 struct usb_serial_port *port, struct file *filp)
221 {
222 int result = 0;
223 struct kobil_private *priv;
224 unsigned char *transfer_buffer;
225 int transfer_buffer_length = 8;
226 int write_urb_transfer_buffer_length = 8;
227
228 dbg("%s - port %d", __func__, port->number);
229 priv = usb_get_serial_port_data(port);
230
231 /* someone sets the dev to 0 if the close method has been called */
232 port->interrupt_in_urb->dev = port->serial->dev;
233
234
235 /* force low_latency on so that our tty_push actually forces
236 * the data through, otherwise it is scheduled, and with high
237 * data rates (like with OHCI) data can get lost.
238 */
239 if (tty) {
240 tty->low_latency = 1;
241
242 /* Default to echo off and other sane device settings */
243 tty->termios->c_lflag = 0;
244 tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN |
245 XCASE);
246 tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
247 /* do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D) */
248 tty->termios->c_oflag &= ~ONLCR;
249 }
250 /* allocate memory for transfer buffer */
251 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
252 if (!transfer_buffer)
253 return -ENOMEM;
254
255 /* allocate write_urb */
256 if (!port->write_urb) {
257 dbg("%s - port %d Allocating port->write_urb",
258 __func__, port->number);
259 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
260 if (!port->write_urb) {
261 dbg("%s - port %d usb_alloc_urb failed",
262 __func__, port->number);
263 kfree(transfer_buffer);
264 return -ENOMEM;
265 }
266 }
267
268 /* allocate memory for write_urb transfer buffer */
269 port->write_urb->transfer_buffer =
270 kmalloc(write_urb_transfer_buffer_length, GFP_KERNEL);
271 if (!port->write_urb->transfer_buffer) {
272 kfree(transfer_buffer);
273 usb_free_urb(port->write_urb);
274 port->write_urb = NULL;
275 return -ENOMEM;
276 }
277
278 /* get hardware version */
279 result = usb_control_msg(port->serial->dev,
280 usb_rcvctrlpipe(port->serial->dev, 0),
281 SUSBCRequest_GetMisc,
282 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN,
283 SUSBCR_MSC_GetHWVersion,
284 0,
285 transfer_buffer,
286 transfer_buffer_length,
287 KOBIL_TIMEOUT
288 );
289 dbg("%s - port %d Send get_HW_version URB returns: %i",
290 __func__, port->number, result);
291 dbg("Harware version: %i.%i.%i",
292 transfer_buffer[0], transfer_buffer[1], transfer_buffer[2]);
293
294 /* get firmware version */
295 result = usb_control_msg(port->serial->dev,
296 usb_rcvctrlpipe(port->serial->dev, 0),
297 SUSBCRequest_GetMisc,
298 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN,
299 SUSBCR_MSC_GetFWVersion,
300 0,
301 transfer_buffer,
302 transfer_buffer_length,
303 KOBIL_TIMEOUT
304 );
305 dbg("%s - port %d Send get_FW_version URB returns: %i",
306 __func__, port->number, result);
307 dbg("Firmware version: %i.%i.%i",
308 transfer_buffer[0], transfer_buffer[1], transfer_buffer[2]);
309
310 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID ||
311 priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) {
312 /* Setting Baudrate, Parity and Stopbits */
313 result = usb_control_msg(port->serial->dev,
314 usb_rcvctrlpipe(port->serial->dev, 0),
315 SUSBCRequest_SetBaudRateParityAndStopBits,
316 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
317 SUSBCR_SBR_9600 | SUSBCR_SPASB_EvenParity |
318 SUSBCR_SPASB_1StopBit,
319 0,
320 transfer_buffer,
321 0,
322 KOBIL_TIMEOUT
323 );
324 dbg("%s - port %d Send set_baudrate URB returns: %i",
325 __func__, port->number, result);
326
327 /* reset all queues */
328 result = usb_control_msg(port->serial->dev,
329 usb_rcvctrlpipe(port->serial->dev, 0),
330 SUSBCRequest_Misc,
331 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
332 SUSBCR_MSC_ResetAllQueues,
333 0,
334 transfer_buffer,
335 0,
336 KOBIL_TIMEOUT
337 );
338 dbg("%s - port %d Send reset_all_queues URB returns: %i",
339 __func__, port->number, result);
340 }
341 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID ||
342 priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID ||
343 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) {
344 /* start reading (Adapter B 'cause PNP string) */
345 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
346 dbg("%s - port %d Send read URB returns: %i",
347 __func__, port->number, result);
348 }
349
350 kfree(transfer_buffer);
351 return 0;
352 }
353
354
355 static void kobil_close(struct tty_struct *tty,
356 struct usb_serial_port *port, struct file *filp)
357 {
358 dbg("%s - port %d", __func__, port->number);
359
360 if (port->write_urb) {
361 usb_kill_urb(port->write_urb);
362 usb_free_urb(port->write_urb);
363 port->write_urb = NULL;
364 }
365 usb_kill_urb(port->interrupt_in_urb);
366 }
367
368
369 static void kobil_read_int_callback(struct urb *urb)
370 {
371 int result;
372 struct usb_serial_port *port = urb->context;
373 struct tty_struct *tty;
374 unsigned char *data = urb->transfer_buffer;
375 int status = urb->status;
376 /* char *dbg_data; */
377
378 dbg("%s - port %d", __func__, port->number);
379
380 if (status) {
381 dbg("%s - port %d Read int status not zero: %d",
382 __func__, port->number, status);
383 return;
384 }
385
386 tty = tty_port_tty_get(&port->port);
387 if (urb->actual_length) {
388
389 /* BEGIN DEBUG */
390 /*
391 dbg_data = kzalloc((3 * purb->actual_length + 10)
392 * sizeof(char), GFP_KERNEL);
393 if (! dbg_data) {
394 return;
395 }
396 for (i = 0; i < purb->actual_length; i++) {
397 sprintf(dbg_data +3*i, "%02X ", data[i]);
398 }
399 dbg(" <-- %s", dbg_data);
400 kfree(dbg_data);
401 */
402 /* END DEBUG */
403
404 tty_buffer_request_room(tty, urb->actual_length);
405 tty_insert_flip_string(tty, data, urb->actual_length);
406 tty_flip_buffer_push(tty);
407 }
408 tty_kref_put(tty);
409 /* someone sets the dev to 0 if the close method has been called */
410 port->interrupt_in_urb->dev = port->serial->dev;
411
412 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
413 dbg("%s - port %d Send read URB returns: %i",
414 __func__, port->number, result);
415 }
416
417
418 static void kobil_write_callback(struct urb *purb)
419 {
420 }
421
422
423 static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port,
424 const unsigned char *buf, int count)
425 {
426 int length = 0;
427 int result = 0;
428 int todo = 0;
429 struct kobil_private *priv;
430
431 if (count == 0) {
432 dbg("%s - port %d write request of 0 bytes",
433 __func__, port->number);
434 return 0;
435 }
436
437 priv = usb_get_serial_port_data(port);
438
439 if (count > (KOBIL_BUF_LENGTH - priv->filled)) {
440 dbg("%s - port %d Error: write request bigger than buffer size", __func__, port->number);
441 return -ENOMEM;
442 }
443
444 /* Copy data to buffer */
445 memcpy(priv->buf + priv->filled, buf, count);
446 usb_serial_debug_data(debug, &port->dev, __func__, count,
447 priv->buf + priv->filled);
448 priv->filled = priv->filled + count;
449
450 /* only send complete block. TWIN, KAAN SIM and adapter K
451 use the same protocol. */
452 if (((priv->device_type != KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 2) && (priv->filled >= (priv->buf[1] + 3))) ||
453 ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 3) && (priv->filled >= (priv->buf[2] + 4)))) {
454 /* stop reading (except TWIN and KAAN SIM) */
455 if ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID)
456 || (priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID))
457 usb_kill_urb(port->interrupt_in_urb);
458
459 todo = priv->filled - priv->cur_pos;
460
461 while (todo > 0) {
462 /* max 8 byte in one urb (endpoint size) */
463 length = (todo < 8) ? todo : 8;
464 /* copy data to transfer buffer */
465 memcpy(port->write_urb->transfer_buffer,
466 priv->buf + priv->cur_pos, length);
467 usb_fill_int_urb(port->write_urb,
468 port->serial->dev,
469 usb_sndintpipe(port->serial->dev,
470 priv->write_int_endpoint_address),
471 port->write_urb->transfer_buffer,
472 length,
473 kobil_write_callback,
474 port,
475 8
476 );
477
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",
481 __func__, port->number, result);
482 todo = priv->filled - priv->cur_pos;
483
484 if (todo > 0)
485 msleep(24);
486 }
487
488 priv->filled = 0;
489 priv->cur_pos = 0;
490
491 /* someone sets the dev to 0 if the close method
492 has been called */
493 port->interrupt_in_urb->dev = port->serial->dev;
494
495 /* start reading (except TWIN and KAAN SIM) */
496 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID ||
497 priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) {
498 /* someone sets the dev to 0 if the close method has
499 been called */
500 port->interrupt_in_urb->dev = port->serial->dev;
501
502 result = usb_submit_urb(port->interrupt_in_urb,
503 GFP_NOIO);
504 dbg("%s - port %d Send read URB returns: %i",
505 __func__, port->number, result);
506 }
507 }
508 return count;
509 }
510
511
512 static int kobil_write_room(struct tty_struct *tty)
513 {
514 /* dbg("%s - port %d", __func__, port->number); */
515 /* FIXME */
516 return 8;
517 }
518
519
520 static int kobil_tiocmget(struct tty_struct *tty, struct file *file)
521 {
522 struct usb_serial_port *port = tty->driver_data;
523 struct kobil_private *priv;
524 int result;
525 unsigned char *transfer_buffer;
526 int transfer_buffer_length = 8;
527
528 priv = usb_get_serial_port_data(port);
529 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID
530 || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) {
531 /* This device doesn't support ioctl calls */
532 return -EINVAL;
533 }
534
535 /* allocate memory for transfer buffer */
536 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
537 if (!transfer_buffer)
538 return -ENOMEM;
539
540 result = usb_control_msg(port->serial->dev,
541 usb_rcvctrlpipe(port->serial->dev, 0),
542 SUSBCRequest_GetStatusLineState,
543 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN,
544 0,
545 0,
546 transfer_buffer,
547 transfer_buffer_length,
548 KOBIL_TIMEOUT);
549
550 dbg("%s - port %d Send get_status_line_state URB returns: %i. Statusline: %02x",
551 __func__, port->number, result, transfer_buffer[0]);
552
553 result = 0;
554 if ((transfer_buffer[0] & SUSBCR_GSL_DSR) != 0)
555 result = TIOCM_DSR;
556 kfree(transfer_buffer);
557 return result;
558 }
559
560 static int kobil_tiocmset(struct tty_struct *tty, struct file *file,
561 unsigned int set, unsigned int clear)
562 {
563 struct usb_serial_port *port = tty->driver_data;
564 struct kobil_private *priv;
565 int result;
566 int dtr = 0;
567 int rts = 0;
568 unsigned char *transfer_buffer;
569 int transfer_buffer_length = 8;
570
571 /* FIXME: locking ? */
572 priv = usb_get_serial_port_data(port);
573 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID
574 || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) {
575 /* This device doesn't support ioctl calls */
576 return -EINVAL;
577 }
578
579 /* allocate memory for transfer buffer */
580 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
581 if (!transfer_buffer)
582 return -ENOMEM;
583
584 if (set & TIOCM_RTS)
585 rts = 1;
586 if (set & TIOCM_DTR)
587 dtr = 1;
588 if (clear & TIOCM_RTS)
589 rts = 0;
590 if (clear & TIOCM_DTR)
591 dtr = 0;
592
593 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) {
594 if (dtr != 0)
595 dbg("%s - port %d Setting DTR",
596 __func__, port->number);
597 else
598 dbg("%s - port %d Clearing DTR",
599 __func__, port->number);
600 result = usb_control_msg(port->serial->dev,
601 usb_rcvctrlpipe(port->serial->dev, 0),
602 SUSBCRequest_SetStatusLinesOrQueues,
603 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
604 ((dtr != 0) ? SUSBCR_SSL_SETDTR : SUSBCR_SSL_CLRDTR),
605 0,
606 transfer_buffer,
607 0,
608 KOBIL_TIMEOUT);
609 } else {
610 if (rts != 0)
611 dbg("%s - port %d Setting RTS",
612 __func__, port->number);
613 else
614 dbg("%s - port %d Clearing RTS",
615 __func__, port->number);
616 result = usb_control_msg(port->serial->dev,
617 usb_rcvctrlpipe(port->serial->dev, 0),
618 SUSBCRequest_SetStatusLinesOrQueues,
619 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
620 ((rts != 0) ? SUSBCR_SSL_SETRTS : SUSBCR_SSL_CLRRTS),
621 0,
622 transfer_buffer,
623 0,
624 KOBIL_TIMEOUT);
625 }
626 dbg("%s - port %d Send set_status_line URB returns: %i",
627 __func__, port->number, result);
628 kfree(transfer_buffer);
629 return (result < 0) ? result : 0;
630 }
631
632 static void kobil_set_termios(struct tty_struct *tty,
633 struct usb_serial_port *port, struct ktermios *old)
634 {
635 struct kobil_private *priv;
636 int result;
637 unsigned short urb_val = 0;
638 int c_cflag = tty->termios->c_cflag;
639 speed_t speed;
640 void *settings;
641
642 priv = usb_get_serial_port_data(port);
643 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID ||
644 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) {
645 /* This device doesn't support ioctl calls */
646 *tty->termios = *old;
647 return;
648 }
649
650 speed = tty_get_baud_rate(tty);
651 switch (speed) {
652 case 1200:
653 urb_val = SUSBCR_SBR_1200;
654 break;
655 default:
656 speed = 9600;
657 case 9600:
658 urb_val = SUSBCR_SBR_9600;
659 break;
660 }
661 urb_val |= (c_cflag & CSTOPB) ? SUSBCR_SPASB_2StopBits :
662 SUSBCR_SPASB_1StopBit;
663
664 settings = kzalloc(50, GFP_KERNEL);
665 if (!settings)
666 return;
667
668 sprintf(settings, "%d ", speed);
669
670 if (c_cflag & PARENB) {
671 if (c_cflag & PARODD) {
672 urb_val |= SUSBCR_SPASB_OddParity;
673 strcat(settings, "Odd Parity");
674 } else {
675 urb_val |= SUSBCR_SPASB_EvenParity;
676 strcat(settings, "Even Parity");
677 }
678 } else {
679 urb_val |= SUSBCR_SPASB_NoParity;
680 strcat(settings, "No Parity");
681 }
682 tty->termios->c_cflag &= ~CMSPAR;
683 tty_encode_baud_rate(tty, speed, speed);
684
685 result = usb_control_msg(port->serial->dev,
686 usb_rcvctrlpipe(port->serial->dev, 0),
687 SUSBCRequest_SetBaudRateParityAndStopBits,
688 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
689 urb_val,
690 0,
691 settings,
692 0,
693 KOBIL_TIMEOUT
694 );
695 kfree(settings);
696 }
697
698 static int kobil_ioctl(struct tty_struct *tty, struct file *file,
699 unsigned int cmd, unsigned long arg)
700 {
701 struct usb_serial_port *port = tty->driver_data;
702 struct kobil_private *priv = usb_get_serial_port_data(port);
703 unsigned char *transfer_buffer;
704 int transfer_buffer_length = 8;
705 int result;
706
707 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID ||
708 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)
709 /* This device doesn't support ioctl calls */
710 return -ENOIOCTLCMD;
711
712 switch (cmd) {
713 case TCFLSH:
714 transfer_buffer = kmalloc(transfer_buffer_length, GFP_KERNEL);
715 if (!transfer_buffer)
716 return -ENOBUFS;
717
718 result = usb_control_msg(port->serial->dev,
719 usb_rcvctrlpipe(port->serial->dev, 0),
720 SUSBCRequest_Misc,
721 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
722 SUSBCR_MSC_ResetAllQueues,
723 0,
724 NULL, /* transfer_buffer, */
725 0,
726 KOBIL_TIMEOUT
727 );
728
729 dbg("%s - port %d Send reset_all_queues (FLUSH) URB returns: %i", __func__, port->number, result);
730 kfree(transfer_buffer);
731 return (result < 0) ? -EIO: 0;
732 default:
733 return -ENOIOCTLCMD;
734 }
735 }
736
737 static int __init kobil_init(void)
738 {
739 int retval;
740 retval = usb_serial_register(&kobil_device);
741 if (retval)
742 goto failed_usb_serial_register;
743 retval = usb_register(&kobil_driver);
744 if (retval)
745 goto failed_usb_register;
746
747 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
748 DRIVER_DESC "\n");
749
750 return 0;
751 failed_usb_register:
752 usb_serial_deregister(&kobil_device);
753 failed_usb_serial_register:
754 return retval;
755 }
756
757
758 static void __exit kobil_exit(void)
759 {
760 usb_deregister(&kobil_driver);
761 usb_serial_deregister(&kobil_device);
762 }
763
764 module_init(kobil_init);
765 module_exit(kobil_exit);
766
767 MODULE_AUTHOR(DRIVER_AUTHOR);
768 MODULE_DESCRIPTION(DRIVER_DESC);
769 MODULE_LICENSE("GPL");
770
771 module_param(debug, bool, S_IRUGO | S_IWUSR);
772 MODULE_PARM_DESC(debug, "Debug enabled or not");
Support for the Chinese Samsung S3C2440 based development boards