]> pilppa.com Git - linux-2.6-omap-h63xx.git/commitdiff
usb_serial: API all change
authorAlan Cox <alan@redhat.com>
Tue, 22 Jul 2008 10:09:07 +0000 (11:09 +0100)
committerLinus Torvalds <torvalds@linux-foundation.org>
Tue, 22 Jul 2008 20:03:22 +0000 (13:03 -0700)
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>
42 files changed:
drivers/usb/serial/aircable.c
drivers/usb/serial/airprime.c [new file with mode: 0644]
drivers/usb/serial/ark3116.c
drivers/usb/serial/belkin_sa.c
drivers/usb/serial/ch341.c
drivers/usb/serial/console.c
drivers/usb/serial/cp2101.c
drivers/usb/serial/cyberjack.c
drivers/usb/serial/cypress_m8.c
drivers/usb/serial/digi_acceleport.c
drivers/usb/serial/empeg.c
drivers/usb/serial/ftdi_sio.c
drivers/usb/serial/garmin_gps.c
drivers/usb/serial/generic.c
drivers/usb/serial/io_edgeport.c
drivers/usb/serial/io_ti.c
drivers/usb/serial/ipaq.c
drivers/usb/serial/ipw.c
drivers/usb/serial/ir-usb.c
drivers/usb/serial/iuu_phoenix.c
drivers/usb/serial/keyspan.c
drivers/usb/serial/keyspan.h
drivers/usb/serial/keyspan_pda.c
drivers/usb/serial/kl5kusb105.c
drivers/usb/serial/kobil_sct.c
drivers/usb/serial/mct_u232.c
drivers/usb/serial/mos7720.c
drivers/usb/serial/mos7840.c
drivers/usb/serial/navman.c
drivers/usb/serial/omninet.c
drivers/usb/serial/option.c
drivers/usb/serial/oti6858.c
drivers/usb/serial/pl2303.c
drivers/usb/serial/safe_serial.c
drivers/usb/serial/sierra.c
drivers/usb/serial/spcp8x5.c
drivers/usb/serial/ti_usb_3410_5052.c
drivers/usb/serial/usb-serial.c
drivers/usb/serial/usb_debug.c
drivers/usb/serial/visor.c
drivers/usb/serial/whiteheat.c
include/linux/usb/serial.h

index db6f97a93c02c3b813e8feafd17ba6cb2acb1efc..79ea98c66fa8d8c1f91ef2b045e9fc19d52375de 100644 (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;
diff --git a/drivers/usb/serial/airprime.c b/drivers/usb/serial/airprime.c
new file mode 100644 (file)
index 0000000..b3f1d1e
--- /dev/null
@@ -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)");
index 77895c8f8f3189fb774acb59cad0f3f3a324cbad..aec61880f36c0485be60ad6774447937ecc14d42 100644 (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;
index 0a322fc53d6e23694e612eb9184e55d005caad31..1a762692c739c92e9e957f52bce75c03585b4a99 100644 (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);
 }
 
 
index 1f7c86bd8297c85e21a72451c5abed5e647a38a2..f61e3ca64305abb3d7bbefda787c073bb30c77ee 100644 (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()");
index 201184c3fb87ebc271db45d244b44ab884745ef6..940f5de68980715ab000c8d1d9613746a0f4d516 100644 (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;
        }
 }
index 2bc5576c443adfa2f18528740d00a3b16ca56987..46c33fc9f6ce3d2e1c02d79a4502d06c9ef48134 100644 (file)
 /*
  * 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_portport, 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_portport, 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_portport,
+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);
index c164e2cf2752169e65a063e861557cf1d107ba60..546178ea6f2d7da059c600ed715186ff2a779ce2 100644 (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);
index 0230d3c0888af92e816d2d432f60a7171c4f547d..6999d3372d85428627ace1a7e9e94af452bd7564 100644 (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),
index 28bc6fcf44f085b2fc4e1c1cbbef01834a7c4c94..dc92dbfc962e305d7954193be0050fb7bbc2d630 100644 (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)
index c5ec309a3cb1434014a1f4f8df801d047099633f..47ebdf5fad8ebcd043abf55095a0c603111ddfad 100644 (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)
-{
-       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)
+static void empeg_set_termios(struct tty_struct *tty,
+               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);
 }
 
 
index 0ff4a3971e45a95ce0e7047a0e6bb7411646c493..abbb447e53750c714e16ce56123f165d72642316 100644 (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;
index 8ce5a56a48e30ec1da010705a093262993c172bb..06cfa43c6f020a884658bf79482938cce4e15df7 100644 (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,
index 537f12a027c224e2a2253224ae020e515714416d..5128018c276619c3163fbe1df74cbc00f61314a7 100644 (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;
 
index 2fd449bcfa35cd2c59fcb112ae0bb84a77be7988..29346d79df7b7b750cc9dc946c753601c1e5b199 100644 (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) {
index a58822a14a87bf2349c1c8df6e7d05211d90e9aa..7cf383a2a5569897dfc934c463c64b90c3507e29 100644 (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)
index 80d9ec5570d6e37d8f09527e5be88516d5b971bc..a7784642d6a11fb32de4ef8dfd07212e239c7c93 100644 (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);
index bc85ca5c1c375d556d0b18c6d30ba201e2f8459f..a89ebfe9e9157f5d5f76c6267b9c08eacafcaa33 100644 (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;
index 0063c11c8081f41015024f65288ab5e28ee5abfb..e59155c6607da7c58dabe8b7d5b83b7957816358 100644 (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)
index a01e987c7d32e274d8d060ef15276fae913a1ca0..d654148883491f83fee46fe627cc9d8f14bd8812 100644 (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__);
index 11e439b90eacd88a2a89e1a48ee6759e7982ccc0..a371c41bb3ab8b5cef70e1e48d1e8b2bde38fd8b 100644 (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);
        }
index 8bf72639b148edf2a7ce5ef3f76bb2f815872f8f..38b4582e073446ad6513b7ed11145ccc6a26e61c 100644 (file)
 
 
 /* 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,
index 60b3e22bd633a43e42f035e6d05fcce6f1b27861..24a08ac2e4eebc53d4068b27b88b6707371e42ca 100644 (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,
index 79787eda95249b987b466f1b04009383b142d421..4a38ec8f5fe330fbc008bae1536c118f35645808 100644 (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);
index 693f00da7c038b0072d360b031479c0f1a30bea5..40c67f0096b10f3b2b5397ade28eb455f21d7f70 100644 (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;
-
-       // 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)
-       
+       if (tty) {
+               tty->low_latency = 1;
+
+               /* 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;
        }
index 5fc2cef30e39f76603421616b3e4a06c9cebd586..7bce4302a5f9973e0d7ae80c83adb562820f3565 100644 (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);
        }
 }
 
index 50f1fe263338dc5fb736a4c8024ddd1afb4fb765..d47f0814ce2d584be429b82b072261be29546b70 100644 (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;
index 78f2f6db494d790fb4d00d75c0ef9c1229ef89ef..2b1fded6619de4b1ff0fa42f27327f215094b315 100644 (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;
 }
 
index 43c8894353bff422fbd93ae9a600efeb750f8bd0..d6736531a0fab1be65f8fe78a01ffb3bc535a207 100644 (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);
index 7b7422f4947854008500f13cb3deabd2cde0be45..5a2d045562f06e201edfd70c5e0cda637d3f51dd 100644 (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];
 
index 1e936a1cbe0bde208b326a807829038d18215538..4350990abf1467a57f45ab5eac9917486c5890bb 100644 (file)
 #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;
 }
 
index a9625c180dc3502206d2d967224a1d6ea31d2bf5..069d276a5276f72a5697133b5022f9928b54cac0 100644 (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) {
index 2a0dd1b50dc43b8dc884f0964c4f6624bfac1921..a0016725d3149fb8a6c7d082d117fa197392a8d3 100644 (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)
index 94bddf06ea4fb8f7d6849b99a5abfd53bb7729b8..f823e4dcea1e006acf53810a5c960418f3aa7992 100644 (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;
 
index 29074c1ba22b6dd504218328e11c177ae4a76ab6..892020d48555ddf5c0950dfa73fc09b6df7ec404 100644 (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,
index 55b2570b8b8b568ad0e694ed575d8153ed4333f6..58495f5cca1f8d2a897191de02c8700214835356 100644 (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;
index a26a629dfc4f7d4f6d65ac5d0648537047f3f49c..48831a755fc1220b7bf7429db1415fd830ab0e07 100644 (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;
index 353798631903de1a12b429f0412d59c9d043de8b..ffaed8ace0665cf5960ed7655d999abb2953c354 100644 (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);
                }
        }
index 9ca4d4db1dddc80c7d91b499f7258a168c3be5be..fc5d9952b03b0aceb901d2f4fb0f95eb62d54bbd 100644 (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 = {
index 5fc20122145f3a31dbd4038377e27680fc0a2f93..373a3c7ea77b3bf8d4bcbebfcf88ec98ced867d4 100644 (file)
 #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;
index 665aa77a917b1c464c5f6da22860a54a6afd1fd6..b07d6a5cac31bb5596de58c7f23539bafec7582a 100644 (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;
index 8f891cbaf9abd497f990e5ae68eabb8d2ae99971..09a3e6a7518fc2e043fd3568f95b74d822b78af6 100644 (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);