struct line *line = container_of(work, struct line, task.work);
 
        if (!line->throttled)
-               chan_interrupt(line, line->driver->read_irq);
+               chan_interrupt(line, line->read_irq);
 }
 
 int enable_chan(struct line *line)
                chan = list_entry(ele, struct chan, free_list);
 
                if (chan->input && chan->enabled)
-                       um_free_irq(chan->line->driver->read_irq, chan);
+                       um_free_irq(chan->line->read_irq, chan);
                if (chan->output && chan->enabled)
-                       um_free_irq(chan->line->driver->write_irq, chan);
+                       um_free_irq(chan->line->write_irq, chan);
                chan->enabled = 0;
        }
 }
                spin_unlock_irqrestore(&irqs_to_free_lock, flags);
        } else {
                if (chan->input && chan->enabled)
-                       um_free_irq(chan->line->driver->read_irq, chan);
+                       um_free_irq(chan->line->read_irq, chan);
                if (chan->output && chan->enabled)
-                       um_free_irq(chan->line->driver->write_irq, chan);
+                       um_free_irq(chan->line->write_irq, chan);
                chan->enabled = 0;
        }
        if (chan->ops->close != NULL)
 
                count = line->buffer + LINE_BUFSIZE - line->head;
 
                n = write_chan(line->chan_out, line->head, count,
-                              line->driver->write_irq);
+                              line->write_irq);
                if (n < 0)
                        return n;
                if (n == count) {
 
        count = line->tail - line->head;
        n = write_chan(line->chan_out, line->head, count,
-                      line->driver->write_irq);
+                      line->write_irq);
 
        if (n < 0)
                return n;
                ret = buffer_data(line, buf, len);
        else {
                n = write_chan(line->chan_out, buf, len,
-                              line->driver->write_irq);
+                              line->write_irq);
                if (n < 0) {
                        ret = n;
                        goto out_up;
 {
        struct line *line = tty->driver_data;
 
-       deactivate_chan(line->chan_in, line->driver->read_irq);
+       deactivate_chan(line->chan_in, line->read_irq);
        line->throttled = 1;
 }
 
        struct line *line = tty->driver_data;
 
        line->throttled = 0;
-       chan_interrupt(line, line->driver->read_irq);
+       chan_interrupt(line, line->read_irq);
 }
 
 static irqreturn_t line_write_interrupt(int irq, void *data)
        int err;
 
        if (input) {
-               err = um_request_irq(driver->read_irq, fd, IRQ_READ,
-                                    line_interrupt, IRQF_SHARED,
+               err = um_request_irq(UM_IRQ_ALLOC, fd, IRQ_READ,
+                                    line_interrupt, 0,
                                     driver->read_irq_name, data);
                if (err < 0)
                        return err;
+
+               line->read_irq = err;
        }
 
        if (output) {
-               err = um_request_irq(driver->write_irq, fd, IRQ_WRITE,
-                                    line_write_interrupt, IRQF_SHARED,
+               err = um_request_irq(UM_IRQ_ALLOC, fd, IRQ_WRITE,
+                                    line_write_interrupt, 0,
                                     driver->write_irq_name, data);
                if (err < 0)
                        return err;
+
+               line->write_irq = err;
        }
 
        return 0;
 
        const short minor_start;
        const short type;
        const short subtype;
-       const int read_irq;
        const char *read_irq_name;
-       const int write_irq;
        const char *write_irq_name;
        struct mc_device mc;
        struct tty_driver *driver;
        struct tty_port port;
        int valid;
 
+       int read_irq, write_irq;
+
        char *init_str;
        struct list_head chan_list;
        struct chan *chan_in, *chan_out;
 
        .minor_start            = 64,
        .type                   = TTY_DRIVER_TYPE_SERIAL,
        .subtype                = 0,
-       .read_irq               = SSL_IRQ,
        .read_irq_name          = "ssl",
-       .write_irq              = SSL_WRITE_IRQ,
        .write_irq_name         = "ssl-write",
        .mc  = {
                .list           = LIST_HEAD_INIT(driver.mc.list),
 
        .minor_start            = 0,
        .type                   = TTY_DRIVER_TYPE_CONSOLE,
        .subtype                = SYSTEM_TYPE_CONSOLE,
-       .read_irq               = CONSOLE_IRQ,
        .read_irq_name          = "console",
-       .write_irq              = CONSOLE_WRITE_IRQ,
        .write_irq_name         = "console-write",
        .mc  = {
                .list           = LIST_HEAD_INIT(driver.mc.list),
 
 
 #define TIMER_IRQ              0
 #define UMN_IRQ                        1
-#define CONSOLE_IRQ            2
-#define CONSOLE_WRITE_IRQ      3
-#define UBD_IRQ                        4
-#define UM_ETH_IRQ             5
-#define SSL_IRQ                        6
-#define SSL_WRITE_IRQ          7
-#define ACCEPT_IRQ             8
-#define MCONSOLE_IRQ           9
-#define WINCH_IRQ              10
-#define SIGIO_WRITE_IRQ        11
-#define TELNETD_IRQ            12
-#define XTERM_IRQ              13
-#define RANDOM_IRQ             14
+#define UBD_IRQ                        2
+#define UM_ETH_IRQ             3
+#define ACCEPT_IRQ             4
+#define MCONSOLE_IRQ           5
+#define WINCH_IRQ              6
+#define SIGIO_WRITE_IRQ        7
+#define TELNETD_IRQ            8
+#define XTERM_IRQ              9
+#define RANDOM_IRQ             10
 
 #ifdef CONFIG_UML_NET_VECTOR