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