2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Prolific PL2303 USB to serial adaptor driver
|
|
|
|
*
|
2007-06-13 02:43:37 +08:00
|
|
|
* Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
|
2005-04-17 06:20:36 +08:00
|
|
|
* Copyright (C) 2003 IBM Corp.
|
|
|
|
*
|
|
|
|
* Original driver for 2.2.x by anonymous
|
|
|
|
*
|
2007-06-13 02:43:37 +08: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 06:20:36 +08:00
|
|
|
*
|
2008-07-22 18:14:49 +08:00
|
|
|
* See Documentation/usb/usb-serial.txt for more information on using this
|
|
|
|
* driver
|
2005-04-17 06:20:36 +08: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 18:14:49 +08:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/usb.h>
|
2006-07-12 12:22:58 +08:00
|
|
|
#include <linux/usb/serial.h>
|
2005-04-17 06:20:36 +08: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)
|
|
|
|
|
|
|
|
#define PL2303_BUF_SIZE 1024
|
|
|
|
#define PL2303_TMP_BUF_SIZE 1024
|
|
|
|
|
|
|
|
struct pl2303_buf {
|
|
|
|
unsigned int buf_size;
|
|
|
|
char *buf_buf;
|
|
|
|
char *buf_get;
|
|
|
|
char *buf_put;
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_device_id id_table [] = {
|
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
|
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
|
2006-06-19 20:47:49 +08:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
|
2005-04-17 06:20:36 +08:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
|
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
|
2008-03-20 17:43:56 +08:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
|
2008-05-24 02:09:05 +08:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
|
2008-07-03 04:25:41 +08:00
|
|
|
{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
|
2005-04-17 06:20:36 +08:00
|
|
|
{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
|
2007-10-23 12:51:57 +08:00
|
|
|
{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
|
2005-04-17 06:20:36 +08: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 16:32:07 +08:00
|
|
|
{ USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
|
2005-04-17 06:20:36 +08: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-18 01:47:32 +08:00
|
|
|
{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
|
2005-04-17 06:20:36 +08:00
|
|
|
{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
|
2005-11-18 01:47:32 +08:00
|
|
|
{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
|
2007-08-24 07:51:11 +08:00
|
|
|
{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
|
2009-04-07 00:35:12 +08:00
|
|
|
{ USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
|
2005-04-19 08:39:32 +08:00
|
|
|
{ USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
|
2006-02-01 21:10:52 +08: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 21:52:38 +08:00
|
|
|
{ USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
|
2006-02-01 21:10:52 +08:00
|
|
|
{ USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
|
2006-03-01 16:53:33 +08:00
|
|
|
{ USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
|
2006-06-22 03:25:53 +08:00
|
|
|
{ USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
|
2006-07-25 13:54:59 +08:00
|
|
|
{ USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
|
2006-09-16 22:17:34 +08:00
|
|
|
{ USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
|
2007-01-26 21:51:38 +08:00
|
|
|
{ USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
|
2007-11-08 15:45:46 +08:00
|
|
|
{ USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
|
2008-01-07 02:51:39 +08:00
|
|
|
{ USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
|
2008-12-13 19:42:53 +08:00
|
|
|
{ USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
|
2008-12-17 04:30:14 +08:00
|
|
|
{ USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
|
2005-04-17 06:20:36 +08:00
|
|
|
{ } /* Terminating entry */
|
|
|
|
};
|
|
|
|
|
2006-08-01 02:39:27 +08:00
|
|
|
MODULE_DEVICE_TABLE(usb, id_table);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
static struct usb_driver pl2303_driver = {
|
|
|
|
.name = "pl2303",
|
|
|
|
.probe = usb_serial_probe,
|
|
|
|
.disconnect = usb_serial_disconnect,
|
|
|
|
.id_table = id_table,
|
2007-12-15 06:09:30 +08:00
|
|
|
.suspend = usb_serial_suspend,
|
|
|
|
.resume = usb_serial_resume,
|
2005-11-17 05:41:28 +08:00
|
|
|
.no_dynamic_id = 1,
|
2007-12-15 06:09:30 +08:00
|
|
|
.supports_autosuspend = 1,
|
2005-04-17 06:20:36 +08: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 18:14:49 +08:00
|
|
|
#define BREAK_REQUEST 0x23
|
2005-04-17 06:20:36 +08: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;
|
|
|
|
struct pl2303_buf *buf;
|
|
|
|
int write_urb_in_use;
|
|
|
|
wait_queue_head_t delta_msr_wait;
|
|
|
|
u8 line_control;
|
|
|
|
u8 line_status;
|
|
|
|
enum pl2303_type type;
|
|
|
|
};
|
|
|
|
|
2006-07-29 21:46:37 +08:00
|
|
|
/*
|
|
|
|
* pl2303_buf_alloc
|
|
|
|
*
|
|
|
|
* Allocate a circular buffer and all associated memory.
|
|
|
|
*/
|
|
|
|
static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
|
|
|
|
{
|
|
|
|
struct pl2303_buf *pb;
|
|
|
|
|
|
|
|
if (size == 0)
|
|
|
|
return NULL;
|
|
|
|
|
2006-12-13 16:35:56 +08:00
|
|
|
pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
|
2006-07-29 21:46:37 +08:00
|
|
|
if (pb == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
pb->buf_buf = kmalloc(size, GFP_KERNEL);
|
|
|
|
if (pb->buf_buf == NULL) {
|
|
|
|
kfree(pb);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
pb->buf_size = size;
|
|
|
|
pb->buf_get = pb->buf_put = pb->buf_buf;
|
|
|
|
|
|
|
|
return pb;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pl2303_buf_free
|
|
|
|
*
|
|
|
|
* Free the buffer and all associated memory.
|
|
|
|
*/
|
|
|
|
static void pl2303_buf_free(struct pl2303_buf *pb)
|
|
|
|
{
|
|
|
|
if (pb) {
|
|
|
|
kfree(pb->buf_buf);
|
|
|
|
kfree(pb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pl2303_buf_clear
|
|
|
|
*
|
|
|
|
* Clear out all data in the circular buffer.
|
|
|
|
*/
|
|
|
|
static void pl2303_buf_clear(struct pl2303_buf *pb)
|
|
|
|
{
|
|
|
|
if (pb != NULL)
|
|
|
|
pb->buf_get = pb->buf_put;
|
|
|
|
/* equivalent to a get of all data available */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pl2303_buf_data_avail
|
|
|
|
*
|
|
|
|
* Return the number of bytes of data available in the circular
|
|
|
|
* buffer.
|
|
|
|
*/
|
|
|
|
static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
|
|
|
|
{
|
|
|
|
if (pb == NULL)
|
|
|
|
return 0;
|
|
|
|
|
2008-07-22 18:14:49 +08:00
|
|
|
return (pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size;
|
2006-07-29 21:46:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pl2303_buf_space_avail
|
|
|
|
*
|
|
|
|
* Return the number of bytes of space available in the circular
|
|
|
|
* buffer.
|
|
|
|
*/
|
|
|
|
static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
|
|
|
|
{
|
|
|
|
if (pb == NULL)
|
|
|
|
return 0;
|
|
|
|
|
2008-07-22 18:14:49 +08:00
|
|
|
return (pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size;
|
2006-07-29 21:46:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pl2303_buf_put
|
|
|
|
*
|
|
|
|
* Copy data data from a user buffer and put it into the circular buffer.
|
|
|
|
* Restrict to the amount of space available.
|
|
|
|
*
|
|
|
|
* Return the number of bytes copied.
|
|
|
|
*/
|
|
|
|
static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf,
|
|
|
|
unsigned int count)
|
|
|
|
{
|
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
if (pb == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
len = pl2303_buf_space_avail(pb);
|
|
|
|
if (count > len)
|
|
|
|
count = len;
|
|
|
|
|
|
|
|
if (count == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
len = pb->buf_buf + pb->buf_size - pb->buf_put;
|
|
|
|
if (count > len) {
|
|
|
|
memcpy(pb->buf_put, buf, len);
|
|
|
|
memcpy(pb->buf_buf, buf+len, count - len);
|
|
|
|
pb->buf_put = pb->buf_buf + count - len;
|
|
|
|
} else {
|
|
|
|
memcpy(pb->buf_put, buf, count);
|
|
|
|
if (count < len)
|
|
|
|
pb->buf_put += count;
|
|
|
|
else /* count == len */
|
|
|
|
pb->buf_put = pb->buf_buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pl2303_buf_get
|
|
|
|
*
|
|
|
|
* Get data from the circular buffer and copy to the given buffer.
|
|
|
|
* Restrict to the amount of data available.
|
|
|
|
*
|
|
|
|
* Return the number of bytes copied.
|
|
|
|
*/
|
|
|
|
static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
|
|
|
|
unsigned int count)
|
|
|
|
{
|
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
if (pb == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
len = pl2303_buf_data_avail(pb);
|
|
|
|
if (count > len)
|
|
|
|
count = len;
|
|
|
|
|
|
|
|
if (count == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
len = pb->buf_buf + pb->buf_size - pb->buf_get;
|
|
|
|
if (count > len) {
|
|
|
|
memcpy(buf, pb->buf_get, len);
|
|
|
|
memcpy(buf+len, pb->buf_buf, count - len);
|
|
|
|
pb->buf_get = pb->buf_buf + count - len;
|
|
|
|
} else {
|
|
|
|
memcpy(buf, pb->buf_get, count);
|
|
|
|
if (count < len)
|
|
|
|
pb->buf_get += count;
|
|
|
|
else /* count == len */
|
|
|
|
pb->buf_get = pb->buf_buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-12-15 06:08:00 +08: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-08-01 02:39:27 +08:00
|
|
|
static int pl2303_startup(struct usb_serial *serial)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct pl2303_private *priv;
|
|
|
|
enum pl2303_type type = type_0;
|
2007-12-15 06:08:35 +08:00
|
|
|
unsigned char *buf;
|
2005-04-17 06:20:36 +08:00
|
|
|
int i;
|
|
|
|
|
2007-12-15 06:08:35 +08:00
|
|
|
buf = kmalloc(10, GFP_KERNEL);
|
|
|
|
if (buf == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2005-04-17 06:20:36 +08: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-28 04:29:43 +08:00
|
|
|
priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!priv)
|
|
|
|
goto cleanup;
|
|
|
|
spin_lock_init(&priv->lock);
|
|
|
|
priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
|
|
|
|
if (priv->buf == NULL) {
|
|
|
|
kfree(priv);
|
|
|
|
goto cleanup;
|
|
|
|
}
|
|
|
|
init_waitqueue_head(&priv->delta_msr_wait);
|
|
|
|
priv->type = type;
|
|
|
|
usb_set_serial_port_data(serial->port[i], priv);
|
|
|
|
}
|
2007-12-15 06:08:35 +08: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 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
cleanup:
|
2007-12-15 06:08:35 +08:00
|
|
|
kfree(buf);
|
2008-07-22 18:14:49 +08:00
|
|
|
for (--i; i >= 0; --i) {
|
2005-04-17 06:20:36 +08:00
|
|
|
priv = usb_get_serial_port_data(serial->port[i]);
|
|
|
|
pl2303_buf_free(priv->buf);
|
|
|
|
kfree(priv);
|
|
|
|
usb_set_serial_port_data(serial->port[i], NULL);
|
|
|
|
}
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2006-08-01 02:39:27 +08:00
|
|
|
static int set_control_lines(struct usb_device *dev, u8 value)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int retval;
|
2008-07-22 18:14:49 +08:00
|
|
|
|
2006-08-01 02:39:27 +08: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 08:08:34 +08:00
|
|
|
dbg("%s - value = %d, retval = %d", __func__, value, retval);
|
2005-04-17 06:20:36 +08:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void pl2303_send(struct usb_serial_port *port)
|
|
|
|
{
|
|
|
|
int count, result;
|
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
|
|
|
|
if (priv->write_urb_in_use) {
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
|
2006-08-01 02:39:27 +08:00
|
|
|
port->bulk_out_size);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (count == 0) {
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv->write_urb_in_use = 1;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
usb_serial_debug_data(debug, &port->dev, __func__, count,
|
2006-08-01 02:39:27 +08:00
|
|
|
port->write_urb->transfer_buffer);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
port->write_urb->transfer_buffer_length = count;
|
|
|
|
port->write_urb->dev = port->serial->dev;
|
2006-08-01 02:39:27 +08:00
|
|
|
result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result) {
|
2006-08-01 02:39:27 +08:00
|
|
|
dev_err(&port->dev, "%s - failed submitting write urb,"
|
2008-03-04 08:08:34 +08:00
|
|
|
" error %d\n", __func__, result);
|
2005-04-17 06:20:36 +08:00
|
|
|
priv->write_urb_in_use = 0;
|
2008-07-22 18:14:49 +08:00
|
|
|
/* TODO: reschedule pl2303_send */
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-05-23 12:58:49 +08:00
|
|
|
usb_serial_port_softint(port);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
static int pl2303_write(struct tty_struct *tty, struct usb_serial_port *port,
|
|
|
|
const unsigned char *buf, int count)
|
2006-07-29 21:46:37 +08:00
|
|
|
{
|
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - port %d, %d bytes", __func__, port->number, count);
|
2006-07-29 21:46:37 +08:00
|
|
|
|
|
|
|
if (!count)
|
|
|
|
return count;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
count = pl2303_buf_put(priv->buf, buf, count);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
pl2303_send(port);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
static int pl2303_write_room(struct tty_struct *tty)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-07-22 18:09:07 +08:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int room = 0;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
room = pl2303_buf_space_avail(priv->buf);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - returns %d", __func__, room);
|
2005-04-17 06:20:36 +08:00
|
|
|
return room;
|
|
|
|
}
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
static int pl2303_chars_in_buffer(struct tty_struct *tty)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-07-22 18:09:07 +08:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int chars = 0;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
chars = pl2303_buf_data_avail(priv->buf);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - returns %d", __func__, chars);
|
2005-04-17 06:20:36 +08:00
|
|
|
return chars;
|
|
|
|
}
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
static void pl2303_set_termios(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port, struct ktermios *old_termios)
|
2005-04-17 06:20:36 +08: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;
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-01-08 22:55:51 +08: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 18:09:07 +08:00
|
|
|
if (!tty_termios_hw_change(tty->termios, old_termios))
|
2008-01-08 22:55:51 +08:00
|
|
|
return;
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
cflag = tty->termios->c_cflag;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-08-01 02:39:27 +08:00
|
|
|
buf = kzalloc(7, GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!buf) {
|
2008-03-04 08:08:34 +08:00
|
|
|
dev_err(&port->dev, "%s - out of memory.\n", __func__);
|
2008-04-09 00:16:06 +08:00
|
|
|
/* Report back no change occurred */
|
2008-07-22 18:09:07 +08:00
|
|
|
*tty->termios = *old_termios;
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-08-01 02:39:27 +08: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 06:20:36 +08:00
|
|
|
|
|
|
|
if (cflag & CSIZE) {
|
|
|
|
switch (cflag & CSIZE) {
|
2008-07-22 18:14:49 +08: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 06:20:36 +08:00
|
|
|
}
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - data bits = %d", __func__, buf[6]);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
baud = tty_get_baud_rate(tty);
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - baud = %d", __func__, baud);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (baud) {
|
|
|
|
buf[0] = baud & 0xff;
|
|
|
|
buf[1] = (baud >> 8) & 0xff;
|
|
|
|
buf[2] = (baud >> 16) & 0xff;
|
|
|
|
buf[3] = (baud >> 24) & 0xff;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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) {
|
|
|
|
buf[4] = 2;
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - stop bits = 2", __func__);
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
|
|
|
buf[4] = 0;
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - stop bits = 1", __func__);
|
2005-04-17 06:20:36 +08: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) {
|
|
|
|
buf[5] = 1;
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - parity = odd", __func__);
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
|
|
|
buf[5] = 2;
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - parity = even", __func__);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
buf[5] = 0;
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - parity = none", __func__);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-08-01 02:39:27 +08: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 06:20:36 +08: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-08-01 02:39:27 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
|
|
|
|
|
2006-08-01 02:39:27 +08: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 06:20:36 +08:00
|
|
|
buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
|
|
|
|
|
|
|
|
if (cflag & CRTSCTS) {
|
|
|
|
if (priv->type == HX)
|
2007-12-15 06:08:00 +08:00
|
|
|
pl2303_vendor_write(0x0, 0x61, serial);
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
2007-12-15 06:08:00 +08:00
|
|
|
pl2303_vendor_write(0x0, 0x41, serial);
|
2007-04-25 21:05:22 +08:00
|
|
|
} else {
|
2007-12-15 06:08:00 +08:00
|
|
|
pl2303_vendor_write(0x0, 0x0, serial);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-07-29 21:46:37 +08:00
|
|
|
|
2007-10-16 03:54:47 +08:00
|
|
|
/* FIXME: Need to read back resulting baud rate */
|
|
|
|
if (baud)
|
2008-07-22 18:09:07 +08:00
|
|
|
tty_encode_baud_rate(tty, baud, baud);
|
2007-10-16 03:54:47 +08:00
|
|
|
|
2006-07-29 21:46:37 +08:00
|
|
|
kfree(buf);
|
|
|
|
}
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
static void pl2303_close(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port, struct file *filp)
|
2006-07-29 21:46:37 +08:00
|
|
|
{
|
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int c_cflag;
|
|
|
|
int bps;
|
|
|
|
long timeout;
|
|
|
|
wait_queue_t wait;
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2006-07-29 21:46:37 +08:00
|
|
|
|
|
|
|
/* wait for data to drain from the buffer */
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
timeout = PL2303_CLOSING_WAIT;
|
|
|
|
init_waitqueue_entry(&wait, current);
|
2008-07-22 18:09:07 +08:00
|
|
|
add_wait_queue(&tty->write_wait, &wait);
|
2006-07-29 21:46:37 +08:00
|
|
|
for (;;) {
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
if (pl2303_buf_data_avail(priv->buf) == 0 ||
|
|
|
|
timeout == 0 || signal_pending(current) ||
|
2008-01-23 19:28:45 +08:00
|
|
|
port->serial->disconnected)
|
2006-07-29 21:46:37 +08:00
|
|
|
break;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
timeout = schedule_timeout(timeout);
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
}
|
|
|
|
set_current_state(TASK_RUNNING);
|
2008-07-22 18:09:07 +08:00
|
|
|
remove_wait_queue(&tty->write_wait, &wait);
|
2006-07-29 21:46:37 +08:00
|
|
|
/* clear out any remaining data in the buffer */
|
|
|
|
pl2303_buf_clear(priv->buf);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
/* wait for characters to drain from the device */
|
|
|
|
/* (this is long enough for the entire 256 byte */
|
|
|
|
/* pl2303 hardware buffer to drain with no flow */
|
|
|
|
/* control for data rates of 1200 bps or more, */
|
|
|
|
/* for lower rates we should really know how much */
|
|
|
|
/* data is in the buffer to compute a delay */
|
|
|
|
/* that is not unnecessarily long) */
|
2008-07-22 18:09:07 +08:00
|
|
|
bps = tty_get_baud_rate(tty);
|
2006-07-29 21:46:37 +08:00
|
|
|
if (bps > 1200)
|
2008-07-22 18:14:49 +08:00
|
|
|
timeout = max((HZ*2560)/bps, HZ/10);
|
2006-07-29 21:46:37 +08:00
|
|
|
else
|
|
|
|
timeout = 2*HZ;
|
|
|
|
schedule_timeout_interruptible(timeout);
|
|
|
|
|
|
|
|
/* shutdown our urbs */
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - shutting down urbs", __func__);
|
2006-07-29 21:46:37 +08:00
|
|
|
usb_kill_urb(port->write_urb);
|
|
|
|
usb_kill_urb(port->read_urb);
|
|
|
|
usb_kill_urb(port->interrupt_in_urb);
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
if (tty) {
|
|
|
|
c_cflag = tty->termios->c_cflag;
|
2006-07-29 21:46:37 +08:00
|
|
|
if (c_cflag & HUPCL) {
|
|
|
|
/* drop DTR and RTS */
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
priv->line_control = 0;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
set_control_lines(port->serial->dev, 0);
|
|
|
|
}
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
static int pl2303_open(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port, struct file *filp)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-12-08 18:38:45 +08:00
|
|
|
struct ktermios tmp_termios;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int result;
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-07-29 00:06:13 +08: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-15 06:08:35 +08:00
|
|
|
} else {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* reset upstream data pipes */
|
2007-12-15 06:08:00 +08:00
|
|
|
pl2303_vendor_write(8, 0, serial);
|
|
|
|
pl2303_vendor_write(9, 0, serial);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Setup termios */
|
2008-07-22 18:09:07 +08:00
|
|
|
if (tty)
|
|
|
|
pl2303_set_termios(tty, port, &tmp_termios);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-22 18:14:49 +08:00
|
|
|
/* FIXME: need to assert RTS and DTR if CRTSCTS off */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - submitting read urb", __func__);
|
2005-04-17 06:20:36 +08:00
|
|
|
port->read_urb->dev = serial->dev;
|
2006-08-01 02:39:27 +08:00
|
|
|
result = usb_submit_urb(port->read_urb, GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result) {
|
2006-08-01 02:39:27 +08:00
|
|
|
dev_err(&port->dev, "%s - failed submitting read urb,"
|
2008-03-04 08:08:34 +08:00
|
|
|
" error %d\n", __func__, result);
|
2008-07-22 18:09:07 +08:00
|
|
|
pl2303_close(tty, port, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EPROTO;
|
|
|
|
}
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - submitting interrupt urb", __func__);
|
2005-04-17 06:20:36 +08:00
|
|
|
port->interrupt_in_urb->dev = serial->dev;
|
2006-08-01 02:39:27 +08:00
|
|
|
result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result) {
|
2006-08-01 02:39:27 +08:00
|
|
|
dev_err(&port->dev, "%s - failed submitting interrupt urb,"
|
2008-03-04 08:08:34 +08:00
|
|
|
" error %d\n", __func__, result);
|
2008-07-22 18:09:07 +08:00
|
|
|
pl2303_close(tty, port, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EPROTO;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
|
2006-08-01 02:39:27 +08:00
|
|
|
unsigned int set, unsigned int clear)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-07-22 18:09:07 +08:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
|
|
|
u8 control;
|
|
|
|
|
2005-04-19 08:39:31 +08:00
|
|
|
if (!usb_get_intfdata(port->serial->interface))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2006-08-01 02:39:27 +08:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-04-17 06:20:36 +08: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-08-01 02:39:27 +08:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-08-01 02:39:27 +08:00
|
|
|
return set_control_lines(port->serial->dev, control);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-07-22 18:09:07 +08:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 06:20:36 +08: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 08:08:34 +08:00
|
|
|
dbg("%s (%d)", __func__, port->number);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-04-19 08:39:31 +08:00
|
|
|
if (!usb_get_intfdata(port->serial->interface))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2006-08-01 02:39:27 +08:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
mcr = priv->line_control;
|
|
|
|
status = priv->line_status;
|
2006-08-01 02:39:27 +08:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2005-04-17 06:20:36 +08: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 08:08:34 +08:00
|
|
|
dbg("%s - result = %x", __func__, result);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
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-08-01 02:39:27 +08:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
prevstatus = priv->line_status;
|
2006-08-01 02:39:27 +08:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
while (1) {
|
|
|
|
interruptible_sleep_on(&priv->delta_msr_wait);
|
|
|
|
/* see if a signal did it */
|
|
|
|
if (signal_pending(current))
|
|
|
|
return -ERESTARTSYS;
|
2006-08-01 02:39:27 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
status = priv->line_status;
|
2006-08-01 02:39:27 +08:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-07-22 18:14:49 +08:00
|
|
|
changed = prevstatus ^ status;
|
2006-08-01 02:39:27 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
|
|
|
|
((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
|
|
|
|
((arg & TIOCM_CD) && (changed & UART_DCD)) ||
|
2008-07-22 18:14:49 +08:00
|
|
|
((arg & TIOCM_CTS) && (changed & UART_CTS))) {
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
prevstatus = status;
|
|
|
|
}
|
|
|
|
/* NOTREACHED */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
|
2006-08-01 02:39:27 +08:00
|
|
|
unsigned int cmd, unsigned long arg)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-07-22 18:09:07 +08:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
switch (cmd) {
|
2008-07-22 18:14:49 +08: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 06:20:36 +08:00
|
|
|
}
|
|
|
|
return -ENOIOCTLCMD;
|
|
|
|
}
|
|
|
|
|
2008-07-22 18:09:07 +08:00
|
|
|
static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-07-22 18:09:07 +08:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
u16 state;
|
|
|
|
int result;
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (break_state == 0)
|
|
|
|
state = BREAK_OFF;
|
|
|
|
else
|
|
|
|
state = BREAK_ON;
|
2008-07-22 18:14:49 +08:00
|
|
|
dbg("%s - turning break %s", __func__,
|
|
|
|
state == BREAK_OFF ? "off" : "on");
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-08-01 02:39:27 +08: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 06:20:36 +08:00
|
|
|
if (result)
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - error sending break = %d", __func__, result);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2006-08-01 02:39:27 +08:00
|
|
|
static void pl2303_shutdown(struct usb_serial *serial)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct pl2303_private *priv;
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s", __func__);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
for (i = 0; i < serial->num_ports; ++i) {
|
|
|
|
priv = usb_get_serial_port_data(serial->port[i]);
|
|
|
|
if (priv) {
|
|
|
|
pl2303_buf_free(priv->buf);
|
|
|
|
kfree(priv);
|
|
|
|
usb_set_serial_port_data(serial->port[i], NULL);
|
|
|
|
}
|
2006-08-01 02:39:27 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2005-04-19 08:39:31 +08: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);
|
|
|
|
unsigned long flags;
|
|
|
|
u8 status_idx = UART_STATE;
|
2005-07-28 21:32:20 +08:00
|
|
|
u8 length = UART_STATE + 1;
|
2006-07-29 21:47:12 +08:00
|
|
|
u16 idv, idp;
|
2005-04-19 08:39:31 +08:00
|
|
|
|
2006-07-29 21:47:12 +08: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 08:39:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (actual_length < length)
|
2006-07-26 03:58:30 +08:00
|
|
|
return;
|
2005-04-19 08:39:31 +08:00
|
|
|
|
2008-07-22 18:14:49 +08:00
|
|
|
/* Save off the uart status for others to look at */
|
2005-04-19 08:39:31 +08:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
priv->line_status = data[status_idx];
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2006-08-01 02:39:27 +08:00
|
|
|
wake_up_interruptible(&priv->delta_msr_wait);
|
2005-04-19 08:39:31 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08: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 21:55:46 +08:00
|
|
|
static void pl2303_read_int_callback(struct urb *urb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-02-24 18:41:47 +08:00
|
|
|
struct usb_serial_port *port = urb->context;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned char *data = urb->transfer_buffer;
|
2005-04-19 08:39:31 +08:00
|
|
|
unsigned int actual_length = urb->actual_length;
|
2007-06-16 06:44:13 +08:00
|
|
|
int status = urb->status;
|
|
|
|
int retval;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s (%d)", __func__, port->number);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-06-16 06:44:13 +08:00
|
|
|
switch (status) {
|
2005-04-17 06:20:36 +08:00
|
|
|
case 0:
|
|
|
|
/* success */
|
|
|
|
break;
|
|
|
|
case -ECONNRESET:
|
|
|
|
case -ENOENT:
|
|
|
|
case -ESHUTDOWN:
|
|
|
|
/* this urb is terminated, clean up */
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - urb shutting down with status: %d", __func__,
|
2007-06-16 06:44:13 +08:00
|
|
|
status);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
default:
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - nonzero urb status received: %d", __func__,
|
2007-06-16 06:44:13 +08:00
|
|
|
status);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
usb_serial_debug_data(debug, &port->dev, __func__,
|
2006-08-01 02:39:27 +08:00
|
|
|
urb->actual_length, urb->transfer_buffer);
|
|
|
|
|
2005-04-19 08:39:31 +08:00
|
|
|
pl2303_update_line_status(port, data, actual_length);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
exit:
|
2007-06-16 06:44:13 +08:00
|
|
|
retval = usb_submit_urb(urb, GFP_ATOMIC);
|
|
|
|
if (retval)
|
2006-08-01 02:39:27 +08:00
|
|
|
dev_err(&urb->dev->dev,
|
|
|
|
"%s - usb_submit_urb failed with result %d\n",
|
2008-03-04 08:08:34 +08:00
|
|
|
__func__, retval);
|
2005-04-17 06:20:36 +08: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 21:55:46 +08:00
|
|
|
static void pl2303_read_bulk_callback(struct urb *urb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-02-24 18:41:47 +08:00
|
|
|
struct usb_serial_port *port = urb->context;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
struct tty_struct *tty;
|
|
|
|
unsigned char *data = urb->transfer_buffer;
|
|
|
|
unsigned long flags;
|
|
|
|
int i;
|
|
|
|
int result;
|
2007-06-16 06:44:13 +08:00
|
|
|
int status = urb->status;
|
|
|
|
u8 line_status;
|
2005-04-17 06:20:36 +08:00
|
|
|
char tty_flag;
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-06-16 06:44:13 +08:00
|
|
|
if (status) {
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - urb status = %d", __func__, status);
|
2008-07-22 18:09:07 +08:00
|
|
|
if (!port->port.count) {
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - port is closed, exiting.", __func__);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
2007-06-16 06:44:13 +08:00
|
|
|
if (status == -EPROTO) {
|
2006-08-01 02:39:27 +08:00
|
|
|
/* PL2303 mysteriously fails with -EPROTO reschedule
|
|
|
|
* the read */
|
|
|
|
dbg("%s - caught -EPROTO, resubmitting the urb",
|
2008-03-04 08:08:34 +08:00
|
|
|
__func__);
|
2005-04-17 06:20:36 +08:00
|
|
|
urb->dev = port->serial->dev;
|
|
|
|
result = usb_submit_urb(urb, GFP_ATOMIC);
|
|
|
|
if (result)
|
2006-08-01 02:39:27 +08:00
|
|
|
dev_err(&urb->dev->dev, "%s - failed"
|
|
|
|
" resubmitting read urb, error %d\n",
|
2008-03-04 08:08:34 +08:00
|
|
|
__func__, result);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - unable to handle the error, exiting.", __func__);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
usb_serial_debug_data(debug, &port->dev, __func__,
|
2006-08-01 02:39:27 +08:00
|
|
|
urb->actual_length, data);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* get tty_flag from status */
|
|
|
|
tty_flag = TTY_NORMAL;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2007-06-16 06:44:13 +08:00
|
|
|
line_status = priv->line_status;
|
2005-04-17 06:20:36 +08:00
|
|
|
priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2006-08-01 02:39:27 +08:00
|
|
|
wake_up_interruptible(&priv->delta_msr_wait);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* break takes precedence over parity, */
|
|
|
|
/* which takes precedence over framing errors */
|
2008-07-22 18:14:49 +08:00
|
|
|
if (line_status & UART_BREAK_ERROR)
|
2005-04-17 06:20:36 +08:00
|
|
|
tty_flag = TTY_BREAK;
|
2007-06-16 06:44:13 +08:00
|
|
|
else if (line_status & UART_PARITY_ERROR)
|
2005-04-17 06:20:36 +08:00
|
|
|
tty_flag = TTY_PARITY;
|
2007-06-16 06:44:13 +08:00
|
|
|
else if (line_status & UART_FRAME_ERROR)
|
2005-04-17 06:20:36 +08:00
|
|
|
tty_flag = TTY_FRAME;
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - tty_flag = %d", __func__, tty_flag);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-10-13 17:39:46 +08:00
|
|
|
tty = tty_port_tty_get(&port->port);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (tty && urb->actual_length) {
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-10 12:54:13 +08:00
|
|
|
tty_buffer_request_room(tty, urb->actual_length + 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
/* overrun is special, not associated with a char */
|
2007-06-16 06:44:13 +08:00
|
|
|
if (line_status & UART_OVERRUN_ERROR)
|
2005-04-17 06:20:36 +08:00
|
|
|
tty_insert_flip_char(tty, 0, TTY_OVERRUN);
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-10 12:54:13 +08:00
|
|
|
for (i = 0; i < urb->actual_length; ++i)
|
2006-08-01 02:39:27 +08:00
|
|
|
tty_insert_flip_char(tty, data[i], tty_flag);
|
|
|
|
tty_flip_buffer_push(tty);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-10-13 17:39:46 +08:00
|
|
|
tty_kref_put(tty);
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Schedule the next read _if_ we are still open */
|
2008-07-22 18:09:07 +08:00
|
|
|
if (port->port.count) {
|
2005-04-17 06:20:36 +08:00
|
|
|
urb->dev = port->serial->dev;
|
|
|
|
result = usb_submit_urb(urb, GFP_ATOMIC);
|
|
|
|
if (result)
|
2006-08-01 02:39:27 +08:00
|
|
|
dev_err(&urb->dev->dev, "%s - failed resubmitting"
|
2008-03-04 08:08:34 +08:00
|
|
|
" read urb, error %d\n", __func__, result);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
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 21:55:46 +08:00
|
|
|
static void pl2303_write_bulk_callback(struct urb *urb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-02-24 18:41:47 +08:00
|
|
|
struct usb_serial_port *port = urb->context;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct pl2303_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int result;
|
2007-06-16 06:44:13 +08:00
|
|
|
int status = urb->status;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-06-16 06:44:13 +08:00
|
|
|
switch (status) {
|
2005-04-17 06:20:36 +08:00
|
|
|
case 0:
|
|
|
|
/* success */
|
|
|
|
break;
|
|
|
|
case -ECONNRESET:
|
|
|
|
case -ENOENT:
|
|
|
|
case -ESHUTDOWN:
|
|
|
|
/* this urb is terminated, clean up */
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - urb shutting down with status: %d", __func__,
|
2007-06-16 06:44:13 +08:00
|
|
|
status);
|
2005-04-17 06:20:36 +08:00
|
|
|
priv->write_urb_in_use = 0;
|
|
|
|
return;
|
|
|
|
default:
|
|
|
|
/* error in the urb, so we have to resubmit it */
|
2008-03-04 08:08:34 +08:00
|
|
|
dbg("%s - Overflow in write", __func__);
|
|
|
|
dbg("%s - nonzero write bulk status received: %d", __func__,
|
2007-06-16 06:44:13 +08:00
|
|
|
status);
|
2005-04-17 06:20:36 +08:00
|
|
|
port->write_urb->transfer_buffer_length = 1;
|
|
|
|
port->write_urb->dev = port->serial->dev;
|
2006-08-01 02:39:27 +08:00
|
|
|
result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result)
|
2006-08-01 02:39:27 +08:00
|
|
|
dev_err(&urb->dev->dev, "%s - failed resubmitting write"
|
2008-03-04 08:08:34 +08:00
|
|
|
" urb, error %d\n", __func__, result);
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv->write_urb_in_use = 0;
|
|
|
|
|
|
|
|
/* send any buffered data */
|
|
|
|
pl2303_send(port);
|
|
|
|
}
|
|
|
|
|
2006-07-29 21:46:37 +08: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-18 04:50:24 +08:00
|
|
|
.usb_driver = &pl2303_driver,
|
2006-07-29 21:46:37 +08:00
|
|
|
.num_ports = 1,
|
|
|
|
.open = pl2303_open,
|
|
|
|
.close = pl2303_close,
|
|
|
|
.write = pl2303_write,
|
|
|
|
.ioctl = pl2303_ioctl,
|
|
|
|
.break_ctl = pl2303_break_ctl,
|
|
|
|
.set_termios = pl2303_set_termios,
|
|
|
|
.tiocmget = pl2303_tiocmget,
|
|
|
|
.tiocmset = pl2303_tiocmset,
|
|
|
|
.read_bulk_callback = pl2303_read_bulk_callback,
|
|
|
|
.read_int_callback = pl2303_read_int_callback,
|
|
|
|
.write_bulk_callback = pl2303_write_bulk_callback,
|
|
|
|
.write_room = pl2303_write_room,
|
|
|
|
.chars_in_buffer = pl2303_chars_in_buffer,
|
|
|
|
.attach = pl2303_startup,
|
|
|
|
.shutdown = pl2303_shutdown,
|
|
|
|
};
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-08-01 02:39:27 +08:00
|
|
|
static int __init pl2303_init(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int retval;
|
2006-08-01 02:39:27 +08:00
|
|
|
|
2005-04-17 06:20:36 +08: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-19 04:21:04 +08:00
|
|
|
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
failed_usb_register:
|
|
|
|
usb_serial_deregister(&pl2303_device);
|
|
|
|
failed_usb_serial_register:
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2006-08-01 02:39:27 +08:00
|
|
|
static void __exit pl2303_exit(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-08-01 02:39:27 +08:00
|
|
|
usb_deregister(&pl2303_driver);
|
|
|
|
usb_serial_deregister(&pl2303_device);
|
2005-04-17 06:20:36 +08: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");
|
|
|
|
|