TTY: ircomm, use open counts from tty_port
[linux-3.10.git] / net / irda / ircomm / ircomm_tty.c
index faa82ca..787578f 100644 (file)
@@ -38,6 +38,7 @@
 #include <linux/seq_file.h>
 #include <linux/termios.h>
 #include <linux/tty.h>
+#include <linux/tty_flip.h>
 #include <linux/interrupt.h>
 #include <linux/device.h>              /* for MODULE_ALIAS_CHARDEV_MAJOR */
 
@@ -121,7 +122,6 @@ static int __init ircomm_tty_init(void)
                return -ENOMEM;
        }
 
-       driver->owner           = THIS_MODULE;
        driver->driver_name     = "ircomm";
        driver->name            = "ircomm";
        driver->major           = IRCOMM_TTY_MAJOR;
@@ -272,25 +272,25 @@ static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self,
 
        /* Wait for carrier detect and the line to become
         * free (i.e., not in use by the callout).  While we are in
-        * this loop, self->open_count is dropped by one, so that
+        * this loop, self->port.count is dropped by one, so that
         * mgsl_close() knows when to free things.  We restore it upon
         * exit, either normal or abnormal.
         */
 
        retval = 0;
-       add_wait_queue(&self->open_wait, &wait);
+       add_wait_queue(&self->port.open_wait, &wait);
 
        IRDA_DEBUG(2, "%s(%d):block_til_ready before block on %s open_count=%d\n",
-             __FILE__,__LINE__, tty->driver->name, self->open_count );
+             __FILE__, __LINE__, tty->driver->name, self->port.count);
 
-       /* As far as I can see, we protect open_count - Jean II */
+       /* As far as I can see, we protect port.count - Jean II */
        spin_lock_irqsave(&self->spinlock, flags);
        if (!tty_hung_up_p(filp)) {
                extra_count = 1;
-               self->open_count--;
+               self->port.count--;
        }
        spin_unlock_irqrestore(&self->spinlock, flags);
-       self->blocked_open++;
+       self->port.blocked_open++;
 
        while (1) {
                if (tty->termios->c_cflag & CBAUD) {
@@ -330,24 +330,24 @@ static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self,
                }
 
                IRDA_DEBUG(1, "%s(%d):block_til_ready blocking on %s open_count=%d\n",
-                     __FILE__,__LINE__, tty->driver->name, self->open_count );
+                     __FILE__, __LINE__, tty->driver->name, self->port.count);
 
                schedule();
        }
 
        __set_current_state(TASK_RUNNING);
-       remove_wait_queue(&self->open_wait, &wait);
+       remove_wait_queue(&self->port.open_wait, &wait);
 
        if (extra_count) {
                /* ++ is not atomic, so this should be protected - Jean II */
                spin_lock_irqsave(&self->spinlock, flags);
-               self->open_count++;
+               self->port.count++;
                spin_unlock_irqrestore(&self->spinlock, flags);
        }
-       self->blocked_open--;
+       self->port.blocked_open--;
 
        IRDA_DEBUG(1, "%s(%d):block_til_ready after blocking on %s open_count=%d\n",
-             __FILE__,__LINE__, tty->driver->name, self->open_count);
+             __FILE__, __LINE__, tty->driver->name, self->port.count);
 
        if (!retval)
                self->flags |= ASYNC_NORMAL_ACTIVE;
@@ -365,16 +365,12 @@ static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self,
 static int ircomm_tty_open(struct tty_struct *tty, struct file *filp)
 {
        struct ircomm_tty_cb *self;
-       unsigned int line;
+       unsigned int line = tty->index;
        unsigned long   flags;
        int ret;
 
        IRDA_DEBUG(2, "%s()\n", __func__ );
 
-       line = tty->index;
-       if (line >= IRCOMM_TTY_PORTS)
-               return -ENODEV;
-
        /* Check if instance already exists */
        self = hashbin_lock_find(ircomm_tty, line, NULL);
        if (!self) {
@@ -385,6 +381,7 @@ static int ircomm_tty_open(struct tty_struct *tty, struct file *filp)
                        return -ENOMEM;
                }
 
+               tty_port_init(&self->port);
                self->magic = IRCOMM_TTY_MAGIC;
                self->flow = FLOW_STOP;
 
@@ -392,13 +389,9 @@ static int ircomm_tty_open(struct tty_struct *tty, struct file *filp)
                INIT_WORK(&self->tqueue, ircomm_tty_do_softint);
                self->max_header_size = IRCOMM_TTY_HDR_UNINITIALISED;
                self->max_data_size = IRCOMM_TTY_DATA_UNINITIALISED;
-               self->close_delay = 5*HZ/10;
-               self->closing_wait = 30*HZ;
 
                /* Init some important stuff */
                init_timer(&self->watchdog_timer);
-               init_waitqueue_head(&self->open_wait);
-               init_waitqueue_head(&self->close_wait);
                spin_lock_init(&self->spinlock);
 
                /*
@@ -412,18 +405,19 @@ static int ircomm_tty_open(struct tty_struct *tty, struct file *filp)
                tty->termios->c_oflag = 0;
 
                /* Insert into hash */
+               /* FIXME there is a window from find to here */
                hashbin_insert(ircomm_tty, (irda_queue_t *) self, line, NULL);
        }
        /* ++ is not atomic, so this should be protected - Jean II */
        spin_lock_irqsave(&self->spinlock, flags);
-       self->open_count++;
+       self->port.count++;
 
        tty->driver_data = self;
        self->tty = tty;
        spin_unlock_irqrestore(&self->spinlock, flags);
 
        IRDA_DEBUG(1, "%s(), %s%d, count = %d\n", __func__ , tty->driver->name,
-                  self->line, self->open_count);
+                  self->line, self->port.count);
 
        /* Not really used by us, but lets do it anyway */
        self->tty->low_latency = (self->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
@@ -442,15 +436,16 @@ static int ircomm_tty_open(struct tty_struct *tty, struct file *filp)
                 * probably better sleep uninterruptible?
                 */
 
-               if (wait_event_interruptible(self->close_wait, !test_bit(ASYNC_B_CLOSING, &self->flags))) {
+               if (wait_event_interruptible(self->port.close_wait,
+                               !test_bit(ASYNC_B_CLOSING, &self->flags))) {
                        IRDA_WARNING("%s - got signal while blocking on ASYNC_CLOSING!\n",
                                     __func__);
                        return -ERESTARTSYS;
                }
 
 #ifdef SERIAL_DO_RESTART
-               return ((self->flags & ASYNC_HUP_NOTIFY) ?
-                       -EAGAIN : -ERESTARTSYS);
+               return (self->flags & ASYNC_HUP_NOTIFY) ?
+                       -EAGAIN : -ERESTARTSYS;
 #else
                return -EAGAIN;
 #endif
@@ -509,7 +504,7 @@ static void ircomm_tty_close(struct tty_struct *tty, struct file *filp)
                return;
        }
 
-       if ((tty->count == 1) && (self->open_count != 1)) {
+       if ((tty->count == 1) && (self->port.count != 1)) {
                /*
                 * Uh, oh.  tty->count is 1, which means that the tty
                 * structure will be freed.  state->count should always
@@ -519,16 +514,16 @@ static void ircomm_tty_close(struct tty_struct *tty, struct file *filp)
                 */
                IRDA_DEBUG(0, "%s(), bad serial port count; "
                           "tty->count is 1, state->count is %d\n", __func__ ,
-                          self->open_count);
-               self->open_count = 1;
+                          self->port.count);
+               self->port.count = 1;
        }
 
-       if (--self->open_count < 0) {
+       if (--self->port.count < 0) {
                IRDA_ERROR("%s(), bad serial port count for ttys%d: %d\n",
-                          __func__, self->line, self->open_count);
-               self->open_count = 0;
+                          __func__, self->line, self->port.count);
+               self->port.count = 0;
        }
-       if (self->open_count) {
+       if (self->port.count) {
                spin_unlock_irqrestore(&self->spinlock, flags);
 
                IRDA_DEBUG(0, "%s(), open count > 0\n", __func__ );
@@ -549,8 +544,8 @@ static void ircomm_tty_close(struct tty_struct *tty, struct file *filp)
         * the line discipline to only process XON/XOFF characters.
         */
        tty->closing = 1;
-       if (self->closing_wait != ASYNC_CLOSING_WAIT_NONE)
-               tty_wait_until_sent(tty, self->closing_wait);
+       if (self->port.closing_wait != ASYNC_CLOSING_WAIT_NONE)
+               tty_wait_until_sent_from_close(tty, self->port.closing_wait);
 
        ircomm_tty_shutdown(self);
 
@@ -560,14 +555,14 @@ static void ircomm_tty_close(struct tty_struct *tty, struct file *filp)
        tty->closing = 0;
        self->tty = NULL;
 
-       if (self->blocked_open) {
-               if (self->close_delay)
-                       schedule_timeout_interruptible(self->close_delay);
-               wake_up_interruptible(&self->open_wait);
+       if (self->port.blocked_open) {
+               if (self->port.close_delay)
+                       schedule_timeout_interruptible(self->port.close_delay);
+               wake_up_interruptible(&self->port.open_wait);
        }
 
        self->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
-       wake_up_interruptible(&self->close_wait);
+       wake_up_interruptible(&self->port.close_wait);
 }
 
 /*
@@ -1012,10 +1007,10 @@ static void ircomm_tty_hangup(struct tty_struct *tty)
        spin_lock_irqsave(&self->spinlock, flags);
        self->flags &= ~ASYNC_NORMAL_ACTIVE;
        self->tty = NULL;
-       self->open_count = 0;
+       self->port.count = 0;
        spin_unlock_irqrestore(&self->spinlock, flags);
 
-       wake_up_interruptible(&self->open_wait);
+       wake_up_interruptible(&self->port.open_wait);
 }
 
 /*
@@ -1088,7 +1083,7 @@ void ircomm_tty_check_modem_status(struct ircomm_tty_cb *self)
                           (status & IRCOMM_CD) ? "on" : "off");
 
                if (status & IRCOMM_CD) {
-                       wake_up_interruptible(&self->open_wait);
+                       wake_up_interruptible(&self->port.open_wait);
                } else {
                        IRDA_DEBUG(2,
                                   "%s(), Doing serial hangup..\n", __func__ );
@@ -1107,7 +1102,7 @@ void ircomm_tty_check_modem_status(struct ircomm_tty_cb *self)
                                tty->hw_stopped = 0;
 
                                /* Wake up processes blocked on open */
-                               wake_up_interruptible(&self->open_wait);
+                               wake_up_interruptible(&self->port.open_wait);
 
                                schedule_work(&self->tqueue);
                                return;
@@ -1132,7 +1127,6 @@ static int ircomm_tty_data_indication(void *instance, void *sap,
                                      struct sk_buff *skb)
 {
        struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
-       struct tty_ldisc *ld;
 
        IRDA_DEBUG(2, "%s()\n", __func__ );
 
@@ -1161,15 +1155,11 @@ static int ircomm_tty_data_indication(void *instance, void *sap,
        }
 
        /*
-        * Just give it over to the line discipline. There is no need to
-        * involve the flip buffers, since we are not running in an interrupt
-        * handler
+        * Use flip buffer functions since the code may be called from interrupt
+        * context
         */
-
-       ld = tty_ldisc_ref(self->tty);
-       if (ld)
-               ld->ops->receive_buf(self->tty, skb->data, NULL, skb->len);
-       tty_ldisc_deref(ld);
+       tty_insert_flip_string(self->tty, skb->data, skb->len);
+       tty_flip_buffer_push(self->tty);
 
        /* No need to kfree_skb - see ircomm_ttp_data_indication() */
 
@@ -1364,7 +1354,7 @@ static void ircomm_tty_line_info(struct ircomm_tty_cb *self, struct seq_file *m)
        seq_putc(m, '\n');
 
        seq_printf(m, "Role: %s\n", self->client ? "client" : "server");
-       seq_printf(m, "Open count: %d\n", self->open_count);
+       seq_printf(m, "Open count: %d\n", self->port.count);
        seq_printf(m, "Max data size: %d\n", self->max_data_size);
        seq_printf(m, "Max header size: %d\n", self->max_header_size);