?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
kmemtrace: SLOB hooks.
[linux-2.6/kmemtrace.git] / drivers / usb / serial / pl2303.c
blob2a0dd1b50dc43b8dc884f0964c4f6624bfac1921
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 driver
14 *
15 */
16
17 #include <linux/kernel.h>
18 #include <linux/errno.h>
19 #include <linux/init.h>
20 #include <linux/slab.h>
21 #include <linux/tty.h>
22 #include <linux/tty_driver.h>
23 #include <linux/tty_flip.h>
24 #include <linux/serial.h>
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/spinlock.h>
28 #include <asm/uaccess.h>
29 #include <linux/usb.h>
30 #include <linux/usb/serial.h>
31 #include "pl2303.h"
32
33 /*
34 * Version Information
35 */
36 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
37
38 static int debug;
39
40 #define PL2303_CLOSING_WAIT (30*HZ)
41
42 #define PL2303_BUF_SIZE 1024
43 #define PL2303_TMP_BUF_SIZE 1024
44
45 struct pl2303_buf {
46 unsigned int buf_size;
47 char *buf_buf;
48 char *buf_get;
49 char *buf_put;
50 };
51
52 static struct usb_device_id id_table [] = {
53 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
54 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
55 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
56 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
57 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
58 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
59 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
60 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
61 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
62 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
63 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
64 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
65 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
66 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
67 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
68 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
69 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
70 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
71 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
72 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
73 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
74 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
75 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
76 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
77 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
78 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
79 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
80 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
81 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
82 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
83 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
84 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
85 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
86 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
87 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
88 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
89 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
90 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
91 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
92 { USB_DEVICE(HL340_VENDOR_ID, HL340_PRODUCT_ID) },
93 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_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 struct pl2303_buf *buf;
153 int write_urb_in_use;
154 wait_queue_head_t delta_msr_wait;
155 u8 line_control;
156 u8 line_status;
157 u8 termios_initialized;
158 enum pl2303_type type;
159 };
160
161 /*
162 * pl2303_buf_alloc
163 *
164 * Allocate a circular buffer and all associated memory.
165 */
166 static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
167 {
168 struct pl2303_buf *pb;
169
170 if (size == 0)
171 return NULL;
172
173 pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
174 if (pb == NULL)
175 return NULL;
176
177 pb->buf_buf = kmalloc(size, GFP_KERNEL);
178 if (pb->buf_buf == NULL) {
179 kfree(pb);
180 return NULL;
181 }
182
183 pb->buf_size = size;
184 pb->buf_get = pb->buf_put = pb->buf_buf;
185
186 return pb;
187 }
188
189 /*
190 * pl2303_buf_free
191 *
192 * Free the buffer and all associated memory.
193 */
194 static void pl2303_buf_free(struct pl2303_buf *pb)
195 {
196 if (pb) {
197 kfree(pb->buf_buf);
198 kfree(pb);
199 }
200 }
201
202 /*
203 * pl2303_buf_clear
204 *
205 * Clear out all data in the circular buffer.
206 */
207 static void pl2303_buf_clear(struct pl2303_buf *pb)
208 {
209 if (pb != NULL)
210 pb->buf_get = pb->buf_put;
211 /* equivalent to a get of all data available */
212 }
213
214 /*
215 * pl2303_buf_data_avail
216 *
217 * Return the number of bytes of data available in the circular
218 * buffer.
219 */
220 static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
221 {
222 if (pb == NULL)
223 return 0;
224
225 return ((pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size);
226 }
227
228 /*
229 * pl2303_buf_space_avail
230 *
231 * Return the number of bytes of space available in the circular
232 * buffer.
233 */
234 static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
235 {
236 if (pb == NULL)
237 return 0;
238
239 return ((pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size);
240 }
241
242 /*
243 * pl2303_buf_put
244 *
245 * Copy data data from a user buffer and put it into the circular buffer.
246 * Restrict to the amount of space available.
247 *
248 * Return the number of bytes copied.
249 */
250 static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf,
251 unsigned int count)
252 {
253 unsigned int len;
254
255 if (pb == NULL)
256 return 0;
257
258 len = pl2303_buf_space_avail(pb);
259 if (count > len)
260 count = len;
261
262 if (count == 0)
263 return 0;
264
265 len = pb->buf_buf + pb->buf_size - pb->buf_put;
266 if (count > len) {
267 memcpy(pb->buf_put, buf, len);
268 memcpy(pb->buf_buf, buf+len, count - len);
269 pb->buf_put = pb->buf_buf + count - len;
270 } else {
271 memcpy(pb->buf_put, buf, count);
272 if (count < len)
273 pb->buf_put += count;
274 else /* count == len */
275 pb->buf_put = pb->buf_buf;
276 }
277
278 return count;
279 }
280
281 /*
282 * pl2303_buf_get
283 *
284 * Get data from the circular buffer and copy to the given buffer.
285 * Restrict to the amount of data available.
286 *
287 * Return the number of bytes copied.
288 */
289 static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
290 unsigned int count)
291 {
292 unsigned int len;
293
294 if (pb == NULL)
295 return 0;
296
297 len = pl2303_buf_data_avail(pb);
298 if (count > len)
299 count = len;
300
301 if (count == 0)
302 return 0;
303
304 len = pb->buf_buf + pb->buf_size - pb->buf_get;
305 if (count > len) {
306 memcpy(buf, pb->buf_get, len);
307 memcpy(buf+len, pb->buf_buf, count - len);
308 pb->buf_get = pb->buf_buf + count - len;
309 } else {
310 memcpy(buf, pb->buf_get, count);
311 if (count < len)
312 pb->buf_get += count;
313 else /* count == len */
314 pb->buf_get = pb->buf_buf;
315 }
316
317 return count;
318 }
319
320 static int pl2303_vendor_read(__u16 value, __u16 index,
321 struct usb_serial *serial, unsigned char *buf)
322 {
323 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
324 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
325 value, index, buf, 1, 100);
326 dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE,
327 VENDOR_READ_REQUEST, value, index, res, buf[0]);
328 return res;
329 }
330
331 static int pl2303_vendor_write(__u16 value, __u16 index,
332 struct usb_serial *serial)
333 {
334 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
335 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
336 value, index, NULL, 0, 100);
337 dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE,
338 VENDOR_WRITE_REQUEST, value, index, res);
339 return res;
340 }
341
342 static int pl2303_startup(struct usb_serial *serial)
343 {
344 struct pl2303_private *priv;
345 enum pl2303_type type = type_0;
346 unsigned char *buf;
347 int i;
348
349 buf = kmalloc(10, GFP_KERNEL);
350 if (buf == NULL)
351 return -ENOMEM;
352
353 if (serial->dev->descriptor.bDeviceClass == 0x02)
354 type = type_0;
355 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
356 type = HX;
357 else if (serial->dev->descriptor.bDeviceClass == 0x00)
358 type = type_1;
359 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
360 type = type_1;
361 dbg("device type: %d", type);
362
363 for (i = 0; i < serial->num_ports; ++i) {
364 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
365 if (!priv)
366 goto cleanup;
367 spin_lock_init(&priv->lock);
368 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
369 if (priv->buf == NULL) {
370 kfree(priv);
371 goto cleanup;
372 }
373 init_waitqueue_head(&priv->delta_msr_wait);
374 priv->type = type;
375 usb_set_serial_port_data(serial->port[i], priv);
376 }
377
378 pl2303_vendor_read(0x8484, 0, serial, buf);
379 pl2303_vendor_write(0x0404, 0, serial);
380 pl2303_vendor_read(0x8484, 0, serial, buf);
381 pl2303_vendor_read(0x8383, 0, serial, buf);
382 pl2303_vendor_read(0x8484, 0, serial, buf);
383 pl2303_vendor_write(0x0404, 1, serial);
384 pl2303_vendor_read(0x8484, 0, serial, buf);
385 pl2303_vendor_read(0x8383, 0, serial, buf);
386 pl2303_vendor_write(0, 1, serial);
387 pl2303_vendor_write(1, 0, serial);
388 if (type == HX)
389 pl2303_vendor_write(2, 0x44, serial);
390 else
391 pl2303_vendor_write(2, 0x24, serial);
392
393 kfree(buf);
394 return 0;
395
396 cleanup:
397 kfree(buf);
398 for (--i; i>=0; --i) {
399 priv = usb_get_serial_port_data(serial->port[i]);
400 pl2303_buf_free(priv->buf);
401 kfree(priv);
402 usb_set_serial_port_data(serial->port[i], NULL);
403 }
404 return -ENOMEM;
405 }
406
407 static int set_control_lines(struct usb_device *dev, u8 value)
408 {
409 int retval;
410
411 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
412 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
413 value, 0, NULL, 0, 100);
414 dbg("%s - value = %d, retval = %d", __func__, value, retval);
415 return retval;
416 }
417
418 static void pl2303_send(struct usb_serial_port *port)
419 {
420 int count, result;
421 struct pl2303_private *priv = usb_get_serial_port_data(port);
422 unsigned long flags;
423
424 dbg("%s - port %d", __func__, port->number);
425
426 spin_lock_irqsave(&priv->lock, flags);
427
428 if (priv->write_urb_in_use) {
429 spin_unlock_irqrestore(&priv->lock, flags);
430 return;
431 }
432
433 count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
434 port->bulk_out_size);
435
436 if (count == 0) {
437 spin_unlock_irqrestore(&priv->lock, flags);
438 return;
439 }
440
441 priv->write_urb_in_use = 1;
442
443 spin_unlock_irqrestore(&priv->lock, flags);
444
445 usb_serial_debug_data(debug, &port->dev, __func__, count,
446 port->write_urb->transfer_buffer);
447
448 port->write_urb->transfer_buffer_length = count;
449 port->write_urb->dev = port->serial->dev;
450 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
451 if (result) {
452 dev_err(&port->dev, "%s - failed submitting write urb,"
453 " error %d\n", __func__, result);
454 priv->write_urb_in_use = 0;
455 // TODO: reschedule pl2303_send
456 }
457
458 usb_serial_port_softint(port);
459 }
460
461 static int pl2303_write(struct usb_serial_port *port, const unsigned char *buf,
462 int count)
463 {
464 struct pl2303_private *priv = usb_get_serial_port_data(port);
465 unsigned long flags;
466
467 dbg("%s - port %d, %d bytes", __func__, port->number, count);
468
469 if (!count)
470 return count;
471
472 spin_lock_irqsave(&priv->lock, flags);
473 count = pl2303_buf_put(priv->buf, buf, count);
474 spin_unlock_irqrestore(&priv->lock, flags);
475
476 pl2303_send(port);
477
478 return count;
479 }
480
481 static int pl2303_write_room(struct usb_serial_port *port)
482 {
483 struct pl2303_private *priv = usb_get_serial_port_data(port);
484 int room = 0;
485 unsigned long flags;
486
487 dbg("%s - port %d", __func__, port->number);
488
489 spin_lock_irqsave(&priv->lock, flags);
490 room = pl2303_buf_space_avail(priv->buf);
491 spin_unlock_irqrestore(&priv->lock, flags);
492
493 dbg("%s - returns %d", __func__, room);
494 return room;
495 }
496
497 static int pl2303_chars_in_buffer(struct usb_serial_port *port)
498 {
499 struct pl2303_private *priv = usb_get_serial_port_data(port);
500 int chars = 0;
501 unsigned long flags;
502
503 dbg("%s - port %d", __func__, port->number);
504
505 spin_lock_irqsave(&priv->lock, flags);
506 chars = pl2303_buf_data_avail(priv->buf);
507 spin_unlock_irqrestore(&priv->lock, flags);
508
509 dbg("%s - returns %d", __func__, chars);
510 return chars;
511 }
512
513 static void pl2303_set_termios(struct usb_serial_port *port,
514 struct ktermios *old_termios)
515 {
516 struct usb_serial *serial = port->serial;
517 struct pl2303_private *priv = usb_get_serial_port_data(port);
518 unsigned long flags;
519 unsigned int cflag;
520 unsigned char *buf;
521 int baud;
522 int i;
523 u8 control;
524
525 dbg("%s - port %d", __func__, port->number);
526
527 spin_lock_irqsave(&priv->lock, flags);
528 if (!priv->termios_initialized) {
529 *(port->tty->termios) = tty_std_termios;
530 port->tty->termios->c_cflag = B9600 | CS8 | CREAD |
531 HUPCL | CLOCAL;
532 port->tty->termios->c_ispeed = 9600;
533 port->tty->termios->c_ospeed = 9600;
534 priv->termios_initialized = 1;
535 }
536 spin_unlock_irqrestore(&priv->lock, flags);
537
538 /* The PL2303 is reported to lose bytes if you change
539 serial settings even to the same values as before. Thus
540 we actually need to filter in this specific case */
541
542 if (!tty_termios_hw_change(port->tty->termios, old_termios))
543 return;
544
545 cflag = port->tty->termios->c_cflag;
546
547 buf = kzalloc(7, GFP_KERNEL);
548 if (!buf) {
549 dev_err(&port->dev, "%s - out of memory.\n", __func__);
550 /* Report back no change occurred */
551 *port->tty->termios = *old_termios;
552 return;
553 }
554
555 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
556 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
557 0, 0, buf, 7, 100);
558 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
559 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
560
561 if (cflag & CSIZE) {
562 switch (cflag & CSIZE) {
563 case CS5: buf[6] = 5; break;
564 case CS6: buf[6] = 6; break;
565 case CS7: buf[6] = 7; break;
566 default:
567 case CS8: buf[6] = 8; break;
568 }
569 dbg("%s - data bits = %d", __func__, buf[6]);
570 }
571
572 baud = tty_get_baud_rate(port->tty);;
573 dbg("%s - baud = %d", __func__, baud);
574 if (baud) {
575 buf[0] = baud & 0xff;
576 buf[1] = (baud >> 8) & 0xff;
577 buf[2] = (baud >> 16) & 0xff;
578 buf[3] = (baud >> 24) & 0xff;
579 }
580
581 /* For reference buf[4]=0 is 1 stop bits */
582 /* For reference buf[4]=1 is 1.5 stop bits */
583 /* For reference buf[4]=2 is 2 stop bits */
584 if (cflag & CSTOPB) {
585 buf[4] = 2;
586 dbg("%s - stop bits = 2", __func__);
587 } else {
588 buf[4] = 0;
589 dbg("%s - stop bits = 1", __func__);
590 }
591
592 if (cflag & PARENB) {
593 /* For reference buf[5]=0 is none parity */
594 /* For reference buf[5]=1 is odd parity */
595 /* For reference buf[5]=2 is even parity */
596 /* For reference buf[5]=3 is mark parity */
597 /* For reference buf[5]=4 is space parity */
598 if (cflag & PARODD) {
599 buf[5] = 1;
600 dbg("%s - parity = odd", __func__);
601 } else {
602 buf[5] = 2;
603 dbg("%s - parity = even", __func__);
604 }
605 } else {
606 buf[5] = 0;
607 dbg("%s - parity = none", __func__);
608 }
609
610 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
611 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
612 0, 0, buf, 7, 100);
613 dbg("0x21:0x20:0:0 %d", i);
614
615 /* change control lines if we are switching to or from B0 */
616 spin_lock_irqsave(&priv->lock, flags);
617 control = priv->line_control;
618 if ((cflag & CBAUD) == B0)
619 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
620 else
621 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
622 if (control != priv->line_control) {
623 control = priv->line_control;
624 spin_unlock_irqrestore(&priv->lock, flags);
625 set_control_lines(serial->dev, control);
626 } else {
627 spin_unlock_irqrestore(&priv->lock, flags);
628 }
629
630 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
631
632 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
633 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
634 0, 0, buf, 7, 100);
635 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
636 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
637
638 if (cflag & CRTSCTS) {
639 if (priv->type == HX)
640 pl2303_vendor_write(0x0, 0x61, serial);
641 else
642 pl2303_vendor_write(0x0, 0x41, serial);
643 } else {
644 pl2303_vendor_write(0x0, 0x0, serial);
645 }
646
647 /* FIXME: Need to read back resulting baud rate */
648 if (baud)
649 tty_encode_baud_rate(port->tty, baud, baud);
650
651 kfree(buf);
652 }
653
654 static void pl2303_close(struct usb_serial_port *port, struct file *filp)
655 {
656 struct pl2303_private *priv = usb_get_serial_port_data(port);
657 unsigned long flags;
658 unsigned int c_cflag;
659 int bps;
660 long timeout;
661 wait_queue_t wait;
662
663 dbg("%s - port %d", __func__, port->number);
664
665 /* wait for data to drain from the buffer */
666 spin_lock_irqsave(&priv->lock, flags);
667 timeout = PL2303_CLOSING_WAIT;
668 init_waitqueue_entry(&wait, current);
669 add_wait_queue(&port->tty->write_wait, &wait);
670 for (;;) {
671 set_current_state(TASK_INTERRUPTIBLE);
672 if (pl2303_buf_data_avail(priv->buf) == 0 ||
673 timeout == 0 || signal_pending(current) ||
674 port->serial->disconnected)
675 break;
676 spin_unlock_irqrestore(&priv->lock, flags);
677 timeout = schedule_timeout(timeout);
678 spin_lock_irqsave(&priv->lock, flags);
679 }
680 set_current_state(TASK_RUNNING);
681 remove_wait_queue(&port->tty->write_wait, &wait);
682 /* clear out any remaining data in the buffer */
683 pl2303_buf_clear(priv->buf);
684 spin_unlock_irqrestore(&priv->lock, flags);
685
686 /* wait for characters to drain from the device */
687 /* (this is long enough for the entire 256 byte */
688 /* pl2303 hardware buffer to drain with no flow */
689 /* control for data rates of 1200 bps or more, */
690 /* for lower rates we should really know how much */
691 /* data is in the buffer to compute a delay */
692 /* that is not unnecessarily long) */
693 bps = tty_get_baud_rate(port->tty);
694 if (bps > 1200)
695 timeout = max((HZ*2560)/bps,HZ/10);
696 else
697 timeout = 2*HZ;
698 schedule_timeout_interruptible(timeout);
699
700 /* shutdown our urbs */
701 dbg("%s - shutting down urbs", __func__);
702 usb_kill_urb(port->write_urb);
703 usb_kill_urb(port->read_urb);
704 usb_kill_urb(port->interrupt_in_urb);
705
706 if (port->tty) {
707 c_cflag = port->tty->termios->c_cflag;
708 if (c_cflag & HUPCL) {
709 /* drop DTR and RTS */
710 spin_lock_irqsave(&priv->lock, flags);
711 priv->line_control = 0;
712 spin_unlock_irqrestore(&priv->lock, flags);
713 set_control_lines(port->serial->dev, 0);
714 }
715 }
716 }
717
718 static int pl2303_open(struct usb_serial_port *port, struct file *filp)
719 {
720 struct ktermios tmp_termios;
721 struct usb_serial *serial = port->serial;
722 struct pl2303_private *priv = usb_get_serial_port_data(port);
723 int result;
724
725 dbg("%s - port %d", __func__, port->number);
726
727 if (priv->type != HX) {
728 usb_clear_halt(serial->dev, port->write_urb->pipe);
729 usb_clear_halt(serial->dev, port->read_urb->pipe);
730 } else {
731 /* reset upstream data pipes */
732 pl2303_vendor_write(8, 0, serial);
733 pl2303_vendor_write(9, 0, serial);
734 }
735
736 /* Setup termios */
737 if (port->tty) {
738 pl2303_set_termios(port, &tmp_termios);
739 }
740
741 //FIXME: need to assert RTS and DTR if CRTSCTS off
742
743 dbg("%s - submitting read urb", __func__);
744 port->read_urb->dev = serial->dev;
745 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
746 if (result) {
747 dev_err(&port->dev, "%s - failed submitting read urb,"
748 " error %d\n", __func__, result);
749 pl2303_close(port, NULL);
750 return -EPROTO;
751 }
752
753 dbg("%s - submitting interrupt urb", __func__);
754 port->interrupt_in_urb->dev = serial->dev;
755 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
756 if (result) {
757 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
758 " error %d\n", __func__, result);
759 pl2303_close(port, NULL);
760 return -EPROTO;
761 }
762 return 0;
763 }
764
765 static int pl2303_tiocmset(struct usb_serial_port *port, struct file *file,
766 unsigned int set, unsigned int clear)
767 {
768 struct pl2303_private *priv = usb_get_serial_port_data(port);
769 unsigned long flags;
770 u8 control;
771
772 if (!usb_get_intfdata(port->serial->interface))
773 return -ENODEV;
774
775 spin_lock_irqsave(&priv->lock, flags);
776 if (set & TIOCM_RTS)
777 priv->line_control |= CONTROL_RTS;
778 if (set & TIOCM_DTR)
779 priv->line_control |= CONTROL_DTR;
780 if (clear & TIOCM_RTS)
781 priv->line_control &= ~CONTROL_RTS;
782 if (clear & TIOCM_DTR)
783 priv->line_control &= ~CONTROL_DTR;
784 control = priv->line_control;
785 spin_unlock_irqrestore(&priv->lock, flags);
786
787 return set_control_lines(port->serial->dev, control);
788 }
789
790 static int pl2303_tiocmget(struct usb_serial_port *port, struct file *file)
791 {
792 struct pl2303_private *priv = usb_get_serial_port_data(port);
793 unsigned long flags;
794 unsigned int mcr;
795 unsigned int status;
796 unsigned int result;
797
798 dbg("%s (%d)", __func__, port->number);
799
800 if (!usb_get_intfdata(port->serial->interface))
801 return -ENODEV;
802
803 spin_lock_irqsave(&priv->lock, flags);
804 mcr = priv->line_control;
805 status = priv->line_status;
806 spin_unlock_irqrestore(&priv->lock, flags);
807
808 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
809 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
810 | ((status & UART_CTS) ? TIOCM_CTS : 0)
811 | ((status & UART_DSR) ? TIOCM_DSR : 0)
812 | ((status & UART_RING) ? TIOCM_RI : 0)
813 | ((status & UART_DCD) ? TIOCM_CD : 0);
814
815 dbg("%s - result = %x", __func__, result);
816
817 return result;
818 }
819
820 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
821 {
822 struct pl2303_private *priv = usb_get_serial_port_data(port);
823 unsigned long flags;
824 unsigned int prevstatus;
825 unsigned int status;
826 unsigned int changed;
827
828 spin_lock_irqsave(&priv->lock, flags);
829 prevstatus = priv->line_status;
830 spin_unlock_irqrestore(&priv->lock, flags);
831
832 while (1) {
833 interruptible_sleep_on(&priv->delta_msr_wait);
834 /* see if a signal did it */
835 if (signal_pending(current))
836 return -ERESTARTSYS;
837
838 spin_lock_irqsave(&priv->lock, flags);
839 status = priv->line_status;
840 spin_unlock_irqrestore(&priv->lock, flags);
841
842 changed=prevstatus^status;
843
844 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
845 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
846 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
847 ((arg & TIOCM_CTS) && (changed & UART_CTS)) ) {
848 return 0;
849 }
850 prevstatus = status;
851 }
852 /* NOTREACHED */
853 return 0;
854 }
855
856 static int pl2303_ioctl(struct usb_serial_port *port, struct file *file,
857 unsigned int cmd, unsigned long arg)
858 {
859 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
860
861 switch (cmd) {
862 case TIOCMIWAIT:
863 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
864 return wait_modem_info(port, arg);
865
866 default:
867 dbg("%s not supported = 0x%04x", __func__, cmd);
868 break;
869 }
870
871 return -ENOIOCTLCMD;
872 }
873
874 static void pl2303_break_ctl(struct usb_serial_port *port, int break_state)
875 {
876 struct usb_serial *serial = port->serial;
877 u16 state;
878 int result;
879
880 dbg("%s - port %d", __func__, port->number);
881
882 if (break_state == 0)
883 state = BREAK_OFF;
884 else
885 state = BREAK_ON;
886 dbg("%s - turning break %s", __func__, state==BREAK_OFF ? "off" : "on");
887
888 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
889 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
890 0, NULL, 0, 100);
891 if (result)
892 dbg("%s - error sending break = %d", __func__, result);
893 }
894
895 static void pl2303_shutdown(struct usb_serial *serial)
896 {
897 int i;
898 struct pl2303_private *priv;
899
900 dbg("%s", __func__);
901
902 for (i = 0; i < serial->num_ports; ++i) {
903 priv = usb_get_serial_port_data(serial->port[i]);
904 if (priv) {
905 pl2303_buf_free(priv->buf);
906 kfree(priv);
907 usb_set_serial_port_data(serial->port[i], NULL);
908 }
909 }
910 }
911
912 static void pl2303_update_line_status(struct usb_serial_port *port,
913 unsigned char *data,
914 unsigned int actual_length)
915 {
916
917 struct pl2303_private *priv = usb_get_serial_port_data(port);
918 unsigned long flags;
919 u8 status_idx = UART_STATE;
920 u8 length = UART_STATE + 1;
921 u16 idv, idp;
922
923 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
924 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
925
926
927 if (idv == SIEMENS_VENDOR_ID) {
928 if (idp == SIEMENS_PRODUCT_ID_X65 ||
929 idp == SIEMENS_PRODUCT_ID_SX1 ||
930 idp == SIEMENS_PRODUCT_ID_X75) {
931
932 length = 1;
933 status_idx = 0;
934 }
935 }
936
937 if (actual_length < length)
938 return;
939
940 /* Save off the uart status for others to look at */
941 spin_lock_irqsave(&priv->lock, flags);
942 priv->line_status = data[status_idx];
943 spin_unlock_irqrestore(&priv->lock, flags);
944 wake_up_interruptible(&priv->delta_msr_wait);
945 }
946
947 static void pl2303_read_int_callback(struct urb *urb)
948 {
949 struct usb_serial_port *port = urb->context;
950 unsigned char *data = urb->transfer_buffer;
951 unsigned int actual_length = urb->actual_length;
952 int status = urb->status;
953 int retval;
954
955 dbg("%s (%d)", __func__, port->number);
956
957 switch (status) {
958 case 0:
959 /* success */
960 break;
961 case -ECONNRESET:
962 case -ENOENT:
963 case -ESHUTDOWN:
964 /* this urb is terminated, clean up */
965 dbg("%s - urb shutting down with status: %d", __func__,
966 status);
967 return;
968 default:
969 dbg("%s - nonzero urb status received: %d", __func__,
970 status);
971 goto exit;
972 }
973
974 usb_serial_debug_data(debug, &port->dev, __func__,
975 urb->actual_length, urb->transfer_buffer);
976
977 pl2303_update_line_status(port, data, actual_length);
978
979 exit:
980 retval = usb_submit_urb(urb, GFP_ATOMIC);
981 if (retval)
982 dev_err(&urb->dev->dev,
983 "%s - usb_submit_urb failed with result %d\n",
984 __func__, retval);
985 }
986
987 static void pl2303_read_bulk_callback(struct urb *urb)
988 {
989 struct usb_serial_port *port = urb->context;
990 struct pl2303_private *priv = usb_get_serial_port_data(port);
991 struct tty_struct *tty;
992 unsigned char *data = urb->transfer_buffer;
993 unsigned long flags;
994 int i;
995 int result;
996 int status = urb->status;
997 u8 line_status;
998 char tty_flag;
999
1000 dbg("%s - port %d", __func__, port->number);
1001
1002 if (status) {
1003 dbg("%s - urb status = %d", __func__, status);
1004 if (!port->open_count) {
1005 dbg("%s - port is closed, exiting.", __func__);
1006 return;
1007 }
1008 if (status == -EPROTO) {
1009 /* PL2303 mysteriously fails with -EPROTO reschedule
1010 * the read */
1011 dbg("%s - caught -EPROTO, resubmitting the urb",
1012 __func__);
1013 urb->dev = port->serial->dev;
1014 result = usb_submit_urb(urb, GFP_ATOMIC);
1015 if (result)
1016 dev_err(&urb->dev->dev, "%s - failed"
1017 " resubmitting read urb, error %d\n",
1018 __func__, result);
1019 return;
1020 }
1021 dbg("%s - unable to handle the error, exiting.", __func__);
1022 return;
1023 }
1024
1025 usb_serial_debug_data(debug, &port->dev, __func__,
1026 urb->actual_length, data);
1027
1028 /* get tty_flag from status */
1029 tty_flag = TTY_NORMAL;
1030
1031 spin_lock_irqsave(&priv->lock, flags);
1032 line_status = priv->line_status;
1033 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1034 spin_unlock_irqrestore(&priv->lock, flags);
1035 wake_up_interruptible(&priv->delta_msr_wait);
1036
1037 /* break takes precedence over parity, */
1038 /* which takes precedence over framing errors */
1039 if (line_status & UART_BREAK_ERROR )
1040 tty_flag = TTY_BREAK;
1041 else if (line_status & UART_PARITY_ERROR)
1042 tty_flag = TTY_PARITY;
1043 else if (line_status & UART_FRAME_ERROR)
1044 tty_flag = TTY_FRAME;
1045 dbg("%s - tty_flag = %d", __func__, tty_flag);
1046
1047 tty = port->tty;
1048 if (tty && urb->actual_length) {
1049 tty_buffer_request_room(tty, urb->actual_length + 1);
1050 /* overrun is special, not associated with a char */
1051 if (line_status & UART_OVERRUN_ERROR)
1052 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1053 for (i = 0; i < urb->actual_length; ++i)
1054 tty_insert_flip_char(tty, data[i], tty_flag);
1055 tty_flip_buffer_push(tty);
1056 }
1057
1058 /* Schedule the next read _if_ we are still open */
1059 if (port->open_count) {
1060 urb->dev = port->serial->dev;
1061 result = usb_submit_urb(urb, GFP_ATOMIC);
1062 if (result)
1063 dev_err(&urb->dev->dev, "%s - failed resubmitting"
1064 " read urb, error %d\n", __func__, result);
1065 }
1066
1067 return;
1068 }
1069
1070 static void pl2303_write_bulk_callback(struct urb *urb)
1071 {
1072 struct usb_serial_port *port = urb->context;
1073 struct pl2303_private *priv = usb_get_serial_port_data(port);
1074 int result;
1075 int status = urb->status;
1076
1077 dbg("%s - port %d", __func__, port->number);
1078
1079 switch (status) {
1080 case 0:
1081 /* success */
1082 break;
1083 case -ECONNRESET:
1084 case -ENOENT:
1085 case -ESHUTDOWN:
1086 /* this urb is terminated, clean up */
1087 dbg("%s - urb shutting down with status: %d", __func__,
1088 status);
1089 priv->write_urb_in_use = 0;
1090 return;
1091 default:
1092 /* error in the urb, so we have to resubmit it */
1093 dbg("%s - Overflow in write", __func__);
1094 dbg("%s - nonzero write bulk status received: %d", __func__,
1095 status);
1096 port->write_urb->transfer_buffer_length = 1;
1097 port->write_urb->dev = port->serial->dev;
1098 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1099 if (result)
1100 dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1101 " urb, error %d\n", __func__, result);
1102 else
1103 return;
1104 }
1105
1106 priv->write_urb_in_use = 0;
1107
1108 /* send any buffered data */
1109 pl2303_send(port);
1110 }
1111
1112 /* All of the device info needed for the PL2303 SIO serial converter */
1113 static struct usb_serial_driver pl2303_device = {
1114 .driver = {
1115 .owner = THIS_MODULE,
1116 .name = "pl2303",
1117 },
1118 .id_table = id_table,
1119 .usb_driver = &pl2303_driver,
1120 .num_ports = 1,
1121 .open = pl2303_open,
1122 .close = pl2303_close,
1123 .write = pl2303_write,
1124 .ioctl = pl2303_ioctl,
1125 .break_ctl = pl2303_break_ctl,
1126 .set_termios = pl2303_set_termios,
1127 .tiocmget = pl2303_tiocmget,
1128 .tiocmset = pl2303_tiocmset,
1129 .read_bulk_callback = pl2303_read_bulk_callback,
1130 .read_int_callback = pl2303_read_int_callback,
1131 .write_bulk_callback = pl2303_write_bulk_callback,
1132 .write_room = pl2303_write_room,
1133 .chars_in_buffer = pl2303_chars_in_buffer,
1134 .attach = pl2303_startup,
1135 .shutdown = pl2303_shutdown,
1136 };
1137
1138 static int __init pl2303_init(void)
1139 {
1140 int retval;
1141
1142 retval = usb_serial_register(&pl2303_device);
1143 if (retval)
1144 goto failed_usb_serial_register;
1145 retval = usb_register(&pl2303_driver);
1146 if (retval)
1147 goto failed_usb_register;
1148 info(DRIVER_DESC);
1149 return 0;
1150 failed_usb_register:
1151 usb_serial_deregister(&pl2303_device);
1152 failed_usb_serial_register:
1153 return retval;
1154 }
1155
1156 static void __exit pl2303_exit(void)
1157 {
1158 usb_deregister(&pl2303_driver);
1159 usb_serial_deregister(&pl2303_device);
1160 }
1161
1162 module_init(pl2303_init);
1163 module_exit(pl2303_exit);
1164
1165 MODULE_DESCRIPTION(DRIVER_DESC);
1166 MODULE_LICENSE("GPL");
1167
1168 module_param(debug, bool, S_IRUGO | S_IWUSR);
1169 MODULE_PARM_DESC(debug, "Debug enabled or not");
1170
kmemtrace - Kernel memory tracer