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