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