leandrof/linux
1
0
Fork 0
forked from Minki/linux
Code Issues Pull Requests Packages Projects Releases Wiki Activity

usb_serial: API all change

Browse Source 
USB serial likes to use port->tty back pointers for the real work it does and
to do so without any actual locking. Unfortunately when you consider hangup
events, hangup/parallel reopen or even worse hangup followed by parallel close
events the tty->port and port->tty pointers are not guaranteed to be the same
as port->tty is the active tty while tty->port is the port the tty may or
may not still be attached to.

So rework the entire API to pass the tty struct. For console cases we need
to pass both for now. This shows up multiple drivers that immediately crash
with USB console some of which have been fixed in the process.

Longer term we need a proper tty as console abstraction

Signed-off-by: Alan Cox <alan@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Alan Cox 2008-07-22 11:09:07 +01:00 committed by Linus Torvalds
parent 1aa3692da5
commit 95da310e66
42 changed files with 1819 additions and 1719 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
drivers/usb/serial/aircable.c
View File

@ -272,7 +272,7 @@ static void aircable_read(struct work_struct *work)
* 64 bytes, to ensure I do not get throttled.
* Ask USB mailing list for better aproach.
*/
tty = port->tty;
tty = port->port.tty;
if (!tty) {
schedule_work(&priv->rx_work);
@ -378,13 +378,14 @@ static void aircable_shutdown(struct usb_serial *serial)
}
}
static int aircable_write_room(struct usb_serial_port *port)
static int aircable_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct aircable_private *priv = usb_get_serial_port_data(port);
return serial_buf_data_avail(priv->tx_buf);
}
static int aircable_write(struct usb_serial_port *port,
static int aircable_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *source, int count)
{
struct aircable_private *priv = usb_get_serial_port_data(port);
@ -466,7 +467,7 @@ static void aircable_read_bulk_callback(struct urb *urb)
if (status) {
dbg("%s - urb status = %d", __func__, status);
if (!port->open_count) {
if (!port->port.count) {
dbg("%s - port is closed, exiting.", __func__);
return;
}
@ -494,7 +495,7 @@ static void aircable_read_bulk_callback(struct urb *urb)
usb_serial_debug_data(debug, &port->dev, __func__,
urb->actual_length, urb->transfer_buffer);
tty = port->tty;
tty = port->port.tty;
if (tty && urb->actual_length) {
if (urb->actual_length <= 2) {
/* This is an incomplete package */
@ -528,7 +529,7 @@ static void aircable_read_bulk_callback(struct urb *urb)
}
/* Schedule the next read _if_ we are still open */
if (port->open_count) {
if (port->port.count) {
usb_fill_bulk_urb(port->read_urb, port->serial->dev,
usb_rcvbulkpipe(port->serial->dev,
port->bulk_in_endpointAddress),
@ -547,8 +548,9 @@ static void aircable_read_bulk_callback(struct urb *urb)
}
/* Based on ftdi_sio.c throttle */
static void aircable_throttle(struct usb_serial_port *port)
static void aircable_throttle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct aircable_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -560,8 +562,9 @@ static void aircable_throttle(struct usb_serial_port *port)
}
/* Based on ftdi_sio.c unthrottle */
static void aircable_unthrottle(struct usb_serial_port *port)
static void aircable_unthrottle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct aircable_private *priv = usb_get_serial_port_data(port);
int actually_throttled;
unsigned long flags;

355
drivers/usb/serial/airprime.c Normal file
View File

@ -0,0 +1,355 @@
/*
* AirPrime CDMA Wireless Serial USB driver
*
* Copyright (C) 2005-2006 Greg Kroah-Hartman <gregkh@suse.de>
*
* 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.
*/
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>
static struct usb_device_id id_table [] = {
{ USB_DEVICE(0x0c88, 0x17da) }, /* Kyocera Wireless KPC650/Passport */
{ },
};
MODULE_DEVICE_TABLE(usb, id_table);
#define URB_TRANSFER_BUFFER_SIZE 4096
#define NUM_READ_URBS 4
#define NUM_WRITE_URBS 4
#define NUM_BULK_EPS 3
#define MAX_BULK_EPS 6
/* if overridden by the user, then use their value for the size of the
* read and write urbs, and the number of endpoints */
static int buffer_size = URB_TRANSFER_BUFFER_SIZE;
static int endpoints = NUM_BULK_EPS;
static int debug;
struct airprime_private {
spinlock_t lock;
int outstanding_urbs;
int throttled;
struct urb *read_urbp[NUM_READ_URBS];
/* Settings for the port */
int rts_state; /* Handshaking pins (outputs) */
int dtr_state;
int cts_state; /* Handshaking pins (inputs) */
int dsr_state;
int dcd_state;
int ri_state;
};
static int airprime_send_setup(struct usb_serial_port *port)
{
struct usb_serial *serial = port->serial;
struct airprime_private *priv;
dbg("%s", __func__);
if (port->number != 0)
return 0;
priv = usb_get_serial_port_data(port);
if (port->port.tty) {
int val = 0;
if (priv->dtr_state)
val |= 0x01;
if (priv->rts_state)
val |= 0x02;
return usb_control_msg(serial->dev,
usb_rcvctrlpipe(serial->dev, 0),
0x22, 0x21, val, 0, NULL, 0,
USB_CTRL_SET_TIMEOUT);
}
return 0;
}
static void airprime_read_bulk_callback(struct urb *urb)
{
struct usb_serial_port *port = urb->context;
unsigned char *data = urb->transfer_buffer;
struct tty_struct *tty;
int result;
int status = urb->status;
dbg("%s - port %d", __func__, port->number);
if (status) {
dbg("%s - nonzero read bulk status received: %d",
__func__, status);
return;
}
usb_serial_debug_data(debug, &port->dev, __func__,
urb->actual_length, data);
tty = port->port.tty;
if (tty && urb->actual_length) {
tty_insert_flip_string(tty, data, urb->actual_length);
tty_flip_buffer_push(tty);
}
result = usb_submit_urb(urb, GFP_ATOMIC);
if (result)
dev_err(&port->dev,
"%s - failed resubmitting read urb, error %d\n",
__func__, result);
return;
}
static void airprime_write_bulk_callback(struct urb *urb)
{
struct usb_serial_port *port = urb->context;
struct airprime_private *priv = usb_get_serial_port_data(port);
int status = urb->status;
unsigned long flags;
dbg("%s - port %d", __func__, port->number);
/* free up the transfer buffer, as usb_free_urb() does not do this */
kfree(urb->transfer_buffer);
if (status)
dbg("%s - nonzero write bulk status received: %d",
__func__, status);
spin_lock_irqsave(&priv->lock, flags);
--priv->outstanding_urbs;
spin_unlock_irqrestore(&priv->lock, flags);
usb_serial_port_softint(port);
}
static int airprime_open(struct tty_struct *tty, struct usb_serial_port *port,
struct file *filp)
{
struct airprime_private *priv = usb_get_serial_port_data(port);
struct usb_serial *serial = port->serial;
struct urb *urb;
char *buffer = NULL;
int i;
int result = 0;
dbg("%s - port %d", __func__, port->number);
/* initialize our private data structure if it isn't already created */
if (!priv) {
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
if (!priv) {
result = -ENOMEM;
goto out;
}
spin_lock_init(&priv->lock);
usb_set_serial_port_data(port, priv);
}
/* Set some sane defaults */
priv->rts_state = 1;
priv->dtr_state = 1;
for (i = 0; i < NUM_READ_URBS; ++i) {
buffer = kmalloc(buffer_size, GFP_KERNEL);
if (!buffer) {
dev_err(&port->dev, "%s - out of memory.\n",
__func__);
result = -ENOMEM;
goto errout;
}
urb = usb_alloc_urb(0, GFP_KERNEL);
if (!urb) {
kfree(buffer);
dev_err(&port->dev, "%s - no more urbs?\n",
__func__);
result = -ENOMEM;
goto errout;
}
usb_fill_bulk_urb(urb, serial->dev,
usb_rcvbulkpipe(serial->dev,
port->bulk_out_endpointAddress),
buffer, buffer_size,
airprime_read_bulk_callback, port);
result = usb_submit_urb(urb, GFP_KERNEL);
if (result) {
usb_free_urb(urb);
kfree(buffer);
dev_err(&port->dev,
"%s - failed submitting read urb %d for port %d, error %d\n",
__func__, i, port->number, result);
goto errout;
}
/* remember this urb so we can kill it when the
port is closed */
priv->read_urbp[i] = urb;
}
airprime_send_setup(port);
goto out;
errout:
/* some error happened, cancel any submitted urbs and clean up
anything that got allocated successfully */
while (i-- != 0) {
urb = priv->read_urbp[i];
buffer = urb->transfer_buffer;
usb_kill_urb(urb);
usb_free_urb(urb);
kfree(buffer);
}
out:
return result;
}
static void airprime_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct airprime_private *priv = usb_get_serial_port_data(port);
int i;
dbg("%s - port %d", __func__, port->number);
priv->rts_state = 0;
priv->dtr_state = 0;
mutex_lock(&port->serial->disc_mutex);
if (!port->serial->disconnected)
airprime_send_setup(port);
mutex_unlock(&port->serial->disc_mutex);
for (i = 0; i < NUM_READ_URBS; ++i) {
usb_kill_urb(priv->read_urbp[i]);
kfree(priv->read_urbp[i]->transfer_buffer);
usb_free_urb(priv->read_urbp[i]);
}
/* free up private structure */
kfree(priv);
usb_set_serial_port_data(port, NULL);
}
static int airprime_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
struct airprime_private *priv = usb_get_serial_port_data(port);
struct usb_serial *serial = port->serial;
struct urb *urb;
unsigned char *buffer;
unsigned long flags;
int status;
dbg("%s - port %d", __func__, port->number);
spin_lock_irqsave(&priv->lock, flags);
if (priv->outstanding_urbs > NUM_WRITE_URBS) {
spin_unlock_irqrestore(&priv->lock, flags);
dbg("%s - write limit hit\n", __func__);
return 0;
}
spin_unlock_irqrestore(&priv->lock, flags);
buffer = kmalloc(count, GFP_ATOMIC);
if (!buffer) {
dev_err(&port->dev, "out of memory\n");
return -ENOMEM;
}
urb = usb_alloc_urb(0, GFP_ATOMIC);
if (!urb) {
dev_err(&port->dev, "no more free urbs\n");
kfree(buffer);
return -ENOMEM;
}
memcpy(buffer, buf, count);
usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
usb_fill_bulk_urb(urb, serial->dev,
usb_sndbulkpipe(serial->dev,
port->bulk_out_endpointAddress),
buffer, count,
airprime_write_bulk_callback, port);
/* send it down the pipe */
status = usb_submit_urb(urb, GFP_ATOMIC);
if (status) {
dev_err(&port->dev,
"%s - usb_submit_urb(write bulk) failed with status = %d\n",
__func__, status);
count = status;
kfree(buffer);
} else {
spin_lock_irqsave(&priv->lock, flags);
++priv->outstanding_urbs;
spin_unlock_irqrestore(&priv->lock, flags);
}
/* we are done with this urb, so let the host driver
* really free it when it is finished with it */
usb_free_urb(urb);
return count;
}
static struct usb_driver airprime_driver = {
.name = "airprime",
.probe = usb_serial_probe,
.disconnect = usb_serial_disconnect,
.id_table = id_table,
.no_dynamic_id = 1,
};
static struct usb_serial_driver airprime_device = {
.driver = {
.owner = THIS_MODULE,
.name = "airprime",
},
.usb_driver = &airprime_driver,
.id_table = id_table,
.open = airprime_open,
.close = airprime_close,
.write = airprime_write,
};
static int __init airprime_init(void)
{
int retval;
airprime_device.num_ports = endpoints;
if (endpoints < 0 || endpoints >= MAX_BULK_EPS)
airprime_device.num_ports = NUM_BULK_EPS;
retval = usb_serial_register(&airprime_device);
if (retval)
return retval;
retval = usb_register(&airprime_driver);
if (retval)
usb_serial_deregister(&airprime_device);
return retval;
}
static void __exit airprime_exit(void)
{
dbg("%s", __func__);
usb_deregister(&airprime_driver);
usb_serial_deregister(&airprime_device);
}
module_init(airprime_init);
module_exit(airprime_exit);
MODULE_LICENSE("GPL");
module_param(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Debug enabled");
module_param(buffer_size, int, 0);
MODULE_PARM_DESC(buffer_size,
"Size of the transfer buffers in bytes (default 4096)");
module_param(endpoints, int, 0);
MODULE_PARM_DESC(endpoints, "Number of bulk EPs to configure (default 3)");

32
drivers/usb/serial/ark3116.c
View File

@ -158,12 +158,13 @@ cleanup:
return -ENOMEM;
}
static void ark3116_set_termios(struct usb_serial_port *port,
static void ark3116_set_termios(struct tty_struct *tty,
struct usb_serial_port *port,
struct ktermios *old_termios)
{
struct usb_serial *serial = port->serial;
struct ark3116_private *priv = usb_get_serial_port_data(port);
struct ktermios *termios = port->tty->termios;
struct ktermios *termios = tty->termios;
unsigned int cflag = termios->c_cflag;
unsigned long flags;
int baud;
@ -177,8 +178,8 @@ static void ark3116_set_termios(struct usb_serial_port *port,
spin_lock_irqsave(&priv->lock, flags);
if (!priv->termios_initialized) {
*(port->tty->termios) = tty_std_termios;
port->tty->termios->c_cflag = B9600 | CS8
*termios = tty_std_termios;
termios->c_cflag = B9600 | CS8
| CREAD | HUPCL | CLOCAL;
termios->c_ispeed = 9600;
termios->c_ospeed = 9600;
@ -192,7 +193,7 @@ static void ark3116_set_termios(struct usb_serial_port *port,
buf = kmalloc(1, GFP_KERNEL);
if (!buf) {
dbg("error kmalloc");
*port->tty->termios = *old_termios;
*termios = *old_termios;
return;
}
@ -243,7 +244,7 @@ static void ark3116_set_termios(struct usb_serial_port *port,
}
/* set baudrate */
baud = tty_get_baud_rate(port->tty);
baud = tty_get_baud_rate(tty);
switch (baud) {
case 75:
@ -262,11 +263,11 @@ static void ark3116_set_termios(struct usb_serial_port *port,
case 230400:
case 460800:
/* Report the resulting rate back to the caller */
tty_encode_baud_rate(port->tty, baud, baud);
tty_encode_baud_rate(tty, baud, baud);
break;
/* set 9600 as default (if given baudrate is invalid for example) */
default:
tty_encode_baud_rate(port->tty, 9600, 9600);
tty_encode_baud_rate(tty, 9600, 9600);
case 0:
baud = 9600;
}
@ -317,7 +318,8 @@ static void ark3116_set_termios(struct usb_serial_port *port,
return;
}
static int ark3116_open(struct usb_serial_port *port, struct file *filp)
static int ark3116_open(struct tty_struct *tty, struct usb_serial_port *port,
struct file *filp)
{
struct ktermios tmp_termios;
struct usb_serial *serial = port->serial;
@ -332,7 +334,7 @@ static int ark3116_open(struct usb_serial_port *port, struct file *filp)
return -ENOMEM;
}
result = usb_serial_generic_open(port, filp);
result = usb_serial_generic_open(tty, port, filp);
if (result)
goto err_out;
@ -362,8 +364,8 @@ static int ark3116_open(struct usb_serial_port *port, struct file *filp)
ARK3116_RCV(serial, 124, 0xFE, 0xC0, 0x0000, 0x0006, 0xFF, buf);
/* initialise termios */
if (port->tty)
ark3116_set_termios(port, &tmp_termios);
if (tty)
ark3116_set_termios(tty, port, &tmp_termios);
err_out:
kfree(buf);
@ -371,9 +373,10 @@ err_out:
return result;
}
static int ark3116_ioctl(struct usb_serial_port *port, struct file *file,
static int ark3116_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
struct serial_struct serstruct;
void __user *user_arg = (void __user *)arg;
@ -403,8 +406,9 @@ static int ark3116_ioctl(struct usb_serial_port *port, struct file *file,
return -ENOIOCTLCMD;
}
static int ark3116_tiocmget(struct usb_serial_port *port, struct file *file)
static int ark3116_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
char *buf;
char temp;

69
drivers/usb/serial/belkin_sa.c
View File

@ -89,14 +89,13 @@ static int debug;
/* function prototypes for a Belkin USB Serial Adapter F5U103 */
static int belkin_sa_startup (struct usb_serial *serial);
static void belkin_sa_shutdown (struct usb_serial *serial);
static int belkin_sa_open (struct usb_serial_port *port, struct file *filp);
static void belkin_sa_close (struct usb_serial_port *port, struct file *filp);
static int belkin_sa_open (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static void belkin_sa_close (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static void belkin_sa_read_int_callback (struct urb *urb);
static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios * old);
static int belkin_sa_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
static void belkin_sa_break_ctl (struct usb_serial_port *port, int break_state );
static int belkin_sa_tiocmget (struct usb_serial_port *port, struct file *file);
static int belkin_sa_tiocmset (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear);
static void belkin_sa_set_termios (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios * old);
static void belkin_sa_break_ctl (struct tty_struct *tty, int break_state );
static int belkin_sa_tiocmget (struct tty_struct *tty, struct file *file);
static int belkin_sa_tiocmset (struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear);
static struct usb_device_id id_table_combined [] = {
@ -132,7 +131,6 @@ static struct usb_serial_driver belkin_device = {
.open = belkin_sa_open,
.close = belkin_sa_close,
.read_int_callback = belkin_sa_read_int_callback, /* How we get the status info */
.ioctl = belkin_sa_ioctl,
.set_termios = belkin_sa_set_termios,
.break_ctl = belkin_sa_break_ctl,
.tiocmget = belkin_sa_tiocmget,
@ -190,7 +188,7 @@ static int belkin_sa_startup (struct usb_serial *serial)
}
static void belkin_sa_shutdown (struct usb_serial *serial)
static void belkin_sa_shutdown(struct usb_serial *serial)
{
struct belkin_sa_private *priv;
int i;
@ -206,7 +204,7 @@ static void belkin_sa_shutdown (struct usb_serial *serial)
}
static int belkin_sa_open (struct usb_serial_port *port, struct file *filp)
static int belkin_sa_open(struct tty_struct *tty, struct usb_serial_port *port, struct file *filp)
{
int retval = 0;
@ -235,7 +233,8 @@ exit:
} /* belkin_sa_open */
static void belkin_sa_close (struct usb_serial_port *port, struct file *filp)
static void belkin_sa_close (struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
dbg("%s port %d", __func__, port->number);
@ -246,7 +245,7 @@ static void belkin_sa_close (struct usb_serial_port *port, struct file *filp)
} /* belkin_sa_close */
static void belkin_sa_read_int_callback (struct urb *urb)
static void belkin_sa_read_int_callback(struct urb *urb)
{
struct usb_serial_port *port = urb->context;
struct belkin_sa_private *priv;
@ -311,7 +310,7 @@ static void belkin_sa_read_int_callback (struct urb *urb)
* to look in to this before committing any code.
*/
if (priv->last_lsr & BELKIN_SA_LSR_ERR) {
tty = port->tty;
tty = port->port.tty;
/* Overrun Error */
if (priv->last_lsr & BELKIN_SA_LSR_OE) {
}
@ -334,7 +333,8 @@ exit:
__func__, retval);
}
static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
static void belkin_sa_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
struct usb_serial *serial = port->serial;
struct belkin_sa_private *priv = usb_get_serial_port_data(port);
@ -347,7 +347,7 @@ static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios
unsigned long control_state;
int bad_flow_control;
speed_t baud;
struct ktermios *termios = port->tty->termios;
struct ktermios *termios = tty->termios;
iflag = termios->c_iflag;
cflag = termios->c_cflag;
@ -377,7 +377,7 @@ static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios
}
}
baud = tty_get_baud_rate(port->tty);
baud = tty_get_baud_rate(tty);
if (baud) {
urb_value = BELKIN_SA_BAUD(baud);
/* Clip to maximum speed */
@ -387,7 +387,7 @@ static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios
baud = BELKIN_SA_BAUD(urb_value);
/* Report the actual baud rate back to the caller */
tty_encode_baud_rate(port->tty, baud, baud);
tty_encode_baud_rate(tty, baud, baud);
if (BSA_USB_CMD(BELKIN_SA_SET_BAUDRATE_REQUEST, urb_value) < 0)
err("Set baudrate error");
} else {
@ -463,8 +463,9 @@ static void belkin_sa_set_termios (struct usb_serial_port *port, struct ktermios
} /* belkin_sa_set_termios */
static void belkin_sa_break_ctl( struct usb_serial_port *port, int break_state )
static void belkin_sa_break_ctl(struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
if (BSA_USB_CMD(BELKIN_SA_SET_BREAK_REQUEST, break_state ? 1 : 0) < 0)
@ -472,8 +473,9 @@ static void belkin_sa_break_ctl( struct usb_serial_port *port, int break_state )
}
static int belkin_sa_tiocmget (struct usb_serial_port *port, struct file *file)
static int belkin_sa_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct belkin_sa_private *priv = usb_get_serial_port_data(port);
unsigned long control_state;
unsigned long flags;
@ -488,9 +490,10 @@ static int belkin_sa_tiocmget (struct usb_serial_port *port, struct file *file)
}
static int belkin_sa_tiocmset (struct usb_serial_port *port, struct file *file,
static int belkin_sa_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
struct belkin_sa_private *priv = usb_get_serial_port_data(port);
unsigned long control_state;
@ -540,29 +543,7 @@ exit:
}
static int belkin_sa_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
{
switch (cmd) {
case TIOCMIWAIT:
/* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
/* TODO */
return( 0 );
case TIOCGICOUNT:
/* return count of modemline transitions */
/* TODO */
return 0;
default:
dbg("belkin_sa_ioctl arg not supported - 0x%04x",cmd);
return(-ENOIOCTLCMD);
break;
}
return 0;
} /* belkin_sa_ioctl */
static int __init belkin_sa_init (void)
static int __init belkin_sa_init(void)
{
int retval;
retval = usb_serial_register(&belkin_device);
@ -583,7 +564,7 @@ failed_usb_serial_register:
static void __exit belkin_sa_exit (void)
{
usb_deregister (&belkin_driver);
usb_serial_deregister (&belkin_device);
usb_serial_deregister(&belkin_device);
}

10
drivers/usb/serial/ch341.c
View File

@ -232,7 +232,8 @@ error: kfree(priv);
}
/* open this device, set default parameters */
static int ch341_open(struct usb_serial_port *port, struct file *filp)
static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port,
struct file *filp)
{
struct usb_serial *serial = port->serial;
struct ch341_private *priv = usb_get_serial_port_data(serial->port[0]);
@ -256,7 +257,7 @@ static int ch341_open(struct usb_serial_port *port, struct file *filp)
if (r)
goto out;
r = usb_serial_generic_open(port, filp);
r = usb_serial_generic_open(tty, port, filp);
out: return r;
}
@ -264,11 +265,10 @@ out: return r;
/* Old_termios contains the original termios settings and
* tty->termios contains the new setting to be used.
*/
static void ch341_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios)
static void ch341_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
struct ch341_private *priv = usb_get_serial_port_data(port);
struct tty_struct *tty = port->tty;
unsigned baud_rate;
dbg("ch341_set_termios()");

34
drivers/usb/serial/console.c
View File

@ -145,12 +145,12 @@ static int usb_console_setup(struct console *co, char *options)
}
port = serial->port[0];
port->tty = NULL;
port->port.tty = NULL;
info->port = port;
++port->open_count;
if (port->open_count == 1) {
++port->port.count;
if (port->port.count == 1) {
if (serial->type->set_termios) {
/*
* allocate a fake tty so the driver can initialize
@ -171,15 +171,15 @@ static int usb_console_setup(struct console *co, char *options)
}
memset(&dummy, 0, sizeof(struct ktermios));
tty->termios = termios;
port->tty = tty;
port->port.tty = tty;
}
/* only call the device specific open if this
* is the first time the port is opened */
if (serial->type->open)
retval = serial->type->open(port, NULL);
retval = serial->type->open(NULL, port, NULL);
else
retval = usb_serial_generic_open(port, NULL);
retval = usb_serial_generic_open(NULL, port, NULL);
if (retval) {
err("could not open USB console port");
@ -188,9 +188,9 @@ static int usb_console_setup(struct console *co, char *options)
if (serial->type->set_termios) {
termios->c_cflag = cflag;
serial->type->set_termios(port, &dummy);
serial->type->set_termios(NULL, port, &dummy);
port->tty = NULL;
port->port.tty = NULL;
kfree(termios);
kfree(tty);
}
@ -203,11 +203,11 @@ out:
return retval;
free_termios:
kfree(termios);
port->tty = NULL;
port->port.tty = NULL;
free_tty:
kfree(tty);
reset_open_count:
port->open_count = 0;
port->port.count = 0;
goto out;
}
@ -227,7 +227,7 @@ static void usb_console_write(struct console *co, const char *buf, unsigned coun
dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
if (!port->open_count) {
if (!port->port.count) {
dbg ("%s - port not opened", __func__);
return;
}
@ -245,17 +245,17 @@ static void usb_console_write(struct console *co, const char *buf, unsigned coun
}
/* pass on to the driver specific version of this function if it is available */
if (serial->type->write)
retval = serial->type->write(port, buf, i);
retval = serial->type->write(NULL, port, buf, i);
else
retval = usb_serial_generic_write(port, buf, i);
retval = usb_serial_generic_write(NULL, port, buf, i);
dbg("%s - return value : %d", __func__, retval);
if (lf) {
/* append CR after LF */
unsigned char cr = 13;
if (serial->type->write)
retval = serial->type->write(port, &cr, 1);
retval = serial->type->write(NULL, port, &cr, 1);
else
retval = usb_serial_generic_write(port, &cr, 1);
retval = usb_serial_generic_write(NULL, port, &cr, 1);
dbg("%s - return value : %d", __func__, retval);
}
buf += i;
@ -306,8 +306,8 @@ void usb_serial_console_exit (void)
{
if (usbcons_info.port) {
unregister_console(&usbcons);
if (usbcons_info.port->open_count)
usbcons_info.port->open_count--;
if (usbcons_info.port->port.count)
usbcons_info.port->port.count--;
usbcons_info.port = NULL;
}
}

74
drivers/usb/serial/cp2101.c
View File

@ -37,15 +37,18 @@
/*
* Function Prototypes
*/
static int cp2101_open(struct usb_serial_port*, struct file*);
static void cp2101_cleanup(struct usb_serial_port*);
static void cp2101_close(struct usb_serial_port*, struct file*);
static void cp2101_get_termios(struct usb_serial_port*);
static void cp2101_set_termios(struct usb_serial_port*, struct ktermios*);
static int cp2101_tiocmget (struct usb_serial_port *, struct file *);
static int cp2101_tiocmset (struct usb_serial_port *, struct file *,
static int cp2101_open(struct tty_struct *, struct usb_serial_port *,
struct file *);
static void cp2101_cleanup(struct usb_serial_port *);
static void cp2101_close(struct tty_struct *, struct usb_serial_port *,
struct file*);
static void cp2101_get_termios(struct tty_struct *);
static void cp2101_set_termios(struct tty_struct *, struct usb_serial_port *,
struct ktermios*);
static int cp2101_tiocmget (struct tty_struct *, struct file *);
static int cp2101_tiocmset (struct tty_struct *, struct file *,
unsigned int, unsigned int);
static void cp2101_break_ctl(struct usb_serial_port*, int);
static void cp2101_break_ctl(struct tty_struct *, int);
static int cp2101_startup (struct usb_serial *);
static void cp2101_shutdown(struct usb_serial*);
@ -182,7 +185,7 @@ static struct usb_serial_driver cp2101_device = {
* 'data' is a pointer to a pre-allocated array of integers large
* enough to hold 'size' bytes (with 4 bytes to each integer)
*/
static int cp2101_get_config(struct usb_serial_port* port, u8 request,
static int cp2101_get_config(struct usb_serial_port *port, u8 request,
unsigned int *data, int size)
{
struct usb_serial *serial = port->serial;
@ -228,7 +231,7 @@ static int cp2101_get_config(struct usb_serial_port* port, u8 request,
* Values less than 16 bits wide are sent directly
* 'size' is specified in bytes.
*/
static int cp2101_set_config(struct usb_serial_port* port, u8 request,
static int cp2101_set_config(struct usb_serial_port *port, u8 request,
unsigned int *data, int size)
{
struct usb_serial *serial = port->serial;
@ -283,13 +286,14 @@ static int cp2101_set_config(struct usb_serial_port* port, u8 request,
* Convenience function for calling cp2101_set_config on single data values
* without requiring an integer pointer
*/
static inline int cp2101_set_config_single(struct usb_serial_port* port,
static inline int cp2101_set_config_single(struct usb_serial_port *port,
u8 request, unsigned int data)
{
return cp2101_set_config(port, request, &data, 2);
}
static int cp2101_open (struct usb_serial_port *port, struct file *filp)
static int cp2101_open (struct tty_struct *tty, struct usb_serial_port *port,
struct file *filp)
{
struct usb_serial *serial = port->serial;
int result;
@ -318,10 +322,10 @@ static int cp2101_open (struct usb_serial_port *port, struct file *filp)
}
/* Configure the termios structure */
cp2101_get_termios(port);
cp2101_get_termios(tty);
/* Set the DTR and RTS pins low */
cp2101_tiocmset(port, NULL, TIOCM_DTR | TIOCM_RTS, 0);
cp2101_tiocmset(tty, NULL, TIOCM_DTR | TIOCM_RTS, 0);
return 0;
}
@ -341,7 +345,8 @@ static void cp2101_cleanup (struct usb_serial_port *port)
}
}
static void cp2101_close (struct usb_serial_port *port, struct file * filp)
static void cp2101_close(struct tty_struct *tty, struct usb_serial_port *port,
struct file * filp)
{
dbg("%s - port %d", __func__, port->number);
@ -362,19 +367,15 @@ static void cp2101_close (struct usb_serial_port *port, struct file * filp)
* from the device, corrects any unsupported values, and configures the
* termios structure to reflect the state of the device
*/
static void cp2101_get_termios (struct usb_serial_port *port)
static void cp2101_get_termios (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
unsigned int cflag, modem_ctl[4];
unsigned int baud;
unsigned int bits;
dbg("%s - port %d", __func__, port->number);
if (!port->tty || !port->tty->termios) {
dbg("%s - no tty structures", __func__);
return;
}
cp2101_get_config(port, CP2101_BAUDRATE, &baud, 2);
/* Convert to baudrate */
if (baud)
@ -382,8 +383,8 @@ static void cp2101_get_termios (struct usb_serial_port *port)
dbg("%s - baud rate = %d", __func__, baud);
tty_encode_baud_rate(port->tty, baud, baud);
cflag = port->tty->termios->c_cflag;
tty_encode_baud_rate(tty, baud, baud);
cflag = tty->termios->c_cflag;
cp2101_get_config(port, CP2101_BITS, &bits, 2);
cflag &= ~CSIZE;
@ -491,11 +492,11 @@ static void cp2101_get_termios (struct usb_serial_port *port)
cflag &= ~CRTSCTS;
}
port->tty->termios->c_cflag = cflag;
tty->termios->c_cflag = cflag;
}
static void cp2101_set_termios (struct usb_serial_port *port,
struct ktermios *old_termios)
static void cp2101_set_termios (struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
unsigned int cflag, old_cflag;
unsigned int baud = 0, bits;
@ -503,15 +504,13 @@ static void cp2101_set_termios (struct usb_serial_port *port,
dbg("%s - port %d", __func__, port->number);
if (!port->tty || !port->tty->termios) {
dbg("%s - no tty structures", __func__);
if (!tty)
return;
}
port->tty->termios->c_cflag &= ~CMSPAR;
cflag = port->tty->termios->c_cflag;
tty->termios->c_cflag &= ~CMSPAR;
cflag = tty->termios->c_cflag;
old_cflag = old_termios->c_cflag;
baud = tty_get_baud_rate(port->tty);
baud = tty_get_baud_rate(tty);
/* If the baud rate is to be updated*/
if (baud != tty_termios_baud_rate(old_termios)) {
@ -554,7 +553,7 @@ static void cp2101_set_termios (struct usb_serial_port *port,
}
}
/* Report back the resulting baud rate */
tty_encode_baud_rate(port->tty, baud, baud);
tty_encode_baud_rate(tty, baud, baud);
/* If the number of data bits is to be updated */
if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
@ -651,9 +650,10 @@ static void cp2101_set_termios (struct usb_serial_port *port,
}
static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file,
static int cp2101_tiocmset (struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
unsigned int control = 0;
dbg("%s - port %d", __func__, port->number);
@ -681,8 +681,9 @@ static int cp2101_tiocmset (struct usb_serial_port *port, struct file *file,
}
static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file)
static int cp2101_tiocmget (struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
unsigned int control;
int result;
@ -702,8 +703,9 @@ static int cp2101_tiocmget (struct usb_serial_port *port, struct file *file)
return result;
}
static void cp2101_break_ctl (struct usb_serial_port *port, int break_state)
static void cp2101_break_ctl (struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
unsigned int state;
dbg("%s - port %d", __func__, port->number);

47
drivers/usb/serial/cyberjack.c
View File

@ -57,15 +57,18 @@ static int debug;
#define CYBERJACK_PRODUCT_ID 0x0100
/* Function prototypes */
static int cyberjack_startup (struct usb_serial *serial);
static void cyberjack_shutdown (struct usb_serial *serial);
static int cyberjack_open (struct usb_serial_port *port, struct file *filp);
static void cyberjack_close (struct usb_serial_port *port, struct file *filp);
static int cyberjack_write (struct usb_serial_port *port, const unsigned char *buf, int count);
static int cyberjack_write_room( struct usb_serial_port *port );
static void cyberjack_read_int_callback (struct urb *urb);
static void cyberjack_read_bulk_callback (struct urb *urb);
static void cyberjack_write_bulk_callback (struct urb *urb);
static int cyberjack_startup(struct usb_serial *serial);
static void cyberjack_shutdown(struct usb_serial *serial);
static int cyberjack_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp);
static void cyberjack_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp);
static int cyberjack_write(struct tty_struct *tty,
struct usb_serial_port *port, const unsigned char *buf, int count);
static int cyberjack_write_room( struct tty_struct *tty);
static void cyberjack_read_int_callback(struct urb *urb);
static void cyberjack_read_bulk_callback(struct urb *urb);
static void cyberjack_write_bulk_callback(struct urb *urb);
static struct usb_device_id id_table [] = {
{ USB_DEVICE(CYBERJACK_VENDOR_ID, CYBERJACK_PRODUCT_ID) },
@ -111,7 +114,7 @@ struct cyberjack_private {
};
/* do some startup allocations not currently performed by usb_serial_probe() */
static int cyberjack_startup (struct usb_serial *serial)
static int cyberjack_startup(struct usb_serial *serial)
{
struct cyberjack_private *priv;
int i;
@ -145,7 +148,7 @@ static int cyberjack_startup (struct usb_serial *serial)
return( 0 );
}
static void cyberjack_shutdown (struct usb_serial *serial)
static void cyberjack_shutdown(struct usb_serial *serial)
{
int i;
@ -159,7 +162,8 @@ static void cyberjack_shutdown (struct usb_serial *serial)
}
}
static int cyberjack_open (struct usb_serial_port *port, struct file *filp)
static int cyberjack_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct cyberjack_private *priv;
unsigned long flags;
@ -174,7 +178,8 @@ static int cyberjack_open (struct usb_serial_port *port, struct file *filp)
* the data through, otherwise it is scheduled, and with high
* data rates (like with OHCI) data can get lost.
*/
port->tty->low_latency = 1;
if (tty)
tty->low_latency = 1;
priv = usb_get_serial_port_data(port);
spin_lock_irqsave(&priv->lock, flags);
@ -186,7 +191,8 @@ static int cyberjack_open (struct usb_serial_port *port, struct file *filp)
return result;
}
static void cyberjack_close (struct usb_serial_port *port, struct file *filp)
static void cyberjack_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
dbg("%s - port %d", __func__, port->number);
@ -197,7 +203,8 @@ static void cyberjack_close (struct usb_serial_port *port, struct file *filp)
}
}
static int cyberjack_write (struct usb_serial_port *port, const unsigned char *buf, int count)
static int cyberjack_write(struct tty_struct *tty,
struct usb_serial_port *port, const unsigned char *buf, int count)
{
struct usb_serial *serial = port->serial;
struct cyberjack_private *priv = usb_get_serial_port_data(port);
@ -292,13 +299,13 @@ static int cyberjack_write (struct usb_serial_port *port, const unsigned char *b
return (count);
}
static int cyberjack_write_room( struct usb_serial_port *port )
static int cyberjack_write_room(struct tty_struct *tty)
{
/* FIXME: .... */
return CYBERJACK_LOCAL_BUF_SIZE;
}
static void cyberjack_read_int_callback( struct urb *urb )
static void cyberjack_read_int_callback(struct urb *urb)
{
struct usb_serial_port *port = urb->context;
struct cyberjack_private *priv = usb_get_serial_port_data(port);
@ -355,7 +362,7 @@ resubmit:
dbg("%s - usb_submit_urb(int urb)", __func__);
}
static void cyberjack_read_bulk_callback (struct urb *urb)
static void cyberjack_read_bulk_callback(struct urb *urb)
{
struct usb_serial_port *port = urb->context;
struct cyberjack_private *priv = usb_get_serial_port_data(port);
@ -374,7 +381,7 @@ static void cyberjack_read_bulk_callback (struct urb *urb)
return;
}
tty = port->tty;
tty = port->port.tty;
if (!tty) {
dbg("%s - ignoring since device not open\n", __func__);
return;
@ -407,7 +414,7 @@ static void cyberjack_read_bulk_callback (struct urb *urb)
}
}
static void cyberjack_write_bulk_callback (struct urb *urb)
static void cyberjack_write_bulk_callback(struct urb *urb)
{
struct usb_serial_port *port = urb->context;
struct cyberjack_private *priv = usb_get_serial_port_data(port);

117
drivers/usb/serial/cypress_m8.c
View File

@ -167,18 +167,18 @@ static int cypress_earthmate_startup (struct usb_serial *serial);
static int cypress_hidcom_startup (struct usb_serial *serial);
static int cypress_ca42v2_startup (struct usb_serial *serial);
static void cypress_shutdown (struct usb_serial *serial);
static int cypress_open (struct usb_serial_port *port, struct file *filp);
static void cypress_close (struct usb_serial_port *port, struct file *filp);
static int cypress_write (struct usb_serial_port *port, const unsigned char *buf, int count);
static int cypress_open (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static void cypress_close (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static int cypress_write (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
static void cypress_send (struct usb_serial_port *port);
static int cypress_write_room (struct usb_serial_port *port);
static int cypress_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
static void cypress_set_termios (struct usb_serial_port *port, struct ktermios * old);
static int cypress_tiocmget (struct usb_serial_port *port, struct file *file);
static int cypress_tiocmset (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear);
static int cypress_chars_in_buffer (struct usb_serial_port *port);
static void cypress_throttle (struct usb_serial_port *port);
static void cypress_unthrottle (struct usb_serial_port *port);
static int cypress_write_room (struct tty_struct *tty);
static int cypress_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg);
static void cypress_set_termios (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios * old);
static int cypress_tiocmget (struct tty_struct *tty, struct file *file);
static int cypress_tiocmset (struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear);
static int cypress_chars_in_buffer (struct tty_struct *tty);
static void cypress_throttle (struct tty_struct *tty);
static void cypress_unthrottle (struct tty_struct *tty);
static void cypress_set_dead (struct usb_serial_port *port);
static void cypress_read_int_callback (struct urb *urb);
static void cypress_write_int_callback (struct urb *urb);
@ -322,8 +322,10 @@ static int analyze_baud_rate(struct usb_serial_port *port, speed_t new_rate)
/* This function can either set or retrieve the current serial line settings */
static int cypress_serial_control (struct usb_serial_port *port, speed_t baud_rate, int data_bits, int stop_bits,
int parity_enable, int parity_type, int reset, int cypress_request_type)
static int cypress_serial_control (struct tty_struct *tty,
struct usb_serial_port *port, speed_t baud_rate, int data_bits,
int stop_bits, int parity_enable, int parity_type, int reset,
int cypress_request_type)
{
int new_baudrate = 0, retval = 0, tries = 0;
struct cypress_private *priv;
@ -395,7 +397,7 @@ static int cypress_serial_control (struct usb_serial_port *port, speed_t baud_ra
spin_unlock_irqrestore(&priv->lock, flags);
/* If we asked for a speed change encode it */
if (baud_rate)
tty_encode_baud_rate(port->tty,
tty_encode_baud_rate(tty,
new_baudrate, new_baudrate);
}
break;
@ -611,7 +613,8 @@ static void cypress_shutdown (struct usb_serial *serial)
}
static int cypress_open (struct usb_serial_port *port, struct file *filp)
static int cypress_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct cypress_private *priv = usb_get_serial_port_data(port);
struct usb_serial *serial = port->serial;
@ -636,14 +639,15 @@ static int cypress_open (struct usb_serial_port *port, struct file *filp)
spin_unlock_irqrestore(&priv->lock, flags);
/* setting to zero could cause data loss */
port->tty->low_latency = 1;
if (tty)
tty->low_latency = 1;
/* raise both lines and set termios */
spin_lock_irqsave(&priv->lock, flags);
priv->line_control = CONTROL_DTR | CONTROL_RTS;
priv->cmd_ctrl = 1;
spin_unlock_irqrestore(&priv->lock, flags);
result = cypress_write(port, NULL, 0);
result = cypress_write(tty, port, NULL, 0);
if (result) {
dev_err(&port->dev, "%s - failed setting the control lines - error %d\n", __func__, result);
@ -651,7 +655,8 @@ static int cypress_open (struct usb_serial_port *port, struct file *filp)
} else
dbg("%s - success setting the control lines", __func__);
cypress_set_termios(port, &priv->tmp_termios);
if (tty)
cypress_set_termios(tty, port, &priv->tmp_termios);
/* setup the port and start reading from the device */
if(!port->interrupt_in_urb){
@ -674,7 +679,8 @@ static int cypress_open (struct usb_serial_port *port, struct file *filp)
} /* cypress_open */
static void cypress_close(struct usb_serial_port *port, struct file * filp)
static void cypress_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file * filp)
{
struct cypress_private *priv = usb_get_serial_port_data(port);
unsigned int c_cflag;
@ -688,7 +694,7 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
spin_lock_irq(&priv->lock);
timeout = CYPRESS_CLOSING_WAIT;
init_waitqueue_entry(&wait, current);
add_wait_queue(&port->tty->write_wait, &wait);
add_wait_queue(&tty->write_wait, &wait);
for (;;) {
set_current_state(TASK_INTERRUPTIBLE);
if (cypress_buf_data_avail(priv->buf) == 0
@ -701,7 +707,7 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
spin_lock_irq(&priv->lock);
}
set_current_state(TASK_RUNNING);
remove_wait_queue(&port->tty->write_wait, &wait);
remove_wait_queue(&tty->write_wait, &wait);
/* clear out any remaining data in the buffer */
cypress_buf_clear(priv->buf);
spin_unlock_irq(&priv->lock);
@ -713,19 +719,21 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
return;
}
/* wait for characters to drain from device */
bps = tty_get_baud_rate(port->tty);
if (bps > 1200)
timeout = max((HZ*2560)/bps,HZ/10);
else
timeout = 2*HZ;
schedule_timeout_interruptible(timeout);
if (tty) {
bps = tty_get_baud_rate(tty);
if (bps > 1200)
timeout = max((HZ*2560)/bps,HZ/10);
else
timeout = 2*HZ;
schedule_timeout_interruptible(timeout);
}
dbg("%s - stopping urbs", __func__);
usb_kill_urb (port->interrupt_in_urb);
usb_kill_urb (port->interrupt_out_urb);
if (port->tty) {
c_cflag = port->tty->termios->c_cflag;
if (tty) {
c_cflag = tty->termios->c_cflag;
if (c_cflag & HUPCL) {
/* drop dtr and rts */
priv = usb_get_serial_port_data(port);
@ -733,7 +741,7 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
priv->line_control = 0;
priv->cmd_ctrl = 1;
spin_unlock_irq(&priv->lock);
cypress_write(port, NULL, 0);
cypress_write(tty, port, NULL, 0);
}
}
@ -744,7 +752,8 @@ static void cypress_close(struct usb_serial_port *port, struct file * filp)
} /* cypress_close */
static int cypress_write(struct usb_serial_port *port, const unsigned char *buf, int count)
static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
struct cypress_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -878,8 +887,9 @@ send:
/* returns how much space is available in the soft buffer */
static int cypress_write_room(struct usb_serial_port *port)
static int cypress_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct cypress_private *priv = usb_get_serial_port_data(port);
int room = 0;
unsigned long flags;
@ -895,8 +905,9 @@ static int cypress_write_room(struct usb_serial_port *port)
}
static int cypress_tiocmget (struct usb_serial_port *port, struct file *file)
static int cypress_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct cypress_private *priv = usb_get_serial_port_data(port);
__u8 status, control;
unsigned int result = 0;
@ -922,9 +933,10 @@ static int cypress_tiocmget (struct usb_serial_port *port, struct file *file)
}
static int cypress_tiocmset (struct usb_serial_port *port, struct file *file,
static int cypress_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct cypress_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -942,12 +954,14 @@ static int cypress_tiocmset (struct usb_serial_port *port, struct file *file,
priv->cmd_ctrl = 1;
spin_unlock_irqrestore(&priv->lock, flags);
return cypress_write(port, NULL, 0);
return cypress_write(tty, port, NULL, 0);
}
static int cypress_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
static int cypress_ioctl(struct tty_struct *tty, struct file * file,
unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
struct cypress_private *priv = usb_get_serial_port_data(port);
dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
@ -983,22 +997,18 @@ static int cypress_ioctl (struct usb_serial_port *port, struct file * file, unsi
}
}
return 0;
break;
default:
break;
}
dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __func__, cmd);
return -ENOIOCTLCMD;
} /* cypress_ioctl */
static void cypress_set_termios (struct usb_serial_port *port,
struct ktermios *old_termios)
static void cypress_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
struct cypress_private *priv = usb_get_serial_port_data(port);
struct tty_struct *tty;
int data_bits, stop_bits, parity_type, parity_enable;
unsigned cflag, iflag;
unsigned long flags;
@ -1007,8 +1017,6 @@ static void cypress_set_termios (struct usb_serial_port *port,
dbg("%s - port %d", __func__, port->number);
tty = port->tty;
spin_lock_irqsave(&priv->lock, flags);
if (!priv->termios_initialized) {
if (priv->chiptype == CT_EARTHMATE) {
@ -1096,13 +1104,13 @@ static void cypress_set_termios (struct usb_serial_port *port,
"%d data_bits (+5)", __func__, stop_bits,
parity_enable, parity_type, data_bits);
cypress_serial_control(port, tty_get_baud_rate(tty), data_bits, stop_bits,
cypress_serial_control(tty, port, tty_get_baud_rate(tty), data_bits, stop_bits,
parity_enable, parity_type, 0, CYPRESS_SET_CONFIG);
/* we perform a CYPRESS_GET_CONFIG so that the current settings are
* filled into the private structure this should confirm that all is
* working if it returns what we just set */
cypress_serial_control(port, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG);
cypress_serial_control(tty, port, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG);
/* Here we can define custom tty settings for devices; the main tty
* termios flag base comes from empeg.c */
@ -1142,14 +1150,15 @@ static void cypress_set_termios (struct usb_serial_port *port,
/* if necessary, set lines */
if (linechange) {
priv->cmd_ctrl = 1;
cypress_write(port, NULL, 0);
cypress_write(tty, port, NULL, 0);
}
} /* cypress_set_termios */
/* returns amount of data still left in soft buffer */
static int cypress_chars_in_buffer(struct usb_serial_port *port)
static int cypress_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct cypress_private *priv = usb_get_serial_port_data(port);
int chars = 0;
unsigned long flags;
@ -1165,8 +1174,9 @@ static int cypress_chars_in_buffer(struct usb_serial_port *port)
}
static void cypress_throttle (struct usb_serial_port *port)
static void cypress_throttle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct cypress_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -1178,8 +1188,9 @@ static void cypress_throttle (struct usb_serial_port *port)
}
static void cypress_unthrottle (struct usb_serial_port *port)
static void cypress_unthrottle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct cypress_private *priv = usb_get_serial_port_data(port);
int actually_throttled, result;
unsigned long flags;
@ -1251,7 +1262,7 @@ static void cypress_read_int_callback(struct urb *urb)
}
spin_unlock_irqrestore(&priv->lock, flags);
tty = port->tty;
tty = port->port.tty;
if (!tty) {
dbg("%s - bad tty pointer - exiting", __func__);
return;
@ -1327,7 +1338,7 @@ static void cypress_read_int_callback(struct urb *urb)
data[i]);
tty_insert_flip_char(tty, data[i], tty_flag);
}
tty_flip_buffer_push(port->tty);
tty_flip_buffer_push(port->port.tty);
}
spin_lock_irqsave(&priv->lock, flags);
@ -1339,7 +1350,7 @@ continue_read:
/* Continue trying to always read... unless the port has closed. */
if (port->open_count > 0 && priv->comm_is_ok) {
if (port->port.count > 0 && priv->comm_is_ok) {
usb_fill_int_urb(port->interrupt_in_urb, port->serial->dev,
usb_rcvintpipe(port->serial->dev,
port->interrupt_in_endpointAddress),

127
drivers/usb/serial/digi_acceleport.c
View File

@ -15,7 +15,7 @@
* Al Borchers (borchers@steinerpoint.com)
*
* (12/03/2001) gkh
* switched to using port->open_count instead of private version.
* switched to using port->port.count instead of private version.
* Removed port->active
*
* (04/08/2001) gb
@ -441,22 +441,23 @@ static int digi_set_modem_signals(struct usb_serial_port *port,
unsigned int modem_signals, int interruptible);
static int digi_transmit_idle(struct usb_serial_port *port,
unsigned long timeout);
static void digi_rx_throttle (struct usb_serial_port *port);
static void digi_rx_unthrottle (struct usb_serial_port *port);
static void digi_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios);
static void digi_break_ctl(struct usb_serial_port *port, int break_state);
static int digi_ioctl(struct usb_serial_port *port, struct file *file,
unsigned int cmd, unsigned long arg);
static int digi_tiocmget(struct usb_serial_port *port, struct file *file);
static int digi_tiocmset(struct usb_serial_port *port, struct file *file,
static void digi_rx_throttle (struct tty_struct *tty);
static void digi_rx_unthrottle (struct tty_struct *tty);
static void digi_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios);
static void digi_break_ctl(struct tty_struct *tty, int break_state);
static int digi_tiocmget(struct tty_struct *tty, struct file *file);
static int digi_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear);
static int digi_write(struct usb_serial_port *port, const unsigned char *buf, int count);
static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count);
static void digi_write_bulk_callback(struct urb *urb);
static int digi_write_room(struct usb_serial_port *port);
static int digi_chars_in_buffer(struct usb_serial_port *port);
static int digi_open(struct usb_serial_port *port, struct file *filp);
static void digi_close(struct usb_serial_port *port, struct file *filp);
static int digi_write_room(struct tty_struct *tty);
static int digi_chars_in_buffer(struct tty_struct *tty);
static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
struct file *filp);
static void digi_close(struct tty_struct *tty, struct usb_serial_port *port,
struct file *filp);
static int digi_startup_device(struct usb_serial *serial);
static int digi_startup(struct usb_serial *serial);
static void digi_shutdown(struct usb_serial *serial);
@ -516,7 +517,6 @@ static struct usb_serial_driver digi_acceleport_2_device = {
.chars_in_buffer = digi_chars_in_buffer,
.throttle = digi_rx_throttle,
.unthrottle = digi_rx_unthrottle,
.ioctl = digi_ioctl,
.set_termios = digi_set_termios,
.break_ctl = digi_break_ctl,
.tiocmget = digi_tiocmget,
@ -543,7 +543,6 @@ static struct usb_serial_driver digi_acceleport_4_device = {
.chars_in_buffer = digi_chars_in_buffer,
.throttle = digi_rx_throttle,
.unthrottle = digi_rx_unthrottle,
.ioctl = digi_ioctl,
.set_termios = digi_set_termios,
.break_ctl = digi_break_ctl,
.tiocmget = digi_tiocmget,
@ -604,7 +603,7 @@ static void digi_wakeup_write_lock(struct work_struct *work)
static void digi_wakeup_write(struct usb_serial_port *port)
{
tty_wakeup(port->tty);
tty_wakeup(port->port.tty);
}
@ -856,9 +855,10 @@ static int digi_transmit_idle(struct usb_serial_port *port,
}
static void digi_rx_throttle(struct usb_serial_port *port)
static void digi_rx_throttle(struct tty_struct *tty)
{
unsigned long flags;
struct usb_serial_port *port = tty->driver_data;
struct digi_port *priv = usb_get_serial_port_data(port);
@ -872,10 +872,11 @@ static void digi_rx_throttle(struct usb_serial_port *port)
}
static void digi_rx_unthrottle(struct usb_serial_port *port)
static void digi_rx_unthrottle(struct tty_struct *tty)
{
int ret = 0;
unsigned long flags;
struct usb_serial_port *port = tty->driver_data;
struct digi_port *priv = usb_get_serial_port_data(port);
dbg("digi_rx_unthrottle: TOP: port=%d", priv->dp_port_num);
@ -900,12 +901,10 @@ static void digi_rx_unthrottle(struct usb_serial_port *port)
}
static void digi_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios)
static void digi_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
struct digi_port *priv = usb_get_serial_port_data(port);
struct tty_struct *tty = port->tty;
unsigned int iflag = tty->termios->c_iflag;
unsigned int cflag = tty->termios->c_cflag;
unsigned int old_iflag = old_termios->c_iflag;
@ -1088,8 +1087,9 @@ static void digi_set_termios(struct usb_serial_port *port,
}
static void digi_break_ctl(struct usb_serial_port *port, int break_state)
static void digi_break_ctl(struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
unsigned char buf[4];
buf[0] = DIGI_CMD_BREAK_CONTROL;
@ -1100,8 +1100,9 @@ static void digi_break_ctl(struct usb_serial_port *port, int break_state)
}
static int digi_tiocmget(struct usb_serial_port *port, struct file *file)
static int digi_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct digi_port *priv = usb_get_serial_port_data(port);
unsigned int val;
unsigned long flags;
@ -1115,9 +1116,10 @@ static int digi_tiocmget(struct usb_serial_port *port, struct file *file)
}
static int digi_tiocmset(struct usb_serial_port *port, struct file *file,
static int digi_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct digi_port *priv = usb_get_serial_port_data(port);
unsigned int val;
unsigned long flags;
@ -1131,27 +1133,8 @@ static int digi_tiocmset(struct usb_serial_port *port, struct file *file,
}
static int digi_ioctl(struct usb_serial_port *port, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct digi_port *priv = usb_get_serial_port_data(port);
dbg("digi_ioctl: TOP: port=%d, cmd=0x%x", priv->dp_port_num, cmd);
switch (cmd) {
case TIOCMIWAIT:
/* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
/* TODO */
return 0;
case TIOCGICOUNT:
/* return count of modemline transitions */
/* TODO */
return 0;
}
return -ENOIOCTLCMD;
}
static int digi_write(struct usb_serial_port *port, const unsigned char *buf, int count)
static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
int ret,data_len,new_len;
@ -1261,7 +1244,7 @@ static void digi_write_bulk_callback(struct urb *urb)
/* try to send any buffered data on this port, if it is open */
spin_lock(&priv->dp_port_lock);
priv->dp_write_urb_in_use = 0;
if (port->open_count && port->write_urb->status != -EINPROGRESS
if (port->port.count && port->write_urb->status != -EINPROGRESS
&& priv->dp_out_buf_len > 0) {
*((unsigned char *)(port->write_urb->transfer_buffer))
= (unsigned char)DIGI_CMD_SEND_DATA;
@ -1288,11 +1271,11 @@ static void digi_write_bulk_callback(struct urb *urb)
__func__, ret, priv->dp_port_num);
}
static int digi_write_room(struct usb_serial_port *port)
static int digi_write_room(struct tty_struct *tty)
{
int room;
struct usb_serial_port *port = tty->driver_data;
struct digi_port *priv = usb_get_serial_port_data(port);
int room;
unsigned long flags = 0;
spin_lock_irqsave(&priv->dp_port_lock, flags);
@ -1308,12 +1291,11 @@ static int digi_write_room(struct usb_serial_port *port)
}
static int digi_chars_in_buffer(struct usb_serial_port *port)
static int digi_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct digi_port *priv = usb_get_serial_port_data(port);
if (port->write_urb->status == -EINPROGRESS
|| priv->dp_write_urb_in_use) {
dbg("digi_chars_in_buffer: port=%d, chars=%d",
@ -1329,7 +1311,8 @@ static int digi_chars_in_buffer(struct usb_serial_port *port)
}
static int digi_open(struct usb_serial_port *port, struct file *filp)
static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
struct file *filp)
{
int ret;
unsigned char buf[32];
@ -1338,7 +1321,7 @@ static int digi_open(struct usb_serial_port *port, struct file *filp)
unsigned long flags = 0;
dbg("digi_open: TOP: port=%d, open_count=%d",
priv->dp_port_num, port->open_count);
priv->dp_port_num, port->port.count);
/* be sure the device is started up */
if (digi_startup_device(port->serial) != 0)
@ -1380,9 +1363,11 @@ static int digi_open(struct usb_serial_port *port, struct file *filp)
dbg("digi_open: write oob failed, ret=%d", ret);
/* set termios settings */
not_termios.c_cflag = ~port->tty->termios->c_cflag;
not_termios.c_iflag = ~port->tty->termios->c_iflag;
digi_set_termios(port, &not_termios);
if (tty) {
not_termios.c_cflag = ~tty->termios->c_cflag;
not_termios.c_iflag = ~tty->termios->c_iflag;
digi_set_termios(tty, port, &not_termios);
}
/* set DTR and RTS */
digi_set_modem_signals(port, TIOCM_DTR|TIOCM_RTS, 1);
@ -1391,16 +1376,16 @@ static int digi_open(struct usb_serial_port *port, struct file *filp)
}
static void digi_close(struct usb_serial_port *port, struct file *filp)
static void digi_close(struct tty_struct *tty, struct usb_serial_port *port,
struct file *filp)
{
DEFINE_WAIT(wait);
int ret;
unsigned char buf[32];
struct tty_struct *tty = port->tty;
struct digi_port *priv = usb_get_serial_port_data(port);
dbg("digi_close: TOP: port=%d, open_count=%d",
priv->dp_port_num, port->open_count);
priv->dp_port_num, port->port.count);
mutex_lock(&port->serial->disc_mutex);
/* if disconnected, just clear flags */
@ -1663,7 +1648,7 @@ static int digi_read_inb_callback(struct urb *urb)
{
struct usb_serial_port *port = urb->context;
struct tty_struct *tty = port->tty;
struct tty_struct *tty = port->port.tty;
struct digi_port *priv = usb_get_serial_port_data(port);
int opcode = ((unsigned char *)urb->transfer_buffer)[0];
int len = ((unsigned char *)urb->transfer_buffer)[1];
@ -1675,7 +1660,7 @@ static int digi_read_inb_callback(struct urb *urb)
/* do not process callbacks on closed ports */
/* but do continue the read chain */
if (port->open_count == 0)
if (port->port.count == 0)
return 0;
/* short/multiple packet check */
@ -1785,17 +1770,17 @@ static int digi_read_oob_callback(struct urb *urb)
if (val & DIGI_READ_INPUT_SIGNALS_CTS) {
priv->dp_modem_signals |= TIOCM_CTS;
/* port must be open to use tty struct */
if (port->open_count
&& port->tty->termios->c_cflag & CRTSCTS) {
port->tty->hw_stopped = 0;
if (port->port.count
&& port->port.tty->termios->c_cflag & CRTSCTS) {
port->port.tty->hw_stopped = 0;
digi_wakeup_write(port);
}
} else {
priv->dp_modem_signals &= ~TIOCM_CTS;
/* port must be open to use tty struct */
if (port->open_count
&& port->tty->termios->c_cflag & CRTSCTS) {
port->tty->hw_stopped = 1;
if (port->port.count
&& port->port.tty->termios->c_cflag & CRTSCTS) {
port->port.tty->hw_stopped = 1;
}
}
if (val & DIGI_READ_INPUT_SIGNALS_DSR)

78
drivers/usb/serial/empeg.c
View File

@ -31,7 +31,7 @@
* Moved MOD_DEC_USE_COUNT to end of empeg_close().
*
* (12/03/2000) gb
* Added port->tty->ldisc.set_termios(port->tty, NULL) to empeg_open()
* Added port->port.tty->ldisc.set_termios(port->port.tty, NULL) to empeg_open()
* This notifies the tty driver that the termios have changed.
*
* (11/13/2000) gb
@ -77,22 +77,18 @@ static int debug;
#define EMPEG_PRODUCT_ID 0x0001
/* function prototypes for an empeg-car player */
static int empeg_open (struct usb_serial_port *port, struct file *filp);
static void empeg_close (struct usb_serial_port *port, struct file *filp);
static int empeg_write (struct usb_serial_port *port,
static int empeg_open (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static void empeg_close (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static int empeg_write (struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf,
int count);
static int empeg_write_room (struct usb_serial_port *port);
static int empeg_chars_in_buffer (struct usb_serial_port *port);
static void empeg_throttle (struct usb_serial_port *port);
static void empeg_unthrottle (struct usb_serial_port *port);
static int empeg_write_room (struct tty_struct *tty);
static int empeg_chars_in_buffer (struct tty_struct *tty);
static void empeg_throttle (struct tty_struct *tty);
static void empeg_unthrottle (struct tty_struct *tty);
static int empeg_startup (struct usb_serial *serial);
static void empeg_shutdown (struct usb_serial *serial);
static int empeg_ioctl (struct usb_serial_port *port,
struct file * file,
unsigned int cmd,
unsigned long arg);
static void empeg_set_termios (struct usb_serial_port *port, struct ktermios *old_termios);
static void empeg_set_termios (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios *old_termios);
static void empeg_write_bulk_callback (struct urb *urb);
static void empeg_read_bulk_callback (struct urb *urb);
@ -125,7 +121,6 @@ static struct usb_serial_driver empeg_device = {
.unthrottle = empeg_unthrottle,
.attach = empeg_startup,
.shutdown = empeg_shutdown,
.ioctl = empeg_ioctl,
.set_termios = empeg_set_termios,
.write = empeg_write,
.write_room = empeg_write_room,
@ -145,7 +140,8 @@ static int bytes_out;
/******************************************************************************
* Empeg specific driver functions
******************************************************************************/
static int empeg_open (struct usb_serial_port *port, struct file *filp)
static int empeg_open(struct tty_struct *tty, struct usb_serial_port *port,
struct file *filp)
{
struct usb_serial *serial = port->serial;
int result = 0;
@ -153,7 +149,7 @@ static int empeg_open (struct usb_serial_port *port, struct file *filp)
dbg("%s - port %d", __func__, port->number);
/* Force default termio settings */
empeg_set_termios (port, NULL) ;
empeg_set_termios (tty, port, NULL) ;
bytes_in = 0;
bytes_out = 0;
@ -178,7 +174,8 @@ static int empeg_open (struct usb_serial_port *port, struct file *filp)
}
static void empeg_close (struct usb_serial_port *port, struct file * filp)
static void empeg_close(struct tty_struct *tty, struct usb_serial_port *port,
struct file * filp)
{
dbg("%s - port %d", __func__, port->number);
@ -189,7 +186,7 @@ static void empeg_close (struct usb_serial_port *port, struct file * filp)
}
static int empeg_write (struct usb_serial_port *port, const unsigned char *buf, int count)
static int empeg_write(struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count)
{
struct usb_serial *serial = port->serial;
struct urb *urb;
@ -203,7 +200,6 @@ static int empeg_write (struct usb_serial_port *port, const unsigned char *buf,
dbg("%s - port %d", __func__, port->number);
while (count > 0) {
/* try to find a free urb in our list of them */
urb = NULL;
@ -262,15 +258,14 @@ static int empeg_write (struct usb_serial_port *port, const unsigned char *buf,
bytes_out += transfer_size;
}
exit:
return bytes_sent;
}
static int empeg_write_room (struct usb_serial_port *port)
static int empeg_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
unsigned long flags;
int i;
int room = 0;
@ -278,25 +273,22 @@ static int empeg_write_room (struct usb_serial_port *port)
dbg("%s - port %d", __func__, port->number);
spin_lock_irqsave (&write_urb_pool_lock, flags);
/* tally up the number of bytes available */
for (i = 0; i < NUM_URBS; ++i) {
if (write_urb_pool[i]->status != -EINPROGRESS) {
room += URB_TRANSFER_BUFFER_SIZE;
}
}
spin_unlock_irqrestore (&write_urb_pool_lock, flags);
dbg("%s - returns %d", __func__, room);
return (room);
return room;
}
static int empeg_chars_in_buffer (struct usb_serial_port *port)
static int empeg_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
unsigned long flags;
int i;
int chars = 0;
@ -356,7 +348,7 @@ static void empeg_read_bulk_callback (struct urb *urb)
usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
tty = port->tty;
tty = port->port.tty;
if (urb->actual_length) {
tty_buffer_request_room(tty, urb->actual_length);
@ -386,27 +378,24 @@ static void empeg_read_bulk_callback (struct urb *urb)
}
static void empeg_throttle (struct usb_serial_port *port)
static void empeg_throttle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
dbg("%s - port %d", __func__, port->number);
usb_kill_urb(port->read_urb);
}
static void empeg_unthrottle (struct usb_serial_port *port)
static void empeg_unthrottle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
int result;
dbg("%s - port %d", __func__, port->number);
port->read_urb->dev = port->serial->dev;
result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
if (result)
dev_err(&port->dev, "%s - failed submitting read urb, error %d\n", __func__, result);
return;
}
@ -436,17 +425,10 @@ static void empeg_shutdown (struct usb_serial *serial)
}
static int empeg_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
static void empeg_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
return -ENOIOCTLCMD;
}
static void empeg_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
{
struct ktermios *termios = port->tty->termios;
struct ktermios *termios = tty->termios;
dbg("%s - port %d", __func__, port->number);
/*
@ -491,8 +473,8 @@ static void empeg_set_termios (struct usb_serial_port *port, struct ktermios *ol
* this is bad as it opens up the possibility of dropping bytes
* on the floor. We don't want to drop bytes on the floor. :)
*/
port->tty->low_latency = 1;
tty_encode_baud_rate(port->tty, 115200, 115200);
tty->low_latency = 1;
tty_encode_baud_rate(tty, 115200, 115200);
}

211
drivers/usb/serial/ftdi_sio.c
View File

@ -682,21 +682,21 @@ static int ftdi_sio_probe (struct usb_serial *serial, const struct usb_device_i
static void ftdi_shutdown (struct usb_serial *serial);
static int ftdi_sio_port_probe (struct usb_serial_port *port);
static int ftdi_sio_port_remove (struct usb_serial_port *port);
static int ftdi_open (struct usb_serial_port *port, struct file *filp);
static void ftdi_close (struct usb_serial_port *port, struct file *filp);
static int ftdi_write (struct usb_serial_port *port, const unsigned char *buf, int count);
static int ftdi_write_room (struct usb_serial_port *port);
static int ftdi_chars_in_buffer (struct usb_serial_port *port);
static int ftdi_open (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static void ftdi_close (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static int ftdi_write (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
static int ftdi_write_room (struct tty_struct *tty);
static int ftdi_chars_in_buffer (struct tty_struct *tty);
static void ftdi_write_bulk_callback (struct urb *urb);
static void ftdi_read_bulk_callback (struct urb *urb);
static void ftdi_process_read (struct work_struct *work);
static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios * old);
static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file);
static int ftdi_tiocmset (struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear);
static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
static void ftdi_break_ctl (struct usb_serial_port *port, int break_state );
static void ftdi_throttle (struct usb_serial_port *port);
static void ftdi_unthrottle (struct usb_serial_port *port);
static void ftdi_set_termios (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios * old);
static int ftdi_tiocmget (struct tty_struct *tty, struct file *file);
static int ftdi_tiocmset (struct tty_struct *tty, struct file * file, unsigned int set, unsigned int clear);
static int ftdi_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg);
static void ftdi_break_ctl (struct tty_struct *tty, int break_state );
static void ftdi_throttle (struct tty_struct *tty);
static void ftdi_unthrottle (struct tty_struct *tty);
static unsigned short int ftdi_232am_baud_base_to_divisor (int baud, int base);
static unsigned short int ftdi_232am_baud_to_divisor (int baud);
@ -843,42 +843,7 @@ static int update_mctrl(struct usb_serial_port *port, unsigned int set, unsigned
}
static __u32 get_ftdi_divisor(struct usb_serial_port * port);
static int change_speed(struct usb_serial_port *port)
{
struct ftdi_private *priv = usb_get_serial_port_data(port);
char *buf;
__u16 urb_value;
__u16 urb_index;
__u32 urb_index_value;
int rv;
buf = kmalloc(1, GFP_NOIO);
if (!buf)
return -ENOMEM;
urb_index_value = get_ftdi_divisor(port);
urb_value = (__u16)urb_index_value;
urb_index = (__u16)(urb_index_value >> 16);
if (priv->interface) { /* FT2232C */
urb_index = (__u16)((urb_index << 8) | priv->interface);
}
rv = usb_control_msg(port->serial->dev,
usb_sndctrlpipe(port->serial->dev, 0),
FTDI_SIO_SET_BAUDRATE_REQUEST,
FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
urb_value, urb_index,
buf, 0, WDR_SHORT_TIMEOUT);
kfree(buf);
return rv;
}
static __u32 get_ftdi_divisor(struct usb_serial_port * port)
static __u32 get_ftdi_divisor(struct tty_struct *tty, struct usb_serial_port *port)
{ /* get_ftdi_divisor */
struct ftdi_private *priv = usb_get_serial_port_data(port);
__u32 div_value = 0;
@ -910,7 +875,7 @@ static __u32 get_ftdi_divisor(struct usb_serial_port * port)
/* 1. Get the baud rate from the tty settings, this observes alt_speed hack */
baud = tty_get_baud_rate(port->tty);
baud = tty_get_baud_rate(tty);
dbg("%s - tty_get_baud_rate reports speed %d", __func__, baud);
/* 2. Observe async-compatible custom_divisor hack, update baudrate if needed */
@ -976,10 +941,42 @@ static __u32 get_ftdi_divisor(struct usb_serial_port * port)
ftdi_chip_name[priv->chip_type]);
}
tty_encode_baud_rate(port->tty, baud, baud);
tty_encode_baud_rate(tty, baud, baud);
return(div_value);
}
static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
{
struct ftdi_private *priv = usb_get_serial_port_data(port);
char *buf;
__u16 urb_value;
__u16 urb_index;
__u32 urb_index_value;
int rv;
buf = kmalloc(1, GFP_NOIO);
if (!buf)
return -ENOMEM;
urb_index_value = get_ftdi_divisor(tty, port);
urb_value = (__u16)urb_index_value;
urb_index = (__u16)(urb_index_value >> 16);
if (priv->interface) { /* FT2232C */
urb_index = (__u16)((urb_index << 8) | priv->interface);
}
rv = usb_control_msg(port->serial->dev,
usb_sndctrlpipe(port->serial->dev, 0),
FTDI_SIO_SET_BAUDRATE_REQUEST,
FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
urb_value, urb_index,
buf, 0, WDR_SHORT_TIMEOUT);
kfree(buf);
return rv;
}
static int get_serial_info(struct usb_serial_port * port, struct serial_struct __user * retinfo)
{
@ -998,7 +995,8 @@ static int get_serial_info(struct usb_serial_port * port, struct serial_struct _
} /* get_serial_info */
static int set_serial_info(struct usb_serial_port * port, struct serial_struct __user * newinfo)
static int set_serial_info(struct tty_struct *tty,
struct usb_serial_port * port, struct serial_struct __user * newinfo)
{ /* set_serial_info */
struct ftdi_private *priv = usb_get_serial_port_data(port);
struct serial_struct new_serial;
@ -1030,30 +1028,29 @@ static int set_serial_info(struct usb_serial_port * port, struct serial_struct _
(new_serial.flags & ASYNC_FLAGS));
priv->custom_divisor = new_serial.custom_divisor;
port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
check_and_exit:
if ((old_priv.flags & ASYNC_SPD_MASK) !=
(priv->flags & ASYNC_SPD_MASK)) {
if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
port->tty->alt_speed = 57600;
tty->alt_speed = 57600;
else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
port->tty->alt_speed = 115200;
tty->alt_speed = 115200;
else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
port->tty->alt_speed = 230400;
tty->alt_speed = 230400;
else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
port->tty->alt_speed = 460800;
tty->alt_speed = 460800;
else
port->tty->alt_speed = 0;
tty->alt_speed = 0;
}
if (((old_priv.flags & ASYNC_SPD_MASK) !=
(priv->flags & ASYNC_SPD_MASK)) ||
(((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
(old_priv.custom_divisor != priv->custom_divisor))) {
change_speed(port);
change_speed(tty, port);
}
return (0);
return 0;
} /* set_serial_info */
@ -1415,7 +1412,8 @@ static int ftdi_sio_port_remove(struct usb_serial_port *port)
return 0;
}
static int ftdi_open (struct usb_serial_port *port, struct file *filp)
static int ftdi_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{ /* ftdi_open */
struct usb_device *dev = port->serial->dev;
struct ftdi_private *priv = usb_get_serial_port_data(port);
@ -1433,8 +1431,8 @@ static int ftdi_open (struct usb_serial_port *port, struct file *filp)
priv->rx_bytes = 0;
spin_unlock_irqrestore(&priv->rx_lock, flags);
if (port->tty)
port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
if (tty)
tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
/* No error checking for this (will get errors later anyway) */
/* See ftdi_sio.h for description of what is reset */
@ -1448,8 +1446,8 @@ static int ftdi_open (struct usb_serial_port *port, struct file *filp)
This is same behaviour as serial.c/rs_open() - Kuba */
/* ftdi_set_termios will send usb control messages */
if (port->tty)
ftdi_set_termios(port, port->tty->termios);
if (tty)
ftdi_set_termios(tty, port, tty->termios);
/* FIXME: Flow control might be enabled, so it should be checked -
we have no control of defaults! */
@ -1485,9 +1483,10 @@ static int ftdi_open (struct usb_serial_port *port, struct file *filp)
*
*/
static void ftdi_close (struct usb_serial_port *port, struct file *filp)
static void ftdi_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{ /* ftdi_close */
unsigned int c_cflag = port->tty->termios->c_cflag;
unsigned int c_cflag = tty->termios->c_cflag;
struct ftdi_private *priv = usb_get_serial_port_data(port);
char buf[1];
@ -1527,7 +1526,7 @@ static void ftdi_close (struct usb_serial_port *port, struct file *filp)
*
* The new devices do not require this byte
*/
static int ftdi_write (struct usb_serial_port *port,
static int ftdi_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{ /* ftdi_write */
struct ftdi_private *priv = usb_get_serial_port_data(port);
@ -1686,8 +1685,9 @@ static void ftdi_write_bulk_callback (struct urb *urb)
} /* ftdi_write_bulk_callback */
static int ftdi_write_room( struct usb_serial_port *port )
static int ftdi_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct ftdi_private *priv = usb_get_serial_port_data(port);
int room;
unsigned long flags;
@ -1707,11 +1707,11 @@ static int ftdi_write_room( struct usb_serial_port *port )
}
spin_unlock_irqrestore(&priv->tx_lock, flags);
return room;
} /* ftdi_write_room */
}
static int ftdi_chars_in_buffer (struct usb_serial_port *port)
{ /* ftdi_chars_in_buffer */
static int ftdi_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct ftdi_private *priv = usb_get_serial_port_data(port);
int buffered;
unsigned long flags;
@ -1726,12 +1726,10 @@ static int ftdi_chars_in_buffer (struct usb_serial_port *port)
buffered = 0;
}
return buffered;
} /* ftdi_chars_in_buffer */
}
static void ftdi_read_bulk_callback (struct urb *urb)
{ /* ftdi_read_bulk_callback */
static void ftdi_read_bulk_callback(struct urb *urb)
{
struct usb_serial_port *port = urb->context;
struct tty_struct *tty;
struct ftdi_private *priv;
@ -1747,10 +1745,10 @@ static void ftdi_read_bulk_callback (struct urb *urb)
dbg("%s - port %d", __func__, port->number);
if (port->open_count <= 0)
if (port->port.count <= 0)
return;
tty = port->tty;
tty = port->port.tty;
if (!tty) {
dbg("%s - bad tty pointer - exiting",__func__);
return;
@ -1803,10 +1801,10 @@ static void ftdi_process_read (struct work_struct *work)
dbg("%s - port %d", __func__, port->number);
if (port->open_count <= 0)
if (port->port.count <= 0)
return;
tty = port->tty;
tty = port->port.tty;
if (!tty) {
dbg("%s - bad tty pointer - exiting",__func__);
return;
@ -1954,7 +1952,7 @@ static void ftdi_process_read (struct work_struct *work)
}
spin_unlock_irqrestore(&priv->rx_lock, flags);
/* if the port is closed stop trying to read */
if (port->open_count > 0){
if (port->port.count > 0){
/* delay processing of remainder */
schedule_delayed_work(&priv->rx_work, 1);
} else {
@ -1967,7 +1965,7 @@ static void ftdi_process_read (struct work_struct *work)
priv->rx_processed = 0;
/* if the port is closed stop trying to read */
if (port->open_count > 0){
if (port->port.count > 0){
/* Continue trying to always read */
usb_fill_bulk_urb(port->read_urb, port->serial->dev,
usb_rcvbulkpipe(port->serial->dev, port->bulk_in_endpointAddress),
@ -1983,8 +1981,9 @@ static void ftdi_process_read (struct work_struct *work)
} /* ftdi_process_read */
static void ftdi_break_ctl( struct usb_serial_port *port, int break_state )
static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
struct ftdi_private *priv = usb_get_serial_port_data(port);
__u16 urb_value = 0;
char buf[1];
@ -2018,11 +2017,12 @@ static void ftdi_break_ctl( struct usb_serial_port *port, int break_state )
* WARNING: set_termios calls this with old_termios in kernel space
*/
static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
static void ftdi_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{ /* ftdi_termios */
struct usb_device *dev = port->serial->dev;
struct ftdi_private *priv = usb_get_serial_port_data(port);
struct ktermios *termios = port->tty->termios;
struct ktermios *termios = tty->termios;
unsigned int cflag = termios->c_cflag;
__u16 urb_value; /* will hold the new flags */
char buf[1]; /* Perhaps I should dynamically alloc this? */
@ -2037,7 +2037,7 @@ static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios *old
/* Force baud rate if this device requires it, unless it is set to B0. */
if (priv->force_baud && ((termios->c_cflag & CBAUD) != B0)) {
dbg("%s: forcing baud rate for this device", __func__);
tty_encode_baud_rate(port->tty, priv->force_baud,
tty_encode_baud_rate(tty, priv->force_baud,
priv->force_baud);
}
@ -2104,7 +2104,7 @@ static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios *old
clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
} else {
/* set the baudrate determined before */
if (change_speed(port)) {
if (change_speed(tty, port)) {
err("%s urb failed to set baudrate", __func__);
}
/* Ensure RTS and DTR are raised when baudrate changed from 0 */
@ -2168,11 +2168,11 @@ static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios *old
}
return;
} /* ftdi_termios */
}
static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file)
static int ftdi_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct ftdi_private *priv = usb_get_serial_port_data(port);
unsigned char buf[2];
int ret;
@ -2221,15 +2221,18 @@ static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file)
priv->last_dtr_rts;
}
static int ftdi_tiocmset(struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear)
static int ftdi_tiocmset(struct tty_struct *tty, struct file * file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
dbg("%s TIOCMSET", __func__);
return update_mctrl(port, set, clear);
}
static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
static int ftdi_ioctl(struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
struct ftdi_private *priv = usb_get_serial_port_data(port);
dbg("%s cmd 0x%04x", __func__, cmd);
@ -2241,7 +2244,7 @@ static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigne
return get_serial_info(port, (struct serial_struct __user *) arg);
case TIOCSSERIAL: /* sets serial port data */
return set_serial_info(port, (struct serial_struct __user *) arg);
return set_serial_info(tty, port, (struct serial_struct __user *) arg);
/*
* Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
@ -2280,25 +2283,20 @@ static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigne
*/
}
}
return(0);
break;
return 0;
default:
break;
}
/* This is not necessarily an error - turns out the higher layers will do
* some ioctls itself (see comment above)
*/
dbg("%s arg not supported - it was 0x%04x - check /usr/include/asm/ioctls.h", __func__, cmd);
return -ENOIOCTLCMD;
}
return(-ENOIOCTLCMD);
} /* ftdi_ioctl */
static void ftdi_throttle (struct usb_serial_port *port)
static void ftdi_throttle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct ftdi_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -2310,8 +2308,9 @@ static void ftdi_throttle (struct usb_serial_port *port)
}
static void ftdi_unthrottle (struct usb_serial_port *port)
static void ftdi_unthrottle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct ftdi_private *priv = usb_get_serial_port_data(port);
int actually_throttled;
unsigned long flags;

58
drivers/usb/serial/garmin_gps.c
View File

@ -275,7 +275,7 @@ static inline int isAbortTrfCmnd(const unsigned char *buf)
static void send_to_tty(struct usb_serial_port *port,
char *data, unsigned int actual_length)
{
struct tty_struct *tty = port->tty;
struct tty_struct *tty = port->port.tty;
if (tty && actual_length) {
@ -970,7 +970,8 @@ static int garmin_init_session(struct usb_serial_port *port)
static int garmin_open (struct usb_serial_port *port, struct file *filp)
static int garmin_open (struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
unsigned long flags;
int status = 0;
@ -983,8 +984,8 @@ static int garmin_open (struct usb_serial_port *port, struct file *filp)
* through, otherwise it is scheduled, and with high data rates (like
* with OHCI) data can get lost.
*/
if (port->tty)
port->tty->low_latency = 1;
if (tty)
tty->low_latency = 1;
spin_lock_irqsave(&garmin_data_p->lock, flags);
garmin_data_p->mode = initial_mode;
@ -998,17 +999,16 @@ static int garmin_open (struct usb_serial_port *port, struct file *filp)
usb_kill_urb (port->write_urb);
usb_kill_urb (port->read_urb);
if (garmin_data_p->state == STATE_RESET) {
if (garmin_data_p->state == STATE_RESET)
status = garmin_init_session(port);
}
garmin_data_p->state = STATE_ACTIVE;
return status;
}
static void garmin_close (struct usb_serial_port *port, struct file * filp)
static void garmin_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file * filp)
{
struct usb_serial *serial = port->serial;
struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
@ -1042,7 +1042,6 @@ static void garmin_close (struct usb_serial_port *port, struct file * filp)
mutex_unlock(&port->serial->disc_mutex);
}
static void garmin_write_bulk_callback (struct urb *urb)
{
unsigned long flags;
@ -1145,10 +1144,8 @@ static int garmin_write_bulk (struct usb_serial_port *port,
return count;
}
static int garmin_write (struct usb_serial_port *port,
const unsigned char *buf, int count)
static int garmin_write (struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
int pktid, pktsiz, len;
struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
@ -1158,7 +1155,6 @@ static int garmin_write (struct usb_serial_port *port,
/* check for our private packets */
if (count >= GARMIN_PKTHDR_LENGTH) {
len = PRIVPKTSIZ;
if (count < len)
len = count;
@ -1226,8 +1222,9 @@ static int garmin_write (struct usb_serial_port *port,
}
static int garmin_write_room (struct usb_serial_port *port)
static int garmin_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
/*
* Report back the bytes currently available in the output buffer.
*/
@ -1236,20 +1233,6 @@ static int garmin_write_room (struct usb_serial_port *port)
}
static int garmin_chars_in_buffer (struct usb_serial_port *port)
{
/*
* Report back the number of bytes currently in our input buffer.
* Will this lock up the driver - the buffer contains an incomplete
* package which will not be written to the device until it
* has been completed ?
*/
//struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
//return garmin_data_p->insize;
return 0;
}
static void garmin_read_process(struct garmin_data * garmin_data_p,
unsigned char *data, unsigned data_length)
{
@ -1468,10 +1451,11 @@ static int garmin_flush_queue(struct garmin_data * garmin_data_p)
}
static void garmin_throttle (struct usb_serial_port *port)
static void garmin_throttle(struct tty_struct *tty)
{
unsigned long flags;
struct usb_serial_port *port = tty->driver_data;
struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
unsigned long flags;
dbg("%s - port %d", __func__, port->number);
/* set flag, data received will be put into a queue
@ -1482,10 +1466,11 @@ static void garmin_throttle (struct usb_serial_port *port)
}
static void garmin_unthrottle (struct usb_serial_port *port)
static void garmin_unthrottle (struct tty_struct *tty)
{
unsigned long flags;
struct usb_serial_port *port = tty->driver_data;
struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
unsigned long flags;
int status;
dbg("%s - port %d", __func__, port->number);
@ -1507,8 +1492,6 @@ static void garmin_unthrottle (struct usb_serial_port *port)
}
}
/*
* The timer is currently only used to send queued packets to
* the tty in cases where the protocol provides no own handshaking
@ -1526,7 +1509,7 @@ static void timeout_handler(unsigned long data)
static int garmin_attach (struct usb_serial *serial)
static int garmin_attach(struct usb_serial *serial)
{
int status = 0;
struct usb_serial_port *port = serial->port[0];
@ -1556,7 +1539,7 @@ static int garmin_attach (struct usb_serial *serial)
}
static void garmin_shutdown (struct usb_serial *serial)
static void garmin_shutdown(struct usb_serial *serial)
{
struct usb_serial_port *port = serial->port[0];
struct garmin_data * garmin_data_p = usb_get_serial_port_data(port);
@ -1588,7 +1571,6 @@ static struct usb_serial_driver garmin_device = {
.shutdown = garmin_shutdown,
.write = garmin_write,
.write_room = garmin_write_room,
.chars_in_buffer = garmin_chars_in_buffer,
.write_bulk_callback = garmin_write_bulk_callback,
.read_bulk_callback = garmin_read_bulk_callback,
.read_int_callback = garmin_read_int_callback,

39
drivers/usb/serial/generic.c
View File

@ -112,7 +112,8 @@ void usb_serial_generic_deregister (void)
#endif
}
int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp)
int usb_serial_generic_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial = port->serial;
int result = 0;
@ -123,8 +124,8 @@ int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp)
/* force low_latency on so that our tty_push actually forces the data through,
otherwise it is scheduled, and with high data rates (like with OHCI) data
can get lost. */
if (port->tty)
port->tty->low_latency = 1;
if (tty)
tty->low_latency = 1;
/* clear the throttle flags */
spin_lock_irqsave(&port->lock, flags);
@ -152,7 +153,7 @@ int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp)
}
EXPORT_SYMBOL_GPL(usb_serial_generic_open);
static void generic_cleanup (struct usb_serial_port *port)
static void generic_cleanup(struct usb_serial_port *port)
{
struct usb_serial *serial = port->serial;
@ -182,7 +183,7 @@ int usb_serial_generic_resume(struct usb_serial *serial)
#endif
for (i = 0; i < serial->num_ports; i++) {
port = serial->port[i];
if (port->open_count && port->read_urb) {
if (port->port.count && port->read_urb) {
r = usb_submit_urb(port->read_urb, GFP_NOIO);
if (r < 0)
c++;
@ -192,13 +193,15 @@ int usb_serial_generic_resume(struct usb_serial *serial)
return c ? -EIO : 0;
}
void usb_serial_generic_close (struct usb_serial_port *port, struct file * filp)
void usb_serial_generic_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file * filp)
{
dbg("%s - port %d", __func__, port->number);
generic_cleanup (port);
}
int usb_serial_generic_write(struct usb_serial_port *port, const unsigned char *buf, int count)
int usb_serial_generic_write(struct tty_struct *tty,
struct usb_serial_port *port, const unsigned char *buf, int count)
{
struct usb_serial *serial = port->serial;
int result;
@ -255,8 +258,9 @@ int usb_serial_generic_write(struct usb_serial_port *port, const unsigned char *
return 0;
}
int usb_serial_generic_write_room (struct usb_serial_port *port)
int usb_serial_generic_write_room (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
int room = 0;
@ -272,8 +276,9 @@ int usb_serial_generic_write_room (struct usb_serial_port *port)
return room;
}
int usb_serial_generic_chars_in_buffer (struct usb_serial_port *port)
int usb_serial_generic_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
int chars = 0;
@ -286,7 +291,7 @@ int usb_serial_generic_chars_in_buffer (struct usb_serial_port *port)
}
dbg("%s - returns %d", __func__, chars);
return (chars);
return chars;
}
@ -311,10 +316,10 @@ static void resubmit_read_urb(struct usb_serial_port *port, gfp_t mem_flags)
}
/* Push data to tty layer and resubmit the bulk read URB */
static void flush_and_resubmit_read_urb (struct usb_serial_port *port)
static void flush_and_resubmit_read_urb(struct usb_serial_port *port)
{
struct urb *urb = port->read_urb;
struct tty_struct *tty = port->tty;
struct tty_struct *tty = port->port.tty;
int room;
/* Push data to tty */
@ -329,7 +334,7 @@ static void flush_and_resubmit_read_urb (struct usb_serial_port *port)
resubmit_read_urb(port, GFP_ATOMIC);
}
void usb_serial_generic_read_bulk_callback (struct urb *urb)
void usb_serial_generic_read_bulk_callback(struct urb *urb)
{
struct usb_serial_port *port = urb->context;
unsigned char *data = urb->transfer_buffer;
@ -357,7 +362,7 @@ void usb_serial_generic_read_bulk_callback (struct urb *urb)
}
EXPORT_SYMBOL_GPL(usb_serial_generic_read_bulk_callback);
void usb_serial_generic_write_bulk_callback (struct urb *urb)
void usb_serial_generic_write_bulk_callback(struct urb *urb)
{
struct usb_serial_port *port = urb->context;
int status = urb->status;
@ -374,8 +379,9 @@ void usb_serial_generic_write_bulk_callback (struct urb *urb)
}
EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback);
void usb_serial_generic_throttle (struct usb_serial_port *port)
void usb_serial_generic_throttle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
unsigned long flags;
dbg("%s - port %d", __func__, port->number);
@ -387,8 +393,9 @@ void usb_serial_generic_throttle (struct usb_serial_port *port)
spin_unlock_irqrestore(&port->lock, flags);
}
void usb_serial_generic_unthrottle (struct usb_serial_port *port)
void usb_serial_generic_unthrottle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
int was_throttled;
unsigned long flags;

175
drivers/usb/serial/io_edgeport.c
View File

@ -206,18 +206,18 @@ static void edge_bulk_out_data_callback (struct urb *urb);
static void edge_bulk_out_cmd_callback (struct urb *urb);
/* function prototypes for the usbserial callbacks */
static int edge_open (struct usb_serial_port *port, struct file *filp);
static void edge_close (struct usb_serial_port *port, struct file *filp);
static int edge_write (struct usb_serial_port *port, const unsigned char *buf, int count);
static int edge_write_room (struct usb_serial_port *port);
static int edge_chars_in_buffer (struct usb_serial_port *port);
static void edge_throttle (struct usb_serial_port *port);
static void edge_unthrottle (struct usb_serial_port *port);
static void edge_set_termios (struct usb_serial_port *port, struct ktermios *old_termios);
static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg);
static void edge_break (struct usb_serial_port *port, int break_state);
static int edge_tiocmget (struct usb_serial_port *port, struct file *file);
static int edge_tiocmset (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear);
static int edge_open (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static void edge_close (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static int edge_write (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
static int edge_write_room (struct tty_struct *tty);
static int edge_chars_in_buffer (struct tty_struct *tty);
static void edge_throttle (struct tty_struct *tty);
static void edge_unthrottle (struct tty_struct *tty);
static void edge_set_termios (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios *old_termios);
static int edge_ioctl (struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
static void edge_break (struct tty_struct *tty, int break_state);
static int edge_tiocmget (struct tty_struct *tty, struct file *file);
static int edge_tiocmset (struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear);
static int edge_startup (struct usb_serial *serial);
static void edge_shutdown (struct usb_serial *serial);
@ -233,7 +233,8 @@ static void handle_new_lsr (struct edgeport_port *edge_port, __u8 lsrData, __u8
static int send_iosp_ext_cmd (struct edgeport_port *edge_port, __u8 command, __u8 param);
static int calc_baud_rate_divisor (int baud_rate, int *divisor);
static int send_cmd_write_baud_rate (struct edgeport_port *edge_port, int baudRate);
static void change_port_settings (struct edgeport_port *edge_port, struct ktermios *old_termios);
static void change_port_settings (struct tty_struct *tty, struct edgeport_port *edge_port,
struct ktermios *old_termios);
static int send_cmd_write_uart_register (struct edgeport_port *edge_port, __u8 regNum, __u8 regValue);
static int write_cmd_usb (struct edgeport_port *edge_port, unsigned char *buffer, int writeLength);
static void send_more_port_data (struct edgeport_serial *edge_serial, struct edgeport_port *edge_port);
@ -639,8 +640,8 @@ static void edge_interrupt_callback (struct urb *urb)
dbg("%s - txcredits for port%d = %d", __func__, portNumber, edge_port->txCredits);
/* tell the tty driver that something has changed */
if (edge_port->port->tty)
tty_wakeup(edge_port->port->tty);
if (edge_port->port->port.tty)
tty_wakeup(edge_port->port->port.tty);
// Since we have more credit, check if more data can be sent
send_more_port_data(edge_serial, edge_port);
@ -737,7 +738,7 @@ static void edge_bulk_out_data_callback (struct urb *urb)
__func__, status);
}
tty = edge_port->port->tty;
tty = edge_port->port->port.tty;
if (tty && edge_port->open) {
/* let the tty driver wakeup if it has a special write_wakeup function */
@ -781,7 +782,7 @@ static void edge_bulk_out_cmd_callback (struct urb *urb)
}
/* Get pointer to tty */
tty = edge_port->port->tty;
tty = edge_port->port->port.tty;
/* tell the tty driver that something has changed */
if (tty && edge_port->open)
@ -803,7 +804,8 @@ static void edge_bulk_out_cmd_callback (struct urb *urb)
* If successful, we return 0
* Otherwise we return a negative error number.
*****************************************************************************/
static int edge_open (struct usb_serial_port *port, struct file * filp)
static int edge_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file * filp)
{
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct usb_serial *serial;
@ -815,16 +817,15 @@ static int edge_open (struct usb_serial_port *port, struct file * filp)
if (edge_port == NULL)
return -ENODEV;
if (port->tty)
port->tty->low_latency = low_latency;
if (tty)
tty->low_latency = low_latency;
/* see if we've set up our endpoint info yet (can't set it up in edge_startup
as the structures were not set up at that time.) */
serial = port->serial;
edge_serial = usb_get_serial_data(serial);
if (edge_serial == NULL) {
if (edge_serial == NULL)
return -ENODEV;
}
if (edge_serial->interrupt_in_buffer == NULL) {
struct usb_serial_port *port0 = serial->port[0];
@ -908,7 +909,7 @@ static int edge_open (struct usb_serial_port *port, struct file * filp)
if (!edge_port->txfifo.fifo) {
dbg("%s - no memory", __func__);
edge_close (port, filp);
edge_close (tty, port, filp);
return -ENOMEM;
}
@ -918,7 +919,7 @@ static int edge_open (struct usb_serial_port *port, struct file * filp)
if (!edge_port->write_urb) {
dbg("%s - no memory", __func__);
edge_close (port, filp);
edge_close (tty, port, filp);
return -ENOMEM;
}
@ -1038,7 +1039,8 @@ static void block_until_tx_empty (struct edgeport_port *edge_port)
* edge_close
* this function is called by the tty driver when a port is closed
*****************************************************************************/
static void edge_close (struct usb_serial_port *port, struct file * filp)
static void edge_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file * filp)
{
struct edgeport_serial *edge_serial;
struct edgeport_port *edge_port;
@ -1106,7 +1108,8 @@ static void edge_close (struct usb_serial_port *port, struct file * filp)
* If successful, we return the number of bytes written, otherwise we return
* a negative error number.
*****************************************************************************/
static int edge_write (struct usb_serial_port *port, const unsigned char *data, int count)
static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *data, int count)
{
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct TxFifo *fifo;
@ -1308,8 +1311,9 @@ exit_send:
* (the txCredits),
* Otherwise we return a negative error number.
*****************************************************************************/
static int edge_write_room (struct usb_serial_port *port)
static int edge_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
int room;
unsigned long flags;
@ -1347,8 +1351,9 @@ static int edge_write_room (struct usb_serial_port *port)
* system,
* Otherwise we return a negative error number.
*****************************************************************************/
static int edge_chars_in_buffer (struct usb_serial_port *port)
static int edge_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
int num_chars;
unsigned long flags;
@ -1381,10 +1386,10 @@ static int edge_chars_in_buffer (struct usb_serial_port *port)
* this function is called by the tty driver when it wants to stop the data
* being read from the port.
*****************************************************************************/
static void edge_throttle (struct usb_serial_port *port)
static void edge_throttle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct tty_struct *tty;
int status;
dbg("%s - port %d", __func__, port->number);
@ -1397,16 +1402,10 @@ static void edge_throttle (struct usb_serial_port *port)
return;
}
tty = port->tty;
if (!tty) {
dbg ("%s - no tty available", __func__);
return;
}
/* if we are implementing XON/XOFF, send the stop character */
if (I_IXOFF(tty)) {
unsigned char stop_char = STOP_CHAR(tty);
status = edge_write (port, &stop_char, 1);
status = edge_write (tty, port, &stop_char, 1);
if (status <= 0) {
return;
}
@ -1430,10 +1429,10 @@ static void edge_throttle (struct usb_serial_port *port)
* this function is called by the tty driver when it wants to resume the data
* being read from the port (called after SerialThrottle is called)
*****************************************************************************/
static void edge_unthrottle (struct usb_serial_port *port)
static void edge_unthrottle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct tty_struct *tty;
int status;
dbg("%s - port %d", __func__, port->number);
@ -1446,31 +1445,18 @@ static void edge_unthrottle (struct usb_serial_port *port)
return;
}
tty = port->tty;
if (!tty) {
dbg ("%s - no tty available", __func__);
return;
}
/* if we are implementing XON/XOFF, send the start character */
if (I_IXOFF(tty)) {
unsigned char start_char = START_CHAR(tty);
status = edge_write (port, &start_char, 1);
if (status <= 0) {
status = edge_write(tty, port, &start_char, 1);
if (status <= 0)
return;
}
}
/* if we are implementing RTS/CTS, toggle that line */
if (tty->termios->c_cflag & CRTSCTS) {
edge_port->shadowMCR |= MCR_RTS;
status = send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
if (status != 0) {
return;
}
send_cmd_write_uart_register(edge_port, MCR, edge_port->shadowMCR);
}
return;
}
@ -1478,11 +1464,10 @@ static void edge_unthrottle (struct usb_serial_port *port)
* SerialSetTermios
* this function is called by the tty driver when it wants to change the termios structure
*****************************************************************************/
static void edge_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
static void edge_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
/* FIXME: This function appears unused ?? */
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct tty_struct *tty = port->tty;
unsigned int cflag;
cflag = tty->termios->c_cflag;
@ -1502,9 +1487,7 @@ static void edge_set_termios (struct usb_serial_port *port, struct ktermios *old
}
/* change the port settings to the new ones specified */
change_port_settings (edge_port, old_termios);
return;
change_port_settings(tty, edge_port, old_termios);
}
@ -1536,25 +1519,9 @@ static int get_lsr_info(struct edgeport_port *edge_port, unsigned int __user *va
return 0;
}
static int get_number_bytes_avail(struct edgeport_port *edge_port, unsigned int __user *value)
{
unsigned int result = 0;
struct tty_struct *tty = edge_port->port->tty;
if (!tty)
return -ENOIOCTLCMD;
result = tty->read_cnt;
dbg("%s(%d) = %d", __func__, edge_port->port->number, result);
if (copy_to_user(value, &result, sizeof(int)))
return -EFAULT;
//return 0;
return -ENOIOCTLCMD;
}
static int edge_tiocmset (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear)
static int edge_tiocmset(struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
unsigned int mcr;
@ -1582,8 +1549,9 @@ static int edge_tiocmset (struct usb_serial_port *port, struct file *file, unsig
return 0;
}
static int edge_tiocmget(struct usb_serial_port *port, struct file *file)
static int edge_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
unsigned int result = 0;
unsigned int msr;
@ -1624,9 +1592,6 @@ static int get_serial_info(struct edgeport_port *edge_port, struct serial_struct
tmp.baud_base = 9600;
tmp.close_delay = 5*HZ;
tmp.closing_wait = 30*HZ;
// tmp.custom_divisor = state->custom_divisor;
// tmp.hub6 = state->hub6;
// tmp.io_type = state->io_type;
if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
return -EFAULT;
@ -1639,8 +1604,10 @@ static int get_serial_info(struct edgeport_port *edge_port, struct serial_struct
* SerialIoctl
* this function handles any ioctl calls to the driver
*****************************************************************************/
static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg)
static int edge_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
DEFINE_WAIT(wait);
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct async_icount cnow;
@ -1650,25 +1617,14 @@ static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned
dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
switch (cmd) {
// return number of bytes available
case TIOCINQ:
dbg("%s (%d) TIOCINQ", __func__, port->number);
return get_number_bytes_avail(edge_port, (unsigned int __user *) arg);
break;
case TIOCSERGETLSR:
dbg("%s (%d) TIOCSERGETLSR", __func__, port->number);
return get_lsr_info(edge_port, (unsigned int __user *) arg);
return 0;
case TIOCGSERIAL:
dbg("%s (%d) TIOCGSERIAL", __func__, port->number);
return get_serial_info(edge_port, (struct serial_struct __user *) arg);
case TIOCSSERIAL:
dbg("%s (%d) TIOCSSERIAL", __func__, port->number);
break;
case TIOCMIWAIT:
dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
cprev = edge_port->icount;
@ -1723,8 +1679,9 @@ static int edge_ioctl (struct usb_serial_port *port, struct file *file, unsigned
* SerialBreak
* this function sends a break to the port
*****************************************************************************/
static void edge_break (struct usb_serial_port *port, int break_state)
static void edge_break (struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct edgeport_serial *edge_serial = usb_get_serial_data(port->serial);
int status;
@ -1866,7 +1823,7 @@ static void process_rcvd_data (struct edgeport_serial *edge_serial, unsigned cha
port = edge_serial->serial->port[edge_serial->rxPort];
edge_port = usb_get_serial_port_data(port);
if (edge_port->open) {
tty = edge_port->port->tty;
tty = edge_port->port->port.tty;
if (tty) {
dbg("%s - Sending %d bytes to TTY for port %d", __func__, rxLen, edge_serial->rxPort);
edge_tty_recv(&edge_serial->serial->dev->dev, tty, buffer, rxLen);
@ -1941,8 +1898,9 @@ static void process_rcvd_status (struct edgeport_serial *edge_serial, __u8 byte2
handle_new_msr (edge_port, byte2);
/* send the current line settings to the port so we are in sync with any further termios calls */
if (edge_port->port->tty)
change_port_settings (edge_port, edge_port->port->tty->termios);
/* FIXME: locking on tty */
if (edge_port->port->port.tty)
change_port_settings(edge_port->port->port.tty, edge_port, edge_port->port->port.tty->termios);
/* we have completed the open */
edge_port->openPending = false;
@ -2078,8 +2036,8 @@ static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData, __u8 l
}
/* Place LSR data byte into Rx buffer */
if (lsrData && edge_port->port->tty)
edge_tty_recv(&edge_port->port->dev, edge_port->port->tty, &data, 1);
if (lsrData && edge_port->port->port.tty)
edge_tty_recv(&edge_port->port->dev, edge_port->port->port.tty, &data, 1);
/* update input line counters */
icount = &edge_port->icount;
@ -2473,13 +2431,11 @@ static int send_cmd_write_uart_register (struct edgeport_port *edge_port, __u8 r
* This routine is called to set the UART on the device to match the specified
* new settings.
*****************************************************************************/
#ifndef CMSPAR
#define CMSPAR 0
#endif
static void change_port_settings (struct edgeport_port *edge_port, struct ktermios *old_termios)
static void change_port_settings(struct tty_struct *tty,
struct edgeport_port *edge_port, struct ktermios *old_termios)
{
struct edgeport_serial *edge_serial = usb_get_serial_data(edge_port->port->serial);
struct tty_struct *tty;
int baud;
unsigned cflag;
__u8 mask = 0xff;
@ -2498,13 +2454,6 @@ static void change_port_settings (struct edgeport_port *edge_port, struct ktermi
return;
}
tty = edge_port->port->tty;
if ((!tty) ||
(!tty->termios)) {
dbg("%s - no tty structures", __func__);
return;
}
cflag = tty->termios->c_cflag;
switch (cflag & CSIZE) {

109
drivers/usb/serial/io_ti.c
View File

@ -243,9 +243,9 @@ static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
static void stop_read(struct edgeport_port *edge_port);
static int restart_read(struct edgeport_port *edge_port);
static void edge_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios);
static void edge_send(struct usb_serial_port *port);
static void edge_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios);
static void edge_send(struct tty_struct *tty);
/* sysfs attributes */
static int edge_create_sysfs_attrs(struct usb_serial_port *port);
@ -572,7 +572,7 @@ static void chase_port(struct edgeport_port *port, unsigned long timeout,
int flush)
{
int baud_rate;
struct tty_struct *tty = port->port->tty;
struct tty_struct *tty = port->port->port.tty;
wait_queue_t wait;
unsigned long flags;
@ -1554,7 +1554,7 @@ static void handle_new_msr(struct edgeport_port *edge_port, __u8 msr)
/* Save the new modem status */
edge_port->shadow_msr = msr & 0xf0;
tty = edge_port->port->tty;
tty = edge_port->port->port.tty;
/* handle CTS flow control */
if (tty && C_CRTSCTS(tty)) {
if (msr & EDGEPORT_MSR_CTS) {
@ -1587,9 +1587,8 @@ static void handle_new_lsr(struct edgeport_port *edge_port, int lsr_data,
new_lsr &= (__u8)(LSR_OVER_ERR | LSR_BREAK);
/* Place LSR data byte into Rx buffer */
if (lsr_data && edge_port->port->tty)
edge_tty_recv(&edge_port->port->dev, edge_port->port->tty,
&data, 1);
if (lsr_data && edge_port->port->port.tty)
edge_tty_recv(&edge_port->port->dev, edge_port->port->port.tty, &data, 1);
/* update input line counters */
icount = &edge_port->icount;
@ -1750,7 +1749,7 @@ static void edge_bulk_in_callback(struct urb *urb)
++data;
}
tty = edge_port->port->tty;
tty = edge_port->port->port.tty;
if (tty && urb->actual_length) {
usb_serial_debug_data(debug, &edge_port->port->dev,
__func__, urb->actual_length, data);
@ -1819,10 +1818,11 @@ static void edge_bulk_out_callback(struct urb *urb)
}
/* send any buffered data */
edge_send(port);
edge_send(port->port.tty);
}
static int edge_open(struct usb_serial_port *port, struct file *filp)
static int edge_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct edgeport_serial *edge_serial;
@ -1838,7 +1838,8 @@ static int edge_open(struct usb_serial_port *port, struct file *filp)
if (edge_port == NULL)
return -ENODEV;
port->tty->low_latency = low_latency;
if (tty)
tty->low_latency = low_latency;
port_number = port->number - port->serial->minor;
switch (port_number) {
@ -1874,7 +1875,8 @@ static int edge_open(struct usb_serial_port *port, struct file *filp)
}
/* set up the port settings */
edge_set_termios(port, port->tty->termios);
if (tty)
edge_set_termios(tty, port, port->port.tty->termios);
/* open up the port */
@ -2000,7 +2002,8 @@ release_es_lock:
return status;
}
static void edge_close(struct usb_serial_port *port, struct file *filp)
static void edge_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct edgeport_serial *edge_serial;
struct edgeport_port *edge_port;
@ -2048,8 +2051,8 @@ static void edge_close(struct usb_serial_port *port, struct file *filp)
dbg("%s - exited", __func__);
}
static int edge_write(struct usb_serial_port *port, const unsigned char *data,
int count)
static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *data, int count)
{
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
unsigned long flags;
@ -2070,16 +2073,16 @@ static int edge_write(struct usb_serial_port *port, const unsigned char *data,
count = edge_buf_put(edge_port->ep_out_buf, data, count);
spin_unlock_irqrestore(&edge_port->ep_lock, flags);
edge_send(port);
edge_send(tty);
return count;
}
static void edge_send(struct usb_serial_port *port)
static void edge_send(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
int count, result;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct tty_struct *tty = port->tty;
unsigned long flags;
@ -2133,8 +2136,9 @@ static void edge_send(struct usb_serial_port *port)
tty_wakeup(tty);
}
static int edge_write_room(struct usb_serial_port *port)
static int edge_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
int room = 0;
unsigned long flags;
@ -2154,8 +2158,9 @@ static int edge_write_room(struct usb_serial_port *port)
return room;
}
static int edge_chars_in_buffer(struct usb_serial_port *port)
static int edge_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
int chars = 0;
unsigned long flags;
@ -2175,10 +2180,10 @@ static int edge_chars_in_buffer(struct usb_serial_port *port)
return chars;
}
static void edge_throttle(struct usb_serial_port *port)
static void edge_throttle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct tty_struct *tty = port->tty;
int status;
dbg("%s - port %d", __func__, port->number);
@ -2189,11 +2194,10 @@ static void edge_throttle(struct usb_serial_port *port)
/* if we are implementing XON/XOFF, send the stop character */
if (I_IXOFF(tty)) {
unsigned char stop_char = STOP_CHAR(tty);
status = edge_write(port, &stop_char, 1);
if (status <= 0)
dev_err(&port->dev,
"%s - failed to write stop character, %d\n",
__func__, status);
status = edge_write(tty, port, &stop_char, 1);
if (status <= 0) {
dev_err(&port->dev, "%s - failed to write stop character, %d\n", __func__, status);
}
}
/* if we are implementing RTS/CTS, stop reads */
@ -2203,10 +2207,10 @@ static void edge_throttle(struct usb_serial_port *port)
}
static void edge_unthrottle(struct usb_serial_port *port)
static void edge_unthrottle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct tty_struct *tty = port->tty;
int status;
dbg("%s - port %d", __func__, port->number);
@ -2217,11 +2221,10 @@ static void edge_unthrottle(struct usb_serial_port *port)
/* if we are implementing XON/XOFF, send the start character */
if (I_IXOFF(tty)) {
unsigned char start_char = START_CHAR(tty);
status = edge_write(port, &start_char, 1);
if (status <= 0)
dev_err(&port->dev,
"%s - failed to write start character, %d\n",
__func__, status);
status = edge_write(tty, port, &start_char, 1);
if (status <= 0) {
dev_err(&port->dev, "%s - failed to write start character, %d\n", __func__, status);
}
}
/* if we are implementing RTS/CTS, restart reads */
/* are the Edgeport will assert the RTS line */
@ -2271,11 +2274,10 @@ static int restart_read(struct edgeport_port *edge_port)
return status;
}
static void change_port_settings(struct edgeport_port *edge_port,
struct ktermios *old_termios)
static void change_port_settings(struct tty_struct *tty,
struct edgeport_port *edge_port, struct ktermios *old_termios)
{
struct ump_uart_config *config;
struct tty_struct *tty;
int baud;
unsigned cflag;
int status;
@ -2284,9 +2286,7 @@ static void change_port_settings(struct edgeport_port *edge_port,
dbg("%s - port %d", __func__, edge_port->port->number);
tty = edge_port->port->tty;
config = kmalloc(sizeof(*config), GFP_KERNEL);
config = kmalloc (sizeof (*config), GFP_KERNEL);
if (!config) {
*tty->termios = *old_termios;
dev_err(&edge_port->port->dev, "%s - out of memory\n",
@ -2419,11 +2419,13 @@ static void change_port_settings(struct edgeport_port *edge_port,
return;
}
static void edge_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios)
static void edge_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct tty_struct *tty = port->tty;
unsigned int cflag;
cflag = tty->termios->c_cflag;
dbg("%s - clfag %08x iflag %08x", __func__,
tty->termios->c_cflag, tty->termios->c_iflag);
@ -2434,12 +2436,14 @@ static void edge_set_termios(struct usb_serial_port *port,
if (edge_port == NULL)
return;
/* change the port settings to the new ones specified */
change_port_settings(edge_port, old_termios);
change_port_settings(tty, edge_port, old_termios);
return;
}
static int edge_tiocmset(struct usb_serial_port *port, struct file *file,
static int edge_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
unsigned int mcr;
unsigned long flags;
@ -2469,8 +2473,9 @@ static int edge_tiocmset(struct usb_serial_port *port, struct file *file,
return 0;
}
static int edge_tiocmget(struct usb_serial_port *port, struct file *file)
static int edge_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
unsigned int result = 0;
unsigned int msr;
@ -2522,9 +2527,10 @@ static int get_serial_info(struct edgeport_port *edge_port,
return 0;
}
static int edge_ioctl(struct usb_serial_port *port, struct file *file,
static int edge_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
struct async_icount cnow;
struct async_icount cprev;
@ -2569,18 +2575,19 @@ static int edge_ioctl(struct usb_serial_port *port, struct file *file,
return -ENOIOCTLCMD;
}
static void edge_break(struct usb_serial_port *port, int on)
static void edge_break(struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
struct edgeport_port *edge_port = usb_get_serial_port_data(port);
int status;
int bv = 0; /* Off */
dbg("%s - state = %d", __func__, on);
dbg("%s - state = %d", __func__, break_state);
/* chase the port close */
chase_port(edge_port, 0, 0);
if (on == -1)
if (break_state == -1)
bv = 1; /* On */
status = ti_do_config(edge_port, UMPC_SET_CLR_BREAK, bv);
if (status)

48
drivers/usb/serial/ipaq.c
View File

@ -74,19 +74,21 @@ static int connect_retries = KP_RETRIES;
static int initial_wait;
/* Function prototypes for an ipaq */
static int ipaq_open (struct usb_serial_port *port, struct file *filp);
static void ipaq_close (struct usb_serial_port *port, struct file *filp);
static int ipaq_startup (struct usb_serial *serial);
static void ipaq_shutdown (struct usb_serial *serial);
static int ipaq_write(struct usb_serial_port *port, const unsigned char *buf,
int count);
static int ipaq_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp);
static void ipaq_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp);
static int ipaq_startup(struct usb_serial *serial);
static void ipaq_shutdown(struct usb_serial *serial);
static int ipaq_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count);
static int ipaq_write_bulk(struct usb_serial_port *port, const unsigned char *buf,
int count);
int count);
static void ipaq_write_gather(struct usb_serial_port *port);
static void ipaq_read_bulk_callback (struct urb *urb);
static void ipaq_write_bulk_callback(struct urb *urb);
static int ipaq_write_room(struct usb_serial_port *port);
static int ipaq_chars_in_buffer(struct usb_serial_port *port);
static int ipaq_write_room(struct tty_struct *tty);
static int ipaq_chars_in_buffer(struct tty_struct *tty);
static void ipaq_destroy_lists(struct usb_serial_port *port);
@ -591,7 +593,8 @@ static spinlock_t write_list_lock;
static int bytes_in;
static int bytes_out;
static int ipaq_open(struct usb_serial_port *port, struct file *filp)
static int ipaq_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial = port->serial;
struct ipaq_private *priv;
@ -637,10 +640,12 @@ static int ipaq_open(struct usb_serial_port *port, struct file *filp)
* discipline instead of queueing.
*/
port->tty->low_latency = 1;
port->tty->raw = 1;
port->tty->real_raw = 1;
if (tty) {
tty->low_latency = 1;
/* FIXME: These two are bogus */
tty->raw = 1;
tty->real_raw = 1;
}
/*
* Lose the small buffers usbserial provides. Make larger ones.
*/
@ -714,7 +719,8 @@ error:
}
static void ipaq_close(struct usb_serial_port *port, struct file *filp)
static void ipaq_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct ipaq_private *priv = usb_get_serial_port_data(port);
@ -751,7 +757,7 @@ static void ipaq_read_bulk_callback(struct urb *urb)
usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
tty = port->tty;
tty = port->port.tty;
if (tty && urb->actual_length) {
tty_buffer_request_room(tty, urb->actual_length);
tty_insert_flip_string(tty, data, urb->actual_length);
@ -770,8 +776,8 @@ static void ipaq_read_bulk_callback(struct urb *urb)
return;
}
static int ipaq_write(struct usb_serial_port *port, const unsigned char *buf,
int count)
static int ipaq_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
const unsigned char *current_position = buf;
int bytes_sent = 0;
@ -905,16 +911,18 @@ static void ipaq_write_bulk_callback(struct urb *urb)
usb_serial_port_softint(port);
}
static int ipaq_write_room(struct usb_serial_port *port)
static int ipaq_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct ipaq_private *priv = usb_get_serial_port_data(port);
dbg("%s - freelen %d", __func__, priv->free_len);
return priv->free_len;
}
static int ipaq_chars_in_buffer(struct usb_serial_port *port)
static int ipaq_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct ipaq_private *priv = usb_get_serial_port_data(port);
dbg("%s - queuelen %d", __func__, priv->queue_len);

15
drivers/usb/serial/ipw.c
View File

@ -179,7 +179,7 @@ static void ipw_read_bulk_callback(struct urb *urb)
usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
tty = port->tty;
tty = port->port.tty;
if (tty && urb->actual_length) {
tty_buffer_request_room(tty, urb->actual_length);
tty_insert_flip_string(tty, data, urb->actual_length);
@ -199,7 +199,8 @@ static void ipw_read_bulk_callback(struct urb *urb)
return;
}
static int ipw_open(struct usb_serial_port *port, struct file *filp)
static int ipw_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct usb_device *dev = port->serial->dev;
u8 buf_flow_static[16] = IPW_BYTES_FLOWINIT;
@ -212,8 +213,8 @@ static int ipw_open(struct usb_serial_port *port, struct file *filp)
if (!buf_flow_init)
return -ENOMEM;
if (port->tty)
port->tty->low_latency = 1;
if (tty)
tty->low_latency = 1;
/* --1: Tell the modem to initialize (we think) From sniffs this is always the
* first thing that gets sent to the modem during opening of the device */
@ -301,7 +302,8 @@ static int ipw_open(struct usb_serial_port *port, struct file *filp)
return 0;
}
static void ipw_close(struct usb_serial_port *port, struct file * filp)
static void ipw_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file * filp)
{
struct usb_device *dev = port->serial->dev;
int result;
@ -384,7 +386,8 @@ static void ipw_write_bulk_callback(struct urb *urb)
usb_serial_port_softint(port);
}
static int ipw_write(struct usb_serial_port *port, const unsigned char *buf, int count)
static int ipw_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
struct usb_device *dev = port->serial->dev;
int ret;

81
drivers/usb/serial/ir-usb.c
View File

@ -85,15 +85,17 @@ static int buffer_size;
/* if overridden by the user, then use the specified number of XBOFs */
static int xbof = -1;
static int ir_startup(struct usb_serial *serial);
static int ir_open(struct usb_serial_port *port, struct file *filep);
static void ir_close(struct usb_serial_port *port, struct file *filep);
static int ir_write(struct usb_serial_port *port,
const unsigned char *buf, int count);
static void ir_write_bulk_callback(struct urb *urb);
static void ir_read_bulk_callback(struct urb *urb);
static void ir_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios);
static int ir_startup (struct usb_serial *serial);
static int ir_open(struct tty_struct *tty, struct usb_serial_port *port,
struct file *filep);
static void ir_close(struct tty_struct *tty, struct usb_serial_port *port,
struct file *filep);
static int ir_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count);
static void ir_write_bulk_callback (struct urb *urb);
static void ir_read_bulk_callback (struct urb *urb);
static void ir_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios);
/* Not that this lot means you can only have one per system */
static u8 ir_baud;
@ -295,7 +297,8 @@ static int ir_startup(struct usb_serial *serial)
return 0;
}
static int ir_open(struct usb_serial_port *port, struct file *filp)
static int ir_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
char *buffer;
int result = 0;
@ -343,7 +346,8 @@ static int ir_open(struct usb_serial_port *port, struct file *filp)
return result;
}
static void ir_close(struct usb_serial_port *port, struct file *filp)
static void ir_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file * filp)
{
dbg("%s - port %d", __func__, port->number);
@ -351,8 +355,8 @@ static void ir_close(struct usb_serial_port *port, struct file *filp)
usb_kill_urb(port->read_urb);
}
static int ir_write(struct usb_serial_port *port,
const unsigned char *buf, int count)
static int ir_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
unsigned char *transfer_buffer;
int result;
@ -360,11 +364,6 @@ static int ir_write(struct usb_serial_port *port,
dbg("%s - port = %d, count = %d", __func__, port->number, count);
if (!port->tty) {
dev_err(&port->dev, "%s - no tty???\n", __func__);
return 0;
}
if (count == 0)
return 0;
@ -450,14 +449,13 @@ static void ir_read_bulk_callback(struct urb *urb)
dbg("%s - port %d", __func__, port->number);
if (!port->open_count) {
if (!port->port.count) {
dbg("%s - port closed.", __func__);
return;
}
switch (status) {
case 0: /* Successful */
/*
* The first byte of the packet we get from the device
* contains a busy indicator and baud rate change.
@ -465,19 +463,11 @@ static void ir_read_bulk_callback(struct urb *urb)
*/
if ((*data & 0x0f) > 0)
ir_baud = *data & 0x0f;
usb_serial_debug_data(
debug,
&port->dev,
__func__,
urb->actual_length,
data);
tty = port->tty;
usb_serial_debug_data(debug, &port->dev, __func__,
urb->actual_length, data);
tty = port->port.tty;
if (tty_buffer_request_room(tty, urb->actual_length - 1)) {
tty_insert_flip_string(tty, data + 1,
urb->actual_length - 1);
tty_insert_flip_string(tty, data+1, urb->actual_length - 1);
tty_flip_buffer_push(tty);
}
@ -488,11 +478,10 @@ static void ir_read_bulk_callback(struct urb *urb)
*/
case -EPROTO: /* taking inspiration from pl2303.c */
/* Continue trying to always read */
/* Continue trying to always read */
usb_fill_bulk_urb(
port->read_urb,
port->serial->dev,
port->serial->dev,
usb_rcvbulkpipe(port->serial->dev,
port->bulk_in_endpointAddress),
port->read_urb->transfer_buffer,
@ -502,23 +491,19 @@ static void ir_read_bulk_callback(struct urb *urb)
result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
if (result)
dev_err(&port->dev,
"%s - failed resubmitting read urb, error %d\n",
dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n",
__func__, result);
break;
break ;
default:
dbg("%s - nonzero read bulk status received: %d",
__func__,
status);
break;
__func__, status);
break ;
}
return;
}
static void ir_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios)
static void ir_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
unsigned char *transfer_buffer;
int result;
@ -527,7 +512,7 @@ static void ir_set_termios(struct usb_serial_port *port,
dbg("%s - port %d", __func__, port->number);
baud = tty_get_baud_rate(port->tty);
baud = tty_get_baud_rate(tty);
/*
* FIXME, we should compare the baud request against the
@ -600,8 +585,8 @@ static void ir_set_termios(struct usb_serial_port *port,
__func__, result);
/* Only speed changes are supported */
tty_termios_copy_hw(port->tty->termios, old_termios);
tty_encode_baud_rate(port->tty, baud, baud);
tty_termios_copy_hw(tty->termios, old_termios);
tty_encode_baud_rate(tty, baud, baud);
}
static int __init ir_init(void)

43
drivers/usb/serial/iuu_phoenix.c
View File

@ -144,9 +144,10 @@ static void iuu_shutdown(struct usb_serial *serial)
}
}
static int iuu_tiocmset(struct usb_serial_port *port, struct file *file,
static int iuu_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct iuu_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -171,8 +172,9 @@ static int iuu_tiocmset(struct usb_serial_port *port, struct file *file,
* When no card , the reader respond with TIOCM_CD
* This is known as CD autodetect mechanism
*/
static int iuu_tiocmget(struct usb_serial_port *port, struct file *file)
static int iuu_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct iuu_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
int rc;
@ -630,7 +632,7 @@ static void read_buf_callback(struct urb *urb)
}
dbg("%s - %i chars to write", __func__, urb->actual_length);
tty = port->tty;
tty = port->port.tty;
if (data == NULL)
dbg("%s - data is NULL !!!", __func__);
if (tty && urb->actual_length && data) {
@ -752,11 +754,10 @@ static void iuu_uart_read_callback(struct urb *urb)
/* if nothing to write call again rxcmd */
dbg("%s - rxcmd recall", __func__);
iuu_led_activity_off(urb);
return;
}
static int iuu_uart_write(struct usb_serial_port *port, const u8 *buf,
int count)
static int iuu_uart_write(struct tty_struct *tty, struct usb_serial_port *port,
const u8 *buf, int count)
{
struct iuu_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -948,7 +949,8 @@ static int set_control_lines(struct usb_device *dev, u8 value)
return 0;
}
static void iuu_close(struct usb_serial_port *port, struct file *filp)
static void iuu_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
/* iuu_led (port,255,0,0,0); */
struct usb_serial *serial;
@ -964,8 +966,8 @@ static void iuu_close(struct usb_serial_port *port, struct file *filp)
iuu_uart_off(port);
if (serial->dev) {
if (port->tty) {
c_cflag = port->tty->termios->c_cflag;
if (tty) {
c_cflag = tty->termios->c_cflag;
if (c_cflag & HUPCL) {
/* drop DTR and RTS */
priv = usb_get_serial_port_data(port);
@ -989,7 +991,8 @@ static void iuu_close(struct usb_serial_port *port, struct file *filp)
}
}
static int iuu_open(struct usb_serial_port *port, struct file *filp)
static int iuu_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial = port->serial;
u8 *buf;
@ -1036,15 +1039,17 @@ static int iuu_open(struct usb_serial_port *port, struct file *filp)
/* set the termios structure */
spin_lock_irqsave(&priv->lock, flags);
if (!priv->termios_initialized) {
*(port->tty->termios) = tty_std_termios;
port->tty->termios->c_cflag = CLOCAL | CREAD | CS8 | B9600
| TIOCM_CTS | CSTOPB | PARENB;
port->tty->termios->c_lflag = 0;
port->tty->termios->c_oflag = 0;
port->tty->termios->c_iflag = 0;
if (tty && !priv->termios_initialized) {
*(tty->termios) = tty_std_termios;
tty->termios->c_cflag = CLOCAL | CREAD | CS8 | B9600
| TIOCM_CTS | CSTOPB | PARENB;
tty->termios->c_ispeed = 9600;
tty->termios->c_ospeed = 9600;
tty->termios->c_lflag = 0;
tty->termios->c_oflag = 0;
tty->termios->c_iflag = 0;
priv->termios_initialized = 1;
port->tty->low_latency = 1;
tty->low_latency = 1;
priv->poll = 0;
}
spin_unlock_irqrestore(&priv->lock, flags);
@ -1148,7 +1153,7 @@ static int iuu_open(struct usb_serial_port *port, struct file *filp)
if (result) {
dev_err(&port->dev, "%s - failed submitting read urb,"
" error %d\n", __func__, result);
iuu_close(port, NULL);
iuu_close(tty, port, NULL);
return -EPROTO;
} else {
dbg("%s - rxcmd OK", __func__);

138
drivers/usb/serial/keyspan.c
View File

@ -244,20 +244,9 @@ static void __exit keyspan_exit (void)
module_init(keyspan_init);
module_exit(keyspan_exit);
static void keyspan_rx_throttle (struct usb_serial_port *port)
{
dbg("%s - port %d", __func__, port->number);
}
static void keyspan_rx_unthrottle (struct usb_serial_port *port)
{
dbg("%s - port %d", __func__, port->number);
}
static void keyspan_break_ctl (struct usb_serial_port *port, int break_state)
static void keyspan_break_ctl(struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
struct keyspan_port_private *p_priv;
dbg("%s", __func__);
@ -273,14 +262,13 @@ static void keyspan_break_ctl (struct usb_serial_port *port, int break_state)
}
static void keyspan_set_termios (struct usb_serial_port *port,
struct ktermios *old_termios)
static void keyspan_set_termios (struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
int baud_rate, device_port;
struct keyspan_port_private *p_priv;
const struct keyspan_device_details *d_details;
unsigned int cflag;
struct tty_struct *tty = port->tty;
dbg("%s", __func__);
@ -312,12 +300,11 @@ static void keyspan_set_termios (struct usb_serial_port *port,
keyspan_send_setup(port, 0);
}
static int keyspan_tiocmget(struct usb_serial_port *port, struct file *file)
static int keyspan_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
unsigned int value;
struct keyspan_port_private *p_priv;
p_priv = usb_get_serial_port_data(port);
value = ((p_priv->rts_state) ? TIOCM_RTS : 0) |
((p_priv->dtr_state) ? TIOCM_DTR : 0) |
@ -329,18 +316,16 @@ static int keyspan_tiocmget(struct usb_serial_port *port, struct file *file)
return value;
}
static int keyspan_tiocmset(struct usb_serial_port *port, struct file *file,
static int keyspan_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct keyspan_port_private *p_priv;
p_priv = usb_get_serial_port_data(port);
struct usb_serial_port *port = tty->driver_data;
struct keyspan_port_private *p_priv = usb_get_serial_port_data(port);
if (set & TIOCM_RTS)
p_priv->rts_state = 1;
if (set & TIOCM_DTR)
p_priv->dtr_state = 1;
if (clear & TIOCM_RTS)
p_priv->rts_state = 0;
if (clear & TIOCM_DTR)
@ -349,16 +334,10 @@ static int keyspan_tiocmset(struct usb_serial_port *port, struct file *file,
return 0;
}
static int keyspan_ioctl(struct usb_serial_port *port, struct file *file,
unsigned int cmd, unsigned long arg)
{
return -ENOIOCTLCMD;
}
/* Write function is similar for the four protocols used
with only a minor change for usa90 (usa19hs) required */
static int keyspan_write(struct usb_serial_port *port,
const unsigned char *buf, int count)
/* Write function is similar for the four protocols used
with only a minor change for usa90 (usa19hs) required */
static int keyspan_write(struct tty_struct *tty,
struct usb_serial_port *port, const unsigned char *buf, int count)
{
struct keyspan_port_private *p_priv;
const struct keyspan_device_details *d_details;
@ -448,7 +427,7 @@ static void usa26_indat_callback(struct urb *urb)
}
port = urb->context;
tty = port->tty;
tty = port->port.tty;
if (tty && urb->actual_length) {
/* 0x80 bit is error flag */
if ((data[0] & 0x80) == 0) {
@ -479,7 +458,7 @@ static void usa26_indat_callback(struct urb *urb)
/* Resubmit urb so we continue receiving */
urb->dev = port->serial->dev;
if (port->open_count)
if (port->port.count)
if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
dbg("%s - resubmit read urb failed. (%d)", __func__, err);
}
@ -496,7 +475,7 @@ static void usa2x_outdat_callback(struct urb *urb)
p_priv = usb_get_serial_port_data(port);
dbg ("%s - urb %d", __func__, urb == p_priv->out_urbs[1]);
if (port->open_count)
if (port->port.count)
usb_serial_port_softint(port);
}
@ -567,10 +546,10 @@ static void usa26_instat_callback(struct urb *urb)
p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
p_priv->ri_state = ((msg->ri) ? 1 : 0);
if (port->tty && !C_CLOCAL(port->tty)
if (port->port.tty && !C_CLOCAL(port->port.tty)
&& old_dcd_state != p_priv->dcd_state) {
if (old_dcd_state)
tty_hangup(port->tty);
tty_hangup(port->port.tty);
/* else */
/* wake_up_interruptible(&p_priv->open_wait); */
}
@ -619,7 +598,7 @@ static void usa28_indat_callback(struct urb *urb)
p_priv = usb_get_serial_port_data(port);
data = urb->transfer_buffer;
tty = port->tty;
tty = port->port.tty;
if (urb->actual_length) {
for (i = 0; i < urb->actual_length ; ++i) {
tty_insert_flip_char(tty, data[i], 0);
@ -629,7 +608,7 @@ static void usa28_indat_callback(struct urb *urb)
/* Resubmit urb so we continue receiving */
urb->dev = port->serial->dev;
if (port->open_count)
if (port->port.count)
if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
dbg("%s - resubmit read urb failed. (%d)", __func__, err);
}
@ -704,10 +683,10 @@ static void usa28_instat_callback(struct urb *urb)
p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
p_priv->ri_state = ((msg->ri) ? 1 : 0);
if (port->tty && !C_CLOCAL(port->tty)
if (port->port.tty && !C_CLOCAL(port->port.tty)
&& old_dcd_state != p_priv->dcd_state) {
if (old_dcd_state)
tty_hangup(port->tty);
tty_hangup(port->port.tty);
/* else */
/* wake_up_interruptible(&p_priv->open_wait); */
}
@ -797,10 +776,10 @@ static void usa49_instat_callback(struct urb *urb)
p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
p_priv->ri_state = ((msg->ri) ? 1 : 0);
if (port->tty && !C_CLOCAL(port->tty)
if (port->port.tty && !C_CLOCAL(port->port.tty)
&& old_dcd_state != p_priv->dcd_state) {
if (old_dcd_state)
tty_hangup(port->tty);
tty_hangup(port->port.tty);
/* else */
/* wake_up_interruptible(&p_priv->open_wait); */
}
@ -839,7 +818,7 @@ static void usa49_indat_callback(struct urb *urb)
}
port = urb->context;
tty = port->tty;
tty = port->port.tty;
if (tty && urb->actual_length) {
/* 0x80 bit is error flag */
if ((data[0] & 0x80) == 0) {
@ -866,7 +845,7 @@ static void usa49_indat_callback(struct urb *urb)
/* Resubmit urb so we continue receiving */
urb->dev = port->serial->dev;
if (port->open_count)
if (port->port.count)
if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
dbg("%s - resubmit read urb failed. (%d)", __func__, err);
}
@ -904,7 +883,7 @@ static void usa49wg_indat_callback(struct urb *urb)
return;
}
port = serial->port[data[i++]];
tty = port->tty;
tty = port->port.tty;
len = data[i++];
/* 0x80 bit is error flag */
@ -912,7 +891,7 @@ static void usa49wg_indat_callback(struct urb *urb)
/* no error on any byte */
i++;
for (x = 1; x < len ; ++x)
if (port->open_count)
if (port->port.count)
tty_insert_flip_char(tty,
data[i++], 0);
else
@ -930,13 +909,13 @@ static void usa49wg_indat_callback(struct urb *urb)
if (stat & RXERROR_PARITY)
flag |= TTY_PARITY;
/* XXX should handle break (0x10) */
if (port->open_count)
if (port->port.count)
tty_insert_flip_char(tty,
data[i+1], flag);
i += 2;
}
}
if (port->open_count)
if (port->port.count)
tty_flip_buffer_push(tty);
}
}
@ -978,7 +957,7 @@ static void usa90_indat_callback(struct urb *urb)
port = urb->context;
p_priv = usb_get_serial_port_data(port);
tty = port->tty;
tty = port->port.tty;
if (urb->actual_length) {
/* if current mode is DMA, looks like usa28 format
@ -1021,7 +1000,7 @@ static void usa90_indat_callback(struct urb *urb)
/* Resubmit urb so we continue receiving */
urb->dev = port->serial->dev;
if (port->open_count)
if (port->port.count)
if ((err = usb_submit_urb(urb, GFP_ATOMIC)) != 0) {
dbg("%s - resubmit read urb failed. (%d)", __func__, err);
}
@ -1064,10 +1043,10 @@ static void usa90_instat_callback(struct urb *urb)
p_priv->dcd_state = ((msg->dcd) ? 1 : 0);
p_priv->ri_state = ((msg->ri) ? 1 : 0);
if (port->tty && !C_CLOCAL(port->tty)
if (port->port.tty && !C_CLOCAL(port->port.tty)
&& old_dcd_state != p_priv->dcd_state) {
if (old_dcd_state)
tty_hangup(port->tty);
tty_hangup(port->port.tty);
/* else */
/* wake_up_interruptible(&p_priv->open_wait); */
}
@ -1139,10 +1118,10 @@ static void usa67_instat_callback(struct urb *urb)
p_priv->cts_state = ((msg->hskia_cts) ? 1 : 0);
p_priv->dcd_state = ((msg->gpia_dcd) ? 1 : 0);
if (port->tty && !C_CLOCAL(port->tty)
if (port->port.tty && !C_CLOCAL(port->port.tty)
&& old_dcd_state != p_priv->dcd_state) {
if (old_dcd_state)
tty_hangup(port->tty);
tty_hangup(port->port.tty);
/* else */
/* wake_up_interruptible(&p_priv->open_wait); */
}
@ -1177,8 +1156,9 @@ static void usa67_glocont_callback(struct urb *urb)
}
}
static int keyspan_write_room (struct usb_serial_port *port)
static int keyspan_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct keyspan_port_private *p_priv;
const struct keyspan_device_details *d_details;
int flip;
@ -1210,13 +1190,8 @@ static int keyspan_write_room (struct usb_serial_port *port)
}
static int keyspan_chars_in_buffer (struct usb_serial_port *port)
{
return 0;
}
static int keyspan_open (struct usb_serial_port *port, struct file *filp)
static int keyspan_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct keyspan_port_private *p_priv;
struct keyspan_serial_private *s_priv;
@ -1225,7 +1200,7 @@ static int keyspan_open (struct usb_serial_port *port, struct file *filp)
int i, err;
int baud_rate, device_port;
struct urb *urb;
unsigned int cflag;
unsigned int cflag = 0;
s_priv = usb_get_serial_data(serial);
p_priv = usb_get_serial_port_data(port);
@ -1271,19 +1246,19 @@ static int keyspan_open (struct usb_serial_port *port, struct file *filp)
/* get the terminal config for the setup message now so we don't
* need to send 2 of them */
cflag = port->tty->termios->c_cflag;
device_port = port->number - port->serial->minor;
/* Baud rate calculation takes baud rate as an integer
so other rates can be generated if desired. */
baud_rate = tty_get_baud_rate(port->tty);
/* If no match or invalid, leave as default */
if (baud_rate >= 0
&& d_details->calculate_baud_rate(baud_rate, d_details->baudclk,
NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
p_priv->baud = baud_rate;
if (tty) {
cflag = tty->termios->c_cflag;
/* Baud rate calculation takes baud rate as an integer
so other rates can be generated if desired. */
baud_rate = tty_get_baud_rate(tty);
/* If no match or invalid, leave as default */
if (baud_rate >= 0
&& d_details->calculate_baud_rate(baud_rate, d_details->baudclk,
NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
p_priv->baud = baud_rate;
}
}
/* set CTS/RTS handshake etc. */
p_priv->cflag = cflag;
p_priv->flow_control = (cflag & CRTSCTS)? flow_cts: flow_none;
@ -1301,7 +1276,8 @@ static inline void stop_urb(struct urb *urb)
usb_kill_urb(urb);
}
static void keyspan_close(struct usb_serial_port *port, struct file *filp)
static void keyspan_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
int i;
struct usb_serial *serial = port->serial;
@ -1338,7 +1314,7 @@ static void keyspan_close(struct usb_serial_port *port, struct file *filp)
stop_urb(p_priv->out_urbs[i]);
}
}
port->tty = NULL;
port->port.tty = NULL;
}
/* download the firmware to a pre-renumeration device */
@ -2427,7 +2403,7 @@ static int keyspan_usa90_send_setup(struct usb_serial *serial,
}
/* Sending intermediate configs */
else {
if (port->open_count)
if (port->port.count)
msg.portEnabled = 1;
msg.txBreak = (p_priv->break_on);
}

39
drivers/usb/serial/keyspan.h
View File

@ -35,17 +35,18 @@
/* Function prototypes for Keyspan serial converter */
static int keyspan_open (struct usb_serial_port *port,
static int keyspan_open (struct tty_struct *tty,
struct usb_serial_port *port,
struct file *filp);
static void keyspan_close (struct usb_serial_port *port,
static void keyspan_close (struct tty_struct *tty,
struct usb_serial_port *port,
struct file *filp);
static int keyspan_startup (struct usb_serial *serial);
static void keyspan_shutdown (struct usb_serial *serial);
static void keyspan_rx_throttle (struct usb_serial_port *port);
static void keyspan_rx_unthrottle (struct usb_serial_port *port);
static int keyspan_write_room (struct usb_serial_port *port);
static int keyspan_write_room (struct tty_struct *tty);
static int keyspan_write (struct usb_serial_port *port,
static int keyspan_write (struct tty_struct *tty,
struct usb_serial_port *port,
const unsigned char *buf,
int count);
@ -53,18 +54,14 @@ static void keyspan_send_setup (struct usb_serial_port *port,
int reset_port);
static int keyspan_chars_in_buffer (struct usb_serial_port *port);
static int keyspan_ioctl (struct usb_serial_port *port,
struct file *file,
unsigned int cmd,
unsigned long arg);
static void keyspan_set_termios (struct usb_serial_port *port,
static void keyspan_set_termios (struct tty_struct *tty,
struct usb_serial_port *port,
struct ktermios *old);
static void keyspan_break_ctl (struct usb_serial_port *port,
static void keyspan_break_ctl (struct tty_struct *tty,
int break_state);
static int keyspan_tiocmget (struct usb_serial_port *port,
static int keyspan_tiocmget (struct tty_struct *tty,
struct file *file);
static int keyspan_tiocmset (struct usb_serial_port *port,
static int keyspan_tiocmset (struct tty_struct *tty,
struct file *file, unsigned int set,
unsigned int clear);
static int keyspan_fake_startup (struct usb_serial *serial);
@ -567,10 +564,6 @@ static struct usb_serial_driver keyspan_1port_device = {
.close = keyspan_close,
.write = keyspan_write,
.write_room = keyspan_write_room,
.chars_in_buffer = keyspan_chars_in_buffer,
.throttle = keyspan_rx_throttle,
.unthrottle = keyspan_rx_unthrottle,
.ioctl = keyspan_ioctl,
.set_termios = keyspan_set_termios,
.break_ctl = keyspan_break_ctl,
.tiocmget = keyspan_tiocmget,
@ -591,10 +584,6 @@ static struct usb_serial_driver keyspan_2port_device = {
.close = keyspan_close,
.write = keyspan_write,
.write_room = keyspan_write_room,
.chars_in_buffer = keyspan_chars_in_buffer,
.throttle = keyspan_rx_throttle,
.unthrottle = keyspan_rx_unthrottle,
.ioctl = keyspan_ioctl,
.set_termios = keyspan_set_termios,
.break_ctl = keyspan_break_ctl,
.tiocmget = keyspan_tiocmget,
@ -615,10 +604,6 @@ static struct usb_serial_driver keyspan_4port_device = {
.close = keyspan_close,
.write = keyspan_write,
.write_room = keyspan_write_room,
.chars_in_buffer = keyspan_chars_in_buffer,
.throttle = keyspan_rx_throttle,
.unthrottle = keyspan_rx_unthrottle,
.ioctl = keyspan_ioctl,
.set_termios = keyspan_set_termios,
.break_ctl = keyspan_break_ctl,
.tiocmget = keyspan_tiocmget,

69
drivers/usb/serial/keyspan_pda.c
View File

@ -171,7 +171,7 @@ static void keyspan_pda_wakeup_write(struct work_struct *work)
container_of(work, struct keyspan_pda_private, wakeup_work);
struct usb_serial_port *port = priv->port;
tty_wakeup(port->tty);
tty_wakeup(port->port.tty);
}
static void keyspan_pda_request_unthrottle(struct work_struct *work)
@ -203,7 +203,7 @@ static void keyspan_pda_request_unthrottle(struct work_struct *work)
static void keyspan_pda_rx_interrupt (struct urb *urb)
{
struct usb_serial_port *port = urb->context;
struct tty_struct *tty = port->tty;
struct tty_struct *tty = port->port.tty;
unsigned char *data = urb->transfer_buffer;
int i;
int retval;
@ -266,7 +266,7 @@ exit:
}
static void keyspan_pda_rx_throttle (struct usb_serial_port *port)
static void keyspan_pda_rx_throttle(struct tty_struct *tty)
{
/* stop receiving characters. We just turn off the URB request, and
let chars pile up in the device. If we're doing hardware
@ -274,14 +274,15 @@ static void keyspan_pda_rx_throttle (struct usb_serial_port *port)
fills up. If we're doing XON/XOFF, this would be a good time to
send an XOFF, although it might make sense to foist that off
upon the device too. */
struct usb_serial_port *port = tty->driver_data;
dbg("keyspan_pda_rx_throttle port %d", port->number);
usb_kill_urb(port->interrupt_in_urb);
}
static void keyspan_pda_rx_unthrottle (struct usb_serial_port *port)
static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
/* just restart the receive interrupt URB */
dbg("keyspan_pda_rx_unthrottle port %d", port->number);
port->interrupt_in_urb->dev = port->serial->dev;
@ -330,8 +331,9 @@ static speed_t keyspan_pda_setbaud (struct usb_serial *serial, speed_t baud)
}
static void keyspan_pda_break_ctl (struct usb_serial_port *port, int break_state)
static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
int value;
int result;
@ -354,8 +356,8 @@ static void keyspan_pda_break_ctl (struct usb_serial_port *port, int break_state
}
static void keyspan_pda_set_termios (struct usb_serial_port *port,
struct ktermios *old_termios)
static void keyspan_pda_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
struct usb_serial *serial = port->serial;
speed_t speed;
@ -380,7 +382,7 @@ static void keyspan_pda_set_termios (struct usb_serial_port *port,
For now, just do baud. */
speed = tty_get_baud_rate(port->tty);
speed = tty_get_baud_rate(tty);
speed = keyspan_pda_setbaud(serial, speed);
if (speed == 0) {
@ -390,8 +392,8 @@ static void keyspan_pda_set_termios (struct usb_serial_port *port,
}
/* Only speed can change so copy the old h/w parameters
then encode the new speed */
tty_termios_copy_hw(port->tty->termios, old_termios);
tty_encode_baud_rate(port->tty, speed, speed);
tty_termios_copy_hw(tty->termios, old_termios);
tty_encode_baud_rate(tty, speed, speed);
}
@ -425,8 +427,9 @@ static int keyspan_pda_set_modem_info(struct usb_serial *serial,
return rc;
}
static int keyspan_pda_tiocmget(struct usb_serial_port *port, struct file *file)
static int keyspan_pda_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
int rc;
unsigned char status;
@ -445,9 +448,10 @@ static int keyspan_pda_tiocmget(struct usb_serial_port *port, struct file *file)
return value;
}
static int keyspan_pda_tiocmset(struct usb_serial_port *port, struct file *file,
static int keyspan_pda_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
int rc;
unsigned char status;
@ -469,23 +473,8 @@ static int keyspan_pda_tiocmset(struct usb_serial_port *port, struct file *file,
return rc;
}
static int keyspan_pda_ioctl(struct usb_serial_port *port, struct file *file,
unsigned int cmd, unsigned long arg)
{
switch (cmd) {
case TIOCMIWAIT:
/* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
/* TODO */
case TIOCGICOUNT:
/* return count of modemline transitions */
return 0; /* TODO */
}
return -ENOIOCTLCMD;
}
static int keyspan_pda_write(struct usb_serial_port *port,
const unsigned char *buf, int count)
static int keyspan_pda_write(struct tty_struct *tty,
struct usb_serial_port *port, const unsigned char *buf, int count)
{
struct usb_serial *serial = port->serial;
int request_unthrottle = 0;
@ -607,22 +596,21 @@ static void keyspan_pda_write_bulk_callback (struct urb *urb)
}
static int keyspan_pda_write_room (struct usb_serial_port *port)
static int keyspan_pda_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct keyspan_pda_private *priv;
priv = usb_get_serial_port_data(port);
/* used by n_tty.c for processing of tabs and such. Giving it our
conservative guess is probably good enough, but needs testing by
running a console through the device. */
return (priv->tx_room);
}
static int keyspan_pda_chars_in_buffer (struct usb_serial_port *port)
static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct keyspan_pda_private *priv;
unsigned long flags;
int ret = 0;
@ -640,7 +628,8 @@ static int keyspan_pda_chars_in_buffer (struct usb_serial_port *port)
}
static int keyspan_pda_open (struct usb_serial_port *port, struct file *filp)
static int keyspan_pda_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial = port->serial;
unsigned char room;
@ -672,7 +661,7 @@ static int keyspan_pda_open (struct usb_serial_port *port, struct file *filp)
/* the normal serial device seems to always turn on DTR and RTS here,
so do the same */
if (port->tty->termios->c_cflag & CBAUD)
if (tty && (tty->termios->c_cflag & CBAUD))
keyspan_pda_set_modem_info(serial, (1<<7) | (1<<2) );
else
keyspan_pda_set_modem_info(serial, 0);
@ -690,13 +679,14 @@ error:
}
static void keyspan_pda_close(struct usb_serial_port *port, struct file *filp)
static void keyspan_pda_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial = port->serial;
if (serial->dev) {
/* the normal serial device seems to always shut off DTR and RTS now */
if (port->tty->termios->c_cflag & HUPCL)
if (tty->termios->c_cflag & HUPCL)
keyspan_pda_set_modem_info(serial, 0);
/* shutdown our bulk reads and writes */
@ -832,7 +822,6 @@ static struct usb_serial_driver keyspan_pda_device = {
.chars_in_buffer = keyspan_pda_chars_in_buffer,
.throttle = keyspan_pda_rx_throttle,
.unthrottle = keyspan_pda_rx_unthrottle,
.ioctl = keyspan_pda_ioctl,
.set_termios = keyspan_pda_set_termios,
.break_ctl = keyspan_pda_break_ctl,
.tiocmget = keyspan_pda_tiocmget,

74
drivers/usb/serial/kl5kusb105.c
View File

@ -74,29 +74,33 @@ static int debug;
*/
static int klsi_105_startup (struct usb_serial *serial);
static void klsi_105_shutdown (struct usb_serial *serial);
static int klsi_105_open (struct usb_serial_port *port,
static int klsi_105_open (struct tty_struct *tty,
struct usb_serial_port *port,
struct file *filp);
static void klsi_105_close (struct usb_serial_port *port,
static void klsi_105_close (struct tty_struct *tty,
struct usb_serial_port *port,
struct file *filp);
static int klsi_105_write (struct usb_serial_port *port,
static int klsi_105_write (struct tty_struct *tty,
struct usb_serial_port *port,
const unsigned char *buf,
int count);
static void klsi_105_write_bulk_callback (struct urb *urb);
static int klsi_105_chars_in_buffer (struct usb_serial_port *port);
static int klsi_105_write_room (struct usb_serial_port *port);
static int klsi_105_chars_in_buffer (struct tty_struct *tty);
static int klsi_105_write_room (struct tty_struct *tty);
static void klsi_105_read_bulk_callback (struct urb *urb);
static void klsi_105_set_termios (struct usb_serial_port *port,
static void klsi_105_set_termios (struct tty_struct *tty,
struct usb_serial_port *port,
struct ktermios *old);
static void klsi_105_throttle (struct usb_serial_port *port);
static void klsi_105_unthrottle (struct usb_serial_port *port);
static void klsi_105_throttle (struct tty_struct *tty);
static void klsi_105_unthrottle (struct tty_struct *tty);
/*
static void klsi_105_break_ctl (struct usb_serial_port *port,
static void klsi_105_break_ctl (struct tty_struct *tty,
int break_state );
*/
static int klsi_105_tiocmget (struct usb_serial_port *port,
static int klsi_105_tiocmget (struct tty_struct *tty,
struct file *file);
static int klsi_105_tiocmset (struct usb_serial_port *port,
static int klsi_105_tiocmset (struct tty_struct *tty,
struct file *file, unsigned int set,
unsigned int clear);
@ -361,7 +365,8 @@ static void klsi_105_shutdown (struct usb_serial *serial)
}
} /* klsi_105_shutdown */
static int klsi_105_open (struct usb_serial_port *port, struct file *filp)
static int klsi_105_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct klsi_105_private *priv = usb_get_serial_port_data(port);
int retval = 0;
@ -375,7 +380,7 @@ static int klsi_105_open (struct usb_serial_port *port, struct file *filp)
/* force low_latency on so that our tty_push actually forces
* the data through
* port->tty->low_latency = 1; */
* tty->low_latency = 1; */
/* Do a defined restart:
* Set up sane default baud rate and send the 'READ_ON'
@ -393,12 +398,12 @@ static int klsi_105_open (struct usb_serial_port *port, struct file *filp)
/* set up termios structure */
spin_lock_irqsave (&priv->lock, flags);
priv->termios.c_iflag = port->tty->termios->c_iflag;
priv->termios.c_oflag = port->tty->termios->c_oflag;
priv->termios.c_cflag = port->tty->termios->c_cflag;
priv->termios.c_lflag = port->tty->termios->c_lflag;
priv->termios.c_iflag = tty->termios->c_iflag;
priv->termios.c_oflag = tty->termios->c_oflag;
priv->termios.c_cflag = tty->termios->c_cflag;
priv->termios.c_lflag = tty->termios->c_lflag;
for (i=0; i<NCCS; i++)
priv->termios.c_cc[i] = port->tty->termios->c_cc[i];
priv->termios.c_cc[i] = tty->termios->c_cc[i];
priv->cfg.pktlen = cfg.pktlen;
priv->cfg.baudrate = cfg.baudrate;
priv->cfg.databits = cfg.databits;
@ -452,7 +457,8 @@ exit:
} /* klsi_105_open */
static void klsi_105_close (struct usb_serial_port *port, struct file *filp)
static void klsi_105_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct klsi_105_private *priv = usb_get_serial_port_data(port);
int rc;
@ -493,8 +499,8 @@ static void klsi_105_close (struct usb_serial_port *port, struct file *filp)
#define KLSI_105_DATA_OFFSET 2 /* in the bulk urb data block */
static int klsi_105_write (struct usb_serial_port *port,
const unsigned char *buf, int count)
static int klsi_105_write(struct tty_struct *tty,
struct usb_serial_port *port, const unsigned char *buf, int count)
{
struct klsi_105_private *priv = usb_get_serial_port_data(port);
int result, size;
@ -584,8 +590,9 @@ static void klsi_105_write_bulk_callback ( struct urb *urb)
/* return number of characters currently in the writing process */
static int klsi_105_chars_in_buffer (struct usb_serial_port *port)
static int klsi_105_chars_in_buffer (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
int chars = 0;
int i;
unsigned long flags;
@ -605,8 +612,9 @@ static int klsi_105_chars_in_buffer (struct usb_serial_port *port)
return (chars);
}
static int klsi_105_write_room (struct usb_serial_port *port)
static int klsi_105_write_room (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
unsigned long flags;
int i;
int room = 0;
@ -660,7 +668,7 @@ static void klsi_105_read_bulk_callback (struct urb *urb)
} else {
int bytes_sent = ((__u8 *) data)[0] +
((unsigned int) ((__u8 *) data)[1] << 8);
tty = port->tty;
tty = port->port.tty;
/* we should immediately resubmit the URB, before attempting
* to pass the data on to the tty layer. But that needs locking
* against re-entry an then mixed-up data because of
@ -699,11 +707,11 @@ static void klsi_105_read_bulk_callback (struct urb *urb)
} /* klsi_105_read_bulk_callback */
static void klsi_105_set_termios (struct usb_serial_port *port,
static void klsi_105_set_termios (struct tty_struct *tty,
struct usb_serial_port *port,
struct ktermios *old_termios)
{
struct klsi_105_private *priv = usb_get_serial_port_data(port);
struct tty_struct *tty = port->tty;
unsigned int iflag = tty->termios->c_iflag;
unsigned int old_iflag = old_termios->c_iflag;
unsigned int cflag = tty->termios->c_cflag;
@ -863,8 +871,9 @@ static void klsi_105_set_termios (struct usb_serial_port *port,
#if 0
static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
static void mct_u232_break_ctl( struct tty_struct *tty, int break_state )
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
struct mct_u232_private *priv = (struct mct_u232_private *)port->private;
unsigned char lcr = priv->last_lcr;
@ -878,8 +887,9 @@ static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
} /* mct_u232_break_ctl */
#endif
static int klsi_105_tiocmget (struct usb_serial_port *port, struct file *file)
static int klsi_105_tiocmget (struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct klsi_105_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
int rc;
@ -900,7 +910,7 @@ static int klsi_105_tiocmget (struct usb_serial_port *port, struct file *file)
return (int)line_state;
}
static int klsi_105_tiocmset (struct usb_serial_port *port, struct file *file,
static int klsi_105_tiocmset (struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
int retval = -EINVAL;
@ -929,14 +939,16 @@ static int klsi_105_tiocmset (struct usb_serial_port *port, struct file *file,
return retval;
}
static void klsi_105_throttle (struct usb_serial_port *port)
static void klsi_105_throttle (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
dbg("%s - port %d", __func__, port->number);
usb_kill_urb(port->read_urb);
}
static void klsi_105_unthrottle (struct usb_serial_port *port)
static void klsi_105_unthrottle (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
int result;
dbg("%s - port %d", __func__, port->number);

78
drivers/usb/serial/kobil_sct.c
View File

@ -70,19 +70,22 @@ static int debug;
/* Function prototypes */
static int kobil_startup (struct usb_serial *serial);
static void kobil_shutdown (struct usb_serial *serial);
static int kobil_open (struct usb_serial_port *port, struct file *filp);
static void kobil_close (struct usb_serial_port *port, struct file *filp);
static int kobil_write (struct usb_serial_port *port,
static int kobil_open (struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp);
static void kobil_close (struct tty_struct *tty, struct usb_serial_port *port,
struct file *filp);
static int kobil_write (struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count);
static int kobil_write_room(struct usb_serial_port *port);
static int kobil_ioctl(struct usb_serial_port *port, struct file *file,
static int kobil_write_room(struct tty_struct *tty);
static int kobil_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg);
static int kobil_tiocmget(struct usb_serial_port *port, struct file *file);
static int kobil_tiocmset(struct usb_serial_port *port, struct file *file,
static int kobil_tiocmget(struct tty_struct *tty, struct file *file);
static int kobil_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear);
static void kobil_read_int_callback( struct urb *urb );
static void kobil_write_callback( struct urb *purb );
static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old);
static void kobil_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old);
static struct usb_device_id id_table [] = {
@ -201,8 +204,8 @@ static void kobil_shutdown (struct usb_serial *serial)
dbg("%s - port %d", __func__, serial->port[0]->number);
for (i=0; i < serial->num_ports; ++i) {
while (serial->port[i]->open_count > 0) {
kobil_close (serial->port[i], NULL);
while (serial->port[i]->port.count > 0) {
kobil_close (NULL, serial->port[i], NULL);
}
kfree(usb_get_serial_port_data(serial->port[i]));
usb_set_serial_port_data(serial->port[i], NULL);
@ -210,7 +213,8 @@ static void kobil_shutdown (struct usb_serial *serial)
}
static int kobil_open (struct usb_serial_port *port, struct file *filp)
static int kobil_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
int result = 0;
struct kobil_private *priv;
@ -229,14 +233,15 @@ static int kobil_open (struct usb_serial_port *port, struct file *filp)
* the data through, otherwise it is scheduled, and with high
* data rates (like with OHCI) data can get lost.
*/
port->tty->low_latency = 1;
if (tty) {
tty->low_latency = 1;
// without this, every push_tty_char is echoed :-(
port->tty->termios->c_lflag = 0;
port->tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN | XCASE);
port->tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
port->tty->termios->c_oflag &= ~ONLCR; // do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D)
/* Default to echo off and other sane device settings */
tty->termios->c_lflag = 0;
tty->termios->c_lflag &= ~(ISIG | ICANON | ECHO | IEXTEN | XCASE);
tty->termios->c_iflag = IGNBRK | IGNPAR | IXOFF;
tty->termios->c_oflag &= ~ONLCR; // do NOT translate CR to CR-NL (0x0A -> 0x0A 0x0D)
}
// allocate memory for transfer buffer
transfer_buffer = kzalloc(transfer_buffer_length, GFP_KERNEL);
if (! transfer_buffer) {
@ -330,7 +335,8 @@ static int kobil_open (struct usb_serial_port *port, struct file *filp)
}
static void kobil_close (struct usb_serial_port *port, struct file *filp)
static void kobil_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
dbg("%s - port %d", __func__, port->number);
@ -360,7 +366,7 @@ static void kobil_read_int_callback(struct urb *urb)
return;
}
tty = port->tty;
tty = port->port.tty;
if (urb->actual_length) {
// BEGIN DEBUG
@ -395,7 +401,7 @@ static void kobil_write_callback( struct urb *purb )
}
static int kobil_write (struct usb_serial_port *port,
static int kobil_write (struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
int length = 0;
@ -417,12 +423,9 @@ static int kobil_write (struct usb_serial_port *port,
// Copy data to buffer
memcpy (priv->buf + priv->filled, buf, count);
usb_serial_debug_data(debug, &port->dev, __func__, count, priv->buf + priv->filled);
priv->filled = priv->filled + count;
// only send complete block. TWIN, KAAN SIM and adapter K use the same protocol.
if ( ((priv->device_type != KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 2) && (priv->filled >= (priv->buf[1] + 3))) ||
((priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) && (priv->filled > 3) && (priv->filled >= (priv->buf[2] + 4))) ) {
@ -478,15 +481,17 @@ static int kobil_write (struct usb_serial_port *port,
}
static int kobil_write_room (struct usb_serial_port *port)
static int kobil_write_room (struct tty_struct *tty)
{
//dbg("%s - port %d", __func__, port->number);
/* FIXME */
return 8;
}
static int kobil_tiocmget(struct usb_serial_port *port, struct file *file)
static int kobil_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct kobil_private * priv;
int result;
unsigned char *transfer_buffer;
@ -524,9 +529,10 @@ static int kobil_tiocmget(struct usb_serial_port *port, struct file *file)
return result;
}
static int kobil_tiocmset(struct usb_serial_port *port, struct file *file,
static int kobil_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct kobil_private * priv;
int result;
int dtr = 0;
@ -590,12 +596,13 @@ static int kobil_tiocmset(struct usb_serial_port *port, struct file *file,
return (result < 0) ? result : 0;
}
static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old)
static void kobil_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old)
{
struct kobil_private * priv;
int result;
unsigned short urb_val = 0;
int c_cflag = port->tty->termios->c_cflag;
int c_cflag = tty->termios->c_cflag;
speed_t speed;
void * settings;
@ -604,7 +611,7 @@ static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old
// This device doesn't support ioctl calls
return;
switch (speed = tty_get_baud_rate(port->tty)) {
switch (speed = tty_get_baud_rate(tty)) {
case 1200:
urb_val = SUSBCR_SBR_1200;
break;
@ -634,8 +641,8 @@ static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old
urb_val |= SUSBCR_SPASB_NoParity;
strcat(settings, "No Parity");
}
port->tty->termios->c_cflag &= ~CMSPAR;
tty_encode_baud_rate(port->tty, speed, speed);
tty->termios->c_cflag &= ~CMSPAR;
tty_encode_baud_rate(tty, speed, speed);
result = usb_control_msg( port->serial->dev,
usb_rcvctrlpipe(port->serial->dev, 0 ),
@ -650,8 +657,9 @@ static void kobil_set_termios(struct usb_serial_port *port, struct ktermios *old
kfree(settings);
}
static int kobil_ioctl(struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
static int kobil_ioctl(struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
struct kobil_private * priv = usb_get_serial_port_data(port);
unsigned char *transfer_buffer;
int transfer_buffer_length = 8;
@ -662,7 +670,7 @@ static int kobil_ioctl(struct usb_serial_port *port, struct file * file, unsigne
return 0;
switch (cmd) {
case TCFLSH: // 0x540B
case TCFLSH:
transfer_buffer = kmalloc(transfer_buffer_length, GFP_KERNEL);
if (! transfer_buffer)
return -ENOBUFS;
@ -680,7 +688,7 @@ static int kobil_ioctl(struct usb_serial_port *port, struct file * file, unsigne
dbg("%s - port %d Send reset_all_queues (FLUSH) URB returns: %i", __func__, port->number, result);
kfree(transfer_buffer);
return (result < 0) ? -EFAULT : 0;
return (result < 0) ? -EIO: 0;
default:
return -ENOIOCTLCMD;
}

121
drivers/usb/serial/mct_u232.c
View File

@ -92,26 +92,25 @@ static int debug;
*/
static int mct_u232_startup (struct usb_serial *serial);
static void mct_u232_shutdown (struct usb_serial *serial);
static int mct_u232_open (struct usb_serial_port *port,
static int mct_u232_open (struct tty_struct *tty,
struct usb_serial_port *port,
struct file *filp);
static void mct_u232_close (struct usb_serial_port *port,
static void mct_u232_close (struct tty_struct *tty,
struct usb_serial_port *port,
struct file *filp);
static void mct_u232_read_int_callback (struct urb *urb);
static void mct_u232_set_termios (struct usb_serial_port *port,
static void mct_u232_set_termios (struct tty_struct *tty,
struct usb_serial_port *port,
struct ktermios * old);
static int mct_u232_ioctl (struct usb_serial_port *port,
struct file * file,
unsigned int cmd,
unsigned long arg);
static void mct_u232_break_ctl (struct usb_serial_port *port,
static void mct_u232_break_ctl (struct tty_struct *tty,
int break_state );
static int mct_u232_tiocmget (struct usb_serial_port *port,
static int mct_u232_tiocmget (struct tty_struct *tty,
struct file *file);
static int mct_u232_tiocmset (struct usb_serial_port *port,
static int mct_u232_tiocmset (struct tty_struct *tty,
struct file *file, unsigned int set,
unsigned int clear);
static void mct_u232_throttle (struct usb_serial_port *port);
static void mct_u232_unthrottle (struct usb_serial_port *port);
static void mct_u232_throttle (struct tty_struct *tty);
static void mct_u232_unthrottle (struct tty_struct *tty);
/*
@ -149,7 +148,6 @@ static struct usb_serial_driver mct_u232_device = {
.throttle = mct_u232_throttle,
.unthrottle = mct_u232_unthrottle,
.read_int_callback = mct_u232_read_int_callback,
.ioctl = mct_u232_ioctl,
.set_termios = mct_u232_set_termios,
.break_ctl = mct_u232_break_ctl,
.tiocmget = mct_u232_tiocmget,
@ -224,8 +222,8 @@ static int mct_u232_calculate_baud_rate(struct usb_serial *serial, speed_t value
}
}
static int mct_u232_set_baud_rate(struct usb_serial *serial, struct usb_serial_port *port,
speed_t value)
static int mct_u232_set_baud_rate(struct tty_struct *tty,
struct usb_serial *serial, struct usb_serial_port *port, speed_t value)
{
__le32 divisor;
int rc;
@ -243,7 +241,7 @@ static int mct_u232_set_baud_rate(struct usb_serial *serial, struct usb_serial_p
if (rc < 0) /*FIXME: What value speed results */
err("Set BAUD RATE %d failed (error = %d)", value, rc);
else
tty_encode_baud_rate(port->tty, speed, speed);
tty_encode_baud_rate(tty, speed, speed);
dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
/* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
@ -272,7 +270,7 @@ static int mct_u232_set_baud_rate(struct usb_serial *serial, struct usb_serial_p
err("Sending USB device request code %d failed (error = %d)",
MCT_U232_SET_UNKNOWN1_REQUEST, rc);
if (port && C_CRTSCTS(port->tty)) {
if (port && C_CRTSCTS(tty)) {
cts_enable_byte = 1;
}
@ -411,7 +409,8 @@ static void mct_u232_shutdown (struct usb_serial *serial)
}
} /* mct_u232_shutdown */
static int mct_u232_open (struct usb_serial_port *port, struct file *filp)
static int mct_u232_open (struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial = port->serial;
struct mct_u232_private *priv = usb_get_serial_port_data(port);
@ -437,7 +436,7 @@ static int mct_u232_open (struct usb_serial_port *port, struct file *filp)
* either.
*/
spin_lock_irqsave(&priv->lock, flags);
if (port->tty->termios->c_cflag & CBAUD)
if (tty && (tty->termios->c_cflag & CBAUD))
priv->control_state = TIOCM_DTR | TIOCM_RTS;
else
priv->control_state = 0;
@ -481,15 +480,16 @@ error:
} /* mct_u232_open */
static void mct_u232_close (struct usb_serial_port *port, struct file *filp)
static void mct_u232_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
unsigned int c_cflag;
unsigned int control_state;
struct mct_u232_private *priv = usb_get_serial_port_data(port);
dbg("%s port %d", __func__, port->number);
if (port->tty) {
c_cflag = port->tty->termios->c_cflag;
if (tty) {
c_cflag = tty->termios->c_cflag;
mutex_lock(&port->serial->disc_mutex);
if (c_cflag & HUPCL && !port->serial->disconnected) {
/* drop DTR and RTS */
@ -553,7 +553,7 @@ static void mct_u232_read_int_callback (struct urb *urb)
*/
if (urb->transfer_buffer_length > 2) {
int i;
tty = port->tty;
tty = port->port.tty;
if (urb->actual_length) {
for (i = 0; i < urb->actual_length ; ++i) {
tty_insert_flip_char(tty, data[i], 0);
@ -583,7 +583,7 @@ static void mct_u232_read_int_callback (struct urb *urb)
* to look in to this before committing any code.
*/
if (priv->last_lsr & MCT_U232_LSR_ERR) {
tty = port->tty;
tty = port->port.tty;
/* Overrun Error */
if (priv->last_lsr & MCT_U232_LSR_OE) {
}
@ -606,12 +606,13 @@ exit:
__func__, retval);
} /* mct_u232_read_int_callback */
static void mct_u232_set_termios (struct usb_serial_port *port,
static void mct_u232_set_termios (struct tty_struct *tty,
struct usb_serial_port *port,
struct ktermios *old_termios)
{
struct usb_serial *serial = port->serial;
struct mct_u232_private *priv = usb_get_serial_port_data(port);
struct ktermios *termios = port->tty->termios;
struct ktermios *termios = tty->termios;
unsigned int cflag = termios->c_cflag;
unsigned int old_cflag = old_termios->c_cflag;
unsigned long flags;
@ -638,7 +639,7 @@ static void mct_u232_set_termios (struct usb_serial_port *port,
mct_u232_set_modem_ctrl(serial, control_state);
}
mct_u232_set_baud_rate(serial, port, tty_get_baud_rate(port->tty));
mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
if ((cflag & CBAUD) == B0 ) {
dbg("%s: baud is B0", __func__);
@ -689,8 +690,9 @@ static void mct_u232_set_termios (struct usb_serial_port *port,
spin_unlock_irqrestore(&priv->lock, flags);
} /* mct_u232_set_termios */
static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
struct mct_u232_private *priv = usb_get_serial_port_data(port);
unsigned char lcr;
@ -709,8 +711,9 @@ static void mct_u232_break_ctl( struct usb_serial_port *port, int break_state )
} /* mct_u232_break_ctl */
static int mct_u232_tiocmget (struct usb_serial_port *port, struct file *file)
static int mct_u232_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct mct_u232_private *priv = usb_get_serial_port_data(port);
unsigned int control_state;
unsigned long flags;
@ -724,9 +727,10 @@ static int mct_u232_tiocmget (struct usb_serial_port *port, struct file *file)
return control_state;
}
static int mct_u232_tiocmset (struct usb_serial_port *port, struct file *file,
static int mct_u232_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
struct mct_u232_private *priv = usb_get_serial_port_data(port);
unsigned int control_state;
@ -751,73 +755,46 @@ static int mct_u232_tiocmset (struct usb_serial_port *port, struct file *file,
return mct_u232_set_modem_ctrl(serial, control_state);
}
static int mct_u232_ioctl (struct usb_serial_port *port, struct file * file,
unsigned int cmd, unsigned long arg)
{
dbg("%scmd=0x%x", __func__, cmd);
/* Based on code from acm.c and others */
switch (cmd) {
case TIOCMIWAIT:
/* wait for any of the 4 modem inputs (DCD,RI,DSR,CTS)*/
/* TODO */
return( 0 );
case TIOCGICOUNT:
/* return count of modemline transitions */
/* TODO */
return 0;
default:
dbg("%s: arg not supported - 0x%04x", __func__,cmd);
return(-ENOIOCTLCMD);
break;
}
return 0;
} /* mct_u232_ioctl */
static void mct_u232_throttle (struct usb_serial_port *port)
static void mct_u232_throttle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct mct_u232_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
unsigned int control_state;
struct tty_struct *tty;
tty = port->tty;
dbg("%s - port %d", __func__, port->number);
spin_lock_irqsave(&priv->lock, flags);
priv->rx_flags |= THROTTLED;
if (C_CRTSCTS(tty)) {
priv->control_state &= ~TIOCM_RTS;
control_state = priv->control_state;
spin_unlock_irqrestore(&priv->lock, flags);
(void) mct_u232_set_modem_ctrl(port->serial, control_state);
priv->control_state &= ~TIOCM_RTS;
control_state = priv->control_state;
spin_unlock_irqrestore(&priv->lock, flags);
(void) mct_u232_set_modem_ctrl(port->serial, control_state);
} else {
spin_unlock_irqrestore(&priv->lock, flags);
spin_unlock_irqrestore(&priv->lock, flags);
}
}
static void mct_u232_unthrottle (struct usb_serial_port *port)
static void mct_u232_unthrottle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct mct_u232_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
unsigned int control_state;
struct tty_struct *tty;
dbg("%s - port %d", __func__, port->number);
tty = port->tty;
spin_lock_irqsave(&priv->lock, flags);
if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) {
priv->rx_flags &= ~THROTTLED;
priv->control_state |= TIOCM_RTS;
control_state = priv->control_state;
spin_unlock_irqrestore(&priv->lock, flags);
(void) mct_u232_set_modem_ctrl(port->serial, control_state);
priv->rx_flags &= ~THROTTLED;
priv->control_state |= TIOCM_RTS;
control_state = priv->control_state;
spin_unlock_irqrestore(&priv->lock, flags);
(void) mct_u232_set_modem_ctrl(port->serial, control_state);
} else {
spin_unlock_irqrestore(&priv->lock, flags);
spin_unlock_irqrestore(&priv->lock, flags);
}
}

87
drivers/usb/serial/mos7720.c
View File

@ -218,7 +218,7 @@ static void mos7720_bulk_in_callback(struct urb *urb)
data = urb->transfer_buffer;
tty = port->tty;
tty = port->port.tty;
if (tty && urb->actual_length) {
tty_buffer_request_room(tty, urb->actual_length);
tty_insert_flip_string(tty, data, urb->actual_length);
@ -264,7 +264,7 @@ static void mos7720_bulk_out_data_callback(struct urb *urb)
dbg("Entering .........");
tty = mos7720_port->port->tty;
tty = mos7720_port->port->port.tty;
if (tty && mos7720_port->open)
tty_wakeup(tty);
@ -320,7 +320,8 @@ static int send_mos_cmd(struct usb_serial *serial, __u8 request, __u16 value,
return status;
}
static int mos7720_open(struct usb_serial_port *port, struct file * filp)
static int mos7720_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file * filp)
{
struct usb_serial *serial;
struct usb_serial_port *port0;
@ -443,14 +444,12 @@ static int mos7720_open(struct usb_serial_port *port, struct file * filp)
data = 0x0c;
send_mos_cmd(serial, MOS_WRITE, port_number, 0x01, &data);
//Matrix
/* force low_latency on so that our tty_push actually forces *
* the data through,otherwise it is scheduled, and with *
* high data rates (like with OHCI) data can get lost. */
if (port->tty)
port->tty->low_latency = 1;
if (tty)
tty->low_latency = 1;
/* see if we've set up our endpoint info yet *
* (can't set it up in mos7720_startup as the *
@ -515,8 +514,9 @@ static int mos7720_open(struct usb_serial_port *port, struct file * filp)
* system,
* Otherwise we return a negative error number.
*/
static int mos7720_chars_in_buffer(struct usb_serial_port *port)
static int mos7720_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
int i;
int chars = 0;
struct moschip_port *mos7720_port;
@ -537,7 +537,8 @@ static int mos7720_chars_in_buffer(struct usb_serial_port *port)
return chars;
}
static void mos7720_close(struct usb_serial_port *port, struct file *filp)
static void mos7720_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial;
struct moschip_port *mos7720_port;
@ -588,8 +589,9 @@ static void mos7720_close(struct usb_serial_port *port, struct file *filp)
dbg("Leaving %s", __func__);
}
static void mos7720_break(struct usb_serial_port *port, int break_state)
static void mos7720_break(struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
unsigned char data;
struct usb_serial *serial;
struct moschip_port *mos7720_port;
@ -621,8 +623,9 @@ static void mos7720_break(struct usb_serial_port *port, int break_state)
* If successful, we return the amount of room that we have for this port
* Otherwise we return a negative error number.
*/
static int mos7720_write_room(struct usb_serial_port *port)
static int mos7720_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct moschip_port *mos7720_port;
int room = 0;
int i;
@ -645,8 +648,8 @@ static int mos7720_write_room(struct usb_serial_port *port)
return room;
}
static int mos7720_write(struct usb_serial_port *port,
const unsigned char *data, int count)
static int mos7720_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *data, int count)
{
int status;
int i;
@ -719,10 +722,10 @@ exit:
return bytes_sent;
}
static void mos7720_throttle(struct usb_serial_port *port)
static void mos7720_throttle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct moschip_port *mos7720_port;
struct tty_struct *tty;
int status;
dbg("%s- port %d\n", __func__, port->number);
@ -739,16 +742,10 @@ static void mos7720_throttle(struct usb_serial_port *port)
dbg("%s: Entering ..........", __func__);
tty = port->tty;
if (!tty) {
dbg("%s - no tty available", __func__);
return;
}
/* if we are implementing XON/XOFF, send the stop character */
if (I_IXOFF(tty)) {
unsigned char stop_char = STOP_CHAR(tty);
status = mos7720_write(port, &stop_char, 1);
status = mos7720_write(tty, port, &stop_char, 1);
if (status <= 0)
return;
}
@ -764,11 +761,11 @@ static void mos7720_throttle(struct usb_serial_port *port)
}
}
static void mos7720_unthrottle(struct usb_serial_port *port)
static void mos7720_unthrottle(struct tty_struct *tty)
{
struct tty_struct *tty;
int status;
struct usb_serial_port *port = tty->driver_data;
struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
int status;
if (mos7720_port == NULL)
return;
@ -780,16 +777,10 @@ static void mos7720_unthrottle(struct usb_serial_port *port)
dbg("%s: Entering ..........", __func__);
tty = port->tty;
if (!tty) {
dbg("%s - no tty available", __func__);
return;
}
/* if we are implementing XON/XOFF, send the start character */
if (I_IXOFF(tty)) {
unsigned char start_char = START_CHAR(tty);
status = mos7720_write(port, &start_char, 1);
status = mos7720_write(tty, port, &start_char, 1);
if (status <= 0)
return;
}
@ -1011,12 +1002,12 @@ static int send_cmd_write_baud_rate(struct moschip_port *mos7720_port,
* This routine is called to set the UART on the device to match
* the specified new settings.
*/
static void change_port_settings(struct moschip_port *mos7720_port,
static void change_port_settings(struct tty_struct *tty,
struct moschip_port *mos7720_port,
struct ktermios *old_termios)
{
struct usb_serial_port *port;
struct usb_serial *serial;
struct tty_struct *tty;
int baud;
unsigned cflag;
unsigned iflag;
@ -1042,8 +1033,6 @@ static void change_port_settings(struct moschip_port *mos7720_port,
return;
}
tty = mos7720_port->port->tty;
dbg("%s: Entering ..........", __func__);
lData = UART_LCR_WLEN8;
@ -1198,14 +1187,13 @@ static void change_port_settings(struct moschip_port *mos7720_port,
* this function is called by the tty driver when it wants to change the
* termios structure.
*/
static void mos7720_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios)
static void mos7720_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
int status;
unsigned int cflag;
struct usb_serial *serial;
struct moschip_port *mos7720_port;
struct tty_struct *tty;
serial = port->serial;
@ -1214,9 +1202,6 @@ static void mos7720_set_termios(struct usb_serial_port *port,
if (mos7720_port == NULL)
return;
tty = port->tty;
if (!mos7720_port->open) {
dbg("%s - port not opened", __func__);
return;
@ -1237,7 +1222,7 @@ static void mos7720_set_termios(struct usb_serial_port *port,
dbg("%s - port %d", __func__, port->number);
/* change the port settings to the new ones specified */
change_port_settings(mos7720_port, old_termios);
change_port_settings(tty, mos7720_port, old_termios);
if(!port->read_urb) {
dbg("%s","URB KILLED !!!!!\n");
@ -1264,13 +1249,13 @@ static void mos7720_set_termios(struct usb_serial_port *port,
* transmit holding register is empty. This functionality
* allows an RS485 driver to be written in user space.
*/
static int get_lsr_info(struct moschip_port *mos7720_port,
static int get_lsr_info(struct tty_struct *tty, struct moschip_port *mos7720_port,
unsigned int __user *value)
{
int count;
unsigned int result = 0;
count = mos7720_chars_in_buffer(mos7720_port->port);
count = mos7720_chars_in_buffer(tty);
if (count == 0) {
dbg("%s -- Empty", __func__);
result = TIOCSER_TEMT;
@ -1290,7 +1275,7 @@ static int get_number_bytes_avail(struct moschip_port *mos7720_port,
unsigned int __user *value)
{
unsigned int result = 0;
struct tty_struct *tty = mos7720_port->port->tty;
struct tty_struct *tty = mos7720_port->port->port.tty;
if (!tty)
return -ENOIOCTLCMD;
@ -1407,9 +1392,10 @@ static int get_serial_info(struct moschip_port *mos7720_port,
return 0;
}
static int mos7720_ioctl(struct usb_serial_port *port, struct file *file,
static int mos7720_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
struct moschip_port *mos7720_port;
struct async_icount cnow;
struct async_icount cprev;
@ -1431,9 +1417,10 @@ static int mos7720_ioctl(struct usb_serial_port *port, struct file *file,
case TIOCSERGETLSR:
dbg("%s (%d) TIOCSERGETLSR", __func__, port->number);
return get_lsr_info(mos7720_port, (unsigned int __user *)arg);
return get_lsr_info(tty, mos7720_port, (unsigned int __user *)arg);
return 0;
/* FIXME: These should be using the mode methods */
case TIOCMBIS:
case TIOCMBIC:
case TIOCMSET:
@ -1452,10 +1439,6 @@ static int mos7720_ioctl(struct usb_serial_port *port, struct file *file,
return get_serial_info(mos7720_port,
(struct serial_struct __user *)arg);
case TIOCSSERIAL:
dbg("%s (%d) TIOCSSERIAL", __func__, port->number);
break;
case TIOCMIWAIT:
dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
cprev = mos7720_port->icount;

165
drivers/usb/serial/mos7840.c
View File

@ -710,7 +710,7 @@ static void mos7840_bulk_in_callback(struct urb *urb)
dbg("%s", "Entering ........... \n");
if (urb->actual_length) {
tty = mos7840_port->port->tty;
tty = mos7840_port->port->port.tty;
if (tty) {
tty_buffer_request_room(tty, urb->actual_length);
tty_insert_flip_string(tty, data, urb->actual_length);
@ -774,7 +774,7 @@ static void mos7840_bulk_out_data_callback(struct urb *urb)
dbg("%s \n", "Entering .........");
tty = mos7840_port->port->tty;
tty = mos7840_port->port->port.tty;
if (tty && mos7840_port->open)
tty_wakeup(tty);
@ -804,7 +804,8 @@ static int mos7840_serial_probe(struct usb_serial *serial,
* Otherwise we return a negative error number.
*****************************************************************************/
static int mos7840_open(struct usb_serial_port *port, struct file *filp)
static int mos7840_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
int response;
int j;
@ -1008,8 +1009,8 @@ static int mos7840_open(struct usb_serial_port *port, struct file *filp)
* the data through,otherwise it is scheduled, and with *
* high data rates (like with OHCI) data can get lost. */
if (port->tty)
port->tty->low_latency = 1;
if (tty)
tty->low_latency = 1;
/* Check to see if we've set up our endpoint info yet *
* (can't set it up in mos7840_startup as the structures *
* were not set up at that time.) */
@ -1104,11 +1105,12 @@ static int mos7840_open(struct usb_serial_port *port, struct file *filp)
* been written, but hasn't made it out the port yet)
* If successful, we return the number of bytes left to be written in the
* system,
* Otherwise we return a negative error number.
* Otherwise we return zero.
*****************************************************************************/
static int mos7840_chars_in_buffer(struct usb_serial_port *port)
static int mos7840_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
int i;
int chars = 0;
unsigned long flags;
@ -1118,21 +1120,19 @@ static int mos7840_chars_in_buffer(struct usb_serial_port *port)
if (mos7840_port_paranoia_check(port, __func__)) {
dbg("%s", "Invalid port \n");
return -1;
return 0;
}
mos7840_port = mos7840_get_port_private(port);
if (mos7840_port == NULL) {
dbg("%s \n", "mos7840_break:leaving ...........");
return -1;
return 0;
}
spin_lock_irqsave(&mos7840_port->pool_lock,flags);
for (i = 0; i < NUM_URBS; ++i) {
if (mos7840_port->busy[i]) {
for (i = 0; i < NUM_URBS; ++i)
if (mos7840_port->busy[i])
chars += URB_TRANSFER_BUFFER_SIZE;
}
}
spin_unlock_irqrestore(&mos7840_port->pool_lock,flags);
dbg("%s - returns %d", __func__, chars);
return chars;
@ -1149,7 +1149,8 @@ static int mos7840_chars_in_buffer(struct usb_serial_port *port)
* 3. A timeout of 3 seconds without activity has expired
*
************************************************************************/
static void mos7840_block_until_tx_empty(struct moschip_port *mos7840_port)
static void mos7840_block_until_tx_empty(struct tty_struct *tty,
struct moschip_port *mos7840_port)
{
int timeout = HZ / 10;
int wait = 30;
@ -1157,7 +1158,7 @@ static void mos7840_block_until_tx_empty(struct moschip_port *mos7840_port)
while (1) {
count = mos7840_chars_in_buffer(mos7840_port->port);
count = mos7840_chars_in_buffer(tty);
/* Check for Buffer status */
if (count <= 0) {
@ -1185,7 +1186,8 @@ static void mos7840_block_until_tx_empty(struct moschip_port *mos7840_port)
* this function is called by the tty driver when a port is closed
*****************************************************************************/
static void mos7840_close(struct usb_serial_port *port, struct file *filp)
static void mos7840_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial;
struct moschip_port *mos7840_port;
@ -1226,20 +1228,17 @@ static void mos7840_close(struct usb_serial_port *port, struct file *filp)
}
}
if (serial->dev) {
if (serial->dev)
/* flush and block until tx is empty */
mos7840_block_until_tx_empty(mos7840_port);
}
mos7840_block_until_tx_empty(tty, mos7840_port);
/* While closing port, shutdown all bulk read, write *
* and interrupt read if they exists */
if (serial->dev) {
if (mos7840_port->write_urb) {
dbg("%s", "Shutdown bulk write\n");
usb_kill_urb(mos7840_port->write_urb);
}
if (mos7840_port->read_urb) {
dbg("%s", "Shutdown bulk read\n");
usb_kill_urb(mos7840_port->read_urb);
@ -1247,11 +1246,10 @@ static void mos7840_close(struct usb_serial_port *port, struct file *filp)
if ((&mos7840_port->control_urb)) {
dbg("%s", "Shutdown control read\n");
// usb_kill_urb (mos7840_port->control_urb);
}
}
// if(mos7840_port->ctrl_buf != NULL)
// kfree(mos7840_port->ctrl_buf);
// if(mos7840_port->ctrl_buf != NULL)
// kfree(mos7840_port->ctrl_buf);
port0->open_ports--;
dbg("mos7840_num_open_ports in close%d:in port%d\n",
port0->open_ports, port->number);
@ -1293,15 +1291,15 @@ static void mos7840_close(struct usb_serial_port *port, struct file *filp)
*
************************************************************************/
static void mos7840_block_until_chase_response(struct moschip_port
*mos7840_port)
static void mos7840_block_until_chase_response(struct tty_struct *tty,
struct moschip_port *mos7840_port)
{
int timeout = 1 * HZ;
int wait = 10;
int count;
while (1) {
count = mos7840_chars_in_buffer(mos7840_port->port);
count = mos7840_chars_in_buffer(tty);
/* Check for Buffer status */
if (count <= 0) {
@ -1328,8 +1326,9 @@ static void mos7840_block_until_chase_response(struct moschip_port
* mos7840_break
* this function sends a break to the port
*****************************************************************************/
static void mos7840_break(struct usb_serial_port *port, int break_state)
static void mos7840_break(struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
unsigned char data;
struct usb_serial *serial;
struct moschip_port *mos7840_port;
@ -1354,17 +1353,14 @@ static void mos7840_break(struct usb_serial_port *port, int break_state)
return;
}
if (serial->dev) {
if (serial->dev)
/* flush and block until tx is empty */
mos7840_block_until_chase_response(mos7840_port);
}
mos7840_block_until_chase_response(tty, mos7840_port);
if (break_state == -1) {
if (break_state == -1)
data = mos7840_port->shadowLCR | LCR_SET_BREAK;
} else {
else
data = mos7840_port->shadowLCR & ~LCR_SET_BREAK;
}
mos7840_port->shadowLCR = data;
dbg("mcs7840_break mos7840_port->shadowLCR is %x\n",
@ -1383,8 +1379,9 @@ static void mos7840_break(struct usb_serial_port *port, int break_state)
* Otherwise we return a negative error number.
*****************************************************************************/
static int mos7840_write_room(struct usb_serial_port *port)
static int mos7840_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
int i;
int room = 0;
unsigned long flags;
@ -1426,7 +1423,7 @@ static int mos7840_write_room(struct usb_serial_port *port)
* return a negative error number.
*****************************************************************************/
static int mos7840_write(struct usb_serial_port *port,
static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *data, int count)
{
int status;
@ -1555,8 +1552,7 @@ static int mos7840_write(struct usb_serial_port *port,
mos7840_port->icount.tx += transfer_size;
smp_wmb();
dbg("mos7840_port->icount.tx is %d:\n", mos7840_port->icount.tx);
exit:
exit:
return bytes_sent;
}
@ -1567,10 +1563,10 @@ static int mos7840_write(struct usb_serial_port *port,
* being read from the port.
*****************************************************************************/
static void mos7840_throttle(struct usb_serial_port *port)
static void mos7840_throttle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct moschip_port *mos7840_port;
struct tty_struct *tty;
int status;
if (mos7840_port_paranoia_check(port, __func__)) {
@ -1592,32 +1588,21 @@ static void mos7840_throttle(struct usb_serial_port *port)
dbg("%s", "Entering .......... \n");
tty = port->tty;
if (!tty) {
dbg("%s - no tty available", __func__);
return;
}
/* if we are implementing XON/XOFF, send the stop character */
if (I_IXOFF(tty)) {
unsigned char stop_char = STOP_CHAR(tty);
status = mos7840_write(port, &stop_char, 1);
if (status <= 0) {
status = mos7840_write(tty, port, &stop_char, 1);
if (status <= 0)
return;
}
}
/* if we are implementing RTS/CTS, toggle that line */
if (tty->termios->c_cflag & CRTSCTS) {
mos7840_port->shadowMCR &= ~MCR_RTS;
status = 0;
status =
mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
mos7840_port->shadowMCR);
if (status < 0) {
if (status < 0)
return;
}
}
return;
@ -1628,9 +1613,9 @@ static void mos7840_throttle(struct usb_serial_port *port)
* this function is called by the tty driver when it wants to resume the data
* being read from the port (called after SerialThrottle is called)
*****************************************************************************/
static void mos7840_unthrottle(struct usb_serial_port *port)
static void mos7840_unthrottle(struct tty_struct *tty)
{
struct tty_struct *tty;
struct usb_serial_port *port = tty->driver_data;
int status;
struct moschip_port *mos7840_port = mos7840_get_port_private(port);
@ -1649,38 +1634,28 @@ static void mos7840_unthrottle(struct usb_serial_port *port)
dbg("%s", "Entering .......... \n");
tty = port->tty;
if (!tty) {
dbg("%s - no tty available", __func__);
return;
}
/* if we are implementing XON/XOFF, send the start character */
if (I_IXOFF(tty)) {
unsigned char start_char = START_CHAR(tty);
status = mos7840_write(port, &start_char, 1);
if (status <= 0) {
status = mos7840_write(tty, port, &start_char, 1);
if (status <= 0)
return;
}
}
/* if we are implementing RTS/CTS, toggle that line */
if (tty->termios->c_cflag & CRTSCTS) {
mos7840_port->shadowMCR |= MCR_RTS;
status = 0;
status =
mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
mos7840_port->shadowMCR);
if (status < 0) {
if (status < 0)
return;
}
}
return;
}
static int mos7840_tiocmget(struct usb_serial_port *port, struct file *file)
static int mos7840_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct moschip_port *mos7840_port;
unsigned int result;
__u16 msr;
@ -1708,9 +1683,10 @@ static int mos7840_tiocmget(struct usb_serial_port *port, struct file *file)
return result;
}
static int mos7840_tiocmset(struct usb_serial_port *port, struct file *file,
static int mos7840_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct moschip_port *mos7840_port;
unsigned int mcr;
int status;
@ -1949,10 +1925,9 @@ static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
* the specified new settings.
*****************************************************************************/
static void mos7840_change_port_settings(struct moschip_port *mos7840_port,
struct ktermios *old_termios)
static void mos7840_change_port_settings(struct tty_struct *tty,
struct moschip_port *mos7840_port, struct ktermios *old_termios)
{
struct tty_struct *tty;
int baud;
unsigned cflag;
unsigned iflag;
@ -1988,8 +1963,6 @@ static void mos7840_change_port_settings(struct moschip_port *mos7840_port,
return;
}
tty = mos7840_port->port->tty;
dbg("%s", "Entering .......... \n");
lData = LCR_BITS_8;
@ -2131,14 +2104,14 @@ static void mos7840_change_port_settings(struct moschip_port *mos7840_port,
* the termios structure
*****************************************************************************/
static void mos7840_set_termios(struct usb_serial_port *port,
static void mos7840_set_termios(struct tty_struct *tty,
struct usb_serial_port *port,
struct ktermios *old_termios)
{
int status;
unsigned int cflag;
struct usb_serial *serial;
struct moschip_port *mos7840_port;
struct tty_struct *tty;
dbg("mos7840_set_termios: START\n");
if (mos7840_port_paranoia_check(port, __func__)) {
dbg("%s", "Invalid port \n");
@ -2157,8 +2130,6 @@ static void mos7840_set_termios(struct usb_serial_port *port,
if (mos7840_port == NULL)
return;
tty = port->tty;
if (!mos7840_port->open) {
dbg("%s - port not opened", __func__);
return;
@ -2176,7 +2147,7 @@ static void mos7840_set_termios(struct usb_serial_port *port,
/* change the port settings to the new ones specified */
mos7840_change_port_settings(mos7840_port, old_termios);
mos7840_change_port_settings(tty, mos7840_port, old_termios);
if (!mos7840_port->read_urb) {
dbg("%s", "URB KILLED !!!!!\n");
@ -2205,13 +2176,13 @@ static void mos7840_set_termios(struct usb_serial_port *port,
* allows an RS485 driver to be written in user space.
*****************************************************************************/
static int mos7840_get_lsr_info(struct moschip_port *mos7840_port,
static int mos7840_get_lsr_info(struct tty_struct *tty,
unsigned int __user *value)
{
int count;
unsigned int result = 0;
count = mos7840_chars_in_buffer(mos7840_port->port);
count = mos7840_chars_in_buffer(tty);
if (count == 0) {
dbg("%s -- Empty", __func__);
result = TIOCSER_TEMT;
@ -2227,6 +2198,8 @@ static int mos7840_get_lsr_info(struct moschip_port *mos7840_port,
* function to set modem info
*****************************************************************************/
/* FIXME: Should be using the model control hooks */
static int mos7840_set_modem_info(struct moschip_port *mos7840_port,
unsigned int cmd, unsigned int __user *value)
{
@ -2304,9 +2277,8 @@ static int mos7840_get_modem_info(struct moschip_port *mos7840_port,
__u16 msr;
unsigned int mcr = mos7840_port->shadowMCR;
int status = 0;
status =
mos7840_get_uart_reg(mos7840_port->port, MODEM_STATUS_REGISTER,
&msr);
status = mos7840_get_uart_reg(mos7840_port->port,
MODEM_STATUS_REGISTER, &msr);
result = ((mcr & MCR_DTR) ? TIOCM_DTR : 0) /* 0x002 */
|((mcr & MCR_RTS) ? TIOCM_RTS : 0) /* 0x004 */
|((msr & MOS7840_MSR_CTS) ? TIOCM_CTS : 0) /* 0x020 */
@ -2359,12 +2331,12 @@ static int mos7840_get_serial_info(struct moschip_port *mos7840_port,
* this function handles any ioctl calls to the driver
*****************************************************************************/
static int mos7840_ioctl(struct usb_serial_port *port, struct file *file,
static int mos7840_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
void __user *argp = (void __user *)arg;
struct moschip_port *mos7840_port;
struct tty_struct *tty;
struct async_icount cnow;
struct async_icount cprev;
@ -2381,8 +2353,6 @@ static int mos7840_ioctl(struct usb_serial_port *port, struct file *file,
if (mos7840_port == NULL)
return -1;
tty = mos7840_port->port->tty;
dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
switch (cmd) {
@ -2390,9 +2360,10 @@ static int mos7840_ioctl(struct usb_serial_port *port, struct file *file,
case TIOCSERGETLSR:
dbg("%s (%d) TIOCSERGETLSR", __func__, port->number);
return mos7840_get_lsr_info(mos7840_port, argp);
return mos7840_get_lsr_info(tty, argp);
return 0;
/* FIXME: use the modem hooks and remove this */
case TIOCMBIS:
case TIOCMBIC:
case TIOCMSET:
@ -2463,13 +2434,9 @@ static int mos7840_ioctl(struct usb_serial_port *port, struct file *file,
if (copy_to_user(argp, &icount, sizeof(icount)))
return -EFAULT;
return 0;
case TIOCEXBAUD:
return 0;
default:
break;
}
return -ENOIOCTLCMD;
}

10
drivers/usb/serial/navman.c
View File

@ -64,7 +64,7 @@ static void navman_read_int_callback(struct urb *urb)
usb_serial_debug_data(debug, &port->dev, __func__,
urb->actual_length, data);
tty = port->tty;
tty = port->port.tty;
if (tty && urb->actual_length) {
tty_buffer_request_room(tty, urb->actual_length);
tty_insert_flip_string(tty, data, urb->actual_length);
@ -79,7 +79,8 @@ exit:
__func__, result);
}
static int navman_open(struct usb_serial_port *port, struct file *filp)
static int navman_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
int result = 0;
@ -96,14 +97,15 @@ static int navman_open(struct usb_serial_port *port, struct file *filp)
return result;
}
static void navman_close(struct usb_serial_port *port, struct file *filp)
static void navman_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
dbg("%s - port %d", __func__, port->number);
usb_kill_urb(port->interrupt_in_urb);
}
static int navman_write(struct usb_serial_port *port,
static int navman_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
dbg("%s - port %d", __func__, port->number);

26
drivers/usb/serial/omninet.c
View File

@ -61,12 +61,12 @@ static int debug;
#define BT_IGNITIONPRO_ID 0x2000 /* This one seems to be a re-branded ZyXEL device */
/* function prototypes */
static int omninet_open (struct usb_serial_port *port, struct file *filp);
static void omninet_close (struct usb_serial_port *port, struct file *filp);
static int omninet_open (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static void omninet_close (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static void omninet_read_bulk_callback (struct urb *urb);
static void omninet_write_bulk_callback (struct urb *urb);
static int omninet_write (struct usb_serial_port *port, const unsigned char *buf, int count);
static int omninet_write_room (struct usb_serial_port *port);
static int omninet_write (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
static int omninet_write_room (struct tty_struct *tty);
static void omninet_shutdown (struct usb_serial *serial);
static int omninet_attach (struct usb_serial *serial);
@ -157,7 +157,8 @@ static int omninet_attach (struct usb_serial *serial)
return 0;
}
static int omninet_open (struct usb_serial_port *port, struct file *filp)
static int omninet_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial = port->serial;
struct usb_serial_port *wport;
@ -166,7 +167,7 @@ static int omninet_open (struct usb_serial_port *port, struct file *filp)
dbg("%s - port %d", __func__, port->number);
wport = serial->port[1];
wport->tty = port->tty;
wport->port.tty = tty; /* FIXME */
/* Start reading from the device */
usb_fill_bulk_urb(port->read_urb, serial->dev,
@ -181,7 +182,8 @@ static int omninet_open (struct usb_serial_port *port, struct file *filp)
return result;
}
static void omninet_close (struct usb_serial_port *port, struct file * filp)
static void omninet_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file * filp)
{
dbg("%s - port %d", __func__, port->number);
usb_kill_urb(port->read_urb);
@ -221,9 +223,9 @@ static void omninet_read_bulk_callback (struct urb *urb)
if (urb->actual_length && header->oh_len) {
for (i = 0; i < header->oh_len; i++) {
tty_insert_flip_char(port->tty, data[OMNINET_DATAOFFSET + i], 0);
tty_insert_flip_char(port->port.tty, data[OMNINET_DATAOFFSET + i], 0);
}
tty_flip_buffer_push(port->tty);
tty_flip_buffer_push(port->port.tty);
}
/* Continue trying to always read */
@ -238,7 +240,8 @@ static void omninet_read_bulk_callback (struct urb *urb)
return;
}
static int omninet_write (struct usb_serial_port *port, const unsigned char *buf, int count)
static int omninet_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
struct usb_serial *serial = port->serial;
struct usb_serial_port *wport = serial->port[1];
@ -290,8 +293,9 @@ static int omninet_write (struct usb_serial_port *port, const unsigned char *buf
}
static int omninet_write_room (struct usb_serial_port *port)
static int omninet_write_room (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
struct usb_serial_port *wport = serial->port[1];

105
drivers/usb/serial/option.c
View File

@ -43,29 +43,23 @@
#include <linux/usb/serial.h>
/* Function prototypes */
static int option_open(struct usb_serial_port *port, struct file *filp);
static void option_close(struct usb_serial_port *port, struct file *filp);
static int option_open(struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static void option_close(struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static int option_startup(struct usb_serial *serial);
static void option_shutdown(struct usb_serial *serial);
static void option_rx_throttle(struct usb_serial_port *port);
static void option_rx_unthrottle(struct usb_serial_port *port);
static int option_write_room(struct usb_serial_port *port);
static int option_write_room(struct tty_struct *tty);
static void option_instat_callback(struct urb *urb);
static int option_write(struct usb_serial_port *port,
static int option_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count);
static int option_chars_in_buffer(struct usb_serial_port *port);
static int option_ioctl(struct usb_serial_port *port, struct file *file,
unsigned int cmd, unsigned long arg);
static void option_set_termios(struct usb_serial_port *port,
struct ktermios *old);
static void option_break_ctl(struct usb_serial_port *port, int break_state);
static int option_tiocmget(struct usb_serial_port *port, struct file *file);
static int option_tiocmset(struct usb_serial_port *port, struct file *file,
static int option_chars_in_buffer(struct tty_struct *tty);
static void option_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old);
static int option_tiocmget(struct tty_struct *tty, struct file *file);
static int option_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear);
static int option_send_setup(struct usb_serial_port *port);
static int option_send_setup(struct tty_struct *tty, struct usb_serial_port *port);
/* Vendor and product IDs */
#define OPTION_VENDOR_ID 0x0AF0
@ -342,11 +336,7 @@ static struct usb_serial_driver option_1port_device = {
.write = option_write,
.write_room = option_write_room,
.chars_in_buffer = option_chars_in_buffer,
.throttle = option_rx_throttle,
.unthrottle = option_rx_unthrottle,
.ioctl = option_ioctl,
.set_termios = option_set_termios,
.break_ctl = option_break_ctl,
.tiocmget = option_tiocmget,
.tiocmset = option_tiocmset,
.attach = option_startup,
@ -417,33 +407,18 @@ static void __exit option_exit(void)
module_init(option_init);
module_exit(option_exit);
static void option_rx_throttle(struct usb_serial_port *port)
{
dbg("%s", __func__);
}
static void option_rx_unthrottle(struct usb_serial_port *port)
{
dbg("%s", __func__);
}
static void option_break_ctl(struct usb_serial_port *port, int break_state)
{
/* Unfortunately, I don't know how to send a break */
dbg("%s", __func__);
}
static void option_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios)
static void option_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
dbg("%s", __func__);
/* Doesn't support option setting */
tty_termios_copy_hw(port->tty->termios, old_termios);
option_send_setup(port);
tty_termios_copy_hw(tty->termios, old_termios);
option_send_setup(tty, port);
}
static int option_tiocmget(struct usb_serial_port *port, struct file *file)
static int option_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
unsigned int value;
struct option_port_private *portdata;
@ -459,9 +434,10 @@ static int option_tiocmget(struct usb_serial_port *port, struct file *file)
return value;
}
static int option_tiocmset(struct usb_serial_port *port, struct file *file,
static int option_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct option_port_private *portdata;
portdata = usb_get_serial_port_data(port);
@ -476,17 +452,11 @@ static int option_tiocmset(struct usb_serial_port *port, struct file *file,
portdata->rts_state = 0;
if (clear & TIOCM_DTR)
portdata->dtr_state = 0;
return option_send_setup(port);
}
static int option_ioctl(struct usb_serial_port *port, struct file *file,
unsigned int cmd, unsigned long arg)
{
return -ENOIOCTLCMD;
return option_send_setup(tty, port);
}
/* Write */
static int option_write(struct usb_serial_port *port,
static int option_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
struct option_port_private *portdata;
@ -562,7 +532,7 @@ static void option_indat_callback(struct urb *urb)
dbg("%s: nonzero status: %d on endpoint %02x.",
__func__, status, endpoint);
} else {
tty = port->tty;
tty = port->port.tty;
if (urb->actual_length) {
tty_buffer_request_room(tty, urb->actual_length);
tty_insert_flip_string(tty, data, urb->actual_length);
@ -572,7 +542,7 @@ static void option_indat_callback(struct urb *urb)
}
/* Resubmit urb so we continue receiving */
if (port->open_count && status != -ESHUTDOWN) {
if (port->port.count && status != -ESHUTDOWN) {
err = usb_submit_urb(urb, GFP_ATOMIC);
if (err)
printk(KERN_ERR "%s: resubmit read urb failed. "
@ -638,9 +608,9 @@ static void option_instat_callback(struct urb *urb)
portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
portdata->ri_state = ((signals & 0x08) ? 1 : 0);
if (port->tty && !C_CLOCAL(port->tty) &&
if (port->port.tty && !C_CLOCAL(port->port.tty) &&
old_dcd_state && !portdata->dcd_state)
tty_hangup(port->tty);
tty_hangup(port->port.tty);
} else {
dbg("%s: type %x req %x", __func__,
req_pkt->bRequestType,req_pkt->bRequest);
@ -658,8 +628,9 @@ static void option_instat_callback(struct urb *urb)
}
}
static int option_write_room(struct usb_serial_port *port)
static int option_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct option_port_private *portdata;
int i;
int data_len = 0;
@ -678,8 +649,9 @@ static int option_write_room(struct usb_serial_port *port)
return data_len;
}
static int option_chars_in_buffer(struct usb_serial_port *port)
static int option_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct option_port_private *portdata;
int i;
int data_len = 0;
@ -698,7 +670,8 @@ static int option_chars_in_buffer(struct usb_serial_port *port)
return data_len;
}
static int option_open(struct usb_serial_port *port, struct file *filp)
static int option_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct option_port_private *portdata;
struct usb_serial *serial = port->serial;
@ -748,14 +721,16 @@ static int option_open(struct usb_serial_port *port, struct file *filp)
usb_pipeout(urb->pipe), 0); */
}
port->tty->low_latency = 1;
if (tty)
tty->low_latency = 1;
option_send_setup(port);
option_send_setup(tty, port);
return (0);
}
static void option_close(struct usb_serial_port *port, struct file *filp)
static void option_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
int i;
struct usb_serial *serial = port->serial;
@ -770,7 +745,7 @@ static void option_close(struct usb_serial_port *port, struct file *filp)
if (serial->dev) {
mutex_lock(&serial->disc_mutex);
if (!serial->disconnected)
option_send_setup(port);
option_send_setup(tty, port);
mutex_unlock(&serial->disc_mutex);
/* Stop reading/writing urbs */
@ -779,7 +754,7 @@ static void option_close(struct usb_serial_port *port, struct file *filp)
for (i = 0; i < N_OUT_URB; i++)
usb_kill_urb(portdata->out_urbs[i]);
}
port->tty = NULL;
port->port.tty = NULL; /* FIXME */
}
/* Helper functions used by option_setup_urbs */
@ -841,7 +816,8 @@ static void option_setup_urbs(struct usb_serial *serial)
* This is exactly the same as SET_CONTROL_LINE_STATE from the PSTN
* CDC.
*/
static int option_send_setup(struct usb_serial_port *port)
static int option_send_setup(struct tty_struct *tty,
struct usb_serial_port *port)
{
struct usb_serial *serial = port->serial;
struct option_port_private *portdata;
@ -850,7 +826,7 @@ static int option_send_setup(struct usb_serial_port *port)
portdata = usb_get_serial_port_data(port);
if (port->tty) {
if (tty) {
int val = 0;
if (portdata->dtr_state)
val |= 0x01;
@ -861,7 +837,6 @@ static int option_send_setup(struct usb_serial_port *port)
usb_rcvctrlpipe(serial->dev, 0),
0x22,0x21,val,ifNum,NULL,0,USB_CTRL_SET_TIMEOUT);
}
return 0;
}

119
drivers/usb/serial/oti6858.c
View File

@ -140,22 +140,23 @@ struct oti6858_control_pkt {
&& ((a)->frame_fmt == (priv)->pending_setup.frame_fmt) )
/* function prototypes */
static int oti6858_open(struct usb_serial_port *port, struct file *filp);
static void oti6858_close(struct usb_serial_port *port, struct file *filp);
static void oti6858_set_termios(struct usb_serial_port *port,
struct ktermios *old);
static int oti6858_ioctl(struct usb_serial_port *port, struct file *file,
static int oti6858_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp);
static void oti6858_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp);
static void oti6858_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old);
static int oti6858_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg);
static void oti6858_read_int_callback(struct urb *urb);
static void oti6858_read_bulk_callback(struct urb *urb);
static void oti6858_write_bulk_callback(struct urb *urb);
static int oti6858_write(struct usb_serial_port *port,
static int oti6858_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count);
static int oti6858_write_room(struct usb_serial_port *port);
static void oti6858_break_ctl(struct usb_serial_port *port, int break_state);
static int oti6858_chars_in_buffer(struct usb_serial_port *port);
static int oti6858_tiocmget(struct usb_serial_port *port, struct file *file);
static int oti6858_tiocmset(struct usb_serial_port *port, struct file *file,
static int oti6858_write_room(struct tty_struct *tty);
static int oti6858_chars_in_buffer(struct tty_struct *tty);
static int oti6858_tiocmget(struct tty_struct *tty, struct file *file);
static int oti6858_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear);
static int oti6858_startup(struct usb_serial *serial);
static void oti6858_shutdown(struct usb_serial *serial);
@ -184,7 +185,6 @@ static struct usb_serial_driver oti6858_device = {
.close = oti6858_close,
.write = oti6858_write,
.ioctl = oti6858_ioctl,
.break_ctl = oti6858_break_ctl,
.set_termios = oti6858_set_termios,
.tiocmget = oti6858_tiocmget,
.tiocmset = oti6858_tiocmset,
@ -395,7 +395,7 @@ static int oti6858_startup(struct usb_serial *serial)
return -ENOMEM;
}
static int oti6858_write(struct usb_serial_port *port,
static int oti6858_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
struct oti6858_private *priv = usb_get_serial_port_data(port);
@ -413,8 +413,9 @@ static int oti6858_write(struct usb_serial_port *port,
return count;
}
static int oti6858_write_room(struct usb_serial_port *port)
static int oti6858_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct oti6858_private *priv = usb_get_serial_port_data(port);
int room = 0;
unsigned long flags;
@ -428,8 +429,9 @@ static int oti6858_write_room(struct usb_serial_port *port)
return room;
}
static int oti6858_chars_in_buffer(struct usb_serial_port *port)
static int oti6858_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct oti6858_private *priv = usb_get_serial_port_data(port);
int chars = 0;
unsigned long flags;
@ -443,8 +445,8 @@ static int oti6858_chars_in_buffer(struct usb_serial_port *port)
return chars;
}
static void oti6858_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios)
static void oti6858_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
struct oti6858_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -455,22 +457,22 @@ static void oti6858_set_termios(struct usb_serial_port *port,
dbg("%s(port = %d)", __func__, port->number);
if (!port->tty || !port->tty->termios) {
if (!tty) {
dbg("%s(): no tty structures", __func__);
return;
}
spin_lock_irqsave(&priv->lock, flags);
if (!priv->flags.termios_initialized) {
*(port->tty->termios) = tty_std_termios;
port->tty->termios->c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
*(tty->termios) = tty_std_termios;
tty->termios->c_cflag = B38400 | CS8 | CREAD | HUPCL | CLOCAL;
tty->termios->c_ispeed = 38400;
tty->termios->c_ospeed = 38400;
priv->flags.termios_initialized = 1;
port->tty->termios->c_ispeed = 38400;
port->tty->termios->c_ospeed = 38400;
}
spin_unlock_irqrestore(&priv->lock, flags);
cflag = port->tty->termios->c_cflag;
cflag = tty->termios->c_cflag;
spin_lock_irqsave(&priv->lock, flags);
divisor = priv->pending_setup.divisor;
@ -500,7 +502,7 @@ static void oti6858_set_termios(struct usb_serial_port *port,
* guarantee that any other baud rate will work (especially
* the higher ones)
*/
br = tty_get_baud_rate(port->tty);
br = tty_get_baud_rate(tty);
if (br == 0) {
divisor = 0;
} else {
@ -511,7 +513,7 @@ static void oti6858_set_termios(struct usb_serial_port *port,
new_divisor = (96000000 + 8 * br) / (16 * br);
real_br = 96000000 / (16 * new_divisor);
divisor = cpu_to_le16(new_divisor);
tty_encode_baud_rate(port->tty, real_br, real_br);
tty_encode_baud_rate(tty, real_br, real_br);
}
frame_fmt &= ~FMT_STOP_BITS_MASK;
@ -564,7 +566,8 @@ static void oti6858_set_termios(struct usb_serial_port *port,
spin_unlock_irqrestore(&priv->lock, flags);
}
static int oti6858_open(struct usb_serial_port *port, struct file *filp)
static int oti6858_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct oti6858_private *priv = usb_get_serial_port_data(port);
struct ktermios tmp_termios;
@ -578,7 +581,7 @@ static int oti6858_open(struct usb_serial_port *port, struct file *filp)
usb_clear_halt(serial->dev, port->write_urb->pipe);
usb_clear_halt(serial->dev, port->read_urb->pipe);
if (port->open_count != 1)
if (port->port.count != 1)
return 0;
if ((buf = kmalloc(OTI6858_CTRL_PKT_SIZE, GFP_KERNEL)) == NULL) {
@ -617,18 +620,19 @@ static int oti6858_open(struct usb_serial_port *port, struct file *filp)
if (result != 0) {
dev_err(&port->dev, "%s(): usb_submit_urb() failed"
" with error %d\n", __func__, result);
oti6858_close(port, NULL);
oti6858_close(tty, port, NULL);
return -EPROTO;
}
/* setup termios */
if (port->tty)
oti6858_set_termios(port, &tmp_termios);
if (tty)
oti6858_set_termios(tty, port, &tmp_termios);
return 0;
}
static void oti6858_close(struct usb_serial_port *port, struct file *filp)
static void oti6858_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct oti6858_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -641,7 +645,7 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
spin_lock_irqsave(&priv->lock, flags);
timeout = 30 * HZ; /* PL2303_CLOSING_WAIT */
init_waitqueue_entry(&wait, current);
add_wait_queue(&port->tty->write_wait, &wait);
add_wait_queue(&tty->write_wait, &wait);
dbg("%s(): entering wait loop", __func__);
for (;;) {
set_current_state(TASK_INTERRUPTIBLE);
@ -654,7 +658,7 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
spin_lock_irqsave(&priv->lock, flags);
}
set_current_state(TASK_RUNNING);
remove_wait_queue(&port->tty->write_wait, &wait);
remove_wait_queue(&tty->write_wait, &wait);
dbg("%s(): after wait loop", __func__);
/* clear out any remaining data in the buffer */
@ -669,7 +673,7 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
/* data is in the buffer to compute a delay */
/* that is not unnecessarily long) */
/* FIXME
bps = tty_get_baud_rate(port->tty);
bps = tty_get_baud_rate(tty);
if (bps > 1200)
timeout = max((HZ*2560)/bps,HZ/10);
else
@ -690,7 +694,7 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
usb_kill_urb(port->interrupt_in_urb);
/*
if (port->tty && (port->tty->termios->c_cflag) & HUPCL) {
if (tty && (tty->termios->c_cflag) & HUPCL) {
// drop DTR and RTS
spin_lock_irqsave(&priv->lock, flags);
priv->pending_setup.control &= ~CONTROL_MASK;
@ -699,9 +703,10 @@ static void oti6858_close(struct usb_serial_port *port, struct file *filp)
*/
}
static int oti6858_tiocmset(struct usb_serial_port *port, struct file *file,
static int oti6858_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct oti6858_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
u8 control;
@ -732,8 +737,9 @@ static int oti6858_tiocmset(struct usb_serial_port *port, struct file *file,
return 0;
}
static int oti6858_tiocmget(struct usb_serial_port *port, struct file *file)
static int oti6858_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct oti6858_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
unsigned pin_state;
@ -802,26 +808,15 @@ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
return 0;
}
static int oti6858_ioctl(struct usb_serial_port *port, struct file *file,
static int oti6858_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg)
{
void __user *user_arg = (void __user *) arg;
unsigned int x;
struct usb_serial_port *port = tty->driver_data;
dbg("%s(port = %d, cmd = 0x%04x, arg = 0x%08lx)",
__func__, port->number, cmd, arg);
switch (cmd) {
case TIOCMBIS:
if (copy_from_user(&x, user_arg, sizeof(x)))
return -EFAULT;
return oti6858_tiocmset(port, NULL, x, 0);
case TIOCMBIC:
if (copy_from_user(&x, user_arg, sizeof(x)))
return -EFAULT;
return oti6858_tiocmset(port, NULL, 0, x);
case TIOCMIWAIT:
dbg("%s(): TIOCMIWAIT", __func__);
return wait_modem_info(port, arg);
@ -834,24 +829,6 @@ static int oti6858_ioctl(struct usb_serial_port *port, struct file *file,
return -ENOIOCTLCMD;
}
static void oti6858_break_ctl(struct usb_serial_port *port, int break_state)
{
int state;
dbg("%s(port = %d)", __func__, port->number);
state = (break_state == 0) ? 0 : 1;
dbg("%s(): turning break %s", __func__, state ? "on" : "off");
/* FIXME */
/*
result = usb_control_msg (serial->dev, usb_sndctrlpipe (serial->dev, 0),
BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
0, NULL, 0, 100);
if (result != 0)
dbg("%s(): error sending break", __func__);
*/
}
static void oti6858_shutdown(struct usb_serial *serial)
{
@ -1002,7 +979,7 @@ static void oti6858_read_bulk_callback(struct urb *urb)
spin_unlock_irqrestore(&priv->lock, flags);
if (status != 0) {
if (!port->open_count) {
if (!port->port.count) {
dbg("%s(): port is closed, exiting", __func__);
return;
}
@ -1020,14 +997,14 @@ static void oti6858_read_bulk_callback(struct urb *urb)
return;
}
tty = port->tty;
tty = port->port.tty;
if (tty != NULL && urb->actual_length > 0) {
tty_insert_flip_string(tty, data, urb->actual_length);
tty_flip_buffer_push(tty);
}
// schedule the interrupt urb if we are still open */
if (port->open_count != 0) {
if (port->port.count != 0) {
port->interrupt_in_urb->dev = port->serial->dev;
result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
if (result != 0) {

76
drivers/usb/serial/pl2303.c
View File

@ -458,8 +458,8 @@ static void pl2303_send(struct usb_serial_port *port)
usb_serial_port_softint(port);
}
static int pl2303_write(struct usb_serial_port *port, const unsigned char *buf,
int count)
static int pl2303_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
struct pl2303_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -478,8 +478,9 @@ static int pl2303_write(struct usb_serial_port *port, const unsigned char *buf,
return count;
}
static int pl2303_write_room(struct usb_serial_port *port)
static int pl2303_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct pl2303_private *priv = usb_get_serial_port_data(port);
int room = 0;
unsigned long flags;
@ -494,8 +495,9 @@ static int pl2303_write_room(struct usb_serial_port *port)
return room;
}
static int pl2303_chars_in_buffer(struct usb_serial_port *port)
static int pl2303_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct pl2303_private *priv = usb_get_serial_port_data(port);
int chars = 0;
unsigned long flags;
@ -510,8 +512,8 @@ static int pl2303_chars_in_buffer(struct usb_serial_port *port)
return chars;
}
static void pl2303_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios)
static void pl2303_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
struct usb_serial *serial = port->serial;
struct pl2303_private *priv = usb_get_serial_port_data(port);
@ -526,11 +528,10 @@ static void pl2303_set_termios(struct usb_serial_port *port,
spin_lock_irqsave(&priv->lock, flags);
if (!priv->termios_initialized) {
*(port->tty->termios) = tty_std_termios;
port->tty->termios->c_cflag = B9600 | CS8 | CREAD |
HUPCL | CLOCAL;
port->tty->termios->c_ispeed = 9600;
port->tty->termios->c_ospeed = 9600;
*(tty->termios) = tty_std_termios;
tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
tty->termios->c_ispeed = 9600;
tty->termios->c_ospeed = 9600;
priv->termios_initialized = 1;
}
spin_unlock_irqrestore(&priv->lock, flags);
@ -539,16 +540,16 @@ static void pl2303_set_termios(struct usb_serial_port *port,
serial settings even to the same values as before. Thus
we actually need to filter in this specific case */
if (!tty_termios_hw_change(port->tty->termios, old_termios))
if (!tty_termios_hw_change(tty->termios, old_termios))
return;
cflag = port->tty->termios->c_cflag;
cflag = tty->termios->c_cflag;
buf = kzalloc(7, GFP_KERNEL);
if (!buf) {
dev_err(&port->dev, "%s - out of memory.\n", __func__);
/* Report back no change occurred */
*port->tty->termios = *old_termios;
*tty->termios = *old_termios;
return;
}
@ -569,7 +570,7 @@ static void pl2303_set_termios(struct usb_serial_port *port,
dbg("%s - data bits = %d", __func__, buf[6]);
}
baud = tty_get_baud_rate(port->tty);;
baud = tty_get_baud_rate(tty);
dbg("%s - baud = %d", __func__, baud);
if (baud) {
buf[0] = baud & 0xff;
@ -646,12 +647,13 @@ static void pl2303_set_termios(struct usb_serial_port *port,
/* FIXME: Need to read back resulting baud rate */
if (baud)
tty_encode_baud_rate(port->tty, baud, baud);
tty_encode_baud_rate(tty, baud, baud);
kfree(buf);
}
static void pl2303_close(struct usb_serial_port *port, struct file *filp)
static void pl2303_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct pl2303_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -666,7 +668,7 @@ static void pl2303_close(struct usb_serial_port *port, struct file *filp)
spin_lock_irqsave(&priv->lock, flags);
timeout = PL2303_CLOSING_WAIT;
init_waitqueue_entry(&wait, current);
add_wait_queue(&port->tty->write_wait, &wait);
add_wait_queue(&tty->write_wait, &wait);
for (;;) {
set_current_state(TASK_INTERRUPTIBLE);
if (pl2303_buf_data_avail(priv->buf) == 0 ||
@ -678,7 +680,7 @@ static void pl2303_close(struct usb_serial_port *port, struct file *filp)
spin_lock_irqsave(&priv->lock, flags);
}
set_current_state(TASK_RUNNING);
remove_wait_queue(&port->tty->write_wait, &wait);
remove_wait_queue(&tty->write_wait, &wait);
/* clear out any remaining data in the buffer */
pl2303_buf_clear(priv->buf);
spin_unlock_irqrestore(&priv->lock, flags);
@ -690,7 +692,7 @@ static void pl2303_close(struct usb_serial_port *port, struct file *filp)
/* for lower rates we should really know how much */
/* data is in the buffer to compute a delay */
/* that is not unnecessarily long) */
bps = tty_get_baud_rate(port->tty);
bps = tty_get_baud_rate(tty);
if (bps > 1200)
timeout = max((HZ*2560)/bps,HZ/10);
else
@ -703,8 +705,8 @@ static void pl2303_close(struct usb_serial_port *port, struct file *filp)
usb_kill_urb(port->read_urb);
usb_kill_urb(port->interrupt_in_urb);
if (port->tty) {
c_cflag = port->tty->termios->c_cflag;
if (tty) {
c_cflag = tty->termios->c_cflag;
if (c_cflag & HUPCL) {
/* drop DTR and RTS */
spin_lock_irqsave(&priv->lock, flags);
@ -715,7 +717,8 @@ static void pl2303_close(struct usb_serial_port *port, struct file *filp)
}
}
static int pl2303_open(struct usb_serial_port *port, struct file *filp)
static int pl2303_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct ktermios tmp_termios;
struct usb_serial *serial = port->serial;
@ -734,9 +737,8 @@ static int pl2303_open(struct usb_serial_port *port, struct file *filp)
}
/* Setup termios */
if (port->tty) {
pl2303_set_termios(port, &tmp_termios);
}
if (tty)
pl2303_set_termios(tty, port, &tmp_termios);
//FIXME: need to assert RTS and DTR if CRTSCTS off
@ -746,7 +748,7 @@ static int pl2303_open(struct usb_serial_port *port, struct file *filp)
if (result) {
dev_err(&port->dev, "%s - failed submitting read urb,"
" error %d\n", __func__, result);
pl2303_close(port, NULL);
pl2303_close(tty, port, NULL);
return -EPROTO;
}
@ -756,15 +758,16 @@ static int pl2303_open(struct usb_serial_port *port, struct file *filp)
if (result) {
dev_err(&port->dev, "%s - failed submitting interrupt urb,"
" error %d\n", __func__, result);
pl2303_close(port, NULL);
pl2303_close(tty, port, NULL);
return -EPROTO;
}
return 0;
}
static int pl2303_tiocmset(struct usb_serial_port *port, struct file *file,
static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct pl2303_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
u8 control;
@ -787,8 +790,9 @@ static int pl2303_tiocmset(struct usb_serial_port *port, struct file *file,
return set_control_lines(port->serial->dev, control);
}
static int pl2303_tiocmget(struct usb_serial_port *port, struct file *file)
static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct pl2303_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
unsigned int mcr;
@ -853,9 +857,10 @@ static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
return 0;
}
static int pl2303_ioctl(struct usb_serial_port *port, struct file *file,
static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
switch (cmd) {
@ -871,8 +876,9 @@ static int pl2303_ioctl(struct usb_serial_port *port, struct file *file,
return -ENOIOCTLCMD;
}
static void pl2303_break_ctl(struct usb_serial_port *port, int break_state)
static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
struct usb_serial *serial = port->serial;
u16 state;
int result;
@ -1001,7 +1007,7 @@ static void pl2303_read_bulk_callback(struct urb *urb)
if (status) {
dbg("%s - urb status = %d", __func__, status);
if (!port->open_count) {
if (!port->port.count) {
dbg("%s - port is closed, exiting.", __func__);
return;
}
@ -1044,7 +1050,7 @@ static void pl2303_read_bulk_callback(struct urb *urb)
tty_flag = TTY_FRAME;
dbg("%s - tty_flag = %d", __func__, tty_flag);
tty = port->tty;
tty = port->port.tty;
if (tty && urb->actual_length) {
tty_buffer_request_room(tty, urb->actual_length + 1);
/* overrun is special, not associated with a char */
@ -1056,7 +1062,7 @@ static void pl2303_read_bulk_callback(struct urb *urb)
}
/* Schedule the next read _if_ we are still open */
if (port->open_count) {
if (port->port.count) {
urb->dev = port->serial->dev;
result = usb_submit_urb(urb, GFP_ATOMIC);
if (result)

14
drivers/usb/serial/safe_serial.c
View File

@ -229,8 +229,8 @@ static void safe_read_bulk_callback (struct urb *urb)
int actual_length = data[length - 2] >> 2;
if (actual_length <= (length - 2)) {
info ("%s - actual: %d", __func__, actual_length);
tty_insert_flip_string(port->tty, data, actual_length);
tty_flip_buffer_push (port->tty);
tty_insert_flip_string(port->port.tty, data, actual_length);
tty_flip_buffer_push (port->port.tty);
} else {
err ("%s - inconsistent lengths %d:%d", __func__,
actual_length, length);
@ -239,8 +239,8 @@ static void safe_read_bulk_callback (struct urb *urb)
err ("%s - bad CRC %x", __func__, fcs);
}
} else {
tty_insert_flip_string(port->tty, data, length);
tty_flip_buffer_push (port->tty);
tty_insert_flip_string(port->port.tty, data, length);
tty_flip_buffer_push (port->port.tty);
}
/* Continue trying to always read */
@ -255,7 +255,8 @@ static void safe_read_bulk_callback (struct urb *urb)
}
}
static int safe_write (struct usb_serial_port *port, const unsigned char *buf, int count)
static int safe_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
unsigned char *data;
int result;
@ -349,8 +350,9 @@ static int safe_write (struct usb_serial_port *port, const unsigned char *buf, i
return (count);
}
static int safe_write_room (struct usb_serial_port *port)
static int safe_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
int room = 0; /* Default: no room */
unsigned long flags;

93
drivers/usb/serial/sierra.c
View File

@ -250,7 +250,8 @@ struct sierra_port_private {
int ri_state;
};
static int sierra_send_setup(struct usb_serial_port *port)
static int sierra_send_setup(struct tty_struct *tty,
struct usb_serial_port *port)
{
struct usb_serial *serial = port->serial;
struct sierra_port_private *portdata;
@ -260,7 +261,7 @@ static int sierra_send_setup(struct usb_serial_port *port)
portdata = usb_get_serial_port_data(port);
if (port->tty) {
if (tty) {
int val = 0;
if (portdata->dtr_state)
val |= 0x01;
@ -284,32 +285,17 @@ static int sierra_send_setup(struct usb_serial_port *port)
return 0;
}
static void sierra_rx_throttle(struct usb_serial_port *port)
static void sierra_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
dbg("%s", __func__);
tty_termios_copy_hw(tty->termios, old_termios);
sierra_send_setup(tty, port);
}
static void sierra_rx_unthrottle(struct usb_serial_port *port)
{
dbg("%s", __func__);
}
static void sierra_break_ctl(struct usb_serial_port *port, int break_state)
{
/* Unfortunately, I don't know how to send a break */
dbg("%s", __func__);
}
static void sierra_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios)
{
dbg("%s", __func__);
tty_termios_copy_hw(port->tty->termios, old_termios);
sierra_send_setup(port);
}
static int sierra_tiocmget(struct usb_serial_port *port, struct file *file)
static int sierra_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
unsigned int value;
struct sierra_port_private *portdata;
@ -325,9 +311,10 @@ static int sierra_tiocmget(struct usb_serial_port *port, struct file *file)
return value;
}
static int sierra_tiocmset(struct usb_serial_port *port, struct file *file,
static int sierra_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct sierra_port_private *portdata;
portdata = usb_get_serial_port_data(port);
@ -341,13 +328,7 @@ static int sierra_tiocmset(struct usb_serial_port *port, struct file *file,
portdata->rts_state = 0;
if (clear & TIOCM_DTR)
portdata->dtr_state = 0;
return sierra_send_setup(port);
}
static int sierra_ioctl(struct usb_serial_port *port, struct file *file,
unsigned int cmd, unsigned long arg)
{
return -ENOIOCTLCMD;
return sierra_send_setup(tty, port);
}
static void sierra_outdat_callback(struct urb *urb)
@ -374,8 +355,8 @@ static void sierra_outdat_callback(struct urb *urb)
}
/* Write */
static int sierra_write(struct usb_serial_port *port,
const unsigned char *buf, int count)
static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
struct sierra_port_private *portdata = usb_get_serial_port_data(port);
struct usb_serial *serial = port->serial;
@ -463,7 +444,7 @@ static void sierra_indat_callback(struct urb *urb)
dbg("%s: nonzero status: %d on endpoint %02x.",
__func__, status, endpoint);
} else {
tty = port->tty;
tty = port->port.tty;
if (urb->actual_length) {
tty_buffer_request_room(tty, urb->actual_length);
tty_insert_flip_string(tty, data, urb->actual_length);
@ -473,7 +454,7 @@ static void sierra_indat_callback(struct urb *urb)
}
/* Resubmit urb so we continue receiving */
if (port->open_count && status != -ESHUTDOWN) {
if (port->port.count && status != -ESHUTDOWN) {
err = usb_submit_urb(urb, GFP_ATOMIC);
if (err)
dev_err(&port->dev, "resubmit read urb failed."
@ -517,9 +498,9 @@ static void sierra_instat_callback(struct urb *urb)
portdata->dsr_state = ((signals & 0x02) ? 1 : 0);
portdata->ri_state = ((signals & 0x08) ? 1 : 0);
if (port->tty && !C_CLOCAL(port->tty) &&
if (port->port.tty && !C_CLOCAL(port->port.tty) &&
old_dcd_state && !portdata->dcd_state)
tty_hangup(port->tty);
tty_hangup(port->port.tty);
} else {
dbg("%s: type %x req %x", __func__,
req_pkt->bRequestType, req_pkt->bRequest);
@ -537,8 +518,9 @@ static void sierra_instat_callback(struct urb *urb)
}
}
static int sierra_write_room(struct usb_serial_port *port)
static int sierra_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct sierra_port_private *portdata = usb_get_serial_port_data(port);
unsigned long flags;
@ -557,22 +539,8 @@ static int sierra_write_room(struct usb_serial_port *port)
return 2048;
}
static int sierra_chars_in_buffer(struct usb_serial_port *port)
{
dbg("%s - port %d", __func__, port->number);
/*
* We can't really account for how much data we
* have sent out, but hasn't made it through to the
* device as we can't see the backend here, so just
* tell the tty layer that everything is flushed.
*
* FIXME: should walk the outstanding urbs info
*/
return 0;
}
static int sierra_open(struct usb_serial_port *port, struct file *filp)
static int sierra_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct sierra_port_private *portdata;
struct usb_serial *serial = port->serial;
@ -612,9 +580,10 @@ static int sierra_open(struct usb_serial_port *port, struct file *filp)
}
}
port->tty->low_latency = 1;
if (tty)
tty->low_latency = 1;
sierra_send_setup(port);
sierra_send_setup(tty, port);
/* start up the interrupt endpoint if we have one */
if (port->interrupt_in_urb) {
@ -626,7 +595,8 @@ static int sierra_open(struct usb_serial_port *port, struct file *filp)
return 0;
}
static void sierra_close(struct usb_serial_port *port, struct file *filp)
static void sierra_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
int i;
struct usb_serial *serial = port->serial;
@ -641,7 +611,7 @@ static void sierra_close(struct usb_serial_port *port, struct file *filp)
if (serial->dev) {
mutex_lock(&serial->disc_mutex);
if (!serial->disconnected)
sierra_send_setup(port);
sierra_send_setup(tty, port);
mutex_unlock(&serial->disc_mutex);
/* Stop reading/writing urbs */
@ -651,7 +621,7 @@ static void sierra_close(struct usb_serial_port *port, struct file *filp)
usb_kill_urb(port->interrupt_in_urb);
port->tty = NULL;
port->port.tty = NULL; /* FIXME */
}
static int sierra_startup(struct usb_serial *serial)
@ -754,12 +724,7 @@ static struct usb_serial_driver sierra_device = {
.close = sierra_close,
.write = sierra_write,
.write_room = sierra_write_room,
.chars_in_buffer = sierra_chars_in_buffer,
.throttle = sierra_rx_throttle,
.unthrottle = sierra_rx_unthrottle,
.ioctl = sierra_ioctl,
.set_termios = sierra_set_termios,
.break_ctl = sierra_break_ctl,
.tiocmget = sierra_tiocmget,
.tiocmset = sierra_tiocmset,
.attach = sierra_startup,

69
drivers/usb/serial/spcp8x5.c
View File

@ -448,7 +448,8 @@ static void spcp8x5_set_workMode(struct usb_device *dev, u16 value,
/* close the serial port. We should wait for data sending to device 1st and
* then kill all urb. */
static void spcp8x5_close(struct usb_serial_port *port, struct file *filp)
static void spcp8x5_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct spcp8x5_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -464,7 +465,7 @@ static void spcp8x5_close(struct usb_serial_port *port, struct file *filp)
spin_lock_irqsave(&priv->lock, flags);
timeout = SPCP8x5_CLOSING_WAIT;
init_waitqueue_entry(&wait, current);
add_wait_queue(&port->tty->write_wait, &wait);
add_wait_queue(&tty->write_wait, &wait);
for (;;) {
set_current_state(TASK_INTERRUPTIBLE);
if (ringbuf_avail_data(priv->buf) == 0 ||
@ -475,7 +476,7 @@ static void spcp8x5_close(struct usb_serial_port *port, struct file *filp)
spin_lock_irqsave(&priv->lock, flags);
}
set_current_state(TASK_RUNNING);
remove_wait_queue(&port->tty->write_wait, &wait);
remove_wait_queue(&tty->write_wait, &wait);
/* clear out any remaining data in the buffer */
clear_ringbuf(priv->buf);
@ -486,7 +487,7 @@ static void spcp8x5_close(struct usb_serial_port *port, struct file *filp)
* 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) */
bps = tty_get_baud_rate(port->tty);
bps = tty_get_baud_rate(tty);
if (bps > 1200)
timeout = max((HZ*2560) / bps, HZ/10);
else
@ -495,8 +496,8 @@ static void spcp8x5_close(struct usb_serial_port *port, struct file *filp)
schedule_timeout(timeout);
/* clear control lines */
if (port->tty) {
c_cflag = port->tty->termios->c_cflag;
if (tty) {
c_cflag = tty->termios->c_cflag;
if (c_cflag & HUPCL) {
spin_lock_irqsave(&priv->lock, flags);
priv->line_control = 0;
@ -518,14 +519,14 @@ static void spcp8x5_close(struct usb_serial_port *port, struct file *filp)
}
/* set the serial param for transfer. we should check if we really need to
* transfer. then if be set flow contorl we should do this too. */
static void spcp8x5_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios)
* transfer. if we set flow control we should do this too. */
static void spcp8x5_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
struct usb_serial *serial = port->serial;
struct spcp8x5_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
unsigned int cflag = port->tty->termios->c_cflag;
unsigned int cflag = tty->termios->c_cflag;
unsigned int old_cflag = old_termios->c_cflag;
unsigned short uartdata;
unsigned char buf[2] = {0, 0};
@ -533,21 +534,19 @@ static void spcp8x5_set_termios(struct usb_serial_port *port,
int i;
u8 control;
if ((!port->tty) || (!port->tty->termios))
return;
/* for the 1st time call this function */
spin_lock_irqsave(&priv->lock, flags);
if (!priv->termios_initialized) {
*(port->tty->termios) = tty_std_termios;
port->tty->termios->c_cflag = B115200 | CS8 | CREAD |
HUPCL | CLOCAL;
*(tty->termios) = tty_std_termios;
tty->termios->c_cflag = B115200 | CS8 | CREAD | HUPCL | CLOCAL;
tty->termios->c_ispeed = 115200;
tty->termios->c_ospeed = 115200;
priv->termios_initialized = 1;
}
spin_unlock_irqrestore(&priv->lock, flags);
/* check that they really want us to change something */
if (!tty_termios_hw_change(port->tty->termios, old_termios))
if (!tty_termios_hw_change(tty->termios, old_termios))
return;
/* set DTR/RTS active */
@ -567,7 +566,7 @@ static void spcp8x5_set_termios(struct usb_serial_port *port,
}
/* Set Baud Rate */
baud = tty_get_baud_rate(port->tty);;
baud = tty_get_baud_rate(tty);;
switch (baud) {
case 300: buf[0] = 0x00; break;
case 600: buf[0] = 0x01; break;
@ -643,7 +642,8 @@ static void spcp8x5_set_termios(struct usb_serial_port *port,
/* open the serial port. do some usb system call. set termios and get the line
* status of the device. then submit the read urb */
static int spcp8x5_open(struct usb_serial_port *port, struct file *filp)
static int spcp8x5_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
struct ktermios tmp_termios;
struct usb_serial *serial = port->serial;
@ -665,7 +665,7 @@ static int spcp8x5_open(struct usb_serial_port *port, struct file *filp)
return ret;
spin_lock_irqsave(&priv->lock, flags);
if (port->tty->termios->c_cflag & CBAUD)
if (tty && (tty->termios->c_cflag & CBAUD))
priv->line_control = MCR_DTR | MCR_RTS;
else
priv->line_control = 0;
@ -674,8 +674,8 @@ static int spcp8x5_open(struct usb_serial_port *port, struct file *filp)
spcp8x5_set_ctrlLine(serial->dev, priv->line_control , priv->type);
/* Setup termios */
if (port->tty)
spcp8x5_set_termios(port, &tmp_termios);
if (tty)
spcp8x5_set_termios(tty, port, &tmp_termios);
spcp8x5_get_msr(serial->dev, &status, priv->type);
@ -690,7 +690,7 @@ static int spcp8x5_open(struct usb_serial_port *port, struct file *filp)
port->read_urb->dev = serial->dev;
ret = usb_submit_urb(port->read_urb, GFP_KERNEL);
if (ret) {
spcp8x5_close(port, NULL);
spcp8x5_close(tty, port, NULL);
return -EPROTO;
}
return 0;
@ -717,7 +717,7 @@ static void spcp8x5_read_bulk_callback(struct urb *urb)
/* check the urb status */
if (urb->status) {
if (!port->open_count)
if (!port->port.count)
return;
if (urb->status == -EPROTO) {
/* spcp8x5 mysteriously fails with -EPROTO */
@ -755,7 +755,7 @@ static void spcp8x5_read_bulk_callback(struct urb *urb)
tty_flag = TTY_FRAME;
dev_dbg(&port->dev, "tty_flag = %d\n", tty_flag);
tty = port->tty;
tty = port->port.tty;
if (tty && urb->actual_length) {
tty_buffer_request_room(tty, urb->actual_length + 1);
/* overrun is special, not associated with a char */
@ -767,7 +767,7 @@ static void spcp8x5_read_bulk_callback(struct urb *urb)
}
/* Schedule the next read _if_ we are still open */
if (port->open_count) {
if (port->port.count) {
urb->dev = port->serial->dev;
result = usb_submit_urb(urb , GFP_ATOMIC);
if (result)
@ -866,7 +866,7 @@ static void spcp8x5_write_bulk_callback(struct urb *urb)
}
/* write data to ring buffer. and then start the write transfer */
static int spcp8x5_write(struct usb_serial_port *port,
static int spcp8x5_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
struct spcp8x5_private *priv = usb_get_serial_port_data(port);
@ -925,9 +925,10 @@ static int spcp8x5_wait_modem_info(struct usb_serial_port *port,
return 0;
}
static int spcp8x5_ioctl(struct usb_serial_port *port, struct file *file,
static int spcp8x5_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
switch (cmd) {
@ -943,9 +944,10 @@ static int spcp8x5_ioctl(struct usb_serial_port *port, struct file *file,
return -ENOIOCTLCMD;
}
static int spcp8x5_tiocmset(struct usb_serial_port *port, struct file *file,
static int spcp8x5_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct spcp8x5_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
u8 control;
@ -965,8 +967,9 @@ static int spcp8x5_tiocmset(struct usb_serial_port *port, struct file *file,
return spcp8x5_set_ctrlLine(port->serial->dev, control , priv->type);
}
static int spcp8x5_tiocmget(struct usb_serial_port *port, struct file *file)
static int spcp8x5_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct spcp8x5_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
unsigned int mcr;
@ -989,8 +992,9 @@ static int spcp8x5_tiocmget(struct usb_serial_port *port, struct file *file)
}
/* get the avail space room in ring buffer */
static int spcp8x5_write_room(struct usb_serial_port *port)
static int spcp8x5_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct spcp8x5_private *priv = usb_get_serial_port_data(port);
int room = 0;
unsigned long flags;
@ -1003,8 +1007,9 @@ static int spcp8x5_write_room(struct usb_serial_port *port)
}
/* get the number of avail data in write ring buffer */
static int spcp8x5_chars_in_buffer(struct usb_serial_port *port)
static int spcp8x5_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct spcp8x5_private *priv = usb_get_serial_port_data(port);
int chars = 0;
unsigned long flags;

203
drivers/usb/serial/ti_usb_3410_5052.c
View File

@ -70,6 +70,7 @@
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/firmware.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/tty.h>
@ -149,21 +150,23 @@ struct ti_device {
static int ti_startup(struct usb_serial *serial);
static void ti_shutdown(struct usb_serial *serial);
static int ti_open(struct usb_serial_port *port, struct file *file);
static void ti_close(struct usb_serial_port *port, struct file *file);
static int ti_write(struct usb_serial_port *port, const unsigned char *data,
int count);
static int ti_write_room(struct usb_serial_port *port);
static int ti_chars_in_buffer(struct usb_serial_port *port);
static void ti_throttle(struct usb_serial_port *port);
static void ti_unthrottle(struct usb_serial_port *port);
static int ti_ioctl(struct usb_serial_port *port, struct file *file, unsigned int cmd, unsigned long arg);
static void ti_set_termios(struct usb_serial_port *port,
static int ti_open(struct tty_struct *tty, struct usb_serial_port *port,
struct file *file);
static void ti_close(struct tty_struct *tty, struct usb_serial_port *port,
struct file *file);
static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *data, int count);
static int ti_write_room(struct tty_struct *tty);
static int ti_chars_in_buffer(struct tty_struct *tty);
static void ti_throttle(struct tty_struct *tty);
static void ti_unthrottle(struct tty_struct *tty);
static int ti_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg);
static void ti_set_termios(struct tty_struct *tty, struct usb_serial_port *port,
struct ktermios *old_termios);
static int ti_tiocmget(struct usb_serial_port *port, struct file *file);
static int ti_tiocmset(struct usb_serial_port *port, struct file *file,
static int ti_tiocmget(struct tty_struct *tty, struct file *file);
static int ti_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear);
static void ti_break(struct usb_serial_port *port, int break_state);
static void ti_break(struct tty_struct *tty, int break_state);
static void ti_interrupt_callback(struct urb *urb);
static void ti_bulk_in_callback(struct urb *urb);
static void ti_bulk_out_callback(struct urb *urb);
@ -192,8 +195,7 @@ static int ti_command_in_sync(struct ti_device *tdev, __u8 command,
static int ti_write_byte(struct ti_device *tdev, unsigned long addr,
__u8 mask, __u8 byte);
static int ti_download_firmware(struct ti_device *tdev, char *fw_name);
static int ti_download_firmware(struct ti_device *tdev, int type);
/* circular buffer */
static struct circ_buf *ti_buf_alloc(void);
@ -430,11 +432,10 @@ static int ti_startup(struct usb_serial *serial)
/* if we have only 1 configuration, download firmware */
if (dev->descriptor.bNumConfigurations == 1) {
if (tdev->td_is_3410)
status = ti_download_firmware(tdev, "ti_3410.fw");
status = ti_download_firmware(tdev, 3410);
else
status = ti_download_firmware(tdev, "ti_5052.fw");
status = ti_download_firmware(tdev, 5052);
if (status)
goto free_tdev;
@ -519,7 +520,8 @@ static void ti_shutdown(struct usb_serial *serial)
}
static int ti_open(struct usb_serial_port *port, struct file *file)
static int ti_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *file)
{
struct ti_port *tport = usb_get_serial_port_data(port);
struct ti_device *tdev;
@ -543,9 +545,9 @@ static int ti_open(struct usb_serial_port *port, struct file *file)
if (mutex_lock_interruptible(&tdev->td_open_close_lock))
return -ERESTARTSYS;
if (port->tty)
port->tty->low_latency =
(tport->tp_flags & ASYNC_LOW_LATENCY) ? 1 : 0;
if (tty)
tty->low_latency =
(tport->tp_flags & ASYNC_LOW_LATENCY) ? 1 : 0;
port_number = port->number - port->serial->minor;
@ -573,7 +575,8 @@ static int ti_open(struct usb_serial_port *port, struct file *file)
}
}
ti_set_termios(port, port->tty->termios);
if (tty)
ti_set_termios(tty, port, tty->termios);
dbg("%s - sending TI_OPEN_PORT", __func__);
status = ti_command_out_sync(tdev, TI_OPEN_PORT,
@ -610,7 +613,8 @@ static int ti_open(struct usb_serial_port *port, struct file *file)
usb_clear_halt(dev, port->write_urb->pipe);
usb_clear_halt(dev, port->read_urb->pipe);
ti_set_termios(port, port->tty->termios);
if (tty)
ti_set_termios(tty, port, tty->termios);
dbg("%s - sending TI_OPEN_PORT (2)", __func__);
status = ti_command_out_sync(tdev, TI_OPEN_PORT,
@ -661,7 +665,8 @@ release_lock:
}
static void ti_close(struct usb_serial_port *port, struct file *file)
static void ti_close(struct tty_struct *tty, struct usb_serial_port *port,
struct file *file)
{
struct ti_device *tdev;
struct ti_port *tport;
@ -707,8 +712,8 @@ static void ti_close(struct usb_serial_port *port, struct file *file)
}
static int ti_write(struct usb_serial_port *port, const unsigned char *data,
int count)
static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *data, int count)
{
struct ti_port *tport = usb_get_serial_port_data(port);
unsigned long flags;
@ -733,8 +738,9 @@ static int ti_write(struct usb_serial_port *port, const unsigned char *data,
}
static int ti_write_room(struct usb_serial_port *port)
static int ti_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct ti_port *tport = usb_get_serial_port_data(port);
int room = 0;
unsigned long flags;
@ -753,8 +759,9 @@ static int ti_write_room(struct usb_serial_port *port)
}
static int ti_chars_in_buffer(struct usb_serial_port *port)
static int ti_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct ti_port *tport = usb_get_serial_port_data(port);
int chars = 0;
unsigned long flags;
@ -773,32 +780,26 @@ static int ti_chars_in_buffer(struct usb_serial_port *port)
}
static void ti_throttle(struct usb_serial_port *port)
static void ti_throttle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct ti_port *tport = usb_get_serial_port_data(port);
struct tty_struct *tty;
dbg("%s - port %d", __func__, port->number);
if (tport == NULL)
return;
tty = port->tty;
if (!tty) {
dbg("%s - no tty", __func__);
return;
}
if (I_IXOFF(tty) || C_CRTSCTS(tty))
ti_stop_read(tport, tty);
}
static void ti_unthrottle(struct usb_serial_port *port)
static void ti_unthrottle(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct ti_port *tport = usb_get_serial_port_data(port);
struct tty_struct *tty;
int status;
dbg("%s - port %d", __func__, port->number);
@ -806,12 +807,6 @@ static void ti_unthrottle(struct usb_serial_port *port)
if (tport == NULL)
return;
tty = port->tty;
if (!tty) {
dbg("%s - no tty", __func__);
return;
}
if (I_IXOFF(tty) || C_CRTSCTS(tty)) {
status = ti_restart_read(tport, tty);
if (status)
@ -820,9 +815,10 @@ static void ti_unthrottle(struct usb_serial_port *port)
}
static int ti_ioctl(struct usb_serial_port *port, struct file *file,
static int ti_ioctl(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
struct ti_port *tport = usb_get_serial_port_data(port);
struct async_icount cnow;
struct async_icount cprev;
@ -875,11 +871,10 @@ static int ti_ioctl(struct usb_serial_port *port, struct file *file,
}
static void ti_set_termios(struct usb_serial_port *port,
struct ktermios *old_termios)
static void ti_set_termios(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old_termios)
{
struct ti_port *tport = usb_get_serial_port_data(port);
struct tty_struct *tty = port->tty;
struct ti_uart_config *config;
tcflag_t cflag,iflag;
int baud;
@ -1008,8 +1003,9 @@ static void ti_set_termios(struct usb_serial_port *port,
}
static int ti_tiocmget(struct usb_serial_port *port, struct file *file)
static int ti_tiocmget(struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct ti_port *tport = usb_get_serial_port_data(port);
unsigned int result;
unsigned int msr;
@ -1040,9 +1036,10 @@ static int ti_tiocmget(struct usb_serial_port *port, struct file *file)
}
static int ti_tiocmset(struct usb_serial_port *port, struct file *file,
static int ti_tiocmset(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct ti_port *tport = usb_get_serial_port_data(port);
unsigned int mcr;
unsigned long flags;
@ -1074,8 +1071,9 @@ static int ti_tiocmset(struct usb_serial_port *port, struct file *file,
}
static void ti_break(struct usb_serial_port *port, int break_state)
static void ti_break(struct tty_struct *tty, int break_state)
{
struct usb_serial_port *port = tty->driver_data;
struct ti_port *tport = usb_get_serial_port_data(port);
int status;
@ -1213,14 +1211,14 @@ static void ti_bulk_in_callback(struct urb *urb)
return;
}
if (port->tty && urb->actual_length) {
if (port->port.tty && urb->actual_length) {
usb_serial_debug_data(debug, dev, __func__,
urb->actual_length, urb->transfer_buffer);
if (!tport->tp_is_open)
dbg("%s - port closed, dropping data", __func__);
else
ti_recv(&urb->dev->dev, port->tty, urb->transfer_buffer,
ti_recv(&urb->dev->dev, port->port.tty, urb->transfer_buffer,
urb->actual_length);
spin_lock(&tport->tp_lock);
@ -1302,7 +1300,7 @@ static void ti_send(struct ti_port *tport)
{
int count, result;
struct usb_serial_port *port = tport->tp_port;
struct tty_struct *tty = port->tty;
struct tty_struct *tty = port->port.tty; /* FIXME */
unsigned long flags;
@ -1442,8 +1440,9 @@ static int ti_set_serial_info(struct ti_port *tport,
return -EFAULT;
tport->tp_flags = new_serial.flags & TI_SET_SERIAL_FLAGS;
if (port->tty)
port->tty->low_latency =
/* FIXME */
if (port->port.tty)
port->port.tty->low_latency =
(tport->tp_flags & ASYNC_LOW_LATENCY) ? 1 : 0;
tport->tp_closing_wait = new_serial.closing_wait;
@ -1477,7 +1476,7 @@ static void ti_handle_new_msr(struct ti_port *tport, __u8 msr)
tport->tp_msr = msr & TI_MSR_MASK;
/* handle CTS flow control */
tty = tport->tp_port->tty;
tty = tport->tp_port->port.tty;
if (tty && C_CRTSCTS(tty)) {
if (msr & TI_MSR_CTS) {
tty->hw_stopped = 0;
@ -1655,65 +1654,65 @@ static int ti_write_byte(struct ti_device *tdev, unsigned long addr,
return status;
}
static int ti_download_firmware(struct ti_device *tdev,
char *fw_name)
static int ti_do_download(struct usb_device *dev, int pipe,
u8 *buffer, int size)
{
const struct firmware *fw;
int status = 0;
int buffer_size;
int pos;
int len;
u8 cs = 0;
int done;
__u8 cs = 0;
__u8 *buffer;
struct usb_device *dev = tdev->td_serial->dev;
struct ti_firmware_header *header;
unsigned int pipe = usb_sndbulkpipe(dev,
tdev->td_serial->port[0]->bulk_out_endpointAddress);
buffer_size = TI_FIRMWARE_BUF_SIZE + sizeof(struct ti_firmware_header);
if (request_firmware(&fw, fw_name, &dev->dev)) {
dev_err(&dev->dev, "%s - failed to load firmware \"%s\"\n",
__func__, fw_name);
return -ENOENT;
}
if (fw->size > buffer_size) {
dev_err(&dev->dev, "%s - firmware \"%s\" is too large\n",
__func__, fw_name);
release_firmware(fw);
return -EINVAL;
}
buffer = kmalloc(buffer_size, GFP_KERNEL);
if (!buffer) {
dev_err(&dev->dev, "%s - out of memory\n", __func__);
release_firmware(fw);
return -ENOMEM;
}
memcpy(buffer, fw->data, fw->size);
memset(buffer+fw->size, 0xff, buffer_size-fw->size);
for(pos = sizeof(struct ti_firmware_header); pos < buffer_size; pos++)
int status;
int len;
for(pos = sizeof(struct ti_firmware_header); pos < size; pos++)
cs = (__u8)(cs + buffer[pos]);
header = (struct ti_firmware_header *)buffer;
header->wLength = cpu_to_le16((__u16)(buffer_size - sizeof(struct ti_firmware_header)));
header->wLength = cpu_to_le16((__u16)(size
- sizeof(struct ti_firmware_header)));
header->bCheckSum = cs;
dbg("%s - downloading firmware", __func__);
for (pos = 0; pos < buffer_size; pos += done) {
len = min(buffer_size - pos, TI_DOWNLOAD_MAX_PACKET_SIZE);
status = usb_bulk_msg(dev, pipe, buffer+pos, len, &done, 1000);
for (pos = 0; pos < size; pos += done) {
len = min(size - pos, TI_DOWNLOAD_MAX_PACKET_SIZE);
status = usb_bulk_msg(dev, pipe, buffer + pos, len,
&done, 1000);
if (status)
break;
}
return status;
}
kfree(buffer);
release_firmware(fw);
static int ti_download_firmware(struct ti_device *tdev, int type)
{
int status = -ENOMEM;
int buffer_size;
__u8 *buffer;
struct usb_device *dev = tdev->td_serial->dev;
unsigned int pipe = usb_sndbulkpipe(dev,
tdev->td_serial->port[0]->bulk_out_endpointAddress);
const struct firmware *fw_p;
char buf[32];
sprintf(buf, "ti_usb-%d.bin", type);
if (request_firmware(&fw_p, buf, &dev->dev)) {
dev_err(&dev->dev, "%s - firmware not found\n", __func__);
return -ENOENT;
}
if (fw_p->size > TI_FIRMWARE_BUF_SIZE) {
dev_err(&dev->dev, "%s - firmware too large\n", __func__);
return -ENOENT;
}
buffer_size = TI_FIRMWARE_BUF_SIZE + sizeof(struct ti_firmware_header);
buffer = kmalloc(buffer_size, GFP_KERNEL);
if (buffer) {
memcpy(buffer, fw_p->data, fw_p->size);
memset(buffer + fw_p->size, 0xff, buffer_size - fw_p->size);
ti_do_download(dev, pipe, buffer, fw_p->size);
kfree(buffer);
}
release_firmware(fw_p);
if (status) {
dev_err(&dev->dev, "%s - error downloading firmware, %d\n", __func__, status);
return status;

82
drivers/usb/serial/usb-serial.c
View File

@ -143,7 +143,7 @@ static void destroy_serial(struct kref *kref)
return_serial(serial);
for (i = 0; i < serial->num_ports; ++i)
serial->port[i]->open_count = 0;
serial->port[i]->port.count = 0;
/* the ports are cleaned up and released in port_release() */
for (i = 0; i < serial->num_ports; ++i)
@ -208,14 +208,14 @@ static int serial_open (struct tty_struct *tty, struct file * filp)
goto bailout_kref_put;
}
++port->open_count;
++port->port.count;
/* set up our port structure making the tty driver
* remember our port object, and us it */
tty->driver_data = port;
port->tty = tty;
port->port.tty = tty;
if (port->open_count == 1) {
if (port->port.count == 1) {
/* lock this module before we call it
* this may fail, which means we must bail out,
@ -230,7 +230,7 @@ static int serial_open (struct tty_struct *tty, struct file * filp)
goto bailout_module_put;
/* only call the device specific open if this
* is the first time the port is opened */
retval = serial->type->open(port, filp);
retval = serial->type->open(tty, port, filp);
if (retval)
goto bailout_interface_put;
}
@ -243,9 +243,9 @@ bailout_interface_put:
bailout_module_put:
module_put(serial->type->driver.owner);
bailout_mutex_unlock:
port->open_count = 0;
port->port.count = 0;
tty->driver_data = NULL;
port->tty = NULL;
port->port.tty = NULL;
mutex_unlock(&port->mutex);
bailout_kref_put:
usb_serial_put(serial);
@ -263,26 +263,26 @@ static void serial_close(struct tty_struct *tty, struct file * filp)
mutex_lock(&port->mutex);
if (port->open_count == 0) {
if (port->port.count == 0) {
mutex_unlock(&port->mutex);
return;
}
--port->open_count;
if (port->open_count == 0)
--port->port.count;
if (port->port.count == 0)
/* only call the device specific close if this
* port is being closed by the last owner */
port->serial->type->close(port, filp);
port->serial->type->close(tty, port, filp);
if (port->open_count == (port->console? 1 : 0)) {
if (port->tty) {
if (port->tty->driver_data)
port->tty->driver_data = NULL;
port->tty = NULL;
if (port->port.count == (port->console? 1 : 0)) {
if (port->port.tty) {
if (port->port.tty->driver_data)
port->port.tty->driver_data = NULL;
port->port.tty = NULL;
}
}
if (port->open_count == 0) {
if (port->port.count == 0) {
mutex_lock(&port->serial->disc_mutex);
if (!port->serial->disconnected)
usb_autopm_put_interface(port->serial->interface);
@ -304,12 +304,12 @@ static int serial_write (struct tty_struct * tty, const unsigned char *buf, int
dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
/* open_count is managed under the mutex lock for the tty so cannot
/* count is managed under the mutex lock for the tty so cannot
drop to zero until after the last close completes */
WARN_ON(!port->open_count);
WARN_ON(!port->port.count);
/* pass on to the driver specific version of this function */
retval = port->serial->type->write(port, buf, count);
retval = port->serial->type->write(tty, port, buf, count);
exit:
return retval;
@ -319,9 +319,9 @@ static int serial_write_room (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
dbg("%s - port %d", __func__, port->number);
WARN_ON(!port->open_count);
WARN_ON(!port->port.count);
/* pass on to the driver specific version of this function */
return port->serial->type->write_room(port);
return port->serial->type->write_room(tty);
}
static int serial_chars_in_buffer (struct tty_struct *tty)
@ -329,9 +329,9 @@ static int serial_chars_in_buffer (struct tty_struct *tty)
struct usb_serial_port *port = tty->driver_data;
dbg("%s = port %d", __func__, port->number);
WARN_ON(!port->open_count);
WARN_ON(!port->port.count);
/* pass on to the driver specific version of this function */
return port->serial->type->chars_in_buffer(port);
return port->serial->type->chars_in_buffer(tty);
}
static void serial_throttle (struct tty_struct * tty)
@ -339,10 +339,10 @@ static void serial_throttle (struct tty_struct * tty)
struct usb_serial_port *port = tty->driver_data;
dbg("%s - port %d", __func__, port->number);
WARN_ON(!port->open_count);
WARN_ON(!port->port.count);
/* pass on to the driver specific version of this function */
if (port->serial->type->throttle)
port->serial->type->throttle(port);
port->serial->type->throttle(tty);
}
static void serial_unthrottle (struct tty_struct * tty)
@ -350,10 +350,10 @@ static void serial_unthrottle (struct tty_struct * tty)
struct usb_serial_port *port = tty->driver_data;
dbg("%s - port %d", __func__, port->number);
WARN_ON(!port->open_count);
WARN_ON(!port->port.count);
/* pass on to the driver specific version of this function */
if (port->serial->type->unthrottle)
port->serial->type->unthrottle(port);
port->serial->type->unthrottle(tty);
}
static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
@ -363,12 +363,12 @@ static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned in
dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
WARN_ON(!port->open_count);
WARN_ON(!port->port.count);
/* pass on to the driver specific version of this function if it is available */
if (port->serial->type->ioctl) {
lock_kernel();
retval = port->serial->type->ioctl(port, file, cmd, arg);
retval = port->serial->type->ioctl(tty, file, cmd, arg);
unlock_kernel();
}
else
@ -381,10 +381,10 @@ static void serial_set_termios (struct tty_struct *tty, struct ktermios * old)
struct usb_serial_port *port = tty->driver_data;
dbg("%s - port %d", __func__, port->number);
WARN_ON(!port->open_count);
WARN_ON(!port->port.count);
/* pass on to the driver specific version of this function if it is available */
if (port->serial->type->set_termios)
port->serial->type->set_termios(port, old);
port->serial->type->set_termios(tty, port, old);
else
tty_termios_copy_hw(tty->termios, old);
}
@ -395,11 +395,11 @@ static void serial_break (struct tty_struct *tty, int break_state)
dbg("%s - port %d", __func__, port->number);
WARN_ON(!port->open_count);
WARN_ON(!port->port.count);
/* pass on to the driver specific version of this function if it is available */
if (port->serial->type->break_ctl) {
lock_kernel();
port->serial->type->break_ctl(port, break_state);
port->serial->type->break_ctl(tty, break_state);
unlock_kernel();
}
}
@ -457,9 +457,9 @@ static int serial_tiocmget (struct tty_struct *tty, struct file *file)
dbg("%s - port %d", __func__, port->number);
WARN_ON(!port->open_count);
WARN_ON(!port->port.count);
if (port->serial->type->tiocmget)
return port->serial->type->tiocmget(port, file);
return port->serial->type->tiocmget(tty, file);
return -EINVAL;
}
@ -470,9 +470,9 @@ static int serial_tiocmset (struct tty_struct *tty, struct file *file,
dbg("%s - port %d", __func__, port->number);
WARN_ON(!port->open_count);
WARN_ON(!port->port.count);
if (port->serial->type->tiocmset)
return port->serial->type->tiocmset(port, file, set, clear);
return port->serial->type->tiocmset(tty, file, set, clear);
return -EINVAL;
}
@ -497,7 +497,7 @@ static void usb_serial_port_work(struct work_struct *work)
if (!port)
return;
tty = port->tty;
tty = port->port.tty;
if (!tty)
return;
@ -1010,8 +1010,8 @@ void usb_serial_disconnect(struct usb_interface *interface)
for (i = 0; i < serial->num_ports; ++i) {
port = serial->port[i];
if (port) {
if (port->tty)
tty_hangup(port->tty);
if (port->port.tty)
tty_hangup(port->port.tty);
kill_traffic(port);
}
}

5
drivers/usb/serial/usb_debug.c
View File

@ -31,10 +31,11 @@ static struct usb_driver debug_driver = {
.no_dynamic_id = 1,
};
int usb_debug_open(struct usb_serial_port *port, struct file *filp)
int usb_debug_open(struct tty_struct *tty, struct usb_serial_port *port,
struct file *filp)
{
port->bulk_out_size = USB_DEBUG_MAX_PACKET_SIZE;
return usb_serial_generic_open(port, filp);
return usb_serial_generic_open(tty, port, filp);
}
static struct usb_serial_driver debug_device = {

66
drivers/usb/serial/visor.c
View File

@ -35,17 +35,15 @@
#define DRIVER_DESC "USB HandSpring Visor / Palm OS driver"
/* function prototypes for a handspring visor */
static int visor_open (struct usb_serial_port *port, struct file *filp);
static void visor_close (struct usb_serial_port *port, struct file *filp);
static int visor_write (struct usb_serial_port *port, const unsigned char *buf, int count);
static int visor_write_room (struct usb_serial_port *port);
static int visor_chars_in_buffer (struct usb_serial_port *port);
static void visor_throttle (struct usb_serial_port *port);
static void visor_unthrottle (struct usb_serial_port *port);
static int visor_open (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static void visor_close (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static int visor_write (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
static int visor_write_room (struct tty_struct *tty);
static void visor_throttle (struct tty_struct *tty);
static void visor_unthrottle (struct tty_struct *tty);
static int visor_probe (struct usb_serial *serial, const struct usb_device_id *id);
static int visor_calc_num_ports(struct usb_serial *serial);
static void visor_shutdown (struct usb_serial *serial);
static int visor_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
static void visor_write_bulk_callback (struct urb *urb);
static void visor_read_bulk_callback (struct urb *urb);
static void visor_read_int_callback (struct urb *urb);
@ -198,10 +196,8 @@ static struct usb_serial_driver handspring_device = {
.probe = visor_probe,
.calc_num_ports = visor_calc_num_ports,
.shutdown = visor_shutdown,
.ioctl = visor_ioctl,
.write = visor_write,
.write_room = visor_write_room,
.chars_in_buffer = visor_chars_in_buffer,
.write_bulk_callback = visor_write_bulk_callback,
.read_bulk_callback = visor_read_bulk_callback,
.read_int_callback = visor_read_int_callback,
@ -225,10 +221,8 @@ static struct usb_serial_driver clie_5_device = {
.probe = visor_probe,
.calc_num_ports = visor_calc_num_ports,
.shutdown = visor_shutdown,
.ioctl = visor_ioctl,
.write = visor_write,
.write_room = visor_write_room,
.chars_in_buffer = visor_chars_in_buffer,
.write_bulk_callback = visor_write_bulk_callback,
.read_bulk_callback = visor_read_bulk_callback,
.read_int_callback = visor_read_int_callback,
@ -249,10 +243,8 @@ static struct usb_serial_driver clie_3_5_device = {
.throttle = visor_throttle,
.unthrottle = visor_unthrottle,
.attach = clie_3_5_startup,
.ioctl = visor_ioctl,
.write = visor_write,
.write_room = visor_write_room,
.chars_in_buffer = visor_chars_in_buffer,
.write_bulk_callback = visor_write_bulk_callback,
.read_bulk_callback = visor_read_bulk_callback,
};
@ -274,7 +266,7 @@ static int stats;
/******************************************************************************
* Handspring Visor specific driver functions
******************************************************************************/
static int visor_open (struct usb_serial_port *port, struct file *filp)
static int visor_open (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial = port->serial;
struct visor_private *priv = usb_get_serial_port_data(port);
@ -300,8 +292,8 @@ static int visor_open (struct usb_serial_port *port, struct file *filp)
* through, otherwise it is scheduled, and with high data rates (like
* with OHCI) data can get lost.
*/
if (port->tty)
port->tty->low_latency = 1;
if (tty)
tty->low_latency = 1;
/* Start reading from the device */
usb_fill_bulk_urb (port->read_urb, serial->dev,
@ -329,7 +321,8 @@ exit:
}
static void visor_close (struct usb_serial_port *port, struct file * filp)
static void visor_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file * filp)
{
struct visor_private *priv = usb_get_serial_port_data(port);
unsigned char *transfer_buffer;
@ -361,7 +354,8 @@ static void visor_close (struct usb_serial_port *port, struct file * filp)
}
static int visor_write (struct usb_serial_port *port, const unsigned char *buf, int count)
static int visor_write(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count)
{
struct visor_private *priv = usb_get_serial_port_data(port);
struct usb_serial *serial = port->serial;
@ -435,8 +429,9 @@ error_no_buffer:
}
static int visor_write_room (struct usb_serial_port *port)
static int visor_write_room (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct visor_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -460,22 +455,6 @@ static int visor_write_room (struct usb_serial_port *port)
}
static int visor_chars_in_buffer (struct usb_serial_port *port)
{
dbg("%s - port %d", __func__, port->number);
/*
* We can't really account for how much data we
* have sent out, but hasn't made it through to the
* device, so just tell the tty layer that everything
* is flushed.
*
* FIXME: Should walk outstanding_urbs
*/
return 0;
}
static void visor_write_bulk_callback (struct urb *urb)
{
struct usb_serial_port *port = urb->context;
@ -520,7 +499,7 @@ static void visor_read_bulk_callback (struct urb *urb)
usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
tty = port->tty;
tty = port->port.tty;
if (tty && urb->actual_length) {
available_room = tty_buffer_request_room(tty, urb->actual_length);
if (available_room) {
@ -591,8 +570,9 @@ exit:
__func__, result);
}
static void visor_throttle (struct usb_serial_port *port)
static void visor_throttle (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct visor_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
@ -603,8 +583,9 @@ static void visor_throttle (struct usb_serial_port *port)
}
static void visor_unthrottle (struct usb_serial_port *port)
static void visor_unthrottle (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct visor_private *priv = usb_get_serial_port_data(port);
unsigned long flags;
int result;
@ -922,13 +903,6 @@ static void visor_shutdown (struct usb_serial *serial)
}
}
static int visor_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
{
dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
return -ENOIOCTLCMD;
}
static int __init visor_init (void)
{
int i, retval;

102
drivers/usb/serial/whiteheat.c
View File

@ -142,18 +142,18 @@ static int whiteheat_firmware_attach (struct usb_serial *serial);
/* function prototypes for the Connect Tech WhiteHEAT serial converter */
static int whiteheat_attach (struct usb_serial *serial);
static void whiteheat_shutdown (struct usb_serial *serial);
static int whiteheat_open (struct usb_serial_port *port, struct file *filp);
static void whiteheat_close (struct usb_serial_port *port, struct file *filp);
static int whiteheat_write (struct usb_serial_port *port, const unsigned char *buf, int count);
static int whiteheat_write_room (struct usb_serial_port *port);
static int whiteheat_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
static void whiteheat_set_termios (struct usb_serial_port *port, struct ktermios * old);
static int whiteheat_tiocmget (struct usb_serial_port *port, struct file *file);
static int whiteheat_tiocmset (struct usb_serial_port *port, struct file *file, unsigned int set, unsigned int clear);
static void whiteheat_break_ctl (struct usb_serial_port *port, int break_state);
static int whiteheat_chars_in_buffer (struct usb_serial_port *port);
static void whiteheat_throttle (struct usb_serial_port *port);
static void whiteheat_unthrottle (struct usb_serial_port *port);
static int whiteheat_open (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static void whiteheat_close (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
static int whiteheat_write (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
static int whiteheat_write_room (struct tty_struct *tty);
static int whiteheat_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg);
static void whiteheat_set_termios (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios * old);
static int whiteheat_tiocmget (struct tty_struct *tty, struct file *file);
static int whiteheat_tiocmset (struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear);
static void whiteheat_break_ctl (struct tty_struct *tty, int break_state);
static int whiteheat_chars_in_buffer (struct tty_struct *tty);
static void whiteheat_throttle (struct tty_struct *tty);
static void whiteheat_unthrottle (struct tty_struct *tty);
static void whiteheat_read_callback (struct urb *urb);
static void whiteheat_write_callback (struct urb *urb);
@ -246,7 +246,7 @@ static void rx_data_softint(struct work_struct *work);
static int firm_send_command(struct usb_serial_port *port, __u8 command, __u8 *data, __u8 datasize);
static int firm_open(struct usb_serial_port *port);
static int firm_close(struct usb_serial_port *port);
static int firm_setup_port(struct usb_serial_port *port);
static int firm_setup_port(struct tty_struct *tty);
static int firm_set_rts(struct usb_serial_port *port, __u8 onoff);
static int firm_set_dtr(struct usb_serial_port *port, __u8 onoff);
static int firm_set_break(struct usb_serial_port *port, __u8 onoff);
@ -613,7 +613,8 @@ static void whiteheat_shutdown (struct usb_serial *serial)
}
static int whiteheat_open (struct usb_serial_port *port, struct file *filp)
static int whiteheat_open (struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp)
{
int retval = 0;
struct ktermios old_term;
@ -624,7 +625,8 @@ static int whiteheat_open (struct usb_serial_port *port, struct file *filp)
if (retval)
goto exit;
port->tty->low_latency = 1;
if (tty)
tty->low_latency = 1;
/* send an open port command */
retval = firm_open(port);
@ -640,9 +642,11 @@ static int whiteheat_open (struct usb_serial_port *port, struct file *filp)
goto exit;
}
old_term.c_cflag = ~port->tty->termios->c_cflag;
old_term.c_iflag = ~port->tty->termios->c_iflag;
whiteheat_set_termios(port, &old_term);
if (tty) {
old_term.c_cflag = ~tty->termios->c_cflag;
old_term.c_iflag = ~tty->termios->c_iflag;
whiteheat_set_termios(tty, port, &old_term);
}
/* Work around HCD bugs */
usb_clear_halt(port->serial->dev, port->read_urb->pipe);
@ -663,7 +667,8 @@ exit:
}
static void whiteheat_close(struct usb_serial_port *port, struct file * filp)
static void whiteheat_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file * filp)
{
struct whiteheat_private *info = usb_get_serial_port_data(port);
struct whiteheat_urb_wrap *wrap;
@ -681,7 +686,7 @@ static void whiteheat_close(struct usb_serial_port *port, struct file * filp)
}
mutex_unlock(&port->serial->disc_mutex);
port->tty->closing = 1;
tty->closing = 1;
/*
* Not currently in use; tty_wait_until_sent() calls
@ -689,12 +694,12 @@ static void whiteheat_close(struct usb_serial_port *port, struct file * filp)
* acquisition. This should be fixed at some point. Greg's been
* notified.
if ((filp->f_flags & (O_NDELAY | O_NONBLOCK)) == 0) {
tty_wait_until_sent(port->tty, CLOSING_DELAY);
tty_wait_until_sent(tty, CLOSING_DELAY);
}
*/
tty_driver_flush_buffer(port->tty);
tty_ldisc_flush(port->tty);
tty_driver_flush_buffer(tty);
tty_ldisc_flush(tty);
firm_report_tx_done(port);
@ -728,11 +733,12 @@ static void whiteheat_close(struct usb_serial_port *port, struct file * filp)
stop_command_port(port->serial);
port->tty->closing = 0;
tty->closing = 0;
}
static int whiteheat_write(struct usb_serial_port *port, const unsigned char *buf, int count)
static int whiteheat_write(struct tty_struct *tty,
struct usb_serial_port *port, const unsigned char *buf, int count)
{
struct usb_serial *serial = port->serial;
struct whiteheat_private *info = usb_get_serial_port_data(port);
@ -791,8 +797,9 @@ static int whiteheat_write(struct usb_serial_port *port, const unsigned char *bu
}
static int whiteheat_write_room(struct usb_serial_port *port)
static int whiteheat_write_room(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct whiteheat_private *info = usb_get_serial_port_data(port);
struct list_head *tmp;
int room = 0;
@ -811,8 +818,9 @@ static int whiteheat_write_room(struct usb_serial_port *port)
}
static int whiteheat_tiocmget (struct usb_serial_port *port, struct file *file)
static int whiteheat_tiocmget (struct tty_struct *tty, struct file *file)
{
struct usb_serial_port *port = tty->driver_data;
struct whiteheat_private *info = usb_get_serial_port_data(port);
unsigned int modem_signals = 0;
@ -828,9 +836,10 @@ static int whiteheat_tiocmget (struct usb_serial_port *port, struct file *file)
}
static int whiteheat_tiocmset (struct usb_serial_port *port, struct file *file,
static int whiteheat_tiocmset (struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear)
{
struct usb_serial_port *port = tty->driver_data;
struct whiteheat_private *info = usb_get_serial_port_data(port);
dbg("%s - port %d", __func__, port->number);
@ -851,8 +860,9 @@ static int whiteheat_tiocmset (struct usb_serial_port *port, struct file *file,
}
static int whiteheat_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
static int whiteheat_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
{
struct usb_serial_port *port = tty->driver_data;
struct serial_struct serstruct;
void __user *user_arg = (void __user *)arg;
@ -896,20 +906,21 @@ static int whiteheat_ioctl (struct usb_serial_port *port, struct file * file, un
}
static void whiteheat_set_termios(struct usb_serial_port *port, struct ktermios *old_termios)
static void whiteheat_set_termios(struct tty_struct *tty, struct usb_serial_port *port, struct ktermios *old_termios)
{
dbg("%s -port %d", __func__, port->number);
firm_setup_port(port);
firm_setup_port(tty);
}
static void whiteheat_break_ctl(struct usb_serial_port *port, int break_state) {
static void whiteheat_break_ctl(struct tty_struct *tty, int break_state) {
struct usb_serial_port *port = tty->driver_data;
firm_set_break(port, break_state);
}
static int whiteheat_chars_in_buffer(struct usb_serial_port *port)
static int whiteheat_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct whiteheat_private *info = usb_get_serial_port_data(port);
struct list_head *tmp;
struct whiteheat_urb_wrap *wrap;
@ -930,8 +941,9 @@ static int whiteheat_chars_in_buffer(struct usb_serial_port *port)
}
static void whiteheat_throttle (struct usb_serial_port *port)
static void whiteheat_throttle (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct whiteheat_private *info = usb_get_serial_port_data(port);
unsigned long flags;
@ -945,8 +957,9 @@ static void whiteheat_throttle (struct usb_serial_port *port)
}
static void whiteheat_unthrottle (struct usb_serial_port *port)
static void whiteheat_unthrottle (struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
struct whiteheat_private *info = usb_get_serial_port_data(port);
int actually_throttled;
unsigned long flags;
@ -1184,9 +1197,10 @@ static int firm_close(struct usb_serial_port *port) {
}
static int firm_setup_port(struct usb_serial_port *port) {
static int firm_setup_port(struct tty_struct *tty) {
struct usb_serial_port *port = tty->driver_data;
struct whiteheat_port_settings port_settings;
unsigned int cflag = port->tty->termios->c_cflag;
unsigned int cflag = tty->termios->c_cflag;
port_settings.port = port->number + 1;
@ -1235,22 +1249,22 @@ static int firm_setup_port(struct usb_serial_port *port) {
(port_settings.hflow & WHITEHEAT_HFLOW_DTR) ? "DTR" : "");
/* determine software flow control */
if (I_IXOFF(port->tty))
if (I_IXOFF(tty))
port_settings.sflow = WHITEHEAT_SFLOW_RXTX;
else
port_settings.sflow = WHITEHEAT_SFLOW_NONE;
dbg("%s - software flow control = %c", __func__, port_settings.sflow);
port_settings.xon = START_CHAR(port->tty);
port_settings.xoff = STOP_CHAR(port->tty);
port_settings.xon = START_CHAR(tty);
port_settings.xoff = STOP_CHAR(tty);
dbg("%s - XON = %2x, XOFF = %2x", __func__, port_settings.xon, port_settings.xoff);
/* get the baud rate wanted */
port_settings.baud = tty_get_baud_rate(port->tty);
port_settings.baud = tty_get_baud_rate(tty);
dbg("%s - baud rate = %d", __func__, port_settings.baud);
/* fixme: should set validated settings */
tty_encode_baud_rate(port->tty, port_settings.baud, port_settings.baud);
tty_encode_baud_rate(tty, port_settings.baud, port_settings.baud);
/* handle any settings that aren't specified in the tty structure */
port_settings.lloop = 0;
@ -1426,7 +1440,7 @@ static void rx_data_softint(struct work_struct *work)
struct whiteheat_private *info =
container_of(work, struct whiteheat_private, rx_work);
struct usb_serial_port *port = info->port;
struct tty_struct *tty = port->tty;
struct tty_struct *tty = port->port.tty;
struct whiteheat_urb_wrap *wrap;
struct urb *urb;
unsigned long flags;

56
include/linux/usb/serial.h
View File

@ -62,7 +62,7 @@
*/
struct usb_serial_port {
struct usb_serial *serial;
struct tty_struct *tty;
struct tty_port port;
spinlock_t lock;
struct mutex mutex;
unsigned char number;
@ -89,7 +89,6 @@ struct usb_serial_port {
wait_queue_head_t write_wait;
struct work_struct work;
int open_count;
char throttled;
char throttle_req;
char console;
@ -217,22 +216,27 @@ struct usb_serial_driver {
int (*resume)(struct usb_serial *serial);
/* serial function calls */
int (*open)(struct usb_serial_port *port, struct file *filp);
void (*close)(struct usb_serial_port *port, struct file *filp);
int (*write)(struct usb_serial_port *port, const unsigned char *buf,
int count);
int (*write_room)(struct usb_serial_port *port);
int (*ioctl)(struct usb_serial_port *port, struct file *file,
/* Called by console with tty = NULL and by tty */
int (*open)(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp);
void (*close)(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp);
int (*write)(struct tty_struct *tty, struct usb_serial_port *port,
const unsigned char *buf, int count);
/* Called only by the tty layer */
int (*write_room)(struct tty_struct *tty);
int (*ioctl)(struct tty_struct *tty, struct file *file,
unsigned int cmd, unsigned long arg);
void (*set_termios)(struct usb_serial_port *port, struct ktermios *old);
void (*break_ctl)(struct usb_serial_port *port, int break_state);
int (*chars_in_buffer)(struct usb_serial_port *port);
void (*throttle)(struct usb_serial_port *port);
void (*unthrottle)(struct usb_serial_port *port);
int (*tiocmget)(struct usb_serial_port *port, struct file *file);
int (*tiocmset)(struct usb_serial_port *port, struct file *file,
void (*set_termios)(struct tty_struct *tty,
struct usb_serial_port *port, struct ktermios *old);
void (*break_ctl)(struct tty_struct *tty, int break_state);
int (*chars_in_buffer)(struct tty_struct *tty);
void (*throttle)(struct tty_struct *tty);
void (*unthrottle)(struct tty_struct *tty);
int (*tiocmget)(struct tty_struct *tty, struct file *file);
int (*tiocmset)(struct tty_struct *tty, struct file *file,
unsigned int set, unsigned int clear);
/* USB events */
void (*read_int_callback)(struct urb *urb);
void (*write_int_callback)(struct urb *urb);
void (*read_bulk_callback)(struct urb *urb);
@ -270,19 +274,19 @@ static inline void usb_serial_console_disconnect(struct usb_serial *serial) {}
/* Functions needed by other parts of the usbserial core */
extern struct usb_serial *usb_serial_get_by_index(unsigned int minor);
extern void usb_serial_put(struct usb_serial *serial);
extern int usb_serial_generic_open(struct usb_serial_port *port,
struct file *filp);
extern int usb_serial_generic_write(struct usb_serial_port *port,
const unsigned char *buf, int count);
extern void usb_serial_generic_close(struct usb_serial_port *port,
struct file *filp);
extern int usb_serial_generic_open(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp);
extern int usb_serial_generic_write(struct tty_struct *tty,
struct usb_serial_port *port, const unsigned char *buf, int count);
extern void usb_serial_generic_close(struct tty_struct *tty,
struct usb_serial_port *port, struct file *filp);
extern int usb_serial_generic_resume(struct usb_serial *serial);
extern int usb_serial_generic_write_room(struct usb_serial_port *port);
extern int usb_serial_generic_chars_in_buffer(struct usb_serial_port *port);
extern int usb_serial_generic_write_room(struct tty_struct *tty);
extern int usb_serial_generic_chars_in_buffer(struct tty_struct *tty);
extern void usb_serial_generic_read_bulk_callback(struct urb *urb);
extern void usb_serial_generic_write_bulk_callback(struct urb *urb);
extern void usb_serial_generic_throttle(struct usb_serial_port *port);
extern void usb_serial_generic_unthrottle(struct usb_serial_port *port);
extern void usb_serial_generic_throttle(struct tty_struct *tty);
extern void usb_serial_generic_unthrottle(struct tty_struct *tty);
extern void usb_serial_generic_shutdown(struct usb_serial *serial);
extern int usb_serial_generic_register(int debug);
extern void usb_serial_generic_deregister(void);