2005-04-17 00:20:36 +02:00
|
|
|
/*
|
|
|
|
* Prolific PL2303 USB to serial adaptor driver
|
|
|
|
*
|
2007-06-12 20:43:37 +02:00
|
|
|
* Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
|
2005-04-17 00:20:36 +02:00
|
|
|
* Copyright (C) 2003 IBM Corp.
|
|
|
|
*
|
|
|
|
* Original driver for 2.2.x by anonymous
|
|
|
|
*
|
2007-06-12 20:43:37 +02:00
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License version
|
|
|
|
* 2 as published by the Free Software Foundation.
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
2008-07-22 12:14:49 +02:00
|
|
|
* See Documentation/usb/usb-serial.txt for more information on using this
|
|
|
|
* driver
|
2005-04-17 00:20:36 +02:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/tty_driver.h>
|
|
|
|
#include <linux/tty_flip.h>
|
|
|
|
#include <linux/serial.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/spinlock.h>
|
2008-07-22 12:14:49 +02:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include <linux/usb.h>
|
2006-07-12 06:22:58 +02:00
|
|
|
#include <linux/usb/serial.h>
|
2005-04-17 00:20:36 +02:00
|
|
|
#include "pl2303.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Version Information
|
|
|
|
*/
|
|
|
|
#define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
|
|
|
|
|
|
|
|
static int debug;
|
|
|
|
|
|
|
|
#define PL2303_CLOSING_WAIT (30*HZ)
|
|
|
|
|
2010-01-10 15:34:24 +01:00
|
|
|
static const struct usb_device_id id_table[] = {
|
2005-04-17 00:20:36 +02:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
|
2006-06-19 14:47:49 +02:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
|
2005-04-17 00:20:36 +02:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
|
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
|
2008-03-20 10:43:56 +01:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
|
2008-05-23 20:09:05 +02:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
|
2008-07-02 22:25:41 +02:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
|
2010-04-12 23:25:10 +02:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
|
2011-01-21 15:35:19 +01:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
|
2005-04-17 00:20:36 +02:00
|
|
|
{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
|
2007-10-23 06:51:57 +02:00
|
|
|
{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
|
2005-04-17 00:20:36 +02:00
|
|
|
{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
|
|
|
|
{ USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
|
2006-04-19 10:32:07 +02:00
|
|
|
{ USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
|
2005-04-17 00:20:36 +02:00
|
|
|
{ USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
|
2005-11-17 18:47:32 +01:00
|
|
|
{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
|
2005-04-17 00:20:36 +02:00
|
|
|
{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
|
2005-11-17 18:47:32 +01:00
|
|
|
{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
|
2007-08-24 01:51:11 +02:00
|
|
|
{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
|
2009-04-06 18:35:12 +02:00
|
|
|
{ USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
|
2005-04-19 02:39:32 +02:00
|
|
|
{ USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
|
2006-02-01 14:10:52 +01:00
|
|
|
{ USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
|
2006-01-19 14:52:38 +01:00
|
|
|
{ USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
|
2006-02-01 14:10:52 +01:00
|
|
|
{ USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
|
2006-03-01 09:53:33 +01:00
|
|
|
{ USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
|
2006-06-21 21:25:53 +02:00
|
|
|
{ USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
|
2006-07-25 07:54:59 +02:00
|
|
|
{ USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
|
2006-09-16 16:17:34 +02:00
|
|
|
{ USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
|
2007-01-26 14:51:38 +01:00
|
|
|
{ USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
|
2007-11-08 08:45:46 +01:00
|
|
|
{ USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
|
2008-01-06 19:51:39 +01:00
|
|
|
{ USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
|
2008-12-13 12:42:53 +01:00
|
|
|
{ USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
|
2008-12-16 21:30:14 +01:00
|
|
|
{ USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
|
2009-06-05 22:57:52 +02:00
|
|
|
{ USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
|
2010-08-09 15:55:32 +02:00
|
|
|
{ USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
|
2009-07-28 19:41:17 +02:00
|
|
|
{ USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
|
2009-08-27 14:15:50 +02:00
|
|
|
{ USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
|
2010-03-29 23:51:57 +02:00
|
|
|
{ USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
|
2011-07-19 11:25:38 +02:00
|
|
|
{ USB_DEVICE(WINCHIPHEAD_VENDOR_ID, WINCHIPHEAD_USBSER_PRODUCT_ID) },
|
2011-09-24 08:04:50 +02:00
|
|
|
{ USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
|
2005-04-17 00:20:36 +02:00
|
|
|
{ } /* Terminating entry */
|
|
|
|
};
|
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
MODULE_DEVICE_TABLE(usb, id_table);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
static struct usb_driver pl2303_driver = {
|
|
|
|
.name = "pl2303",
|
|
|
|
.probe = usb_serial_probe,
|
|
|
|
.disconnect = usb_serial_disconnect,
|
|
|
|
.id_table = id_table,
|
2007-12-14 23:09:30 +01:00
|
|
|
.suspend = usb_serial_suspend,
|
|
|
|
.resume = usb_serial_resume,
|
2005-11-16 22:41:28 +01:00
|
|
|
.no_dynamic_id = 1,
|
2007-12-14 23:09:30 +01:00
|
|
|
.supports_autosuspend = 1,
|
2005-04-17 00:20:36 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
#define SET_LINE_REQUEST_TYPE 0x21
|
|
|
|
#define SET_LINE_REQUEST 0x20
|
|
|
|
|
|
|
|
#define SET_CONTROL_REQUEST_TYPE 0x21
|
|
|
|
#define SET_CONTROL_REQUEST 0x22
|
|
|
|
#define CONTROL_DTR 0x01
|
|
|
|
#define CONTROL_RTS 0x02
|
|
|
|
|
|
|
|
#define BREAK_REQUEST_TYPE 0x21
|
2008-07-22 12:14:49 +02:00
|
|
|
#define BREAK_REQUEST 0x23
|
2005-04-17 00:20:36 +02:00
|
|
|
#define BREAK_ON 0xffff
|
|
|
|
#define BREAK_OFF 0x0000
|
|
|
|
|
|
|
|
#define GET_LINE_REQUEST_TYPE 0xa1
|
|
|
|
#define GET_LINE_REQUEST 0x21
|
|
|
|
|
|
|
|
#define VENDOR_WRITE_REQUEST_TYPE 0x40
|
|
|
|
#define VENDOR_WRITE_REQUEST 0x01
|
|
|
|
|
|
|
|
#define VENDOR_READ_REQUEST_TYPE 0xc0
|
|
|
|
#define VENDOR_READ_REQUEST 0x01
|
|
|
|
|
|
|
|
#define UART_STATE 0x08
|
|
|
|
#define UART_STATE_TRANSIENT_MASK 0x74
|
|
|
|
#define UART_DCD 0x01
|
|
|
|
#define UART_DSR 0x02
|
|
|
|
#define UART_BREAK_ERROR 0x04
|
|
|
|
#define UART_RING 0x08
|
|
|
|
#define UART_FRAME_ERROR 0x10
|
|
|
|
#define UART_PARITY_ERROR 0x20
|
|
|
|
#define UART_OVERRUN_ERROR 0x40
|
|
|
|
#define UART_CTS 0x80
|
|
|
|
|
|
|
|
|
|
|
|
enum pl2303_type {
|
|
|
|
type_0, /* don't know the difference between type 0 and */
|
|
|
|
type_1, /* type 1, until someone from prolific tells us... */
|
|
|
|
HX, /* HX version of the pl2303 chip */
|
|
|
|
};
|
|
|
|
|
|
|
|
struct pl2303_private {
|
|
|
|
spinlock_t lock;
|
|
|
|
wait_queue_head_t delta_msr_wait;
|
|
|
|
u8 line_control;
|
|
|
|
u8 line_status;
|
|
|
|
enum pl2303_type type;
|
|
|
|
};
|
|
|
|
|
2007-12-14 23:08:00 +01:00
|
|
|
static int pl2303_vendor_read(__u16 value, __u16 index,
|
|
|
|
struct usb_serial *serial, unsigned char *buf)
|
|
|
|
{
|
|
|
|
int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
|
|
|
|
VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
|
|
|
|
value, index, buf, 1, 100);
|
|
|
|
dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE,
|
|
|
|
VENDOR_READ_REQUEST, value, index, res, buf[0]);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int pl2303_vendor_write(__u16 value, __u16 index,
|
|
|
|
struct usb_serial *serial)
|
|
|
|
{
|
|
|
|
int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
|
|
|
|
VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
|
|
|
|
value, index, NULL, 0, 100);
|
|
|
|
dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE,
|
|
|
|
VENDOR_WRITE_REQUEST, value, index, res);
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
static int pl2303_startup(struct usb_serial *serial)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct pl2303_private *priv;
|
|
|
|
enum pl2303_type type = type_0;
|
2007-12-14 23:08:35 +01:00
|
|
|
unsigned char *buf;
|
2005-04-17 00:20:36 +02:00
|
|
|
int i;
|
|
|
|
|
2007-12-14 23:08:35 +01:00
|
|
|
buf = kmalloc(10, GFP_KERNEL);
|
|
|
|
if (buf == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (serial->dev->descriptor.bDeviceClass == 0x02)
|
|
|
|
type = type_0;
|
|
|
|
else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
|
|
|
|
type = HX;
|
|
|
|
else if (serial->dev->descriptor.bDeviceClass == 0x00)
|
|
|
|
type = type_1;
|
|
|
|
else if (serial->dev->descriptor.bDeviceClass == 0xFF)
|
|
|
|
type = type_1;
|
|
|
|
dbg("device type: %d", type);
|
|
|
|
|
|
|
|
for (i = 0; i < serial->num_ports; ++i) {
|
2006-02-27 21:29:43 +01:00
|
|
|
priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!priv)
|
|
|
|
goto cleanup;
|
|
|
|
spin_lock_init(&priv->lock);
|
|
|
|
init_waitqueue_head(&priv->delta_msr_wait);
|
|
|
|
priv->type = type;
|
|
|
|
usb_set_serial_port_data(serial->port[i], priv);
|
|
|
|
}
|
2007-12-14 23:08:35 +01:00
|
|
|
|
|
|
|
pl2303_vendor_read(0x8484, 0, serial, buf);
|
|
|
|
pl2303_vendor_write(0x0404, 0, serial);
|
|
|
|
pl2303_vendor_read(0x8484, 0, serial, buf);
|
|
|
|
pl2303_vendor_read(0x8383, 0, serial, buf);
|
|
|
|
pl2303_vendor_read(0x8484, 0, serial, buf);
|
|
|
|
pl2303_vendor_write(0x0404, 1, serial);
|
|
|
|
pl2303_vendor_read(0x8484, 0, serial, buf);
|
|
|
|
pl2303_vendor_read(0x8383, 0, serial, buf);
|
|
|
|
pl2303_vendor_write(0, 1, serial);
|
|
|
|
pl2303_vendor_write(1, 0, serial);
|
|
|
|
if (type == HX)
|
|
|
|
pl2303_vendor_write(2, 0x44, serial);
|
|
|
|
else
|
|
|
|
pl2303_vendor_write(2, 0x24, serial);
|
|
|
|
|
|
|
|
kfree(buf);
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
cleanup:
|
2007-12-14 23:08:35 +01:00
|
|
|
kfree(buf);
|
2008-07-22 12:14:49 +02:00
|
|
|
for (--i; i >= 0; --i) {
|
2005-04-17 00:20:36 +02:00
|
|
|
priv = usb_get_serial_port_data(serial->port[i]);
|
|
|
|
kfree(priv);
|
|
|
|
usb_set_serial_port_data(serial->port[i], NULL);
|
|
|
|
}
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
static int set_control_lines(struct usb_device *dev, u8 value)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int retval;
|
2008-07-22 12:14:49 +02:00
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
|
|
|
|
SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
|
|
|
|
value, 0, NULL, 0, 100);
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - value = %d, retval = %d", __func__, value, retval);
|
2005-04-17 00:20:36 +02:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2008-07-22 12:09:07 +02:00
|
|
|
static void pl2303_set_termios(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port, struct ktermios *old_termios)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int cflag;
|
|
|
|
unsigned char *buf;
|
|
|
|
int baud;
|
|
|
|
int i;
|
|
|
|
u8 control;
|
2009-08-18 20:15:07 +02:00
|
|
|
const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
|
|
|
|
4800, 7200, 9600, 14400, 19200, 28800, 38400,
|
|
|
|
57600, 115200, 230400, 460800, 614400,
|
|
|
|
921600, 1228800, 2457600, 3000000, 6000000 };
|
|
|
|
int baud_floor, baud_ceil;
|
|
|
|
int k;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-01-08 15:55:51 +01:00
|
|
|
/* The PL2303 is reported to lose bytes if you change
|
|
|
|
serial settings even to the same values as before. Thus
|
|
|
|
we actually need to filter in this specific case */
|
|
|
|
|
2008-07-22 12:09:07 +02:00
|
|
|
if (!tty_termios_hw_change(tty->termios, old_termios))
|
2008-01-08 15:55:51 +01:00
|
|
|
return;
|
|
|
|
|
2008-07-22 12:09:07 +02:00
|
|
|
cflag = tty->termios->c_cflag;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
buf = kzalloc(7, GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (!buf) {
|
2008-03-04 01:08:34 +01:00
|
|
|
dev_err(&port->dev, "%s - out of memory.\n", __func__);
|
2008-04-08 18:16:06 +02:00
|
|
|
/* Report back no change occurred */
|
2008-07-22 12:09:07 +02:00
|
|
|
*tty->termios = *old_termios;
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
|
|
|
|
GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
|
|
|
|
0, 0, buf, 7, 100);
|
|
|
|
dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
|
|
|
|
buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (cflag & CSIZE) {
|
|
|
|
switch (cflag & CSIZE) {
|
2008-07-22 12:14:49 +02:00
|
|
|
case CS5:
|
|
|
|
buf[6] = 5;
|
|
|
|
break;
|
|
|
|
case CS6:
|
|
|
|
buf[6] = 6;
|
|
|
|
break;
|
|
|
|
case CS7:
|
|
|
|
buf[6] = 7;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
case CS8:
|
|
|
|
buf[6] = 8;
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - data bits = %d", __func__, buf[6]);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-08-18 20:15:07 +02:00
|
|
|
/* For reference buf[0]:buf[3] baud rate value */
|
|
|
|
/* NOTE: Only the values defined in baud_sup are supported !
|
|
|
|
* => if unsupported values are set, the PL2303 seems to use
|
|
|
|
* 9600 baud (at least my PL2303X always does)
|
|
|
|
*/
|
2008-07-22 12:09:07 +02:00
|
|
|
baud = tty_get_baud_rate(tty);
|
2009-08-18 20:15:07 +02:00
|
|
|
dbg("%s - baud requested = %d", __func__, baud);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (baud) {
|
2009-08-18 20:15:07 +02:00
|
|
|
/* Set baudrate to nearest supported value */
|
|
|
|
for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
|
|
|
|
if (baud_sup[k] / baud) {
|
|
|
|
baud_ceil = baud_sup[k];
|
|
|
|
if (k==0) {
|
|
|
|
baud = baud_ceil;
|
|
|
|
} else {
|
|
|
|
baud_floor = baud_sup[k-1];
|
|
|
|
if ((baud_ceil % baud)
|
|
|
|
> (baud % baud_floor))
|
|
|
|
baud = baud_floor;
|
|
|
|
else
|
|
|
|
baud = baud_ceil;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (baud > 1228800) {
|
|
|
|
/* type_0, type_1 only support up to 1228800 baud */
|
|
|
|
if (priv->type != HX)
|
|
|
|
baud = 1228800;
|
|
|
|
else if (baud > 6000000)
|
|
|
|
baud = 6000000;
|
|
|
|
}
|
|
|
|
dbg("%s - baud set = %d", __func__, baud);
|
2011-07-05 21:53:35 +02:00
|
|
|
if (baud <= 115200) {
|
|
|
|
buf[0] = baud & 0xff;
|
|
|
|
buf[1] = (baud >> 8) & 0xff;
|
|
|
|
buf[2] = (baud >> 16) & 0xff;
|
|
|
|
buf[3] = (baud >> 24) & 0xff;
|
|
|
|
} else {
|
|
|
|
/* apparently the formula for higher speeds is:
|
|
|
|
* baudrate = 12M * 32 / (2^buf[1]) / buf[0]
|
|
|
|
*/
|
|
|
|
unsigned tmp = 12*1000*1000*32 / baud;
|
|
|
|
buf[3] = 0x80;
|
|
|
|
buf[2] = 0;
|
|
|
|
buf[1] = (tmp >= 256);
|
|
|
|
while (tmp >= 256) {
|
|
|
|
tmp >>= 2;
|
|
|
|
buf[1] <<= 1;
|
|
|
|
}
|
|
|
|
buf[0] = tmp;
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* For reference buf[4]=0 is 1 stop bits */
|
|
|
|
/* For reference buf[4]=1 is 1.5 stop bits */
|
|
|
|
/* For reference buf[4]=2 is 2 stop bits */
|
|
|
|
if (cflag & CSTOPB) {
|
2009-08-18 20:34:24 +02:00
|
|
|
/* NOTE: Comply with "real" UARTs / RS232:
|
|
|
|
* use 1.5 instead of 2 stop bits with 5 data bits
|
|
|
|
*/
|
|
|
|
if ((cflag & CSIZE) == CS5) {
|
|
|
|
buf[4] = 1;
|
|
|
|
dbg("%s - stop bits = 1.5", __func__);
|
|
|
|
} else {
|
|
|
|
buf[4] = 2;
|
|
|
|
dbg("%s - stop bits = 2", __func__);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
|
|
|
buf[4] = 0;
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - stop bits = 1", __func__);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cflag & PARENB) {
|
|
|
|
/* For reference buf[5]=0 is none parity */
|
|
|
|
/* For reference buf[5]=1 is odd parity */
|
|
|
|
/* For reference buf[5]=2 is even parity */
|
|
|
|
/* For reference buf[5]=3 is mark parity */
|
|
|
|
/* For reference buf[5]=4 is space parity */
|
|
|
|
if (cflag & PARODD) {
|
2009-08-18 20:31:11 +02:00
|
|
|
if (cflag & CMSPAR) {
|
|
|
|
buf[5] = 3;
|
|
|
|
dbg("%s - parity = mark", __func__);
|
|
|
|
} else {
|
|
|
|
buf[5] = 1;
|
|
|
|
dbg("%s - parity = odd", __func__);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
} else {
|
2009-08-18 20:31:11 +02:00
|
|
|
if (cflag & CMSPAR) {
|
|
|
|
buf[5] = 4;
|
|
|
|
dbg("%s - parity = space", __func__);
|
|
|
|
} else {
|
|
|
|
buf[5] = 2;
|
|
|
|
dbg("%s - parity = even", __func__);
|
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
buf[5] = 0;
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - parity = none", __func__);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
|
|
|
|
SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
|
|
|
|
0, 0, buf, 7, 100);
|
|
|
|
dbg("0x21:0x20:0:0 %d", i);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
/* change control lines if we are switching to or from B0 */
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
control = priv->line_control;
|
|
|
|
if ((cflag & CBAUD) == B0)
|
|
|
|
priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
|
|
|
|
else
|
|
|
|
priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
|
|
|
|
if (control != priv->line_control) {
|
|
|
|
control = priv->line_control;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
set_control_lines(serial->dev, control);
|
|
|
|
} else {
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
}
|
2006-07-31 20:39:27 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
|
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
|
|
|
|
GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
|
|
|
|
0, 0, buf, 7, 100);
|
|
|
|
dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
|
2005-04-17 00:20:36 +02:00
|
|
|
buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
|
|
|
|
|
|
|
|
if (cflag & CRTSCTS) {
|
|
|
|
if (priv->type == HX)
|
2007-12-14 23:08:00 +01:00
|
|
|
pl2303_vendor_write(0x0, 0x61, serial);
|
2005-04-17 00:20:36 +02:00
|
|
|
else
|
2007-12-14 23:08:00 +01:00
|
|
|
pl2303_vendor_write(0x0, 0x41, serial);
|
2007-04-25 15:05:22 +02:00
|
|
|
} else {
|
2007-12-14 23:08:00 +01:00
|
|
|
pl2303_vendor_write(0x0, 0x0, serial);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
2006-07-29 15:46:37 +02:00
|
|
|
|
2009-08-18 20:15:07 +02:00
|
|
|
/* Save resulting baud rate */
|
2007-10-15 21:54:47 +02:00
|
|
|
if (baud)
|
2008-07-22 12:09:07 +02:00
|
|
|
tty_encode_baud_rate(tty, baud, baud);
|
2007-10-15 21:54:47 +02:00
|
|
|
|
2006-07-29 15:46:37 +02:00
|
|
|
kfree(buf);
|
|
|
|
}
|
|
|
|
|
2009-06-11 13:26:29 +02:00
|
|
|
static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
|
|
|
|
{
|
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
|
|
|
u8 control;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
/* Change DTR and RTS */
|
|
|
|
if (on)
|
|
|
|
priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
|
|
|
|
else
|
|
|
|
priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
|
|
|
|
control = priv->line_control;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
set_control_lines(port->serial->dev, control);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pl2303_close(struct usb_serial_port *port)
|
2006-07-29 15:46:37 +02:00
|
|
|
{
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2006-07-29 15:46:37 +02:00
|
|
|
|
2010-03-17 23:06:04 +01:00
|
|
|
usb_serial_generic_close(port);
|
2006-07-29 15:46:37 +02:00
|
|
|
usb_kill_urb(port->interrupt_in_urb);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-09-19 22:13:26 +02:00
|
|
|
static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-12-08 11:38:45 +01:00
|
|
|
struct ktermios tmp_termios;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int result;
|
|
|
|
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-07-28 18:06:13 +02:00
|
|
|
if (priv->type != HX) {
|
|
|
|
usb_clear_halt(serial->dev, port->write_urb->pipe);
|
|
|
|
usb_clear_halt(serial->dev, port->read_urb->pipe);
|
2007-12-14 23:08:35 +01:00
|
|
|
} else {
|
2005-04-17 00:20:36 +02:00
|
|
|
/* reset upstream data pipes */
|
2007-12-14 23:08:00 +01:00
|
|
|
pl2303_vendor_write(8, 0, serial);
|
|
|
|
pl2303_vendor_write(9, 0, serial);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Setup termios */
|
2008-07-22 12:09:07 +02:00
|
|
|
if (tty)
|
|
|
|
pl2303_set_termios(tty, port, &tmp_termios);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - submitting read urb", __func__);
|
2010-03-17 23:05:58 +01:00
|
|
|
result = usb_serial_generic_submit_read_urb(port, GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (result) {
|
2009-06-11 13:26:29 +02:00
|
|
|
pl2303_close(port);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EPROTO;
|
|
|
|
}
|
|
|
|
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - submitting interrupt urb", __func__);
|
2006-07-31 20:39:27 +02:00
|
|
|
result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (result) {
|
2006-07-31 20:39:27 +02:00
|
|
|
dev_err(&port->dev, "%s - failed submitting interrupt urb,"
|
2008-03-04 01:08:34 +01:00
|
|
|
" error %d\n", __func__, result);
|
2009-06-11 13:26:29 +02:00
|
|
|
pl2303_close(port);
|
2005-04-17 00:20:36 +02:00
|
|
|
return -EPROTO;
|
|
|
|
}
|
2009-06-11 13:26:29 +02:00
|
|
|
port->port.drain_delay = 256;
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-14 17:26:50 +01:00
|
|
|
static int pl2303_tiocmset(struct tty_struct *tty,
|
2006-07-31 20:39:27 +02:00
|
|
|
unsigned int set, unsigned int clear)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-07-22 12:09:07 +02:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
|
|
|
u8 control;
|
|
|
|
|
2005-04-19 02:39:31 +02:00
|
|
|
if (!usb_get_intfdata(port->serial->interface))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (set & TIOCM_RTS)
|
|
|
|
priv->line_control |= CONTROL_RTS;
|
|
|
|
if (set & TIOCM_DTR)
|
|
|
|
priv->line_control |= CONTROL_DTR;
|
|
|
|
if (clear & TIOCM_RTS)
|
|
|
|
priv->line_control &= ~CONTROL_RTS;
|
|
|
|
if (clear & TIOCM_DTR)
|
|
|
|
priv->line_control &= ~CONTROL_DTR;
|
|
|
|
control = priv->line_control;
|
2006-07-31 20:39:27 +02:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
return set_control_lines(port->serial->dev, control);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2011-02-14 17:26:14 +01:00
|
|
|
static int pl2303_tiocmget(struct tty_struct *tty)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-07-22 12:09:07 +02:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int mcr;
|
|
|
|
unsigned int status;
|
|
|
|
unsigned int result;
|
|
|
|
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s (%d)", __func__, port->number);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2005-04-19 02:39:31 +02:00
|
|
|
if (!usb_get_intfdata(port->serial->interface))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
mcr = priv->line_control;
|
|
|
|
status = priv->line_status;
|
2006-07-31 20:39:27 +02:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
|
|
|
|
| ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
|
|
|
|
| ((status & UART_CTS) ? TIOCM_CTS : 0)
|
|
|
|
| ((status & UART_DSR) ? TIOCM_DSR : 0)
|
|
|
|
| ((status & UART_RING) ? TIOCM_RI : 0)
|
|
|
|
| ((status & UART_DCD) ? TIOCM_CD : 0);
|
|
|
|
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - result = %x", __func__, result);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2009-06-11 13:26:29 +02:00
|
|
|
static int pl2303_carrier_raised(struct usb_serial_port *port)
|
|
|
|
{
|
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
if (priv->line_status & UART_DCD)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
|
|
|
|
{
|
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int prevstatus;
|
|
|
|
unsigned int status;
|
|
|
|
unsigned int changed;
|
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
prevstatus = priv->line_status;
|
2006-07-31 20:39:27 +02:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
while (1) {
|
|
|
|
interruptible_sleep_on(&priv->delta_msr_wait);
|
|
|
|
/* see if a signal did it */
|
|
|
|
if (signal_pending(current))
|
|
|
|
return -ERESTARTSYS;
|
2006-07-31 20:39:27 +02:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-04-17 00:20:36 +02:00
|
|
|
status = priv->line_status;
|
2006-07-31 20:39:27 +02:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-07-22 12:14:49 +02:00
|
|
|
changed = prevstatus ^ status;
|
2006-07-31 20:39:27 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
|
|
|
|
((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
|
|
|
|
((arg & TIOCM_CD) && (changed & UART_DCD)) ||
|
2008-07-22 12:14:49 +02:00
|
|
|
((arg & TIOCM_CTS) && (changed & UART_CTS))) {
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
prevstatus = status;
|
|
|
|
}
|
|
|
|
/* NOTREACHED */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-14 17:27:06 +01:00
|
|
|
static int pl2303_ioctl(struct tty_struct *tty,
|
2006-07-31 20:39:27 +02:00
|
|
|
unsigned int cmd, unsigned long arg)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2010-02-25 16:09:08 +01:00
|
|
|
struct serial_struct ser;
|
2008-07-22 12:09:07 +02:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
switch (cmd) {
|
2010-02-25 16:09:08 +01:00
|
|
|
case TIOCGSERIAL:
|
|
|
|
memset(&ser, 0, sizeof ser);
|
|
|
|
ser.type = PORT_16654;
|
|
|
|
ser.line = port->serial->minor;
|
|
|
|
ser.port = port->number;
|
|
|
|
ser.baud_base = 460800;
|
|
|
|
|
|
|
|
if (copy_to_user((void __user *)arg, &ser, sizeof ser))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
2008-07-22 12:14:49 +02:00
|
|
|
case TIOCMIWAIT:
|
|
|
|
dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
|
|
|
|
return wait_modem_info(port, arg);
|
|
|
|
default:
|
|
|
|
dbg("%s not supported = 0x%04x", __func__, cmd);
|
|
|
|
break;
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
return -ENOIOCTLCMD;
|
|
|
|
}
|
|
|
|
|
2008-07-22 12:09:07 +02:00
|
|
|
static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-07-22 12:09:07 +02:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 00:20:36 +02:00
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
u16 state;
|
|
|
|
int result;
|
|
|
|
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
if (break_state == 0)
|
|
|
|
state = BREAK_OFF;
|
|
|
|
else
|
|
|
|
state = BREAK_ON;
|
2008-07-22 12:14:49 +02:00
|
|
|
dbg("%s - turning break %s", __func__,
|
|
|
|
state == BREAK_OFF ? "off" : "on");
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
|
|
|
|
BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
|
|
|
|
0, NULL, 0, 100);
|
2005-04-17 00:20:36 +02:00
|
|
|
if (result)
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - error sending break = %d", __func__, result);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2009-06-02 17:53:55 +02:00
|
|
|
static void pl2303_release(struct usb_serial *serial)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct pl2303_private *priv;
|
|
|
|
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s", __func__);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
for (i = 0; i < serial->num_ports; ++i) {
|
|
|
|
priv = usb_get_serial_port_data(serial->port[i]);
|
2010-03-17 23:06:03 +01:00
|
|
|
kfree(priv);
|
2006-07-31 20:39:27 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2005-04-19 02:39:31 +02:00
|
|
|
static void pl2303_update_line_status(struct usb_serial_port *port,
|
|
|
|
unsigned char *data,
|
|
|
|
unsigned int actual_length)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
2011-01-14 14:30:21 +01:00
|
|
|
struct tty_struct *tty;
|
2005-04-19 02:39:31 +02:00
|
|
|
unsigned long flags;
|
|
|
|
u8 status_idx = UART_STATE;
|
2005-07-28 15:32:20 +02:00
|
|
|
u8 length = UART_STATE + 1;
|
2011-01-14 14:30:21 +01:00
|
|
|
u8 prev_line_status;
|
2006-07-29 15:47:12 +02:00
|
|
|
u16 idv, idp;
|
2005-04-19 02:39:31 +02:00
|
|
|
|
2006-07-29 15:47:12 +02:00
|
|
|
idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
|
|
|
|
idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
|
|
|
|
|
|
|
|
|
|
|
|
if (idv == SIEMENS_VENDOR_ID) {
|
|
|
|
if (idp == SIEMENS_PRODUCT_ID_X65 ||
|
|
|
|
idp == SIEMENS_PRODUCT_ID_SX1 ||
|
|
|
|
idp == SIEMENS_PRODUCT_ID_X75) {
|
|
|
|
|
|
|
|
length = 1;
|
|
|
|
status_idx = 0;
|
|
|
|
}
|
2005-04-19 02:39:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if (actual_length < length)
|
2006-07-25 21:58:30 +02:00
|
|
|
return;
|
2005-04-19 02:39:31 +02:00
|
|
|
|
2008-07-22 12:14:49 +02:00
|
|
|
/* Save off the uart status for others to look at */
|
2005-04-19 02:39:31 +02:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2011-01-14 14:30:21 +01:00
|
|
|
prev_line_status = priv->line_status;
|
2005-04-19 02:39:31 +02:00
|
|
|
priv->line_status = data[status_idx];
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2009-05-29 20:34:16 +02:00
|
|
|
if (priv->line_status & UART_BREAK_ERROR)
|
|
|
|
usb_serial_handle_break(port);
|
2006-07-31 20:39:27 +02:00
|
|
|
wake_up_interruptible(&priv->delta_msr_wait);
|
2011-01-14 14:30:21 +01:00
|
|
|
|
|
|
|
tty = tty_port_tty_get(&port->port);
|
|
|
|
if (!tty)
|
|
|
|
return;
|
|
|
|
if ((priv->line_status ^ prev_line_status) & UART_DCD)
|
|
|
|
usb_serial_handle_dcd_change(port, tty,
|
|
|
|
priv->line_status & UART_DCD);
|
|
|
|
tty_kref_put(tty);
|
2005-04-19 02:39:31 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 15:55:46 +02:00
|
|
|
static void pl2303_read_int_callback(struct urb *urb)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2008-02-24 11:41:47 +01:00
|
|
|
struct usb_serial_port *port = urb->context;
|
2005-04-17 00:20:36 +02:00
|
|
|
unsigned char *data = urb->transfer_buffer;
|
2005-04-19 02:39:31 +02:00
|
|
|
unsigned int actual_length = urb->actual_length;
|
2007-06-16 00:44:13 +02:00
|
|
|
int status = urb->status;
|
|
|
|
int retval;
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s (%d)", __func__, port->number);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2007-06-16 00:44:13 +02:00
|
|
|
switch (status) {
|
2005-04-17 00:20:36 +02:00
|
|
|
case 0:
|
|
|
|
/* success */
|
|
|
|
break;
|
|
|
|
case -ECONNRESET:
|
|
|
|
case -ENOENT:
|
|
|
|
case -ESHUTDOWN:
|
|
|
|
/* this urb is terminated, clean up */
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - urb shutting down with status: %d", __func__,
|
2007-06-16 00:44:13 +02:00
|
|
|
status);
|
2005-04-17 00:20:36 +02:00
|
|
|
return;
|
|
|
|
default:
|
2008-03-04 01:08:34 +01:00
|
|
|
dbg("%s - nonzero urb status received: %d", __func__,
|
2007-06-16 00:44:13 +02:00
|
|
|
status);
|
2005-04-17 00:20:36 +02:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2008-03-04 01:08:34 +01:00
|
|
|
usb_serial_debug_data(debug, &port->dev, __func__,
|
2006-07-31 20:39:27 +02:00
|
|
|
urb->actual_length, urb->transfer_buffer);
|
|
|
|
|
2005-04-19 02:39:31 +02:00
|
|
|
pl2303_update_line_status(port, data, actual_length);
|
2005-04-17 00:20:36 +02:00
|
|
|
|
|
|
|
exit:
|
2007-06-16 00:44:13 +02:00
|
|
|
retval = usb_submit_urb(urb, GFP_ATOMIC);
|
|
|
|
if (retval)
|
2006-07-31 20:39:27 +02:00
|
|
|
dev_err(&urb->dev->dev,
|
|
|
|
"%s - usb_submit_urb failed with result %d\n",
|
2008-03-04 01:08:34 +01:00
|
|
|
__func__, retval);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2010-03-17 23:05:58 +01:00
|
|
|
static void pl2303_process_read_urb(struct urb *urb)
|
2009-07-09 14:36:58 +02:00
|
|
|
{
|
2010-03-17 23:05:58 +01:00
|
|
|
struct usb_serial_port *port = urb->context;
|
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
struct tty_struct *tty;
|
2009-07-09 14:36:58 +02:00
|
|
|
unsigned char *data = urb->transfer_buffer;
|
|
|
|
char tty_flag = TTY_NORMAL;
|
2010-03-17 23:05:58 +01:00
|
|
|
unsigned long flags;
|
|
|
|
u8 line_status;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
/* update line status */
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
line_status = priv->line_status;
|
|
|
|
priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
wake_up_interruptible(&priv->delta_msr_wait);
|
|
|
|
|
|
|
|
if (!urb->actual_length)
|
|
|
|
return;
|
|
|
|
|
|
|
|
tty = tty_port_tty_get(&port->port);
|
|
|
|
if (!tty)
|
|
|
|
return;
|
|
|
|
|
2009-07-09 14:36:58 +02:00
|
|
|
/* break takes precedence over parity, */
|
|
|
|
/* which takes precedence over framing errors */
|
|
|
|
if (line_status & UART_BREAK_ERROR)
|
|
|
|
tty_flag = TTY_BREAK;
|
|
|
|
else if (line_status & UART_PARITY_ERROR)
|
|
|
|
tty_flag = TTY_PARITY;
|
|
|
|
else if (line_status & UART_FRAME_ERROR)
|
|
|
|
tty_flag = TTY_FRAME;
|
|
|
|
dbg("%s - tty_flag = %d", __func__, tty_flag);
|
|
|
|
|
|
|
|
/* overrun is special, not associated with a char */
|
|
|
|
if (line_status & UART_OVERRUN_ERROR)
|
|
|
|
tty_insert_flip_char(tty, 0, TTY_OVERRUN);
|
2009-10-08 11:36:46 +02:00
|
|
|
|
2010-05-08 15:18:41 +02:00
|
|
|
if (port->port.console && port->sysrq) {
|
2009-07-09 14:36:58 +02:00
|
|
|
for (i = 0; i < urb->actual_length; ++i)
|
2010-08-18 06:15:47 +02:00
|
|
|
if (!usb_serial_handle_sysrq_char(port, data[i]))
|
2009-07-09 14:36:58 +02:00
|
|
|
tty_insert_flip_char(tty, data[i], tty_flag);
|
2010-05-08 15:18:41 +02:00
|
|
|
} else {
|
|
|
|
tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
|
|
|
|
urb->actual_length);
|
2009-10-08 11:36:46 +02:00
|
|
|
}
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2010-03-17 23:05:58 +01:00
|
|
|
tty_flip_buffer_push(tty);
|
2008-10-13 11:39:46 +02:00
|
|
|
tty_kref_put(tty);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
2006-07-29 15:46:37 +02:00
|
|
|
/* All of the device info needed for the PL2303 SIO serial converter */
|
|
|
|
static struct usb_serial_driver pl2303_device = {
|
|
|
|
.driver = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.name = "pl2303",
|
|
|
|
},
|
|
|
|
.id_table = id_table,
|
2006-12-17 21:50:24 +01:00
|
|
|
.usb_driver = &pl2303_driver,
|
2006-07-29 15:46:37 +02:00
|
|
|
.num_ports = 1,
|
2010-03-17 23:00:41 +01:00
|
|
|
.bulk_in_size = 256,
|
2010-03-17 23:00:40 +01:00
|
|
|
.bulk_out_size = 256,
|
2006-07-29 15:46:37 +02:00
|
|
|
.open = pl2303_open,
|
|
|
|
.close = pl2303_close,
|
2009-06-11 13:26:29 +02:00
|
|
|
.dtr_rts = pl2303_dtr_rts,
|
|
|
|
.carrier_raised = pl2303_carrier_raised,
|
2006-07-29 15:46:37 +02:00
|
|
|
.ioctl = pl2303_ioctl,
|
|
|
|
.break_ctl = pl2303_break_ctl,
|
|
|
|
.set_termios = pl2303_set_termios,
|
|
|
|
.tiocmget = pl2303_tiocmget,
|
|
|
|
.tiocmset = pl2303_tiocmset,
|
2010-03-17 23:05:58 +01:00
|
|
|
.process_read_urb = pl2303_process_read_urb,
|
2006-07-29 15:46:37 +02:00
|
|
|
.read_int_callback = pl2303_read_int_callback,
|
|
|
|
.attach = pl2303_startup,
|
2009-06-02 17:53:55 +02:00
|
|
|
.release = pl2303_release,
|
2006-07-29 15:46:37 +02:00
|
|
|
};
|
2005-04-17 00:20:36 +02:00
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
static int __init pl2303_init(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
|
|
|
int retval;
|
2006-07-31 20:39:27 +02:00
|
|
|
|
2005-04-17 00:20:36 +02:00
|
|
|
retval = usb_serial_register(&pl2303_device);
|
|
|
|
if (retval)
|
|
|
|
goto failed_usb_serial_register;
|
|
|
|
retval = usb_register(&pl2303_driver);
|
|
|
|
if (retval)
|
|
|
|
goto failed_usb_register;
|
2008-08-18 22:21:04 +02:00
|
|
|
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
|
2005-04-17 00:20:36 +02:00
|
|
|
return 0;
|
|
|
|
failed_usb_register:
|
|
|
|
usb_serial_deregister(&pl2303_device);
|
|
|
|
failed_usb_serial_register:
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2006-07-31 20:39:27 +02:00
|
|
|
static void __exit pl2303_exit(void)
|
2005-04-17 00:20:36 +02:00
|
|
|
{
|
2006-07-31 20:39:27 +02:00
|
|
|
usb_deregister(&pl2303_driver);
|
|
|
|
usb_serial_deregister(&pl2303_device);
|
2005-04-17 00:20:36 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
module_init(pl2303_init);
|
|
|
|
module_exit(pl2303_exit);
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
module_param(debug, bool, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(debug, "Debug enabled or not");
|
|
|
|
|