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