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