?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tty-usb-kobil-sct: Coding style
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / usb / serial / kobil_sct.c
blobf0f8353ec1acb9b7b52f761446225c0deff49fa3
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 = port->port.tty;
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 /* someone sets the dev to 0 if the close method has been called */
409 port->interrupt_in_urb->dev = port->serial->dev;
410
411 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
412 dbg("%s - port %d Send read URB returns: %i",
413 __func__, port->number, result);
414 }
415
416
417 static void kobil_write_callback(struct urb *purb)
418 {
419 }
420
421
422 static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port,
423 const unsigned char *buf, int count)
424 {
425 int length = 0;
426 int result = 0;
427 int todo = 0;
428 struct kobil_private *priv;
429
430 if (count == 0) {
431 dbg("%s - port %d write request of 0 bytes",
432 __func__, port->number);
433 return 0;
434 }
435
436 priv = usb_get_serial_port_data(port);
437
438 if (count > (KOBIL_BUF_LENGTH - priv->filled)) {
439 dbg("%s - port %d Error: write request bigger than buffer size", __func__, port->number);
440 return -ENOMEM;
441 }
442
443 /* Copy data to buffer */
444 memcpy(priv->buf + priv->filled, buf, count);
445 usb_serial_debug_data(debug, &port->dev, __func__, count,
446 priv->buf + priv->filled);
447 priv->filled = priv->filled + count;
448
449 /* only send complete block. TWIN, KAAN SIM and adapter K
450 use the same protocol. */
451 if (((priv->device_type != KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 2) && (priv->filled >= (priv->buf[1] + 3))) ||
452 ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 3) && (priv->filled >= (priv->buf[2] + 4)))) {
453 /* stop reading (except TWIN and KAAN SIM) */
454 if ((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID)
455 || (priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID))
456 usb_kill_urb(port->interrupt_in_urb);
457
458 todo = priv->filled - priv->cur_pos;
459
460 while (todo > 0) {
461 /* max 8 byte in one urb (endpoint size) */
462 length = (todo < 8) ? todo : 8;
463 /* copy data to transfer buffer */
464 memcpy(port->write_urb->transfer_buffer,
465 priv->buf + priv->cur_pos, length);
466 usb_fill_int_urb(port->write_urb,
467 port->serial->dev,
468 usb_sndintpipe(port->serial->dev,
469 priv->write_int_endpoint_address),
470 port->write_urb->transfer_buffer,
471 length,
472 kobil_write_callback,
473 port,
474 8
475 );
476
477 priv->cur_pos = priv->cur_pos + length;
478 result = usb_submit_urb(port->write_urb, GFP_NOIO);
479 dbg("%s - port %d Send write URB returns: %i",
480 __func__, port->number, result);
481 todo = priv->filled - priv->cur_pos;
482
483 if (todo > 0)
484 msleep(24);
485 }
486
487 priv->filled = 0;
488 priv->cur_pos = 0;
489
490 /* someone sets the dev to 0 if the close method
491 has been called */
492 port->interrupt_in_urb->dev = port->serial->dev;
493
494 /* start reading (except TWIN and KAAN SIM) */
495 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID ||
496 priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) {
497 /* someone sets the dev to 0 if the close method has
498 been called */
499 port->interrupt_in_urb->dev = port->serial->dev;
500
501 result = usb_submit_urb(port->interrupt_in_urb,
502 GFP_NOIO);
503 dbg("%s - port %d Send read URB returns: %i",
504 __func__, port->number, result);
505 }
506 }
507 return count;
508 }
509
510
511 static int kobil_write_room(struct tty_struct *tty)
512 {
513 /* dbg("%s - port %d", __func__, port->number); */
514 /* FIXME */
515 return 8;
516 }
517
518
519 static int kobil_tiocmget(struct tty_struct *tty, struct file *file)
520 {
521 struct usb_serial_port *port = tty->driver_data;
522 struct kobil_private *priv;
523 int result;
524 unsigned char *transfer_buffer;
525 int transfer_buffer_length = 8;
526
527 priv = usb_get_serial_port_data(port);
528 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID
529 || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) {
530 /* This device doesn't support ioctl calls */
531 return -EINVAL;
532 }
533
534 /* allocate memory for transfer buffer */
535 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
536 if (!transfer_buffer)
537 return -ENOMEM;
538
539 result = usb_control_msg(port->serial->dev,
540 usb_rcvctrlpipe(port->serial->dev, 0),
541 SUSBCRequest_GetStatusLineState,
542 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_IN,
543 0,
544 0,
545 transfer_buffer,
546 transfer_buffer_length,
547 KOBIL_TIMEOUT);
548
549 dbg("%s - port %d Send get_status_line_state URB returns: %i. Statusline: %02x",
550 __func__, port->number, result, transfer_buffer[0]);
551
552 result = 0;
553 if ((transfer_buffer[0] & SUSBCR_GSL_DSR) != 0)
554 result = TIOCM_DSR;
555 kfree(transfer_buffer);
556 return result;
557 }
558
559 static int kobil_tiocmset(struct tty_struct *tty, struct file *file,
560 unsigned int set, unsigned int clear)
561 {
562 struct usb_serial_port *port = tty->driver_data;
563 struct kobil_private *priv;
564 int result;
565 int dtr = 0;
566 int rts = 0;
567 unsigned char *transfer_buffer;
568 int transfer_buffer_length = 8;
569
570 /* FIXME: locking ? */
571 priv = usb_get_serial_port_data(port);
572 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID
573 || priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) {
574 /* This device doesn't support ioctl calls */
575 return -EINVAL;
576 }
577
578 /* allocate memory for transfer buffer */
579 transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
580 if (!transfer_buffer)
581 return -ENOMEM;
582
583 if (set & TIOCM_RTS)
584 rts = 1;
585 if (set & TIOCM_DTR)
586 dtr = 1;
587 if (clear & TIOCM_RTS)
588 rts = 0;
589 if (clear & TIOCM_DTR)
590 dtr = 0;
591
592 if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) {
593 if (dtr != 0)
594 dbg("%s - port %d Setting DTR",
595 __func__, port->number);
596 else
597 dbg("%s - port %d Clearing DTR",
598 __func__, port->number);
599 result = usb_control_msg(port->serial->dev,
600 usb_rcvctrlpipe(port->serial->dev, 0),
601 SUSBCRequest_SetStatusLinesOrQueues,
602 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
603 ((dtr != 0) ? SUSBCR_SSL_SETDTR : SUSBCR_SSL_CLRDTR),
604 0,
605 transfer_buffer,
606 0,
607 KOBIL_TIMEOUT);
608 } else {
609 if (rts != 0)
610 dbg("%s - port %d Setting RTS",
611 __func__, port->number);
612 else
613 dbg("%s - port %d Clearing RTS",
614 __func__, port->number);
615 result = usb_control_msg(port->serial->dev,
616 usb_rcvctrlpipe(port->serial->dev, 0),
617 SUSBCRequest_SetStatusLinesOrQueues,
618 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
619 ((rts != 0) ? SUSBCR_SSL_SETRTS : SUSBCR_SSL_CLRRTS),
620 0,
621 transfer_buffer,
622 0,
623 KOBIL_TIMEOUT);
624 }
625 dbg("%s - port %d Send set_status_line URB returns: %i",
626 __func__, port->number, result);
627 kfree(transfer_buffer);
628 return (result < 0) ? result : 0;
629 }
630
631 static void kobil_set_termios(struct tty_struct *tty,
632 struct usb_serial_port *port, struct ktermios *old)
633 {
634 struct kobil_private *priv;
635 int result;
636 unsigned short urb_val = 0;
637 int c_cflag = tty->termios->c_cflag;
638 speed_t speed;
639 void *settings;
640
641 priv = usb_get_serial_port_data(port);
642 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID ||
643 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)
644 /* This device doesn't support ioctl calls */
645 return;
646
647 speed = tty_get_baud_rate(tty);
648 switch (speed) {
649 case 1200:
650 urb_val = SUSBCR_SBR_1200;
651 break;
652 default:
653 speed = 9600;
654 case 9600:
655 urb_val = SUSBCR_SBR_9600;
656 break;
657 }
658 urb_val |= (c_cflag & CSTOPB) ? SUSBCR_SPASB_2StopBits :
659 SUSBCR_SPASB_1StopBit;
660
661 settings = kzalloc(50, GFP_KERNEL);
662 if (!settings)
663 return;
664
665 sprintf(settings, "%d ", speed);
666
667 if (c_cflag & PARENB) {
668 if (c_cflag & PARODD) {
669 urb_val |= SUSBCR_SPASB_OddParity;
670 strcat(settings, "Odd Parity");
671 } else {
672 urb_val |= SUSBCR_SPASB_EvenParity;
673 strcat(settings, "Even Parity");
674 }
675 } else {
676 urb_val |= SUSBCR_SPASB_NoParity;
677 strcat(settings, "No Parity");
678 }
679 tty->termios->c_cflag &= ~CMSPAR;
680 tty_encode_baud_rate(tty, speed, speed);
681
682 result = usb_control_msg(port->serial->dev,
683 usb_rcvctrlpipe(port->serial->dev, 0),
684 SUSBCRequest_SetBaudRateParityAndStopBits,
685 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
686 urb_val,
687 0,
688 settings,
689 0,
690 KOBIL_TIMEOUT
691 );
692 kfree(settings);
693 }
694
695 static int kobil_ioctl(struct tty_struct *tty, struct file *file,
696 unsigned int cmd, unsigned long arg)
697 {
698 struct usb_serial_port *port = tty->driver_data;
699 struct kobil_private *priv = usb_get_serial_port_data(port);
700 unsigned char *transfer_buffer;
701 int transfer_buffer_length = 8;
702 int result;
703
704 if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID ||
705 priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID)
706 /* This device doesn't support ioctl calls */
707 return 0;
708
709 switch (cmd) {
710 case TCFLSH:
711 transfer_buffer = kmalloc(transfer_buffer_length, GFP_KERNEL);
712 if (!transfer_buffer)
713 return -ENOBUFS;
714
715 result = usb_control_msg(port->serial->dev,
716 usb_rcvctrlpipe(port->serial->dev, 0),
717 SUSBCRequest_Misc,
718 USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT,
719 SUSBCR_MSC_ResetAllQueues,
720 0,
721 NULL, /* transfer_buffer, */
722 0,
723 KOBIL_TIMEOUT
724 );
725
726 dbg("%s - port %d Send reset_all_queues (FLUSH) URB returns: %i", __func__, port->number, result);
727 kfree(transfer_buffer);
728 return (result < 0) ? -EIO: 0;
729 default:
730 return -ENOIOCTLCMD;
731 }
732 }
733
734 static int __init kobil_init(void)
735 {
736 int retval;
737 retval = usb_serial_register(&kobil_device);
738 if (retval)
739 goto failed_usb_serial_register;
740 retval = usb_register(&kobil_driver);
741 if (retval)
742 goto failed_usb_register;
743
744 info(DRIVER_VERSION " " DRIVER_AUTHOR);
745 info(DRIVER_DESC);
746
747 return 0;
748 failed_usb_register:
749 usb_serial_deregister(&kobil_device);
750 failed_usb_serial_register:
751 return retval;
752 }
753
754
755 static void __exit kobil_exit(void)
756 {
757 usb_deregister(&kobil_driver);
758 usb_serial_deregister(&kobil_device);
759 }
760
761 module_init(kobil_init);
762 module_exit(kobil_exit);
763
764 MODULE_AUTHOR(DRIVER_AUTHOR);
765 MODULE_DESCRIPTION(DRIVER_DESC);
766 MODULE_LICENSE("GPL");
767
768 module_param(debug, bool, S_IRUGO | S_IWUSR);
769 MODULE_PARM_DESC(debug, "Debug enabled or not");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree