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