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