blob: ff4a174fa5de8e536572584b32b08a41defc7e1e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Prolific PL2303 USB to serial adaptor driver
3 *
Greg Kroah-Hartman4d0dce32007-06-12 11:43:37 -07004 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Copyright (C) 2003 IBM Corp.
6 *
7 * Original driver for 2.2.x by anonymous
8 *
Greg Kroah-Hartman4d0dce32007-06-12 11:43:37 -07009 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 *
Alan Cox3a0f43e2008-07-22 11:14:49 +010013 * See Documentation/usb/usb-serial.txt for more information on using this
14 * driver
Linus Torvalds1da177e2005-04-16 15:20:36 -070015 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070016 */
17
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#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>
Alan Cox3a0f43e2008-07-22 11:14:49 +010029#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/usb.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070031#include <linux/usb/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "pl2303.h"
33
34/*
35 * Version Information
36 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
38
Rusty Russell90ab5ee2012-01-13 09:32:20 +103039static bool debug;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
41#define PL2303_CLOSING_WAIT (30*HZ)
42
Németh Márton7d40d7e2010-01-10 15:34:24 +010043static const struct usb_device_id id_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
Peter Moulder3d861492006-06-19 22:47:49 +100046 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
Max Arnoldb483b6a2008-03-20 16:43:56 +070049 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
Steve Murphy4be2fa12008-05-23 23:39:05 +053050 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
Greg Kroah-Hartman727df352008-07-02 15:25:41 -050051 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
Simone Contini18344a12010-04-12 23:25:10 +020052 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
Dario Lombardo96a3e792011-01-21 15:35:19 +010053 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
Masakazu Mokuno8a28dea2007-10-23 13:51:57 +090055 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
Linus Torvalds1da177e2005-04-16 15:20:36 -070056 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
57 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
58 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
59 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
60 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
Wang Jun58381712006-04-19 16:32:07 +080061 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
63 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
64 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
65 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
66 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
67 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
68 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
69 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
Luiz Fernando Capitulinoa8310f32005-11-17 09:47:32 -080070 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
Linus Torvalds1da177e2005-04-16 15:20:36 -070071 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
Luiz Fernando Capitulinoa8310f32005-11-17 09:47:32 -080072 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
Andreas Loible7beb662007-08-24 01:51:11 +020073 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
Alan Cox912299f2009-04-06 17:35:12 +010074 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
Peter Favrholdtacbb36f2005-04-18 17:39:32 -070075 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
Christian Lindnerc6c27722006-02-01 14:10:52 +010076 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
77 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
Denis MONTERRAT6cceb052006-01-19 14:52:38 +010078 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
Christian Lindnerc6c27722006-02-01 14:10:52 +010079 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
Dick Streefland491b04c2006-03-01 00:53:33 -080080 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
Matthew Meno3b928472006-06-21 15:25:53 -040081 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
Kim Oldfieldb7aa94b2006-07-25 15:54:59 +100082 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
Johannes Steingraeber8fd80132006-09-16 16:17:34 +020083 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
YOSHIFUJI Hideaki2d94b982007-01-26 22:51:38 +090084 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
Magnus Damm9e3285d2007-11-08 16:45:46 +090085 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
Damien Stuartcc311ee2008-01-06 13:51:39 -050086 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
Matthew Arnold7c992002008-12-13 22:42:53 +110087 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
Mike Provencheraf4b8512008-12-16 14:30:14 -060088 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
Gianpaolo Cugola8540d662009-06-05 22:57:52 +020089 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
Jef Driesenf36ecd52010-08-09 15:55:32 +020090 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
Khanh-Dang Nguyen Thu Lam49276562009-07-28 19:41:17 +020091 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
Pawel Ludwikow35904e62009-08-27 14:15:50 +020092 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
Manuel Jander9a61d722010-03-29 23:51:57 +020093 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
Eric Benoit598f0b72011-09-24 02:04:50 -040094 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 { } /* Terminating entry */
96};
97
Thiago Galesi372db8a2006-07-31 15:39:27 -030098MODULE_DEVICE_TABLE(usb, id_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
100static struct usb_driver pl2303_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 .name = "pl2303",
102 .probe = usb_serial_probe,
103 .disconnect = usb_serial_disconnect,
104 .id_table = id_table,
Sarah Sharpfcf9e552007-12-14 14:09:30 -0800105 .suspend = usb_serial_suspend,
106 .resume = usb_serial_resume,
Sarah Sharpfcf9e552007-12-14 14:09:30 -0800107 .supports_autosuspend = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108};
109
110#define SET_LINE_REQUEST_TYPE 0x21
111#define SET_LINE_REQUEST 0x20
112
113#define SET_CONTROL_REQUEST_TYPE 0x21
114#define SET_CONTROL_REQUEST 0x22
115#define CONTROL_DTR 0x01
116#define CONTROL_RTS 0x02
117
118#define BREAK_REQUEST_TYPE 0x21
Alan Cox3a0f43e2008-07-22 11:14:49 +0100119#define BREAK_REQUEST 0x23
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120#define BREAK_ON 0xffff
121#define BREAK_OFF 0x0000
122
123#define GET_LINE_REQUEST_TYPE 0xa1
124#define GET_LINE_REQUEST 0x21
125
126#define VENDOR_WRITE_REQUEST_TYPE 0x40
127#define VENDOR_WRITE_REQUEST 0x01
128
129#define VENDOR_READ_REQUEST_TYPE 0xc0
130#define VENDOR_READ_REQUEST 0x01
131
132#define UART_STATE 0x08
133#define UART_STATE_TRANSIENT_MASK 0x74
134#define UART_DCD 0x01
135#define UART_DSR 0x02
136#define UART_BREAK_ERROR 0x04
137#define UART_RING 0x08
138#define UART_FRAME_ERROR 0x10
139#define UART_PARITY_ERROR 0x20
140#define UART_OVERRUN_ERROR 0x40
141#define UART_CTS 0x80
142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
144enum pl2303_type {
145 type_0, /* don't know the difference between type 0 and */
146 type_1, /* type 1, until someone from prolific tells us... */
147 HX, /* HX version of the pl2303 chip */
148};
149
150struct pl2303_private {
151 spinlock_t lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 wait_queue_head_t delta_msr_wait;
153 u8 line_control;
154 u8 line_status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155 enum pl2303_type type;
156};
157
Sarah Sharpeb44da02007-12-14 14:08:00 -0800158static int pl2303_vendor_read(__u16 value, __u16 index,
159 struct usb_serial *serial, unsigned char *buf)
160{
161 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
162 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
163 value, index, buf, 1, 100);
164 dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE,
165 VENDOR_READ_REQUEST, value, index, res, buf[0]);
166 return res;
167}
168
169static int pl2303_vendor_write(__u16 value, __u16 index,
170 struct usb_serial *serial)
171{
172 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
173 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
174 value, index, NULL, 0, 100);
175 dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE,
176 VENDOR_WRITE_REQUEST, value, index, res);
177 return res;
178}
179
Thiago Galesi372db8a2006-07-31 15:39:27 -0300180static int pl2303_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181{
182 struct pl2303_private *priv;
183 enum pl2303_type type = type_0;
Sarah Sharp3e152502007-12-14 14:08:35 -0800184 unsigned char *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 int i;
186
Sarah Sharp3e152502007-12-14 14:08:35 -0800187 buf = kmalloc(10, GFP_KERNEL);
188 if (buf == NULL)
189 return -ENOMEM;
190
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 if (serial->dev->descriptor.bDeviceClass == 0x02)
192 type = type_0;
193 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
194 type = HX;
195 else if (serial->dev->descriptor.bDeviceClass == 0x00)
196 type = type_1;
197 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
198 type = type_1;
199 dbg("device type: %d", type);
200
201 for (i = 0; i < serial->num_ports; ++i) {
Eric Sesterhenn80b6ca42006-02-27 21:29:43 +0100202 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 if (!priv)
204 goto cleanup;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 spin_lock_init(&priv->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 init_waitqueue_head(&priv->delta_msr_wait);
207 priv->type = type;
208 usb_set_serial_port_data(serial->port[i], priv);
209 }
Sarah Sharp3e152502007-12-14 14:08:35 -0800210
211 pl2303_vendor_read(0x8484, 0, serial, buf);
212 pl2303_vendor_write(0x0404, 0, serial);
213 pl2303_vendor_read(0x8484, 0, serial, buf);
214 pl2303_vendor_read(0x8383, 0, serial, buf);
215 pl2303_vendor_read(0x8484, 0, serial, buf);
216 pl2303_vendor_write(0x0404, 1, serial);
217 pl2303_vendor_read(0x8484, 0, serial, buf);
218 pl2303_vendor_read(0x8383, 0, serial, buf);
219 pl2303_vendor_write(0, 1, serial);
220 pl2303_vendor_write(1, 0, serial);
221 if (type == HX)
222 pl2303_vendor_write(2, 0x44, serial);
223 else
224 pl2303_vendor_write(2, 0x24, serial);
225
226 kfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 return 0;
228
229cleanup:
Sarah Sharp3e152502007-12-14 14:08:35 -0800230 kfree(buf);
Alan Cox3a0f43e2008-07-22 11:14:49 +0100231 for (--i; i >= 0; --i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 priv = usb_get_serial_port_data(serial->port[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 kfree(priv);
234 usb_set_serial_port_data(serial->port[i], NULL);
235 }
236 return -ENOMEM;
237}
238
Thiago Galesi372db8a2006-07-31 15:39:27 -0300239static int set_control_lines(struct usb_device *dev, u8 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240{
241 int retval;
Alan Cox3a0f43e2008-07-22 11:14:49 +0100242
Thiago Galesi372db8a2006-07-31 15:39:27 -0300243 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
244 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
245 value, 0, NULL, 0, 100);
Harvey Harrison441b62c2008-03-03 16:08:34 -0800246 dbg("%s - value = %d, retval = %d", __func__, value, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 return retval;
248}
249
Alan Cox95da3102008-07-22 11:09:07 +0100250static void pl2303_set_termios(struct tty_struct *tty,
251 struct usb_serial_port *port, struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252{
253 struct usb_serial *serial = port->serial;
254 struct pl2303_private *priv = usb_get_serial_port_data(port);
255 unsigned long flags;
256 unsigned int cflag;
257 unsigned char *buf;
258 int baud;
259 int i;
260 u8 control;
Frank Schaefer25b82862009-08-18 20:15:07 +0200261 const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
262 4800, 7200, 9600, 14400, 19200, 28800, 38400,
263 57600, 115200, 230400, 460800, 614400,
264 921600, 1228800, 2457600, 3000000, 6000000 };
265 int baud_floor, baud_ceil;
266 int k;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267
Harvey Harrison441b62c2008-03-03 16:08:34 -0800268 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269
Alan Coxbf5e5832008-01-08 14:55:51 +0000270 /* The PL2303 is reported to lose bytes if you change
271 serial settings even to the same values as before. Thus
272 we actually need to filter in this specific case */
273
Alan Cox95da3102008-07-22 11:09:07 +0100274 if (!tty_termios_hw_change(tty->termios, old_termios))
Alan Coxbf5e5832008-01-08 14:55:51 +0000275 return;
276
Alan Cox95da3102008-07-22 11:09:07 +0100277 cflag = tty->termios->c_cflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278
Thiago Galesi372db8a2006-07-31 15:39:27 -0300279 buf = kzalloc(7, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 if (!buf) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800281 dev_err(&port->dev, "%s - out of memory.\n", __func__);
Alan Coxa5b6f602008-04-08 17:16:06 +0100282 /* Report back no change occurred */
Alan Cox95da3102008-07-22 11:09:07 +0100283 *tty->termios = *old_termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 return;
285 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286
Thiago Galesi372db8a2006-07-31 15:39:27 -0300287 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
288 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
289 0, 0, buf, 7, 100);
290 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
291 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292
293 if (cflag & CSIZE) {
294 switch (cflag & CSIZE) {
Alan Cox3a0f43e2008-07-22 11:14:49 +0100295 case CS5:
296 buf[6] = 5;
297 break;
298 case CS6:
299 buf[6] = 6;
300 break;
301 case CS7:
302 buf[6] = 7;
303 break;
304 default:
305 case CS8:
306 buf[6] = 8;
307 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 }
Harvey Harrison441b62c2008-03-03 16:08:34 -0800309 dbg("%s - data bits = %d", __func__, buf[6]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 }
311
Frank Schaefer25b82862009-08-18 20:15:07 +0200312 /* For reference buf[0]:buf[3] baud rate value */
313 /* NOTE: Only the values defined in baud_sup are supported !
314 * => if unsupported values are set, the PL2303 seems to use
315 * 9600 baud (at least my PL2303X always does)
316 */
Alan Cox95da3102008-07-22 11:09:07 +0100317 baud = tty_get_baud_rate(tty);
Frank Schaefer25b82862009-08-18 20:15:07 +0200318 dbg("%s - baud requested = %d", __func__, baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 if (baud) {
Frank Schaefer25b82862009-08-18 20:15:07 +0200320 /* Set baudrate to nearest supported value */
321 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
322 if (baud_sup[k] / baud) {
323 baud_ceil = baud_sup[k];
324 if (k==0) {
325 baud = baud_ceil;
326 } else {
327 baud_floor = baud_sup[k-1];
328 if ((baud_ceil % baud)
329 > (baud % baud_floor))
330 baud = baud_floor;
331 else
332 baud = baud_ceil;
333 }
334 break;
335 }
336 }
337 if (baud > 1228800) {
338 /* type_0, type_1 only support up to 1228800 baud */
339 if (priv->type != HX)
340 baud = 1228800;
341 else if (baud > 6000000)
342 baud = 6000000;
343 }
344 dbg("%s - baud set = %d", __func__, baud);
Michał Sroczyński8d48fdf2011-07-05 21:53:35 +0200345 if (baud <= 115200) {
346 buf[0] = baud & 0xff;
347 buf[1] = (baud >> 8) & 0xff;
348 buf[2] = (baud >> 16) & 0xff;
349 buf[3] = (baud >> 24) & 0xff;
350 } else {
351 /* apparently the formula for higher speeds is:
352 * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
353 */
354 unsigned tmp = 12*1000*1000*32 / baud;
355 buf[3] = 0x80;
356 buf[2] = 0;
357 buf[1] = (tmp >= 256);
358 while (tmp >= 256) {
359 tmp >>= 2;
360 buf[1] <<= 1;
361 }
Michał Sroczyński8d48fdf2011-07-05 21:53:35 +0200362 buf[0] = tmp;
363 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 }
365
366 /* For reference buf[4]=0 is 1 stop bits */
367 /* For reference buf[4]=1 is 1.5 stop bits */
368 /* For reference buf[4]=2 is 2 stop bits */
369 if (cflag & CSTOPB) {
Frank Schaefer29cf1b72009-08-18 20:34:24 +0200370 /* NOTE: Comply with "real" UARTs / RS232:
371 * use 1.5 instead of 2 stop bits with 5 data bits
372 */
373 if ((cflag & CSIZE) == CS5) {
374 buf[4] = 1;
375 dbg("%s - stop bits = 1.5", __func__);
376 } else {
377 buf[4] = 2;
378 dbg("%s - stop bits = 2", __func__);
379 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700380 } else {
381 buf[4] = 0;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800382 dbg("%s - stop bits = 1", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 }
384
385 if (cflag & PARENB) {
386 /* For reference buf[5]=0 is none parity */
387 /* For reference buf[5]=1 is odd parity */
388 /* For reference buf[5]=2 is even parity */
389 /* For reference buf[5]=3 is mark parity */
390 /* For reference buf[5]=4 is space parity */
391 if (cflag & PARODD) {
Frank Schaefer6dd81b42009-08-18 20:31:11 +0200392 if (cflag & CMSPAR) {
393 buf[5] = 3;
394 dbg("%s - parity = mark", __func__);
395 } else {
396 buf[5] = 1;
397 dbg("%s - parity = odd", __func__);
398 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 } else {
Frank Schaefer6dd81b42009-08-18 20:31:11 +0200400 if (cflag & CMSPAR) {
401 buf[5] = 4;
402 dbg("%s - parity = space", __func__);
403 } else {
404 buf[5] = 2;
405 dbg("%s - parity = even", __func__);
406 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 }
408 } else {
409 buf[5] = 0;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800410 dbg("%s - parity = none", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 }
412
Thiago Galesi372db8a2006-07-31 15:39:27 -0300413 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
414 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
415 0, 0, buf, 7, 100);
416 dbg("0x21:0x20:0:0 %d", i);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
418 /* change control lines if we are switching to or from B0 */
419 spin_lock_irqsave(&priv->lock, flags);
420 control = priv->line_control;
421 if ((cflag & CBAUD) == B0)
422 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
423 else
424 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
425 if (control != priv->line_control) {
426 control = priv->line_control;
427 spin_unlock_irqrestore(&priv->lock, flags);
428 set_control_lines(serial->dev, control);
429 } else {
430 spin_unlock_irqrestore(&priv->lock, flags);
431 }
Thiago Galesi372db8a2006-07-31 15:39:27 -0300432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
434
Thiago Galesi372db8a2006-07-31 15:39:27 -0300435 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
436 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
437 0, 0, buf, 7, 100);
438 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
440
441 if (cflag & CRTSCTS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 if (priv->type == HX)
Sarah Sharpeb44da02007-12-14 14:08:00 -0800443 pl2303_vendor_write(0x0, 0x61, serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 else
Sarah Sharpeb44da02007-12-14 14:08:00 -0800445 pl2303_vendor_write(0x0, 0x41, serial);
t.sefzick715f9522007-04-25 15:05:22 +0200446 } else {
Sarah Sharpeb44da02007-12-14 14:08:00 -0800447 pl2303_vendor_write(0x0, 0x0, serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 }
449
Frank Schaefer25b82862009-08-18 20:15:07 +0200450 /* Save resulting baud rate */
Alan Coxdf64c472007-10-15 20:54:47 +0100451 if (baud)
Alan Cox95da3102008-07-22 11:09:07 +0100452 tty_encode_baud_rate(tty, baud, baud);
Alan Coxdf64c472007-10-15 20:54:47 +0100453
Thiago Galesi372db8a2006-07-31 15:39:27 -0300454 kfree(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455}
456
Alan Cox335f8512009-06-11 12:26:29 +0100457static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
Thiago Galesi572d3132006-07-29 10:46:37 -0300458{
459 struct pl2303_private *priv = usb_get_serial_port_data(port);
460 unsigned long flags;
Alan Cox335f8512009-06-11 12:26:29 +0100461 u8 control;
462
463 spin_lock_irqsave(&priv->lock, flags);
464 /* Change DTR and RTS */
465 if (on)
466 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
467 else
468 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
469 control = priv->line_control;
470 spin_unlock_irqrestore(&priv->lock, flags);
471 set_control_lines(port->serial->dev, control);
472}
473
474static void pl2303_close(struct usb_serial_port *port)
475{
Harvey Harrison441b62c2008-03-03 16:08:34 -0800476 dbg("%s - port %d", __func__, port->number);
Thiago Galesi572d3132006-07-29 10:46:37 -0300477
Johan Hovold8b0127b2010-03-17 23:06:04 +0100478 usb_serial_generic_close(port);
Thiago Galesi572d3132006-07-29 10:46:37 -0300479 usb_kill_urb(port->interrupt_in_urb);
Thiago Galesi572d3132006-07-29 10:46:37 -0300480}
481
Alan Coxa509a7e2009-09-19 13:13:26 -0700482static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483{
Alan Cox606d0992006-12-08 02:38:45 -0800484 struct ktermios tmp_termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 struct usb_serial *serial = port->serial;
486 struct pl2303_private *priv = usb_get_serial_port_data(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 int result;
488
Harvey Harrison441b62c2008-03-03 16:08:34 -0800489 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
Dariusz M16948992005-07-28 18:06:13 +0200491 if (priv->type != HX) {
492 usb_clear_halt(serial->dev, port->write_urb->pipe);
493 usb_clear_halt(serial->dev, port->read_urb->pipe);
Sarah Sharp3e152502007-12-14 14:08:35 -0800494 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 /* reset upstream data pipes */
Sarah Sharpeb44da02007-12-14 14:08:00 -0800496 pl2303_vendor_write(8, 0, serial);
497 pl2303_vendor_write(9, 0, serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 }
499
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 /* Setup termios */
Alan Cox95da3102008-07-22 11:09:07 +0100501 if (tty)
502 pl2303_set_termios(tty, port, &tmp_termios);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
Harvey Harrison441b62c2008-03-03 16:08:34 -0800504 dbg("%s - submitting interrupt urb", __func__);
Thiago Galesi372db8a2006-07-31 15:39:27 -0300505 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 if (result) {
Thiago Galesi372db8a2006-07-31 15:39:27 -0300507 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
Harvey Harrison441b62c2008-03-03 16:08:34 -0800508 " error %d\n", __func__, result);
Johan Hovolddb6e9182011-11-06 19:06:34 +0100509 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 }
Johan Hovoldd4691c32011-11-06 19:06:35 +0100511
Johan Hovoldf5230a52011-11-06 19:06:36 +0100512 result = usb_serial_generic_open(tty, port);
Johan Hovoldd4691c32011-11-06 19:06:35 +0100513 if (result) {
514 usb_kill_urb(port->interrupt_in_urb);
515 return result;
516 }
517
Alan Cox335f8512009-06-11 12:26:29 +0100518 port->port.drain_delay = 256;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 return 0;
520}
521
Alan Cox20b9d172011-02-14 16:26:50 +0000522static int pl2303_tiocmset(struct tty_struct *tty,
Thiago Galesi372db8a2006-07-31 15:39:27 -0300523 unsigned int set, unsigned int clear)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700524{
Alan Cox95da3102008-07-22 11:09:07 +0100525 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 struct pl2303_private *priv = usb_get_serial_port_data(port);
527 unsigned long flags;
528 u8 control;
529
Flavio Leitner6fdd8e82005-04-18 17:39:31 -0700530 if (!usb_get_intfdata(port->serial->interface))
531 return -ENODEV;
532
Thiago Galesi372db8a2006-07-31 15:39:27 -0300533 spin_lock_irqsave(&priv->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 if (set & TIOCM_RTS)
535 priv->line_control |= CONTROL_RTS;
536 if (set & TIOCM_DTR)
537 priv->line_control |= CONTROL_DTR;
538 if (clear & TIOCM_RTS)
539 priv->line_control &= ~CONTROL_RTS;
540 if (clear & TIOCM_DTR)
541 priv->line_control &= ~CONTROL_DTR;
542 control = priv->line_control;
Thiago Galesi372db8a2006-07-31 15:39:27 -0300543 spin_unlock_irqrestore(&priv->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544
Thiago Galesi372db8a2006-07-31 15:39:27 -0300545 return set_control_lines(port->serial->dev, control);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546}
547
Alan Cox60b33c12011-02-14 16:26:14 +0000548static int pl2303_tiocmget(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549{
Alan Cox95da3102008-07-22 11:09:07 +0100550 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 struct pl2303_private *priv = usb_get_serial_port_data(port);
552 unsigned long flags;
553 unsigned int mcr;
554 unsigned int status;
555 unsigned int result;
556
Harvey Harrison441b62c2008-03-03 16:08:34 -0800557 dbg("%s (%d)", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
Flavio Leitner6fdd8e82005-04-18 17:39:31 -0700559 if (!usb_get_intfdata(port->serial->interface))
560 return -ENODEV;
561
Thiago Galesi372db8a2006-07-31 15:39:27 -0300562 spin_lock_irqsave(&priv->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 mcr = priv->line_control;
564 status = priv->line_status;
Thiago Galesi372db8a2006-07-31 15:39:27 -0300565 spin_unlock_irqrestore(&priv->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
567 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
568 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
569 | ((status & UART_CTS) ? TIOCM_CTS : 0)
570 | ((status & UART_DSR) ? TIOCM_DSR : 0)
571 | ((status & UART_RING) ? TIOCM_RI : 0)
572 | ((status & UART_DCD) ? TIOCM_CD : 0);
573
Harvey Harrison441b62c2008-03-03 16:08:34 -0800574 dbg("%s - result = %x", __func__, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575
576 return result;
577}
578
Alan Cox335f8512009-06-11 12:26:29 +0100579static int pl2303_carrier_raised(struct usb_serial_port *port)
580{
581 struct pl2303_private *priv = usb_get_serial_port_data(port);
582 if (priv->line_status & UART_DCD)
583 return 1;
584 return 0;
585}
586
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
588{
589 struct pl2303_private *priv = usb_get_serial_port_data(port);
590 unsigned long flags;
591 unsigned int prevstatus;
592 unsigned int status;
593 unsigned int changed;
594
Thiago Galesi372db8a2006-07-31 15:39:27 -0300595 spin_lock_irqsave(&priv->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 prevstatus = priv->line_status;
Thiago Galesi372db8a2006-07-31 15:39:27 -0300597 spin_unlock_irqrestore(&priv->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598
599 while (1) {
600 interruptible_sleep_on(&priv->delta_msr_wait);
601 /* see if a signal did it */
602 if (signal_pending(current))
603 return -ERESTARTSYS;
Thiago Galesi372db8a2006-07-31 15:39:27 -0300604
605 spin_lock_irqsave(&priv->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 status = priv->line_status;
Thiago Galesi372db8a2006-07-31 15:39:27 -0300607 spin_unlock_irqrestore(&priv->lock, flags);
608
Alan Cox3a0f43e2008-07-22 11:14:49 +0100609 changed = prevstatus ^ status;
Thiago Galesi372db8a2006-07-31 15:39:27 -0300610
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
612 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
613 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
Alan Cox3a0f43e2008-07-22 11:14:49 +0100614 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 return 0;
616 }
617 prevstatus = status;
618 }
619 /* NOTREACHED */
620 return 0;
621}
622
Alan Cox00a0d0d2011-02-14 16:27:06 +0000623static int pl2303_ioctl(struct tty_struct *tty,
Thiago Galesi372db8a2006-07-31 15:39:27 -0300624 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625{
John Tsiombikas67b99462010-02-25 17:09:08 +0200626 struct serial_struct ser;
Alan Cox95da3102008-07-22 11:09:07 +0100627 struct usb_serial_port *port = tty->driver_data;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800628 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629
630 switch (cmd) {
John Tsiombikas67b99462010-02-25 17:09:08 +0200631 case TIOCGSERIAL:
632 memset(&ser, 0, sizeof ser);
633 ser.type = PORT_16654;
634 ser.line = port->serial->minor;
635 ser.port = port->number;
636 ser.baud_base = 460800;
637
638 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
639 return -EFAULT;
640
641 return 0;
642
Alan Cox3a0f43e2008-07-22 11:14:49 +0100643 case TIOCMIWAIT:
644 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
645 return wait_modem_info(port, arg);
646 default:
647 dbg("%s not supported = 0x%04x", __func__, cmd);
648 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 return -ENOIOCTLCMD;
651}
652
Alan Cox95da3102008-07-22 11:09:07 +0100653static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654{
Alan Cox95da3102008-07-22 11:09:07 +0100655 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 struct usb_serial *serial = port->serial;
657 u16 state;
658 int result;
659
Harvey Harrison441b62c2008-03-03 16:08:34 -0800660 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
662 if (break_state == 0)
663 state = BREAK_OFF;
664 else
665 state = BREAK_ON;
Alan Cox3a0f43e2008-07-22 11:14:49 +0100666 dbg("%s - turning break %s", __func__,
667 state == BREAK_OFF ? "off" : "on");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668
Thiago Galesi372db8a2006-07-31 15:39:27 -0300669 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
670 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
671 0, NULL, 0, 100);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 if (result)
Harvey Harrison441b62c2008-03-03 16:08:34 -0800673 dbg("%s - error sending break = %d", __func__, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674}
675
Alan Sternf9c99bb2009-06-02 11:53:55 -0400676static void pl2303_release(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677{
678 int i;
679 struct pl2303_private *priv;
680
Harvey Harrison441b62c2008-03-03 16:08:34 -0800681 dbg("%s", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682
683 for (i = 0; i < serial->num_ports; ++i) {
684 priv = usb_get_serial_port_data(serial->port[i]);
Johan Hovold684c6e32010-03-17 23:06:03 +0100685 kfree(priv);
Thiago Galesi372db8a2006-07-31 15:39:27 -0300686 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687}
688
Flavio Leitner97bb13e2005-04-18 17:39:31 -0700689static void pl2303_update_line_status(struct usb_serial_port *port,
690 unsigned char *data,
691 unsigned int actual_length)
692{
693
694 struct pl2303_private *priv = usb_get_serial_port_data(port);
Libor Pechacekd14fc1a2011-01-14 14:30:21 +0100695 struct tty_struct *tty;
Flavio Leitner97bb13e2005-04-18 17:39:31 -0700696 unsigned long flags;
697 u8 status_idx = UART_STATE;
Horst Schirmeier95f209f2005-07-28 15:32:20 +0200698 u8 length = UART_STATE + 1;
Libor Pechacekd14fc1a2011-01-14 14:30:21 +0100699 u8 prev_line_status;
Thiago Galesi9c537612006-07-29 10:47:12 -0300700 u16 idv, idp;
Flavio Leitner97bb13e2005-04-18 17:39:31 -0700701
Thiago Galesi9c537612006-07-29 10:47:12 -0300702 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
703 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
704
705
706 if (idv == SIEMENS_VENDOR_ID) {
707 if (idp == SIEMENS_PRODUCT_ID_X65 ||
708 idp == SIEMENS_PRODUCT_ID_SX1 ||
709 idp == SIEMENS_PRODUCT_ID_X75) {
710
711 length = 1;
712 status_idx = 0;
713 }
Flavio Leitner97bb13e2005-04-18 17:39:31 -0700714 }
715
716 if (actual_length < length)
Luiz Fernando N. Capitulinoa009b752006-07-25 16:58:30 -0300717 return;
Flavio Leitner97bb13e2005-04-18 17:39:31 -0700718
Alan Cox3a0f43e2008-07-22 11:14:49 +0100719 /* Save off the uart status for others to look at */
Flavio Leitner97bb13e2005-04-18 17:39:31 -0700720 spin_lock_irqsave(&priv->lock, flags);
Libor Pechacekd14fc1a2011-01-14 14:30:21 +0100721 prev_line_status = priv->line_status;
Flavio Leitner97bb13e2005-04-18 17:39:31 -0700722 priv->line_status = data[status_idx];
723 spin_unlock_irqrestore(&priv->lock, flags);
Jason Wessel430eb0d2009-05-29 13:34:16 -0500724 if (priv->line_status & UART_BREAK_ERROR)
725 usb_serial_handle_break(port);
Thiago Galesi372db8a2006-07-31 15:39:27 -0300726 wake_up_interruptible(&priv->delta_msr_wait);
Libor Pechacekd14fc1a2011-01-14 14:30:21 +0100727
728 tty = tty_port_tty_get(&port->port);
729 if (!tty)
730 return;
731 if ((priv->line_status ^ prev_line_status) & UART_DCD)
732 usb_serial_handle_dcd_change(port, tty,
733 priv->line_status & UART_DCD);
734 tty_kref_put(tty);
Flavio Leitner97bb13e2005-04-18 17:39:31 -0700735}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
David Howells7d12e782006-10-05 14:55:46 +0100737static void pl2303_read_int_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738{
Ming Leicdc97792008-02-24 18:41:47 +0800739 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 unsigned char *data = urb->transfer_buffer;
Flavio Leitner97bb13e2005-04-18 17:39:31 -0700741 unsigned int actual_length = urb->actual_length;
Greg Kroah-Hartman461d6962007-06-15 15:44:13 -0700742 int status = urb->status;
743 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744
Harvey Harrison441b62c2008-03-03 16:08:34 -0800745 dbg("%s (%d)", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
Greg Kroah-Hartman461d6962007-06-15 15:44:13 -0700747 switch (status) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 case 0:
749 /* success */
750 break;
751 case -ECONNRESET:
752 case -ENOENT:
753 case -ESHUTDOWN:
754 /* this urb is terminated, clean up */
Harvey Harrison441b62c2008-03-03 16:08:34 -0800755 dbg("%s - urb shutting down with status: %d", __func__,
Greg Kroah-Hartman461d6962007-06-15 15:44:13 -0700756 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 return;
758 default:
Harvey Harrison441b62c2008-03-03 16:08:34 -0800759 dbg("%s - nonzero urb status received: %d", __func__,
Greg Kroah-Hartman461d6962007-06-15 15:44:13 -0700760 status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 goto exit;
762 }
763
Harvey Harrison441b62c2008-03-03 16:08:34 -0800764 usb_serial_debug_data(debug, &port->dev, __func__,
Thiago Galesi372db8a2006-07-31 15:39:27 -0300765 urb->actual_length, urb->transfer_buffer);
766
Flavio Leitner97bb13e2005-04-18 17:39:31 -0700767 pl2303_update_line_status(port, data, actual_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769exit:
Greg Kroah-Hartman461d6962007-06-15 15:44:13 -0700770 retval = usb_submit_urb(urb, GFP_ATOMIC);
771 if (retval)
Thiago Galesi372db8a2006-07-31 15:39:27 -0300772 dev_err(&urb->dev->dev,
773 "%s - usb_submit_urb failed with result %d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800774 __func__, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775}
776
Johan Hovoldf08e07a2010-03-17 23:05:58 +0100777static void pl2303_process_read_urb(struct urb *urb)
Alan Coxd4fc4a72009-07-09 13:36:58 +0100778{
Johan Hovoldf08e07a2010-03-17 23:05:58 +0100779 struct usb_serial_port *port = urb->context;
780 struct pl2303_private *priv = usb_get_serial_port_data(port);
781 struct tty_struct *tty;
Alan Coxd4fc4a72009-07-09 13:36:58 +0100782 unsigned char *data = urb->transfer_buffer;
Alan Coxd4fc4a72009-07-09 13:36:58 +0100783 char tty_flag = TTY_NORMAL;
Johan Hovoldf08e07a2010-03-17 23:05:58 +0100784 unsigned long flags;
785 u8 line_status;
786 int i;
787
788 /* update line status */
789 spin_lock_irqsave(&priv->lock, flags);
790 line_status = priv->line_status;
791 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
792 spin_unlock_irqrestore(&priv->lock, flags);
793 wake_up_interruptible(&priv->delta_msr_wait);
794
795 if (!urb->actual_length)
796 return;
797
798 tty = tty_port_tty_get(&port->port);
799 if (!tty)
800 return;
801
Alan Coxd4fc4a72009-07-09 13:36:58 +0100802 /* break takes precedence over parity, */
803 /* which takes precedence over framing errors */
804 if (line_status & UART_BREAK_ERROR)
805 tty_flag = TTY_BREAK;
806 else if (line_status & UART_PARITY_ERROR)
807 tty_flag = TTY_PARITY;
808 else if (line_status & UART_FRAME_ERROR)
809 tty_flag = TTY_FRAME;
810 dbg("%s - tty_flag = %d", __func__, tty_flag);
811
Alan Coxd4fc4a72009-07-09 13:36:58 +0100812 /* overrun is special, not associated with a char */
813 if (line_status & UART_OVERRUN_ERROR)
814 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
Johan Hovold9388e2e2009-10-08 11:36:46 +0200815
Johan Hovoldd45cc8d2010-05-08 15:18:41 +0200816 if (port->port.console && port->sysrq) {
Alan Coxd4fc4a72009-07-09 13:36:58 +0100817 for (i = 0; i < urb->actual_length; ++i)
Dmitry Torokhov6ee9f4b2010-08-17 21:15:47 -0700818 if (!usb_serial_handle_sysrq_char(port, data[i]))
Alan Coxd4fc4a72009-07-09 13:36:58 +0100819 tty_insert_flip_char(tty, data[i], tty_flag);
Johan Hovoldd45cc8d2010-05-08 15:18:41 +0200820 } else {
821 tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
822 urb->actual_length);
Johan Hovold9388e2e2009-10-08 11:36:46 +0200823 }
Johan Hovoldf08e07a2010-03-17 23:05:58 +0100824
Alan Coxd4fc4a72009-07-09 13:36:58 +0100825 tty_flip_buffer_push(tty);
Alan Cox4a90f092008-10-13 10:39:46 +0100826 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827}
828
Thiago Galesi572d3132006-07-29 10:46:37 -0300829/* All of the device info needed for the PL2303 SIO serial converter */
830static struct usb_serial_driver pl2303_device = {
831 .driver = {
832 .owner = THIS_MODULE,
833 .name = "pl2303",
834 },
835 .id_table = id_table,
Thiago Galesi572d3132006-07-29 10:46:37 -0300836 .num_ports = 1,
Johan Hovold7919c2f2010-03-17 23:00:41 +0100837 .bulk_in_size = 256,
Johan Hovold3efeaff2010-03-17 23:00:40 +0100838 .bulk_out_size = 256,
Thiago Galesi572d3132006-07-29 10:46:37 -0300839 .open = pl2303_open,
840 .close = pl2303_close,
Alan Cox335f8512009-06-11 12:26:29 +0100841 .dtr_rts = pl2303_dtr_rts,
842 .carrier_raised = pl2303_carrier_raised,
Thiago Galesi572d3132006-07-29 10:46:37 -0300843 .ioctl = pl2303_ioctl,
844 .break_ctl = pl2303_break_ctl,
845 .set_termios = pl2303_set_termios,
846 .tiocmget = pl2303_tiocmget,
847 .tiocmset = pl2303_tiocmset,
Johan Hovoldf08e07a2010-03-17 23:05:58 +0100848 .process_read_urb = pl2303_process_read_urb,
Thiago Galesi572d3132006-07-29 10:46:37 -0300849 .read_int_callback = pl2303_read_int_callback,
Thiago Galesi572d3132006-07-29 10:46:37 -0300850 .attach = pl2303_startup,
Alan Sternf9c99bb2009-06-02 11:53:55 -0400851 .release = pl2303_release,
Thiago Galesi572d3132006-07-29 10:46:37 -0300852};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
Alan Sternf667dda2012-02-23 14:57:18 -0500854static struct usb_serial_driver * const serial_drivers[] = {
855 &pl2303_device, NULL
856};
857
Greg KHd1cddb42012-02-24 15:38:14 -0800858module_usb_serial_driver(pl2303_driver, serial_drivers);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859
860MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861MODULE_LICENSE("GPL");
862
863module_param(debug, bool, S_IRUGO | S_IWUSR);
864MODULE_PARM_DESC(debug, "Debug enabled or not");
865