?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: pl2303: use generic close
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / usb / serial / pl2303.c
blob18d1c44faa512a29da95d105403fe356800d0aba
1 /*
2 * Prolific PL2303 USB to serial adaptor driver
3 *
4 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
5 * Copyright (C) 2003 IBM Corp.
6 *
7 * Original driver for 2.2.x by anonymous
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License version
11 * 2 as published by the Free Software Foundation.
12 *
13 * See Documentation/usb/usb-serial.txt for more information on using this
14 * driver
15 *
16 */
17
18 #include <linux/kernel.h>
19 #include <linux/errno.h>
20 #include <linux/init.h>
21 #include <linux/slab.h>
22 #include <linux/tty.h>
23 #include <linux/tty_driver.h>
24 #include <linux/tty_flip.h>
25 #include <linux/serial.h>
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <linux/spinlock.h>
29 #include <linux/uaccess.h>
30 #include <linux/usb.h>
31 #include <linux/usb/serial.h>
32 #include "pl2303.h"
33
34 /*
35 * Version Information
36 */
37 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
38
39 static int debug;
40
41 #define PL2303_CLOSING_WAIT (30*HZ)
42
43 static const struct usb_device_id id_table[] = {
44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
49 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
50 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
51 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
52 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
53 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
54 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
55 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
56 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
57 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
58 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
59 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
60 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
61 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
62 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
63 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
64 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
65 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
66 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
67 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
68 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
69 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
70 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
71 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
72 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
73 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
74 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
75 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
76 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
77 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
78 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
79 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
80 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
81 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
82 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
83 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
84 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
85 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
86 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
87 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
88 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
89 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
90 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
91 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
92 { } /* Terminating entry */
93 };
94
95 MODULE_DEVICE_TABLE(usb, id_table);
96
97 static struct usb_driver pl2303_driver = {
98 .name = "pl2303",
99 .probe = usb_serial_probe,
100 .disconnect = usb_serial_disconnect,
101 .id_table = id_table,
102 .suspend = usb_serial_suspend,
103 .resume = usb_serial_resume,
104 .no_dynamic_id = 1,
105 .supports_autosuspend = 1,
106 };
107
108 #define SET_LINE_REQUEST_TYPE 0x21
109 #define SET_LINE_REQUEST 0x20
110
111 #define SET_CONTROL_REQUEST_TYPE 0x21
112 #define SET_CONTROL_REQUEST 0x22
113 #define CONTROL_DTR 0x01
114 #define CONTROL_RTS 0x02
115
116 #define BREAK_REQUEST_TYPE 0x21
117 #define BREAK_REQUEST 0x23
118 #define BREAK_ON 0xffff
119 #define BREAK_OFF 0x0000
120
121 #define GET_LINE_REQUEST_TYPE 0xa1
122 #define GET_LINE_REQUEST 0x21
123
124 #define VENDOR_WRITE_REQUEST_TYPE 0x40
125 #define VENDOR_WRITE_REQUEST 0x01
126
127 #define VENDOR_READ_REQUEST_TYPE 0xc0
128 #define VENDOR_READ_REQUEST 0x01
129
130 #define UART_STATE 0x08
131 #define UART_STATE_TRANSIENT_MASK 0x74
132 #define UART_DCD 0x01
133 #define UART_DSR 0x02
134 #define UART_BREAK_ERROR 0x04
135 #define UART_RING 0x08
136 #define UART_FRAME_ERROR 0x10
137 #define UART_PARITY_ERROR 0x20
138 #define UART_OVERRUN_ERROR 0x40
139 #define UART_CTS 0x80
140
141
142 enum pl2303_type {
143 type_0, /* don't know the difference between type 0 and */
144 type_1, /* type 1, until someone from prolific tells us... */
145 HX, /* HX version of the pl2303 chip */
146 };
147
148 struct pl2303_private {
149 spinlock_t lock;
150 wait_queue_head_t delta_msr_wait;
151 u8 line_control;
152 u8 line_status;
153 enum pl2303_type type;
154 };
155
156 static int pl2303_vendor_read(__u16 value, __u16 index,
157 struct usb_serial *serial, unsigned char *buf)
158 {
159 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
160 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
161 value, index, buf, 1, 100);
162 dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE,
163 VENDOR_READ_REQUEST, value, index, res, buf[0]);
164 return res;
165 }
166
167 static int pl2303_vendor_write(__u16 value, __u16 index,
168 struct usb_serial *serial)
169 {
170 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
171 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
172 value, index, NULL, 0, 100);
173 dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE,
174 VENDOR_WRITE_REQUEST, value, index, res);
175 return res;
176 }
177
178 static int pl2303_startup(struct usb_serial *serial)
179 {
180 struct pl2303_private *priv;
181 enum pl2303_type type = type_0;
182 unsigned char *buf;
183 int i;
184
185 buf = kmalloc(10, GFP_KERNEL);
186 if (buf == NULL)
187 return -ENOMEM;
188
189 if (serial->dev->descriptor.bDeviceClass == 0x02)
190 type = type_0;
191 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
192 type = HX;
193 else if (serial->dev->descriptor.bDeviceClass == 0x00)
194 type = type_1;
195 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
196 type = type_1;
197 dbg("device type: %d", type);
198
199 for (i = 0; i < serial->num_ports; ++i) {
200 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
201 if (!priv)
202 goto cleanup;
203 spin_lock_init(&priv->lock);
204 init_waitqueue_head(&priv->delta_msr_wait);
205 priv->type = type;
206 usb_set_serial_port_data(serial->port[i], priv);
207 }
208
209 pl2303_vendor_read(0x8484, 0, serial, buf);
210 pl2303_vendor_write(0x0404, 0, serial);
211 pl2303_vendor_read(0x8484, 0, serial, buf);
212 pl2303_vendor_read(0x8383, 0, serial, buf);
213 pl2303_vendor_read(0x8484, 0, serial, buf);
214 pl2303_vendor_write(0x0404, 1, serial);
215 pl2303_vendor_read(0x8484, 0, serial, buf);
216 pl2303_vendor_read(0x8383, 0, serial, buf);
217 pl2303_vendor_write(0, 1, serial);
218 pl2303_vendor_write(1, 0, serial);
219 if (type == HX)
220 pl2303_vendor_write(2, 0x44, serial);
221 else
222 pl2303_vendor_write(2, 0x24, serial);
223
224 kfree(buf);
225 return 0;
226
227 cleanup:
228 kfree(buf);
229 for (--i; i >= 0; --i) {
230 priv = usb_get_serial_port_data(serial->port[i]);
231 kfree(priv);
232 usb_set_serial_port_data(serial->port[i], NULL);
233 }
234 return -ENOMEM;
235 }
236
237 static int set_control_lines(struct usb_device *dev, u8 value)
238 {
239 int retval;
240
241 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
242 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
243 value, 0, NULL, 0, 100);
244 dbg("%s - value = %d, retval = %d", __func__, value, retval);
245 return retval;
246 }
247
248 static void pl2303_set_termios(struct tty_struct *tty,
249 struct usb_serial_port *port, struct ktermios *old_termios)
250 {
251 struct usb_serial *serial = port->serial;
252 struct pl2303_private *priv = usb_get_serial_port_data(port);
253 unsigned long flags;
254 unsigned int cflag;
255 unsigned char *buf;
256 int baud;
257 int i;
258 u8 control;
259 const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
260 4800, 7200, 9600, 14400, 19200, 28800, 38400,
261 57600, 115200, 230400, 460800, 614400,
262 921600, 1228800, 2457600, 3000000, 6000000 };
263 int baud_floor, baud_ceil;
264 int k;
265
266 dbg("%s - port %d", __func__, port->number);
267
268 /* The PL2303 is reported to lose bytes if you change
269 serial settings even to the same values as before. Thus
270 we actually need to filter in this specific case */
271
272 if (!tty_termios_hw_change(tty->termios, old_termios))
273 return;
274
275 cflag = tty->termios->c_cflag;
276
277 buf = kzalloc(7, GFP_KERNEL);
278 if (!buf) {
279 dev_err(&port->dev, "%s - out of memory.\n", __func__);
280 /* Report back no change occurred */
281 *tty->termios = *old_termios;
282 return;
283 }
284
285 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
286 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
287 0, 0, buf, 7, 100);
288 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
289 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
290
291 if (cflag & CSIZE) {
292 switch (cflag & CSIZE) {
293 case CS5:
294 buf[6] = 5;
295 break;
296 case CS6:
297 buf[6] = 6;
298 break;
299 case CS7:
300 buf[6] = 7;
301 break;
302 default:
303 case CS8:
304 buf[6] = 8;
305 break;
306 }
307 dbg("%s - data bits = %d", __func__, buf[6]);
308 }
309
310 /* For reference buf[0]:buf[3] baud rate value */
311 /* NOTE: Only the values defined in baud_sup are supported !
312 * => if unsupported values are set, the PL2303 seems to use
313 * 9600 baud (at least my PL2303X always does)
314 */
315 baud = tty_get_baud_rate(tty);
316 dbg("%s - baud requested = %d", __func__, baud);
317 if (baud) {
318 /* Set baudrate to nearest supported value */
319 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
320 if (baud_sup[k] / baud) {
321 baud_ceil = baud_sup[k];
322 if (k==0) {
323 baud = baud_ceil;
324 } else {
325 baud_floor = baud_sup[k-1];
326 if ((baud_ceil % baud)
327 > (baud % baud_floor))
328 baud = baud_floor;
329 else
330 baud = baud_ceil;
331 }
332 break;
333 }
334 }
335 if (baud > 1228800) {
336 /* type_0, type_1 only support up to 1228800 baud */
337 if (priv->type != HX)
338 baud = 1228800;
339 else if (baud > 6000000)
340 baud = 6000000;
341 }
342 dbg("%s - baud set = %d", __func__, baud);
343 buf[0] = baud & 0xff;
344 buf[1] = (baud >> 8) & 0xff;
345 buf[2] = (baud >> 16) & 0xff;
346 buf[3] = (baud >> 24) & 0xff;
347 }
348
349 /* For reference buf[4]=0 is 1 stop bits */
350 /* For reference buf[4]=1 is 1.5 stop bits */
351 /* For reference buf[4]=2 is 2 stop bits */
352 if (cflag & CSTOPB) {
353 /* NOTE: Comply with "real" UARTs / RS232:
354 * use 1.5 instead of 2 stop bits with 5 data bits
355 */
356 if ((cflag & CSIZE) == CS5) {
357 buf[4] = 1;
358 dbg("%s - stop bits = 1.5", __func__);
359 } else {
360 buf[4] = 2;
361 dbg("%s - stop bits = 2", __func__);
362 }
363 } else {
364 buf[4] = 0;
365 dbg("%s - stop bits = 1", __func__);
366 }
367
368 if (cflag & PARENB) {
369 /* For reference buf[5]=0 is none parity */
370 /* For reference buf[5]=1 is odd parity */
371 /* For reference buf[5]=2 is even parity */
372 /* For reference buf[5]=3 is mark parity */
373 /* For reference buf[5]=4 is space parity */
374 if (cflag & PARODD) {
375 if (cflag & CMSPAR) {
376 buf[5] = 3;
377 dbg("%s - parity = mark", __func__);
378 } else {
379 buf[5] = 1;
380 dbg("%s - parity = odd", __func__);
381 }
382 } else {
383 if (cflag & CMSPAR) {
384 buf[5] = 4;
385 dbg("%s - parity = space", __func__);
386 } else {
387 buf[5] = 2;
388 dbg("%s - parity = even", __func__);
389 }
390 }
391 } else {
392 buf[5] = 0;
393 dbg("%s - parity = none", __func__);
394 }
395
396 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
397 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
398 0, 0, buf, 7, 100);
399 dbg("0x21:0x20:0:0 %d", i);
400
401 /* change control lines if we are switching to or from B0 */
402 spin_lock_irqsave(&priv->lock, flags);
403 control = priv->line_control;
404 if ((cflag & CBAUD) == B0)
405 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
406 else
407 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
408 if (control != priv->line_control) {
409 control = priv->line_control;
410 spin_unlock_irqrestore(&priv->lock, flags);
411 set_control_lines(serial->dev, control);
412 } else {
413 spin_unlock_irqrestore(&priv->lock, flags);
414 }
415
416 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
417
418 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
419 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
420 0, 0, buf, 7, 100);
421 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
422 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
423
424 if (cflag & CRTSCTS) {
425 if (priv->type == HX)
426 pl2303_vendor_write(0x0, 0x61, serial);
427 else
428 pl2303_vendor_write(0x0, 0x41, serial);
429 } else {
430 pl2303_vendor_write(0x0, 0x0, serial);
431 }
432
433 /* Save resulting baud rate */
434 if (baud)
435 tty_encode_baud_rate(tty, baud, baud);
436
437 kfree(buf);
438 }
439
440 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
441 {
442 struct pl2303_private *priv = usb_get_serial_port_data(port);
443 unsigned long flags;
444 u8 control;
445
446 spin_lock_irqsave(&priv->lock, flags);
447 /* Change DTR and RTS */
448 if (on)
449 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
450 else
451 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
452 control = priv->line_control;
453 spin_unlock_irqrestore(&priv->lock, flags);
454 set_control_lines(port->serial->dev, control);
455 }
456
457 static void pl2303_close(struct usb_serial_port *port)
458 {
459 dbg("%s - port %d", __func__, port->number);
460
461 usb_serial_generic_close(port);
462 usb_kill_urb(port->interrupt_in_urb);
463 }
464
465 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
466 {
467 struct ktermios tmp_termios;
468 struct usb_serial *serial = port->serial;
469 struct pl2303_private *priv = usb_get_serial_port_data(port);
470 int result;
471
472 dbg("%s - port %d", __func__, port->number);
473
474 if (priv->type != HX) {
475 usb_clear_halt(serial->dev, port->write_urb->pipe);
476 usb_clear_halt(serial->dev, port->read_urb->pipe);
477 } else {
478 /* reset upstream data pipes */
479 pl2303_vendor_write(8, 0, serial);
480 pl2303_vendor_write(9, 0, serial);
481 }
482
483 /* Setup termios */
484 if (tty)
485 pl2303_set_termios(tty, port, &tmp_termios);
486
487 dbg("%s - submitting read urb", __func__);
488 result = usb_serial_generic_submit_read_urb(port, GFP_KERNEL);
489 if (result) {
490 pl2303_close(port);
491 return -EPROTO;
492 }
493
494 dbg("%s - submitting interrupt urb", __func__);
495 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
496 if (result) {
497 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
498 " error %d\n", __func__, result);
499 pl2303_close(port);
500 return -EPROTO;
501 }
502 port->port.drain_delay = 256;
503 return 0;
504 }
505
506 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
507 unsigned int set, unsigned int clear)
508 {
509 struct usb_serial_port *port = tty->driver_data;
510 struct pl2303_private *priv = usb_get_serial_port_data(port);
511 unsigned long flags;
512 u8 control;
513
514 if (!usb_get_intfdata(port->serial->interface))
515 return -ENODEV;
516
517 spin_lock_irqsave(&priv->lock, flags);
518 if (set & TIOCM_RTS)
519 priv->line_control |= CONTROL_RTS;
520 if (set & TIOCM_DTR)
521 priv->line_control |= CONTROL_DTR;
522 if (clear & TIOCM_RTS)
523 priv->line_control &= ~CONTROL_RTS;
524 if (clear & TIOCM_DTR)
525 priv->line_control &= ~CONTROL_DTR;
526 control = priv->line_control;
527 spin_unlock_irqrestore(&priv->lock, flags);
528
529 return set_control_lines(port->serial->dev, control);
530 }
531
532 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
533 {
534 struct usb_serial_port *port = tty->driver_data;
535 struct pl2303_private *priv = usb_get_serial_port_data(port);
536 unsigned long flags;
537 unsigned int mcr;
538 unsigned int status;
539 unsigned int result;
540
541 dbg("%s (%d)", __func__, port->number);
542
543 if (!usb_get_intfdata(port->serial->interface))
544 return -ENODEV;
545
546 spin_lock_irqsave(&priv->lock, flags);
547 mcr = priv->line_control;
548 status = priv->line_status;
549 spin_unlock_irqrestore(&priv->lock, flags);
550
551 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
552 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
553 | ((status & UART_CTS) ? TIOCM_CTS : 0)
554 | ((status & UART_DSR) ? TIOCM_DSR : 0)
555 | ((status & UART_RING) ? TIOCM_RI : 0)
556 | ((status & UART_DCD) ? TIOCM_CD : 0);
557
558 dbg("%s - result = %x", __func__, result);
559
560 return result;
561 }
562
563 static int pl2303_carrier_raised(struct usb_serial_port *port)
564 {
565 struct pl2303_private *priv = usb_get_serial_port_data(port);
566 if (priv->line_status & UART_DCD)
567 return 1;
568 return 0;
569 }
570
571 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
572 {
573 struct pl2303_private *priv = usb_get_serial_port_data(port);
574 unsigned long flags;
575 unsigned int prevstatus;
576 unsigned int status;
577 unsigned int changed;
578
579 spin_lock_irqsave(&priv->lock, flags);
580 prevstatus = priv->line_status;
581 spin_unlock_irqrestore(&priv->lock, flags);
582
583 while (1) {
584 interruptible_sleep_on(&priv->delta_msr_wait);
585 /* see if a signal did it */
586 if (signal_pending(current))
587 return -ERESTARTSYS;
588
589 spin_lock_irqsave(&priv->lock, flags);
590 status = priv->line_status;
591 spin_unlock_irqrestore(&priv->lock, flags);
592
593 changed = prevstatus ^ status;
594
595 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
596 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
597 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
598 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
599 return 0;
600 }
601 prevstatus = status;
602 }
603 /* NOTREACHED */
604 return 0;
605 }
606
607 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
608 unsigned int cmd, unsigned long arg)
609 {
610 struct serial_struct ser;
611 struct usb_serial_port *port = tty->driver_data;
612 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
613
614 switch (cmd) {
615 case TIOCGSERIAL:
616 memset(&ser, 0, sizeof ser);
617 ser.type = PORT_16654;
618 ser.line = port->serial->minor;
619 ser.port = port->number;
620 ser.baud_base = 460800;
621
622 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
623 return -EFAULT;
624
625 return 0;
626
627 case TIOCMIWAIT:
628 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
629 return wait_modem_info(port, arg);
630 default:
631 dbg("%s not supported = 0x%04x", __func__, cmd);
632 break;
633 }
634 return -ENOIOCTLCMD;
635 }
636
637 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
638 {
639 struct usb_serial_port *port = tty->driver_data;
640 struct usb_serial *serial = port->serial;
641 u16 state;
642 int result;
643
644 dbg("%s - port %d", __func__, port->number);
645
646 if (break_state == 0)
647 state = BREAK_OFF;
648 else
649 state = BREAK_ON;
650 dbg("%s - turning break %s", __func__,
651 state == BREAK_OFF ? "off" : "on");
652
653 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
654 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
655 0, NULL, 0, 100);
656 if (result)
657 dbg("%s - error sending break = %d", __func__, result);
658 }
659
660 static void pl2303_release(struct usb_serial *serial)
661 {
662 int i;
663 struct pl2303_private *priv;
664
665 dbg("%s", __func__);
666
667 for (i = 0; i < serial->num_ports; ++i) {
668 priv = usb_get_serial_port_data(serial->port[i]);
669 kfree(priv);
670 }
671 }
672
673 static void pl2303_update_line_status(struct usb_serial_port *port,
674 unsigned char *data,
675 unsigned int actual_length)
676 {
677
678 struct pl2303_private *priv = usb_get_serial_port_data(port);
679 unsigned long flags;
680 u8 status_idx = UART_STATE;
681 u8 length = UART_STATE + 1;
682 u16 idv, idp;
683
684 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
685 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
686
687
688 if (idv == SIEMENS_VENDOR_ID) {
689 if (idp == SIEMENS_PRODUCT_ID_X65 ||
690 idp == SIEMENS_PRODUCT_ID_SX1 ||
691 idp == SIEMENS_PRODUCT_ID_X75) {
692
693 length = 1;
694 status_idx = 0;
695 }
696 }
697
698 if (actual_length < length)
699 return;
700
701 /* Save off the uart status for others to look at */
702 spin_lock_irqsave(&priv->lock, flags);
703 priv->line_status = data[status_idx];
704 spin_unlock_irqrestore(&priv->lock, flags);
705 if (priv->line_status & UART_BREAK_ERROR)
706 usb_serial_handle_break(port);
707 wake_up_interruptible(&priv->delta_msr_wait);
708 }
709
710 static void pl2303_read_int_callback(struct urb *urb)
711 {
712 struct usb_serial_port *port = urb->context;
713 unsigned char *data = urb->transfer_buffer;
714 unsigned int actual_length = urb->actual_length;
715 int status = urb->status;
716 int retval;
717
718 dbg("%s (%d)", __func__, port->number);
719
720 switch (status) {
721 case 0:
722 /* success */
723 break;
724 case -ECONNRESET:
725 case -ENOENT:
726 case -ESHUTDOWN:
727 /* this urb is terminated, clean up */
728 dbg("%s - urb shutting down with status: %d", __func__,
729 status);
730 return;
731 default:
732 dbg("%s - nonzero urb status received: %d", __func__,
733 status);
734 goto exit;
735 }
736
737 usb_serial_debug_data(debug, &port->dev, __func__,
738 urb->actual_length, urb->transfer_buffer);
739
740 pl2303_update_line_status(port, data, actual_length);
741
742 exit:
743 retval = usb_submit_urb(urb, GFP_ATOMIC);
744 if (retval)
745 dev_err(&urb->dev->dev,
746 "%s - usb_submit_urb failed with result %d\n",
747 __func__, retval);
748 }
749
750 static void pl2303_process_read_urb(struct urb *urb)
751 {
752 struct usb_serial_port *port = urb->context;
753 struct pl2303_private *priv = usb_get_serial_port_data(port);
754 struct tty_struct *tty;
755 unsigned char *data = urb->transfer_buffer;
756 char tty_flag = TTY_NORMAL;
757 unsigned long flags;
758 u8 line_status;
759 int i;
760
761 /* update line status */
762 spin_lock_irqsave(&priv->lock, flags);
763 line_status = priv->line_status;
764 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
765 spin_unlock_irqrestore(&priv->lock, flags);
766 wake_up_interruptible(&priv->delta_msr_wait);
767
768 if (!urb->actual_length)
769 return;
770
771 tty = tty_port_tty_get(&port->port);
772 if (!tty)
773 return;
774
775 /* break takes precedence over parity, */
776 /* which takes precedence over framing errors */
777 if (line_status & UART_BREAK_ERROR)
778 tty_flag = TTY_BREAK;
779 else if (line_status & UART_PARITY_ERROR)
780 tty_flag = TTY_PARITY;
781 else if (line_status & UART_FRAME_ERROR)
782 tty_flag = TTY_FRAME;
783 dbg("%s - tty_flag = %d", __func__, tty_flag);
784
785 /* overrun is special, not associated with a char */
786 if (line_status & UART_OVERRUN_ERROR)
787 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
788
789 if (tty_flag == TTY_NORMAL && !(port->port.console && port->sysrq))
790 tty_insert_flip_string(tty, data, urb->actual_length);
791 else {
792 for (i = 0; i < urb->actual_length; ++i)
793 if (!usb_serial_handle_sysrq_char(tty, port, data[i]))
794 tty_insert_flip_char(tty, data[i], tty_flag);
795 }
796
797 tty_flip_buffer_push(tty);
798 tty_kref_put(tty);
799 }
800
801 /* All of the device info needed for the PL2303 SIO serial converter */
802 static struct usb_serial_driver pl2303_device = {
803 .driver = {
804 .owner = THIS_MODULE,
805 .name = "pl2303",
806 },
807 .id_table = id_table,
808 .usb_driver = &pl2303_driver,
809 .num_ports = 1,
810 .bulk_in_size = 256,
811 .bulk_out_size = 256,
812 .open = pl2303_open,
813 .close = pl2303_close,
814 .dtr_rts = pl2303_dtr_rts,
815 .carrier_raised = pl2303_carrier_raised,
816 .ioctl = pl2303_ioctl,
817 .break_ctl = pl2303_break_ctl,
818 .set_termios = pl2303_set_termios,
819 .tiocmget = pl2303_tiocmget,
820 .tiocmset = pl2303_tiocmset,
821 .process_read_urb = pl2303_process_read_urb,
822 .read_int_callback = pl2303_read_int_callback,
823 .attach = pl2303_startup,
824 .release = pl2303_release,
825 };
826
827 static int __init pl2303_init(void)
828 {
829 int retval;
830
831 retval = usb_serial_register(&pl2303_device);
832 if (retval)
833 goto failed_usb_serial_register;
834 retval = usb_register(&pl2303_driver);
835 if (retval)
836 goto failed_usb_register;
837 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
838 return 0;
839 failed_usb_register:
840 usb_serial_deregister(&pl2303_device);
841 failed_usb_serial_register:
842 return retval;
843 }
844
845 static void __exit pl2303_exit(void)
846 {
847 usb_deregister(&pl2303_driver);
848 usb_serial_deregister(&pl2303_device);
849 }
850
851 module_init(pl2303_init);
852 module_exit(pl2303_exit);
853
854 MODULE_DESCRIPTION(DRIVER_DESC);
855 MODULE_LICENSE("GPL");
856
857 module_param(debug, bool, S_IRUGO | S_IWUSR);
858 MODULE_PARM_DESC(debug, "Debug enabled or not");
859
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree