int console_open_chan(struct line *line, struct console *co,
                      struct chan_opts *opts)
 {
-       if (!list_empty(&line->chan_list))
-               return 0;
+       int err;
+
+       err = open_chan(&line->chan_list);
+       if(err)
+               return err;
 
-       if (0 != parse_chan_pair(line->init_str, &line->chan_list,
-                                co->index, opts))
-               return -1;
-       if (0 != open_chan(&line->chan_list))
-               return -1;
        printk("Console initialized on /dev/%s%d\n",co->name,co->index);
        return 0;
 }
                                        tty_hangup(tty);
                                line_disable(tty, irq);
                                close_chan(chans);
-                               free_chan(chans);
                                return;
                        }
                        else {
                                if(chan->ops->close != NULL)
                                        chan->ops->close(chan->fd, chan->data);
-                               free_one_chan(chan);
                        }
                }
        }
 
        line->have_irq = 0;
 }
 
-int line_open(struct line *lines, struct tty_struct *tty,
-             struct chan_opts *opts)
+int line_open(struct line *lines, struct tty_struct *tty)
 {
        struct line *line;
        int err = 0;
                        err = -ENODEV;
                        goto out;
                }
-               if (list_empty(&line->chan_list)) {
-                       err = parse_chan_pair(line->init_str, &line->chan_list,
-                                             tty->index, opts);
-                       if(err) goto out;
-                       err = open_chan(&line->chan_list);
-                       if(err) goto out;
-               }
+
+               err = open_chan(&line->chan_list);
+               if(err)
+                       goto out;
+
                /* Here the interrupt is registered.*/
                enable_chan(&line->chan_list, tty);
                INIT_WORK(&line->task, line_timer_cb, tty);
        return n == -1 ? num : n;
 }
 
-int line_config(struct line *lines, unsigned int num, char *str)
+int line_config(struct line *lines, unsigned int num, char *str,
+               struct chan_opts *opts)
 {
+       struct line *line;
        char *new;
        int n;
 
        new = kstrdup(str, GFP_KERNEL);
        if(new == NULL){
                printk("line_config - kstrdup failed\n");
-               return -ENOMEM;
+               return 1;
        }
        n = line_setup(lines, num, new);
-       return n < 0 ? n : 0;
+       if(n < 0)
+               return 1;
+
+       line = &lines[n];
+       return parse_chan_pair(line->init_str, &line->chan_list, n, opts);
 }
 
 int line_get_config(char *name, struct line *lines, unsigned int num, char *str,
 static DEFINE_SPINLOCK(winch_handler_lock);
 static LIST_HEAD(winch_handlers);
 
-void lines_init(struct line *lines, int nlines)
+void lines_init(struct line *lines, int nlines, struct chan_opts *opts)
 {
        struct line *line;
        int i;
                line->init_str = kstrdup(line->init_str, GFP_KERNEL);
                if(line->init_str == NULL)
                        printk("lines_init - kstrdup returned NULL\n");
+
+               if(parse_chan_pair(line->init_str, &line->chan_list, i, opts)){
+                       printk("parse_chan_pair failed for device %d\n", i);
+                       line->valid = 0;
+               }
        }
 }
 
 
 
 static int ssl_config(char *str)
 {
-       return line_config(serial_lines, ARRAY_SIZE(serial_lines), str);
+       return line_config(serial_lines, ARRAY_SIZE(serial_lines), str, &opts);
 }
 
 static int ssl_get_config(char *dev, char *str, int size, char **error_out)
 
 int ssl_open(struct tty_struct *tty, struct file *filp)
 {
-       return line_open(serial_lines, tty, &opts);
+       return line_open(serial_lines, tty);
 }
 
 #if 0
                                         serial_lines,
                                         ARRAY_SIZE(serial_lines));
 
-       lines_init(serial_lines, ARRAY_SIZE(serial_lines));
+       lines_init(serial_lines, ARRAY_SIZE(serial_lines), &opts);
 
        new_title = add_xterm_umid(opts.xterm_title);
        if (new_title != NULL)
 
 
 static int con_config(char *str)
 {
-       return line_config(vts, ARRAY_SIZE(vts), str);
+       return line_config(vts, ARRAY_SIZE(vts), str, &opts);
 }
 
 static int con_get_config(char *dev, char *str, int size, char **error_out)
 
 static int con_open(struct tty_struct *tty, struct file *filp)
 {
-       return line_open(vts, tty, &opts);
+       return line_open(vts, tty);
 }
 
 static int con_init_done = 0;
                return -1;
        printk(KERN_INFO "Initialized stdio console driver\n");
 
-       lines_init(vts, ARRAY_SIZE(vts));
+       lines_init(vts, ARRAY_SIZE(vts), &opts);
 
        new_title = add_xterm_umid(opts.xterm_title);
        if(new_title != NULL)
 
 #define LINES_INIT(n) {  num :         n }
 
 extern void line_close(struct tty_struct *tty, struct file * filp);
-extern int line_open(struct line *lines, struct tty_struct *tty,
-                    struct chan_opts *opts);
+extern int line_open(struct line *lines, struct tty_struct *tty);
 extern int line_setup(struct line *lines, unsigned int sizeof_lines,
                      char *init);
 extern int line_write(struct tty_struct *tty, const unsigned char *buf,
                                struct tty_operations *driver,
                                struct line *lines,
                                int nlines);
-extern void lines_init(struct line *lines, int nlines);
+extern void lines_init(struct line *lines, int nlines, struct chan_opts *opts);
 extern void close_lines(struct line *lines, int nlines);
 
 extern int line_config(struct line *lines, unsigned int sizeof_lines,
-                      char *str);
+                      char *str, struct chan_opts *opts);
 extern int line_id(char **str, int *start_out, int *end_out);
 extern int line_remove(struct line *lines, unsigned int sizeof_lines, int n);
 extern int line_get_config(char *dev, struct line *lines,