Driver core: Remove unneeded get_{device,driver}() calls.
[linux-2.6.git] / drivers / serial / serial_core.c
1 /*
2  *  linux/drivers/char/core.c
3  *
4  *  Driver core for serial ports
5  *
6  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
7  *
8  *  Copyright 1999 ARM Limited
9  *  Copyright (C) 2000-2001 Deep Blue Solutions Ltd.
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
24  */
25 #include <linux/module.h>
26 #include <linux/tty.h>
27 #include <linux/slab.h>
28 #include <linux/init.h>
29 #include <linux/console.h>
30 #include <linux/serial_core.h>
31 #include <linux/smp_lock.h>
32 #include <linux/device.h>
33 #include <linux/serial.h> /* for serial_state and serial_icounter_struct */
34 #include <linux/delay.h>
35 #include <linux/mutex.h>
36
37 #include <asm/irq.h>
38 #include <asm/uaccess.h>
39
40 /*
41  * This is used to lock changes in serial line configuration.
42  */
43 static DEFINE_MUTEX(port_mutex);
44
45 /*
46  * lockdep: port->lock is initialized in two places, but we
47  *          want only one lock-class:
48  */
49 static struct lock_class_key port_lock_key;
50
51 #define HIGH_BITS_OFFSET        ((sizeof(long)-sizeof(int))*8)
52
53 #define uart_users(state)       ((state)->count + ((state)->info ? (state)->info->blocked_open : 0))
54
55 #ifdef CONFIG_SERIAL_CORE_CONSOLE
56 #define uart_console(port)      ((port)->cons && (port)->cons->index == (port)->line)
57 #else
58 #define uart_console(port)      (0)
59 #endif
60
61 static void uart_change_speed(struct uart_state *state, struct ktermios *old_termios);
62 static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
63 static void uart_change_pm(struct uart_state *state, int pm_state);
64
65 /*
66  * This routine is used by the interrupt handler to schedule processing in
67  * the software interrupt portion of the driver.
68  */
69 void uart_write_wakeup(struct uart_port *port)
70 {
71         struct uart_info *info = port->info;
72         /*
73          * This means you called this function _after_ the port was
74          * closed.  No cookie for you.
75          */
76         BUG_ON(!info);
77         tasklet_schedule(&info->tlet);
78 }
79
80 static void uart_stop(struct tty_struct *tty)
81 {
82         struct uart_state *state = tty->driver_data;
83         struct uart_port *port = state->port;
84         unsigned long flags;
85
86         spin_lock_irqsave(&port->lock, flags);
87         port->ops->stop_tx(port);
88         spin_unlock_irqrestore(&port->lock, flags);
89 }
90
91 static void __uart_start(struct tty_struct *tty)
92 {
93         struct uart_state *state = tty->driver_data;
94         struct uart_port *port = state->port;
95
96         if (!uart_circ_empty(&state->info->xmit) && state->info->xmit.buf &&
97             !tty->stopped && !tty->hw_stopped)
98                 port->ops->start_tx(port);
99 }
100
101 static void uart_start(struct tty_struct *tty)
102 {
103         struct uart_state *state = tty->driver_data;
104         struct uart_port *port = state->port;
105         unsigned long flags;
106
107         spin_lock_irqsave(&port->lock, flags);
108         __uart_start(tty);
109         spin_unlock_irqrestore(&port->lock, flags);
110 }
111
112 static void uart_tasklet_action(unsigned long data)
113 {
114         struct uart_state *state = (struct uart_state *)data;
115         tty_wakeup(state->info->tty);
116 }
117
118 static inline void
119 uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
120 {
121         unsigned long flags;
122         unsigned int old;
123
124         spin_lock_irqsave(&port->lock, flags);
125         old = port->mctrl;
126         port->mctrl = (old & ~clear) | set;
127         if (old != port->mctrl)
128                 port->ops->set_mctrl(port, port->mctrl);
129         spin_unlock_irqrestore(&port->lock, flags);
130 }
131
132 #define uart_set_mctrl(port,set)        uart_update_mctrl(port,set,0)
133 #define uart_clear_mctrl(port,clear)    uart_update_mctrl(port,0,clear)
134
135 /*
136  * Startup the port.  This will be called once per open.  All calls
137  * will be serialised by the per-port semaphore.
138  */
139 static int uart_startup(struct uart_state *state, int init_hw)
140 {
141         struct uart_info *info = state->info;
142         struct uart_port *port = state->port;
143         unsigned long page;
144         int retval = 0;
145
146         if (info->flags & UIF_INITIALIZED)
147                 return 0;
148
149         /*
150          * Set the TTY IO error marker - we will only clear this
151          * once we have successfully opened the port.  Also set
152          * up the tty->alt_speed kludge
153          */
154         set_bit(TTY_IO_ERROR, &info->tty->flags);
155
156         if (port->type == PORT_UNKNOWN)
157                 return 0;
158
159         /*
160          * Initialise and allocate the transmit and temporary
161          * buffer.
162          */
163         if (!info->xmit.buf) {
164                 page = get_zeroed_page(GFP_KERNEL);
165                 if (!page)
166                         return -ENOMEM;
167
168                 info->xmit.buf = (unsigned char *) page;
169                 uart_circ_clear(&info->xmit);
170         }
171
172         retval = port->ops->startup(port);
173         if (retval == 0) {
174                 if (init_hw) {
175                         /*
176                          * Initialise the hardware port settings.
177                          */
178                         uart_change_speed(state, NULL);
179
180                         /*
181                          * Setup the RTS and DTR signals once the
182                          * port is open and ready to respond.
183                          */
184                         if (info->tty->termios->c_cflag & CBAUD)
185                                 uart_set_mctrl(port, TIOCM_RTS | TIOCM_DTR);
186                 }
187
188                 if (info->flags & UIF_CTS_FLOW) {
189                         spin_lock_irq(&port->lock);
190                         if (!(port->ops->get_mctrl(port) & TIOCM_CTS))
191                                 info->tty->hw_stopped = 1;
192                         spin_unlock_irq(&port->lock);
193                 }
194
195                 info->flags |= UIF_INITIALIZED;
196
197                 clear_bit(TTY_IO_ERROR, &info->tty->flags);
198         }
199
200         if (retval && capable(CAP_SYS_ADMIN))
201                 retval = 0;
202
203         return retval;
204 }
205
206 /*
207  * This routine will shutdown a serial port; interrupts are disabled, and
208  * DTR is dropped if the hangup on close termio flag is on.  Calls to
209  * uart_shutdown are serialised by the per-port semaphore.
210  */
211 static void uart_shutdown(struct uart_state *state)
212 {
213         struct uart_info *info = state->info;
214         struct uart_port *port = state->port;
215
216         /*
217          * Set the TTY IO error marker
218          */
219         if (info->tty)
220                 set_bit(TTY_IO_ERROR, &info->tty->flags);
221
222         if (info->flags & UIF_INITIALIZED) {
223                 info->flags &= ~UIF_INITIALIZED;
224
225                 /*
226                  * Turn off DTR and RTS early.
227                  */
228                 if (!info->tty || (info->tty->termios->c_cflag & HUPCL))
229                         uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
230
231                 /*
232                  * clear delta_msr_wait queue to avoid mem leaks: we may free
233                  * the irq here so the queue might never be woken up.  Note
234                  * that we won't end up waiting on delta_msr_wait again since
235                  * any outstanding file descriptors should be pointing at
236                  * hung_up_tty_fops now.
237                  */
238                 wake_up_interruptible(&info->delta_msr_wait);
239
240                 /*
241                  * Free the IRQ and disable the port.
242                  */
243                 port->ops->shutdown(port);
244
245                 /*
246                  * Ensure that the IRQ handler isn't running on another CPU.
247                  */
248                 synchronize_irq(port->irq);
249         }
250
251         /*
252          * kill off our tasklet
253          */
254         tasklet_kill(&info->tlet);
255
256         /*
257          * Free the transmit buffer page.
258          */
259         if (info->xmit.buf) {
260                 free_page((unsigned long)info->xmit.buf);
261                 info->xmit.buf = NULL;
262         }
263 }
264
265 /**
266  *      uart_update_timeout - update per-port FIFO timeout.
267  *      @port:  uart_port structure describing the port
268  *      @cflag: termios cflag value
269  *      @baud:  speed of the port
270  *
271  *      Set the port FIFO timeout value.  The @cflag value should
272  *      reflect the actual hardware settings.
273  */
274 void
275 uart_update_timeout(struct uart_port *port, unsigned int cflag,
276                     unsigned int baud)
277 {
278         unsigned int bits;
279
280         /* byte size and parity */
281         switch (cflag & CSIZE) {
282         case CS5:
283                 bits = 7;
284                 break;
285         case CS6:
286                 bits = 8;
287                 break;
288         case CS7:
289                 bits = 9;
290                 break;
291         default:
292                 bits = 10;
293                 break; // CS8
294         }
295
296         if (cflag & CSTOPB)
297                 bits++;
298         if (cflag & PARENB)
299                 bits++;
300
301         /*
302          * The total number of bits to be transmitted in the fifo.
303          */
304         bits = bits * port->fifosize;
305
306         /*
307          * Figure the timeout to send the above number of bits.
308          * Add .02 seconds of slop
309          */
310         port->timeout = (HZ * bits) / baud + HZ/50;
311 }
312
313 EXPORT_SYMBOL(uart_update_timeout);
314
315 /**
316  *      uart_get_baud_rate - return baud rate for a particular port
317  *      @port: uart_port structure describing the port in question.
318  *      @termios: desired termios settings.
319  *      @old: old termios (or NULL)
320  *      @min: minimum acceptable baud rate
321  *      @max: maximum acceptable baud rate
322  *
323  *      Decode the termios structure into a numeric baud rate,
324  *      taking account of the magic 38400 baud rate (with spd_*
325  *      flags), and mapping the %B0 rate to 9600 baud.
326  *
327  *      If the new baud rate is invalid, try the old termios setting.
328  *      If it's still invalid, we try 9600 baud.
329  *
330  *      Update the @termios structure to reflect the baud rate
331  *      we're actually going to be using.
332  */
333 unsigned int
334 uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
335                    struct ktermios *old, unsigned int min, unsigned int max)
336 {
337         unsigned int try, baud, altbaud = 38400;
338         upf_t flags = port->flags & UPF_SPD_MASK;
339
340         if (flags == UPF_SPD_HI)
341                 altbaud = 57600;
342         if (flags == UPF_SPD_VHI)
343                 altbaud = 115200;
344         if (flags == UPF_SPD_SHI)
345                 altbaud = 230400;
346         if (flags == UPF_SPD_WARP)
347                 altbaud = 460800;
348
349         for (try = 0; try < 2; try++) {
350                 baud = tty_termios_baud_rate(termios);
351
352                 /*
353                  * The spd_hi, spd_vhi, spd_shi, spd_warp kludge...
354                  * Die! Die! Die!
355                  */
356                 if (baud == 38400)
357                         baud = altbaud;
358
359                 /*
360                  * Special case: B0 rate.
361                  */
362                 if (baud == 0)
363                         baud = 9600;
364
365                 if (baud >= min && baud <= max)
366                         return baud;
367
368                 /*
369                  * Oops, the quotient was zero.  Try again with
370                  * the old baud rate if possible.
371                  */
372                 termios->c_cflag &= ~CBAUD;
373                 if (old) {
374                         termios->c_cflag |= old->c_cflag & CBAUD;
375                         old = NULL;
376                         continue;
377                 }
378
379                 /*
380                  * As a last resort, if the quotient is zero,
381                  * default to 9600 bps
382                  */
383                 termios->c_cflag |= B9600;
384         }
385
386         return 0;
387 }
388
389 EXPORT_SYMBOL(uart_get_baud_rate);
390
391 /**
392  *      uart_get_divisor - return uart clock divisor
393  *      @port: uart_port structure describing the port.
394  *      @baud: desired baud rate
395  *
396  *      Calculate the uart clock divisor for the port.
397  */
398 unsigned int
399 uart_get_divisor(struct uart_port *port, unsigned int baud)
400 {
401         unsigned int quot;
402
403         /*
404          * Old custom speed handling.
405          */
406         if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)
407                 quot = port->custom_divisor;
408         else
409                 quot = (port->uartclk + (8 * baud)) / (16 * baud);
410
411         return quot;
412 }
413
414 EXPORT_SYMBOL(uart_get_divisor);
415
416 static void
417 uart_change_speed(struct uart_state *state, struct ktermios *old_termios)
418 {
419         struct tty_struct *tty = state->info->tty;
420         struct uart_port *port = state->port;
421         struct ktermios *termios;
422
423         /*
424          * If we have no tty, termios, or the port does not exist,
425          * then we can't set the parameters for this port.
426          */
427         if (!tty || !tty->termios || port->type == PORT_UNKNOWN)
428                 return;
429
430         termios = tty->termios;
431
432         /*
433          * Set flags based on termios cflag
434          */
435         if (termios->c_cflag & CRTSCTS)
436                 state->info->flags |= UIF_CTS_FLOW;
437         else
438                 state->info->flags &= ~UIF_CTS_FLOW;
439
440         if (termios->c_cflag & CLOCAL)
441                 state->info->flags &= ~UIF_CHECK_CD;
442         else
443                 state->info->flags |= UIF_CHECK_CD;
444
445         port->ops->set_termios(port, termios, old_termios);
446 }
447
448 static inline void
449 __uart_put_char(struct uart_port *port, struct circ_buf *circ, unsigned char c)
450 {
451         unsigned long flags;
452
453         if (!circ->buf)
454                 return;
455
456         spin_lock_irqsave(&port->lock, flags);
457         if (uart_circ_chars_free(circ) != 0) {
458                 circ->buf[circ->head] = c;
459                 circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1);
460         }
461         spin_unlock_irqrestore(&port->lock, flags);
462 }
463
464 static void uart_put_char(struct tty_struct *tty, unsigned char ch)
465 {
466         struct uart_state *state = tty->driver_data;
467
468         __uart_put_char(state->port, &state->info->xmit, ch);
469 }
470
471 static void uart_flush_chars(struct tty_struct *tty)
472 {
473         uart_start(tty);
474 }
475
476 static int
477 uart_write(struct tty_struct *tty, const unsigned char *buf, int count)
478 {
479         struct uart_state *state = tty->driver_data;
480         struct uart_port *port;
481         struct circ_buf *circ;
482         unsigned long flags;
483         int c, ret = 0;
484
485         /*
486          * This means you called this function _after_ the port was
487          * closed.  No cookie for you.
488          */
489         if (!state || !state->info) {
490                 WARN_ON(1);
491                 return -EL3HLT;
492         }
493
494         port = state->port;
495         circ = &state->info->xmit;
496
497         if (!circ->buf)
498                 return 0;
499
500         spin_lock_irqsave(&port->lock, flags);
501         while (1) {
502                 c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
503                 if (count < c)
504                         c = count;
505                 if (c <= 0)
506                         break;
507                 memcpy(circ->buf + circ->head, buf, c);
508                 circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
509                 buf += c;
510                 count -= c;
511                 ret += c;
512         }
513         spin_unlock_irqrestore(&port->lock, flags);
514
515         uart_start(tty);
516         return ret;
517 }
518
519 static int uart_write_room(struct tty_struct *tty)
520 {
521         struct uart_state *state = tty->driver_data;
522
523         return uart_circ_chars_free(&state->info->xmit);
524 }
525
526 static int uart_chars_in_buffer(struct tty_struct *tty)
527 {
528         struct uart_state *state = tty->driver_data;
529
530         return uart_circ_chars_pending(&state->info->xmit);
531 }
532
533 static void uart_flush_buffer(struct tty_struct *tty)
534 {
535         struct uart_state *state = tty->driver_data;
536         struct uart_port *port = state->port;
537         unsigned long flags;
538
539         /*
540          * This means you called this function _after_ the port was
541          * closed.  No cookie for you.
542          */
543         if (!state || !state->info) {
544                 WARN_ON(1);
545                 return;
546         }
547
548         pr_debug("uart_flush_buffer(%d) called\n", tty->index);
549
550         spin_lock_irqsave(&port->lock, flags);
551         uart_circ_clear(&state->info->xmit);
552         spin_unlock_irqrestore(&port->lock, flags);
553         tty_wakeup(tty);
554 }
555
556 /*
557  * This function is used to send a high-priority XON/XOFF character to
558  * the device
559  */
560 static void uart_send_xchar(struct tty_struct *tty, char ch)
561 {
562         struct uart_state *state = tty->driver_data;
563         struct uart_port *port = state->port;
564         unsigned long flags;
565
566         if (port->ops->send_xchar)
567                 port->ops->send_xchar(port, ch);
568         else {
569                 port->x_char = ch;
570                 if (ch) {
571                         spin_lock_irqsave(&port->lock, flags);
572                         port->ops->start_tx(port);
573                         spin_unlock_irqrestore(&port->lock, flags);
574                 }
575         }
576 }
577
578 static void uart_throttle(struct tty_struct *tty)
579 {
580         struct uart_state *state = tty->driver_data;
581
582         if (I_IXOFF(tty))
583                 uart_send_xchar(tty, STOP_CHAR(tty));
584
585         if (tty->termios->c_cflag & CRTSCTS)
586                 uart_clear_mctrl(state->port, TIOCM_RTS);
587 }
588
589 static void uart_unthrottle(struct tty_struct *tty)
590 {
591         struct uart_state *state = tty->driver_data;
592         struct uart_port *port = state->port;
593
594         if (I_IXOFF(tty)) {
595                 if (port->x_char)
596                         port->x_char = 0;
597                 else
598                         uart_send_xchar(tty, START_CHAR(tty));
599         }
600
601         if (tty->termios->c_cflag & CRTSCTS)
602                 uart_set_mctrl(port, TIOCM_RTS);
603 }
604
605 static int uart_get_info(struct uart_state *state,
606                          struct serial_struct __user *retinfo)
607 {
608         struct uart_port *port = state->port;
609         struct serial_struct tmp;
610
611         memset(&tmp, 0, sizeof(tmp));
612         tmp.type            = port->type;
613         tmp.line            = port->line;
614         tmp.port            = port->iobase;
615         if (HIGH_BITS_OFFSET)
616                 tmp.port_high = (long) port->iobase >> HIGH_BITS_OFFSET;
617         tmp.irq             = port->irq;
618         tmp.flags           = port->flags;
619         tmp.xmit_fifo_size  = port->fifosize;
620         tmp.baud_base       = port->uartclk / 16;
621         tmp.close_delay     = state->close_delay / 10;
622         tmp.closing_wait    = state->closing_wait == USF_CLOSING_WAIT_NONE ?
623                                 ASYNC_CLOSING_WAIT_NONE :
624                                 state->closing_wait / 10;
625         tmp.custom_divisor  = port->custom_divisor;
626         tmp.hub6            = port->hub6;
627         tmp.io_type         = port->iotype;
628         tmp.iomem_reg_shift = port->regshift;
629         tmp.iomem_base      = (void *)(unsigned long)port->mapbase;
630
631         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
632                 return -EFAULT;
633         return 0;
634 }
635
636 static int uart_set_info(struct uart_state *state,
637                          struct serial_struct __user *newinfo)
638 {
639         struct serial_struct new_serial;
640         struct uart_port *port = state->port;
641         unsigned long new_port;
642         unsigned int change_irq, change_port, closing_wait;
643         unsigned int old_custom_divisor, close_delay;
644         upf_t old_flags, new_flags;
645         int retval = 0;
646
647         if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
648                 return -EFAULT;
649
650         new_port = new_serial.port;
651         if (HIGH_BITS_OFFSET)
652                 new_port += (unsigned long) new_serial.port_high << HIGH_BITS_OFFSET;
653
654         new_serial.irq = irq_canonicalize(new_serial.irq);
655         close_delay = new_serial.close_delay * 10;
656         closing_wait = new_serial.closing_wait == ASYNC_CLOSING_WAIT_NONE ?
657                         USF_CLOSING_WAIT_NONE : new_serial.closing_wait * 10;
658
659         /*
660          * This semaphore protects state->count.  It is also
661          * very useful to prevent opens.  Also, take the
662          * port configuration semaphore to make sure that a
663          * module insertion/removal doesn't change anything
664          * under us.
665          */
666         mutex_lock(&state->mutex);
667
668         change_irq  = !(port->flags & UPF_FIXED_PORT)
669                 && new_serial.irq != port->irq;
670
671         /*
672          * Since changing the 'type' of the port changes its resource
673          * allocations, we should treat type changes the same as
674          * IO port changes.
675          */
676         change_port = !(port->flags & UPF_FIXED_PORT)
677                 && (new_port != port->iobase ||
678                     (unsigned long)new_serial.iomem_base != port->mapbase ||
679                     new_serial.hub6 != port->hub6 ||
680                     new_serial.io_type != port->iotype ||
681                     new_serial.iomem_reg_shift != port->regshift ||
682                     new_serial.type != port->type);
683
684         old_flags = port->flags;
685         new_flags = new_serial.flags;
686         old_custom_divisor = port->custom_divisor;
687
688         if (!capable(CAP_SYS_ADMIN)) {
689                 retval = -EPERM;
690                 if (change_irq || change_port ||
691                     (new_serial.baud_base != port->uartclk / 16) ||
692                     (close_delay != state->close_delay) ||
693                     (closing_wait != state->closing_wait) ||
694                     (new_serial.xmit_fifo_size &&
695                      new_serial.xmit_fifo_size != port->fifosize) ||
696                     (((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0))
697                         goto exit;
698                 port->flags = ((port->flags & ~UPF_USR_MASK) |
699                                (new_flags & UPF_USR_MASK));
700                 port->custom_divisor = new_serial.custom_divisor;
701                 goto check_and_exit;
702         }
703
704         /*
705          * Ask the low level driver to verify the settings.
706          */
707         if (port->ops->verify_port)
708                 retval = port->ops->verify_port(port, &new_serial);
709
710         if ((new_serial.irq >= NR_IRQS) || (new_serial.irq < 0) ||
711             (new_serial.baud_base < 9600))
712                 retval = -EINVAL;
713
714         if (retval)
715                 goto exit;
716
717         if (change_port || change_irq) {
718                 retval = -EBUSY;
719
720                 /*
721                  * Make sure that we are the sole user of this port.
722                  */
723                 if (uart_users(state) > 1)
724                         goto exit;
725
726                 /*
727                  * We need to shutdown the serial port at the old
728                  * port/type/irq combination.
729                  */
730                 uart_shutdown(state);
731         }
732
733         if (change_port) {
734                 unsigned long old_iobase, old_mapbase;
735                 unsigned int old_type, old_iotype, old_hub6, old_shift;
736
737                 old_iobase = port->iobase;
738                 old_mapbase = port->mapbase;
739                 old_type = port->type;
740                 old_hub6 = port->hub6;
741                 old_iotype = port->iotype;
742                 old_shift = port->regshift;
743
744                 /*
745                  * Free and release old regions
746                  */
747                 if (old_type != PORT_UNKNOWN)
748                         port->ops->release_port(port);
749
750                 port->iobase = new_port;
751                 port->type = new_serial.type;
752                 port->hub6 = new_serial.hub6;
753                 port->iotype = new_serial.io_type;
754                 port->regshift = new_serial.iomem_reg_shift;
755                 port->mapbase = (unsigned long)new_serial.iomem_base;
756
757                 /*
758                  * Claim and map the new regions
759                  */
760                 if (port->type != PORT_UNKNOWN) {
761                         retval = port->ops->request_port(port);
762                 } else {
763                         /* Always success - Jean II */
764                         retval = 0;
765                 }
766
767                 /*
768                  * If we fail to request resources for the
769                  * new port, try to restore the old settings.
770                  */
771                 if (retval && old_type != PORT_UNKNOWN) {
772                         port->iobase = old_iobase;
773                         port->type = old_type;
774                         port->hub6 = old_hub6;
775                         port->iotype = old_iotype;
776                         port->regshift = old_shift;
777                         port->mapbase = old_mapbase;
778                         retval = port->ops->request_port(port);
779                         /*
780                          * If we failed to restore the old settings,
781                          * we fail like this.
782                          */
783                         if (retval)
784                                 port->type = PORT_UNKNOWN;
785
786                         /*
787                          * We failed anyway.
788                          */
789                         retval = -EBUSY;
790                         goto exit;  // Added to return the correct error -Ram Gupta
791                 }
792         }
793
794         if (change_irq)
795                 port->irq      = new_serial.irq;
796         if (!(port->flags & UPF_FIXED_PORT))
797                 port->uartclk  = new_serial.baud_base * 16;
798         port->flags            = (port->flags & ~UPF_CHANGE_MASK) |
799                                  (new_flags & UPF_CHANGE_MASK);
800         port->custom_divisor   = new_serial.custom_divisor;
801         state->close_delay     = close_delay;
802         state->closing_wait    = closing_wait;
803         if (new_serial.xmit_fifo_size)
804                 port->fifosize = new_serial.xmit_fifo_size;
805         if (state->info->tty)
806                 state->info->tty->low_latency =
807                         (port->flags & UPF_LOW_LATENCY) ? 1 : 0;
808
809  check_and_exit:
810         retval = 0;
811         if (port->type == PORT_UNKNOWN)
812                 goto exit;
813         if (state->info->flags & UIF_INITIALIZED) {
814                 if (((old_flags ^ port->flags) & UPF_SPD_MASK) ||
815                     old_custom_divisor != port->custom_divisor) {
816                         /*
817                          * If they're setting up a custom divisor or speed,
818                          * instead of clearing it, then bitch about it. No
819                          * need to rate-limit; it's CAP_SYS_ADMIN only.
820                          */
821                         if (port->flags & UPF_SPD_MASK) {
822                                 char buf[64];
823                                 printk(KERN_NOTICE
824                                        "%s sets custom speed on %s. This "
825                                        "is deprecated.\n", current->comm,
826                                        tty_name(state->info->tty, buf));
827                         }
828                         uart_change_speed(state, NULL);
829                 }
830         } else
831                 retval = uart_startup(state, 1);
832  exit:
833         mutex_unlock(&state->mutex);
834         return retval;
835 }
836
837
838 /*
839  * uart_get_lsr_info - get line status register info.
840  * Note: uart_ioctl protects us against hangups.
841  */
842 static int uart_get_lsr_info(struct uart_state *state,
843                              unsigned int __user *value)
844 {
845         struct uart_port *port = state->port;
846         unsigned int result;
847
848         result = port->ops->tx_empty(port);
849
850         /*
851          * If we're about to load something into the transmit
852          * register, we'll pretend the transmitter isn't empty to
853          * avoid a race condition (depending on when the transmit
854          * interrupt happens).
855          */
856         if (port->x_char ||
857             ((uart_circ_chars_pending(&state->info->xmit) > 0) &&
858              !state->info->tty->stopped && !state->info->tty->hw_stopped))
859                 result &= ~TIOCSER_TEMT;
860         
861         return put_user(result, value);
862 }
863
864 static int uart_tiocmget(struct tty_struct *tty, struct file *file)
865 {
866         struct uart_state *state = tty->driver_data;
867         struct uart_port *port = state->port;
868         int result = -EIO;
869
870         mutex_lock(&state->mutex);
871         if ((!file || !tty_hung_up_p(file)) &&
872             !(tty->flags & (1 << TTY_IO_ERROR))) {
873                 result = port->mctrl;
874
875                 spin_lock_irq(&port->lock);
876                 result |= port->ops->get_mctrl(port);
877                 spin_unlock_irq(&port->lock);
878         }
879         mutex_unlock(&state->mutex);
880
881         return result;
882 }
883
884 static int
885 uart_tiocmset(struct tty_struct *tty, struct file *file,
886               unsigned int set, unsigned int clear)
887 {
888         struct uart_state *state = tty->driver_data;
889         struct uart_port *port = state->port;
890         int ret = -EIO;
891
892         mutex_lock(&state->mutex);
893         if ((!file || !tty_hung_up_p(file)) &&
894             !(tty->flags & (1 << TTY_IO_ERROR))) {
895                 uart_update_mctrl(port, set, clear);
896                 ret = 0;
897         }
898         mutex_unlock(&state->mutex);
899         return ret;
900 }
901
902 static void uart_break_ctl(struct tty_struct *tty, int break_state)
903 {
904         struct uart_state *state = tty->driver_data;
905         struct uart_port *port = state->port;
906
907         BUG_ON(!kernel_locked());
908
909         mutex_lock(&state->mutex);
910
911         if (port->type != PORT_UNKNOWN)
912                 port->ops->break_ctl(port, break_state);
913
914         mutex_unlock(&state->mutex);
915 }
916
917 static int uart_do_autoconfig(struct uart_state *state)
918 {
919         struct uart_port *port = state->port;
920         int flags, ret;
921
922         if (!capable(CAP_SYS_ADMIN))
923                 return -EPERM;
924
925         /*
926          * Take the per-port semaphore.  This prevents count from
927          * changing, and hence any extra opens of the port while
928          * we're auto-configuring.
929          */
930         if (mutex_lock_interruptible(&state->mutex))
931                 return -ERESTARTSYS;
932
933         ret = -EBUSY;
934         if (uart_users(state) == 1) {
935                 uart_shutdown(state);
936
937                 /*
938                  * If we already have a port type configured,
939                  * we must release its resources.
940                  */
941                 if (port->type != PORT_UNKNOWN)
942                         port->ops->release_port(port);
943
944                 flags = UART_CONFIG_TYPE;
945                 if (port->flags & UPF_AUTO_IRQ)
946                         flags |= UART_CONFIG_IRQ;
947
948                 /*
949                  * This will claim the ports resources if
950                  * a port is found.
951                  */
952                 port->ops->config_port(port, flags);
953
954                 ret = uart_startup(state, 1);
955         }
956         mutex_unlock(&state->mutex);
957         return ret;
958 }
959
960 /*
961  * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
962  * - mask passed in arg for lines of interest
963  *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
964  * Caller should use TIOCGICOUNT to see which one it was
965  */
966 static int
967 uart_wait_modem_status(struct uart_state *state, unsigned long arg)
968 {
969         struct uart_port *port = state->port;
970         DECLARE_WAITQUEUE(wait, current);
971         struct uart_icount cprev, cnow;
972         int ret;
973
974         /*
975          * note the counters on entry
976          */
977         spin_lock_irq(&port->lock);
978         memcpy(&cprev, &port->icount, sizeof(struct uart_icount));
979
980         /*
981          * Force modem status interrupts on
982          */
983         port->ops->enable_ms(port);
984         spin_unlock_irq(&port->lock);
985
986         add_wait_queue(&state->info->delta_msr_wait, &wait);
987         for (;;) {
988                 spin_lock_irq(&port->lock);
989                 memcpy(&cnow, &port->icount, sizeof(struct uart_icount));
990                 spin_unlock_irq(&port->lock);
991
992                 set_current_state(TASK_INTERRUPTIBLE);
993
994                 if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
995                     ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
996                     ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
997                     ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
998                         ret = 0;
999                         break;
1000                 }
1001
1002                 schedule();
1003
1004                 /* see if a signal did it */
1005                 if (signal_pending(current)) {
1006                         ret = -ERESTARTSYS;
1007                         break;
1008                 }
1009
1010                 cprev = cnow;
1011         }
1012
1013         current->state = TASK_RUNNING;
1014         remove_wait_queue(&state->info->delta_msr_wait, &wait);
1015
1016         return ret;
1017 }
1018
1019 /*
1020  * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1021  * Return: write counters to the user passed counter struct
1022  * NB: both 1->0 and 0->1 transitions are counted except for
1023  *     RI where only 0->1 is counted.
1024  */
1025 static int uart_get_count(struct uart_state *state,
1026                           struct serial_icounter_struct __user *icnt)
1027 {
1028         struct serial_icounter_struct icount;
1029         struct uart_icount cnow;
1030         struct uart_port *port = state->port;
1031
1032         spin_lock_irq(&port->lock);
1033         memcpy(&cnow, &port->icount, sizeof(struct uart_icount));
1034         spin_unlock_irq(&port->lock);
1035
1036         icount.cts         = cnow.cts;
1037         icount.dsr         = cnow.dsr;
1038         icount.rng         = cnow.rng;
1039         icount.dcd         = cnow.dcd;
1040         icount.rx          = cnow.rx;
1041         icount.tx          = cnow.tx;
1042         icount.frame       = cnow.frame;
1043         icount.overrun     = cnow.overrun;
1044         icount.parity      = cnow.parity;
1045         icount.brk         = cnow.brk;
1046         icount.buf_overrun = cnow.buf_overrun;
1047
1048         return copy_to_user(icnt, &icount, sizeof(icount)) ? -EFAULT : 0;
1049 }
1050
1051 /*
1052  * Called via sys_ioctl under the BKL.  We can use spin_lock_irq() here.
1053  */
1054 static int
1055 uart_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd,
1056            unsigned long arg)
1057 {
1058         struct uart_state *state = tty->driver_data;
1059         void __user *uarg = (void __user *)arg;
1060         int ret = -ENOIOCTLCMD;
1061
1062         BUG_ON(!kernel_locked());
1063
1064         /*
1065          * These ioctls don't rely on the hardware to be present.
1066          */
1067         switch (cmd) {
1068         case TIOCGSERIAL:
1069                 ret = uart_get_info(state, uarg);
1070                 break;
1071
1072         case TIOCSSERIAL:
1073                 ret = uart_set_info(state, uarg);
1074                 break;
1075
1076         case TIOCSERCONFIG:
1077                 ret = uart_do_autoconfig(state);
1078                 break;
1079
1080         case TIOCSERGWILD: /* obsolete */
1081         case TIOCSERSWILD: /* obsolete */
1082                 ret = 0;
1083                 break;
1084         }
1085
1086         if (ret != -ENOIOCTLCMD)
1087                 goto out;
1088
1089         if (tty->flags & (1 << TTY_IO_ERROR)) {
1090                 ret = -EIO;
1091                 goto out;
1092         }
1093
1094         /*
1095          * The following should only be used when hardware is present.
1096          */
1097         switch (cmd) {
1098         case TIOCMIWAIT:
1099                 ret = uart_wait_modem_status(state, arg);
1100                 break;
1101
1102         case TIOCGICOUNT:
1103                 ret = uart_get_count(state, uarg);
1104                 break;
1105         }
1106
1107         if (ret != -ENOIOCTLCMD)
1108                 goto out;
1109
1110         mutex_lock(&state->mutex);
1111
1112         if (tty_hung_up_p(filp)) {
1113                 ret = -EIO;
1114                 goto out_up;
1115         }
1116
1117         /*
1118          * All these rely on hardware being present and need to be
1119          * protected against the tty being hung up.
1120          */
1121         switch (cmd) {
1122         case TIOCSERGETLSR: /* Get line status register */
1123                 ret = uart_get_lsr_info(state, uarg);
1124                 break;
1125
1126         default: {
1127                 struct uart_port *port = state->port;
1128                 if (port->ops->ioctl)
1129                         ret = port->ops->ioctl(port, cmd, arg);
1130                 break;
1131         }
1132         }
1133  out_up:
1134         mutex_unlock(&state->mutex);
1135  out:
1136         return ret;
1137 }
1138
1139 static void uart_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
1140 {
1141         struct uart_state *state = tty->driver_data;
1142         unsigned long flags;
1143         unsigned int cflag = tty->termios->c_cflag;
1144
1145         BUG_ON(!kernel_locked());
1146
1147         /*
1148          * These are the bits that are used to setup various
1149          * flags in the low level driver. We can ignore the Bfoo
1150          * bits in c_cflag; c_[io]speed will always be set
1151          * appropriately by set_termios() in tty_ioctl.c
1152          */
1153 #define RELEVANT_IFLAG(iflag)   ((iflag) & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
1154         if ((cflag ^ old_termios->c_cflag) == 0 &&
1155             tty->termios->c_ospeed == old_termios->c_ospeed &&
1156             tty->termios->c_ispeed == old_termios->c_ispeed &&
1157             RELEVANT_IFLAG(tty->termios->c_iflag ^ old_termios->c_iflag) == 0)
1158                 return;
1159
1160         uart_change_speed(state, old_termios);
1161
1162         /* Handle transition to B0 status */
1163         if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
1164                 uart_clear_mctrl(state->port, TIOCM_RTS | TIOCM_DTR);
1165
1166         /* Handle transition away from B0 status */
1167         if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
1168                 unsigned int mask = TIOCM_DTR;
1169                 if (!(cflag & CRTSCTS) ||
1170                     !test_bit(TTY_THROTTLED, &tty->flags))
1171                         mask |= TIOCM_RTS;
1172                 uart_set_mctrl(state->port, mask);
1173         }
1174
1175         /* Handle turning off CRTSCTS */
1176         if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
1177                 spin_lock_irqsave(&state->port->lock, flags);
1178                 tty->hw_stopped = 0;
1179                 __uart_start(tty);
1180                 spin_unlock_irqrestore(&state->port->lock, flags);
1181         }
1182
1183         /* Handle turning on CRTSCTS */
1184         if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
1185                 spin_lock_irqsave(&state->port->lock, flags);
1186                 if (!(state->port->ops->get_mctrl(state->port) & TIOCM_CTS)) {
1187                         tty->hw_stopped = 1;
1188                         state->port->ops->stop_tx(state->port);
1189                 }
1190                 spin_unlock_irqrestore(&state->port->lock, flags);
1191         }
1192
1193 #if 0
1194         /*
1195          * No need to wake up processes in open wait, since they
1196          * sample the CLOCAL flag once, and don't recheck it.
1197          * XXX  It's not clear whether the current behavior is correct
1198          * or not.  Hence, this may change.....
1199          */
1200         if (!(old_termios->c_cflag & CLOCAL) &&
1201             (tty->termios->c_cflag & CLOCAL))
1202                 wake_up_interruptible(&state->info->open_wait);
1203 #endif
1204 }
1205
1206 /*
1207  * In 2.4.5, calls to this will be serialized via the BKL in
1208  *  linux/drivers/char/tty_io.c:tty_release()
1209  *  linux/drivers/char/tty_io.c:do_tty_handup()
1210  */
1211 static void uart_close(struct tty_struct *tty, struct file *filp)
1212 {
1213         struct uart_state *state = tty->driver_data;
1214         struct uart_port *port;
1215         
1216         BUG_ON(!kernel_locked());
1217
1218         if (!state || !state->port)
1219                 return;
1220
1221         port = state->port;
1222
1223         pr_debug("uart_close(%d) called\n", port->line);
1224
1225         mutex_lock(&state->mutex);
1226
1227         if (tty_hung_up_p(filp))
1228                 goto done;
1229
1230         if ((tty->count == 1) && (state->count != 1)) {
1231                 /*
1232                  * Uh, oh.  tty->count is 1, which means that the tty
1233                  * structure will be freed.  state->count should always
1234                  * be one in these conditions.  If it's greater than
1235                  * one, we've got real problems, since it means the
1236                  * serial port won't be shutdown.
1237                  */
1238                 printk(KERN_ERR "uart_close: bad serial port count; tty->count is 1, "
1239                        "state->count is %d\n", state->count);
1240                 state->count = 1;
1241         }
1242         if (--state->count < 0) {
1243                 printk(KERN_ERR "uart_close: bad serial port count for %s: %d\n",
1244                        tty->name, state->count);
1245                 state->count = 0;
1246         }
1247         if (state->count)
1248                 goto done;
1249
1250         /*
1251          * Now we wait for the transmit buffer to clear; and we notify
1252          * the line discipline to only process XON/XOFF characters by
1253          * setting tty->closing.
1254          */
1255         tty->closing = 1;
1256
1257         if (state->closing_wait != USF_CLOSING_WAIT_NONE)
1258                 tty_wait_until_sent(tty, msecs_to_jiffies(state->closing_wait));
1259
1260         /*
1261          * At this point, we stop accepting input.  To do this, we
1262          * disable the receive line status interrupts.
1263          */
1264         if (state->info->flags & UIF_INITIALIZED) {
1265                 unsigned long flags;
1266                 spin_lock_irqsave(&port->lock, flags);
1267                 port->ops->stop_rx(port);
1268                 spin_unlock_irqrestore(&port->lock, flags);
1269                 /*
1270                  * Before we drop DTR, make sure the UART transmitter
1271                  * has completely drained; this is especially
1272                  * important if there is a transmit FIFO!
1273                  */
1274                 uart_wait_until_sent(tty, port->timeout);
1275         }
1276
1277         uart_shutdown(state);
1278         uart_flush_buffer(tty);
1279
1280         tty_ldisc_flush(tty);   
1281         
1282         tty->closing = 0;
1283         state->info->tty = NULL;
1284
1285         if (state->info->blocked_open) {
1286                 if (state->close_delay)
1287                         msleep_interruptible(state->close_delay);
1288         } else if (!uart_console(port)) {
1289                 uart_change_pm(state, 3);
1290         }
1291
1292         /*
1293          * Wake up anyone trying to open this port.
1294          */
1295         state->info->flags &= ~UIF_NORMAL_ACTIVE;
1296         wake_up_interruptible(&state->info->open_wait);
1297
1298  done:
1299         mutex_unlock(&state->mutex);
1300 }
1301
1302 static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
1303 {
1304         struct uart_state *state = tty->driver_data;
1305         struct uart_port *port = state->port;
1306         unsigned long char_time, expire;
1307
1308         BUG_ON(!kernel_locked());
1309
1310         if (port->type == PORT_UNKNOWN || port->fifosize == 0)
1311                 return;
1312
1313         /*
1314          * Set the check interval to be 1/5 of the estimated time to
1315          * send a single character, and make it at least 1.  The check
1316          * interval should also be less than the timeout.
1317          *
1318          * Note: we have to use pretty tight timings here to satisfy
1319          * the NIST-PCTS.
1320          */
1321         char_time = (port->timeout - HZ/50) / port->fifosize;
1322         char_time = char_time / 5;
1323         if (char_time == 0)
1324                 char_time = 1;
1325         if (timeout && timeout < char_time)
1326                 char_time = timeout;
1327
1328         /*
1329          * If the transmitter hasn't cleared in twice the approximate
1330          * amount of time to send the entire FIFO, it probably won't
1331          * ever clear.  This assumes the UART isn't doing flow
1332          * control, which is currently the case.  Hence, if it ever
1333          * takes longer than port->timeout, this is probably due to a
1334          * UART bug of some kind.  So, we clamp the timeout parameter at
1335          * 2*port->timeout.
1336          */
1337         if (timeout == 0 || timeout > 2 * port->timeout)
1338                 timeout = 2 * port->timeout;
1339
1340         expire = jiffies + timeout;
1341
1342         pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n",
1343                 port->line, jiffies, expire);
1344
1345         /*
1346          * Check whether the transmitter is empty every 'char_time'.
1347          * 'timeout' / 'expire' give us the maximum amount of time
1348          * we wait.
1349          */
1350         while (!port->ops->tx_empty(port)) {
1351                 msleep_interruptible(jiffies_to_msecs(char_time));
1352                 if (signal_pending(current))
1353                         break;
1354                 if (time_after(jiffies, expire))
1355                         break;
1356         }
1357         set_current_state(TASK_RUNNING); /* might not be needed */
1358 }
1359
1360 /*
1361  * This is called with the BKL held in
1362  *  linux/drivers/char/tty_io.c:do_tty_hangup()
1363  * We're called from the eventd thread, so we can sleep for
1364  * a _short_ time only.
1365  */
1366 static void uart_hangup(struct tty_struct *tty)
1367 {
1368         struct uart_state *state = tty->driver_data;
1369
1370         BUG_ON(!kernel_locked());
1371         pr_debug("uart_hangup(%d)\n", state->port->line);
1372
1373         mutex_lock(&state->mutex);
1374         if (state->info && state->info->flags & UIF_NORMAL_ACTIVE) {
1375                 uart_flush_buffer(tty);
1376                 uart_shutdown(state);
1377                 state->count = 0;
1378                 state->info->flags &= ~UIF_NORMAL_ACTIVE;
1379                 state->info->tty = NULL;
1380                 wake_up_interruptible(&state->info->open_wait);
1381                 wake_up_interruptible(&state->info->delta_msr_wait);
1382         }
1383         mutex_unlock(&state->mutex);
1384 }
1385
1386 /*
1387  * Copy across the serial console cflag setting into the termios settings
1388  * for the initial open of the port.  This allows continuity between the
1389  * kernel settings, and the settings init adopts when it opens the port
1390  * for the first time.
1391  */
1392 static void uart_update_termios(struct uart_state *state)
1393 {
1394         struct tty_struct *tty = state->info->tty;
1395         struct uart_port *port = state->port;
1396
1397         if (uart_console(port) && port->cons->cflag) {
1398                 tty->termios->c_cflag = port->cons->cflag;
1399                 port->cons->cflag = 0;
1400         }
1401
1402         /*
1403          * If the device failed to grab its irq resources,
1404          * or some other error occurred, don't try to talk
1405          * to the port hardware.
1406          */
1407         if (!(tty->flags & (1 << TTY_IO_ERROR))) {
1408                 /*
1409                  * Make termios settings take effect.
1410                  */
1411                 uart_change_speed(state, NULL);
1412
1413                 /*
1414                  * And finally enable the RTS and DTR signals.
1415                  */
1416                 if (tty->termios->c_cflag & CBAUD)
1417                         uart_set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1418         }
1419 }
1420
1421 /*
1422  * Block the open until the port is ready.  We must be called with
1423  * the per-port semaphore held.
1424  */
1425 static int
1426 uart_block_til_ready(struct file *filp, struct uart_state *state)
1427 {
1428         DECLARE_WAITQUEUE(wait, current);
1429         struct uart_info *info = state->info;
1430         struct uart_port *port = state->port;
1431         unsigned int mctrl;
1432
1433         info->blocked_open++;
1434         state->count--;
1435
1436         add_wait_queue(&info->open_wait, &wait);
1437         while (1) {
1438                 set_current_state(TASK_INTERRUPTIBLE);
1439
1440                 /*
1441                  * If we have been hung up, tell userspace/restart open.
1442                  */
1443                 if (tty_hung_up_p(filp) || info->tty == NULL)
1444                         break;
1445
1446                 /*
1447                  * If the port has been closed, tell userspace/restart open.
1448                  */
1449                 if (!(info->flags & UIF_INITIALIZED))
1450                         break;
1451
1452                 /*
1453                  * If non-blocking mode is set, or CLOCAL mode is set,
1454                  * we don't want to wait for the modem status lines to
1455                  * indicate that the port is ready.
1456                  *
1457                  * Also, if the port is not enabled/configured, we want
1458                  * to allow the open to succeed here.  Note that we will
1459                  * have set TTY_IO_ERROR for a non-existant port.
1460                  */
1461                 if ((filp->f_flags & O_NONBLOCK) ||
1462                     (info->tty->termios->c_cflag & CLOCAL) ||
1463                     (info->tty->flags & (1 << TTY_IO_ERROR))) {
1464                         break;
1465                 }
1466
1467                 /*
1468                  * Set DTR to allow modem to know we're waiting.  Do
1469                  * not set RTS here - we want to make sure we catch
1470                  * the data from the modem.
1471                  */
1472                 if (info->tty->termios->c_cflag & CBAUD)
1473                         uart_set_mctrl(port, TIOCM_DTR);
1474
1475                 /*
1476                  * and wait for the carrier to indicate that the
1477                  * modem is ready for us.
1478                  */
1479                 spin_lock_irq(&port->lock);
1480                 port->ops->enable_ms(port);
1481                 mctrl = port->ops->get_mctrl(port);
1482                 spin_unlock_irq(&port->lock);
1483                 if (mctrl & TIOCM_CAR)
1484                         break;
1485
1486                 mutex_unlock(&state->mutex);
1487                 schedule();
1488                 mutex_lock(&state->mutex);
1489
1490                 if (signal_pending(current))
1491                         break;
1492         }
1493         set_current_state(TASK_RUNNING);
1494         remove_wait_queue(&info->open_wait, &wait);
1495
1496         state->count++;
1497         info->blocked_open--;
1498
1499         if (signal_pending(current))
1500                 return -ERESTARTSYS;
1501
1502         if (!info->tty || tty_hung_up_p(filp))
1503                 return -EAGAIN;
1504
1505         return 0;
1506 }
1507
1508 static struct uart_state *uart_get(struct uart_driver *drv, int line)
1509 {
1510         struct uart_state *state;
1511         int ret = 0;
1512
1513         state = drv->state + line;
1514         if (mutex_lock_interruptible(&state->mutex)) {
1515                 ret = -ERESTARTSYS;
1516                 goto err;
1517         }
1518
1519         state->count++;
1520         if (!state->port || state->port->flags & UPF_DEAD) {
1521                 ret = -ENXIO;
1522                 goto err_unlock;
1523         }
1524
1525         if (!state->info) {
1526                 state->info = kzalloc(sizeof(struct uart_info), GFP_KERNEL);
1527                 if (state->info) {
1528                         init_waitqueue_head(&state->info->open_wait);
1529                         init_waitqueue_head(&state->info->delta_msr_wait);
1530
1531                         /*
1532                          * Link the info into the other structures.
1533                          */
1534                         state->port->info = state->info;
1535
1536                         tasklet_init(&state->info->tlet, uart_tasklet_action,
1537                                      (unsigned long)state);
1538                 } else {
1539                         ret = -ENOMEM;
1540                         goto err_unlock;
1541                 }
1542         }
1543         return state;
1544
1545  err_unlock:
1546         state->count--;
1547         mutex_unlock(&state->mutex);
1548  err:
1549         return ERR_PTR(ret);
1550 }
1551
1552 /*
1553  * In 2.4.5, calls to uart_open are serialised by the BKL in
1554  *   linux/fs/devices.c:chrdev_open()
1555  * Note that if this fails, then uart_close() _will_ be called.
1556  *
1557  * In time, we want to scrap the "opening nonpresent ports"
1558  * behaviour and implement an alternative way for setserial
1559  * to set base addresses/ports/types.  This will allow us to
1560  * get rid of a certain amount of extra tests.
1561  */
1562 static int uart_open(struct tty_struct *tty, struct file *filp)
1563 {
1564         struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;
1565         struct uart_state *state;
1566         int retval, line = tty->index;
1567
1568         BUG_ON(!kernel_locked());
1569         pr_debug("uart_open(%d) called\n", line);
1570
1571         /*
1572          * tty->driver->num won't change, so we won't fail here with
1573          * tty->driver_data set to something non-NULL (and therefore
1574          * we won't get caught by uart_close()).
1575          */
1576         retval = -ENODEV;
1577         if (line >= tty->driver->num)
1578                 goto fail;
1579
1580         /*
1581          * We take the semaphore inside uart_get to guarantee that we won't
1582          * be re-entered while allocating the info structure, or while we
1583          * request any IRQs that the driver may need.  This also has the nice
1584          * side-effect that it delays the action of uart_hangup, so we can
1585          * guarantee that info->tty will always contain something reasonable.
1586          */
1587         state = uart_get(drv, line);
1588         if (IS_ERR(state)) {
1589                 retval = PTR_ERR(state);
1590                 goto fail;
1591         }
1592
1593         /*
1594          * Once we set tty->driver_data here, we are guaranteed that
1595          * uart_close() will decrement the driver module use count.
1596          * Any failures from here onwards should not touch the count.
1597          */
1598         tty->driver_data = state;
1599         tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0;
1600         tty->alt_speed = 0;
1601         state->info->tty = tty;
1602
1603         /*
1604          * If the port is in the middle of closing, bail out now.
1605          */
1606         if (tty_hung_up_p(filp)) {
1607                 retval = -EAGAIN;
1608                 state->count--;
1609                 mutex_unlock(&state->mutex);
1610                 goto fail;
1611         }
1612
1613         /*
1614          * Make sure the device is in D0 state.
1615          */
1616         if (state->count == 1)
1617                 uart_change_pm(state, 0);
1618
1619         /*
1620          * Start up the serial port.
1621          */
1622         retval = uart_startup(state, 0);
1623
1624         /*
1625          * If we succeeded, wait until the port is ready.
1626          */
1627         if (retval == 0)
1628                 retval = uart_block_til_ready(filp, state);
1629         mutex_unlock(&state->mutex);
1630
1631         /*
1632          * If this is the first open to succeed, adjust things to suit.
1633          */
1634         if (retval == 0 && !(state->info->flags & UIF_NORMAL_ACTIVE)) {
1635                 state->info->flags |= UIF_NORMAL_ACTIVE;
1636
1637                 uart_update_termios(state);
1638         }
1639
1640  fail:
1641         return retval;
1642 }
1643
1644 static const char *uart_type(struct uart_port *port)
1645 {
1646         const char *str = NULL;
1647
1648         if (port->ops->type)
1649                 str = port->ops->type(port);
1650
1651         if (!str)
1652                 str = "unknown";
1653
1654         return str;
1655 }
1656
1657 #ifdef CONFIG_PROC_FS
1658
1659 static int uart_line_info(char *buf, struct uart_driver *drv, int i)
1660 {
1661         struct uart_state *state = drv->state + i;
1662         int pm_state;
1663         struct uart_port *port = state->port;
1664         char stat_buf[32];
1665         unsigned int status;
1666         int mmio, ret;
1667
1668         if (!port)
1669                 return 0;
1670
1671         mmio = port->iotype >= UPIO_MEM;
1672         ret = sprintf(buf, "%d: uart:%s %s%08llX irq:%d",
1673                         port->line, uart_type(port),
1674                         mmio ? "mmio:0x" : "port:",
1675                         mmio ? (unsigned long long)port->mapbase
1676                              : (unsigned long long) port->iobase,
1677                         port->irq);
1678
1679         if (port->type == PORT_UNKNOWN) {
1680                 strcat(buf, "\n");
1681                 return ret + 1;
1682         }
1683
1684         if(capable(CAP_SYS_ADMIN))
1685         {
1686                 mutex_lock(&state->mutex);
1687                 pm_state = state->pm_state;
1688                 if (pm_state)
1689                         uart_change_pm(state, 0);
1690                 spin_lock_irq(&port->lock);
1691                 status = port->ops->get_mctrl(port);
1692                 spin_unlock_irq(&port->lock);
1693                 if (pm_state)
1694                         uart_change_pm(state, pm_state);
1695                 mutex_unlock(&state->mutex);
1696
1697                 ret += sprintf(buf + ret, " tx:%d rx:%d",
1698                                 port->icount.tx, port->icount.rx);
1699                 if (port->icount.frame)
1700                         ret += sprintf(buf + ret, " fe:%d",
1701                                 port->icount.frame);
1702                 if (port->icount.parity)
1703                         ret += sprintf(buf + ret, " pe:%d",
1704                                 port->icount.parity);
1705                 if (port->icount.brk)
1706                         ret += sprintf(buf + ret, " brk:%d",
1707                                 port->icount.brk);
1708                 if (port->icount.overrun)
1709                         ret += sprintf(buf + ret, " oe:%d",
1710                                 port->icount.overrun);
1711         
1712 #define INFOBIT(bit,str) \
1713         if (port->mctrl & (bit)) \
1714                 strncat(stat_buf, (str), sizeof(stat_buf) - \
1715                         strlen(stat_buf) - 2)
1716 #define STATBIT(bit,str) \
1717         if (status & (bit)) \
1718                 strncat(stat_buf, (str), sizeof(stat_buf) - \
1719                        strlen(stat_buf) - 2)
1720
1721                 stat_buf[0] = '\0';
1722                 stat_buf[1] = '\0';
1723                 INFOBIT(TIOCM_RTS, "|RTS");
1724                 STATBIT(TIOCM_CTS, "|CTS");
1725                 INFOBIT(TIOCM_DTR, "|DTR");
1726                 STATBIT(TIOCM_DSR, "|DSR");
1727                 STATBIT(TIOCM_CAR, "|CD");
1728                 STATBIT(TIOCM_RNG, "|RI");
1729                 if (stat_buf[0])
1730                         stat_buf[0] = ' ';
1731                 strcat(stat_buf, "\n");
1732         
1733                 ret += sprintf(buf + ret, stat_buf);
1734         } else {
1735                 strcat(buf, "\n");
1736                 ret++;
1737         }
1738 #undef STATBIT
1739 #undef INFOBIT
1740         return ret;
1741 }
1742
1743 static int uart_read_proc(char *page, char **start, off_t off,
1744                           int count, int *eof, void *data)
1745 {
1746         struct tty_driver *ttydrv = data;
1747         struct uart_driver *drv = ttydrv->driver_state;
1748         int i, len = 0, l;
1749         off_t begin = 0;
1750
1751         len += sprintf(page, "serinfo:1.0 driver%s%s revision:%s\n",
1752                         "", "", "");
1753         for (i = 0; i < drv->nr && len < PAGE_SIZE - 96; i++) {
1754                 l = uart_line_info(page + len, drv, i);
1755                 len += l;
1756                 if (len + begin > off + count)
1757                         goto done;
1758                 if (len + begin < off) {
1759                         begin += len;
1760                         len = 0;
1761                 }
1762         }
1763         *eof = 1;
1764  done:
1765         if (off >= len + begin)
1766                 return 0;
1767         *start = page + (off - begin);
1768         return (count < begin + len - off) ? count : (begin + len - off);
1769 }
1770 #endif
1771
1772 #ifdef CONFIG_SERIAL_CORE_CONSOLE
1773 /*
1774  *      uart_console_write - write a console message to a serial port
1775  *      @port: the port to write the message
1776  *      @s: array of characters
1777  *      @count: number of characters in string to write
1778  *      @write: function to write character to port
1779  */
1780 void uart_console_write(struct uart_port *port, const char *s,
1781                         unsigned int count,
1782                         void (*putchar)(struct uart_port *, int))
1783 {
1784         unsigned int i;
1785
1786         for (i = 0; i < count; i++, s++) {
1787                 if (*s == '\n')
1788                         putchar(port, '\r');
1789                 putchar(port, *s);
1790         }
1791 }
1792 EXPORT_SYMBOL_GPL(uart_console_write);
1793
1794 /*
1795  *      Check whether an invalid uart number has been specified, and
1796  *      if so, search for the first available port that does have
1797  *      console support.
1798  */
1799 struct uart_port * __init
1800 uart_get_console(struct uart_port *ports, int nr, struct console *co)
1801 {
1802         int idx = co->index;
1803
1804         if (idx < 0 || idx >= nr || (ports[idx].iobase == 0 &&
1805                                      ports[idx].membase == NULL))
1806                 for (idx = 0; idx < nr; idx++)
1807                         if (ports[idx].iobase != 0 ||
1808                             ports[idx].membase != NULL)
1809                                 break;
1810
1811         co->index = idx;
1812
1813         return ports + idx;
1814 }
1815
1816 /**
1817  *      uart_parse_options - Parse serial port baud/parity/bits/flow contro.
1818  *      @options: pointer to option string
1819  *      @baud: pointer to an 'int' variable for the baud rate.
1820  *      @parity: pointer to an 'int' variable for the parity.
1821  *      @bits: pointer to an 'int' variable for the number of data bits.
1822  *      @flow: pointer to an 'int' variable for the flow control character.
1823  *
1824  *      uart_parse_options decodes a string containing the serial console
1825  *      options.  The format of the string is <baud><parity><bits><flow>,
1826  *      eg: 115200n8r
1827  */
1828 void __init
1829 uart_parse_options(char *options, int *baud, int *parity, int *bits, int *flow)
1830 {
1831         char *s = options;
1832
1833         *baud = simple_strtoul(s, NULL, 10);
1834         while (*s >= '0' && *s <= '9')
1835                 s++;
1836         if (*s)
1837                 *parity = *s++;
1838         if (*s)
1839                 *bits = *s++ - '0';
1840         if (*s)
1841                 *flow = *s;
1842 }
1843
1844 struct baud_rates {
1845         unsigned int rate;
1846         unsigned int cflag;
1847 };
1848
1849 static const struct baud_rates baud_rates[] = {
1850         { 921600, B921600 },
1851         { 460800, B460800 },
1852         { 230400, B230400 },
1853         { 115200, B115200 },
1854         {  57600, B57600  },
1855         {  38400, B38400  },
1856         {  19200, B19200  },
1857         {   9600, B9600   },
1858         {   4800, B4800   },
1859         {   2400, B2400   },
1860         {   1200, B1200   },
1861         {      0, B38400  }
1862 };
1863
1864 /**
1865  *      uart_set_options - setup the serial console parameters
1866  *      @port: pointer to the serial ports uart_port structure
1867  *      @co: console pointer
1868  *      @baud: baud rate
1869  *      @parity: parity character - 'n' (none), 'o' (odd), 'e' (even)
1870  *      @bits: number of data bits
1871  *      @flow: flow control character - 'r' (rts)
1872  */
1873 int __init
1874 uart_set_options(struct uart_port *port, struct console *co,
1875                  int baud, int parity, int bits, int flow)
1876 {
1877         struct ktermios termios;
1878         static struct ktermios dummy;
1879         int i;
1880
1881         /*
1882          * Ensure that the serial console lock is initialised
1883          * early.
1884          */
1885         spin_lock_init(&port->lock);
1886         lockdep_set_class(&port->lock, &port_lock_key);
1887
1888         memset(&termios, 0, sizeof(struct ktermios));
1889
1890         termios.c_cflag = CREAD | HUPCL | CLOCAL;
1891
1892         /*
1893          * Construct a cflag setting.
1894          */
1895         for (i = 0; baud_rates[i].rate; i++)
1896                 if (baud_rates[i].rate <= baud)
1897                         break;
1898
1899         termios.c_cflag |= baud_rates[i].cflag;
1900
1901         if (bits == 7)
1902                 termios.c_cflag |= CS7;
1903         else
1904                 termios.c_cflag |= CS8;
1905
1906         switch (parity) {
1907         case 'o': case 'O':
1908                 termios.c_cflag |= PARODD;
1909                 /*fall through*/
1910         case 'e': case 'E':
1911                 termios.c_cflag |= PARENB;
1912                 break;
1913         }
1914
1915         if (flow == 'r')
1916                 termios.c_cflag |= CRTSCTS;
1917
1918         /*
1919          * some uarts on other side don't support no flow control.
1920          * So we set * DTR in host uart to make them happy
1921          */
1922         port->mctrl |= TIOCM_DTR;
1923
1924         port->ops->set_termios(port, &termios, &dummy);
1925         co->cflag = termios.c_cflag;
1926
1927         return 0;
1928 }
1929 #endif /* CONFIG_SERIAL_CORE_CONSOLE */
1930
1931 static void uart_change_pm(struct uart_state *state, int pm_state)
1932 {
1933         struct uart_port *port = state->port;
1934
1935         if (state->pm_state != pm_state) {
1936                 if (port->ops->pm)
1937                         port->ops->pm(port, pm_state, state->pm_state);
1938                 state->pm_state = pm_state;
1939         }
1940 }
1941
1942 struct uart_match {
1943         struct uart_port *port;
1944         struct uart_driver *driver;
1945 };
1946
1947 static int serial_match_port(struct device *dev, void *data)
1948 {
1949         struct uart_match *match = data;
1950         dev_t devt = MKDEV(match->driver->major, match->driver->minor) + match->port->line;
1951
1952         return dev->devt == devt; /* Actually, only one tty per port */
1953 }
1954
1955 int uart_suspend_port(struct uart_driver *drv, struct uart_port *port)
1956 {
1957         struct uart_state *state = drv->state + port->line;
1958         struct device *tty_dev;
1959         struct uart_match match = {port, drv};
1960
1961         mutex_lock(&state->mutex);
1962
1963         if (!console_suspend_enabled && uart_console(port)) {
1964                 /* we're going to avoid suspending serial console */
1965                 mutex_unlock(&state->mutex);
1966                 return 0;
1967         }
1968
1969         tty_dev = device_find_child(port->dev, &match, serial_match_port);
1970         if (device_may_wakeup(tty_dev)) {
1971                 enable_irq_wake(port->irq);
1972                 put_device(tty_dev);
1973                 mutex_unlock(&state->mutex);
1974                 return 0;
1975         }
1976         port->suspended = 1;
1977
1978         if (state->info && state->info->flags & UIF_INITIALIZED) {
1979                 const struct uart_ops *ops = port->ops;
1980
1981                 state->info->flags = (state->info->flags & ~UIF_INITIALIZED)
1982                                      | UIF_SUSPENDED;
1983
1984                 spin_lock_irq(&port->lock);
1985                 ops->stop_tx(port);
1986                 ops->set_mctrl(port, 0);
1987                 ops->stop_rx(port);
1988                 spin_unlock_irq(&port->lock);
1989
1990                 /*
1991                  * Wait for the transmitter to empty.
1992                  */
1993                 while (!ops->tx_empty(port)) {
1994                         msleep(10);
1995                 }
1996
1997                 ops->shutdown(port);
1998         }
1999
2000         /*
2001          * Disable the console device before suspending.
2002          */
2003         if (uart_console(port))
2004                 console_stop(port->cons);
2005
2006         uart_change_pm(state, 3);
2007
2008         mutex_unlock(&state->mutex);
2009
2010         return 0;
2011 }
2012
2013 int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
2014 {
2015         struct uart_state *state = drv->state + port->line;
2016
2017         mutex_lock(&state->mutex);
2018
2019         if (!console_suspend_enabled && uart_console(port)) {
2020                 /* no need to resume serial console, it wasn't suspended */
2021                 mutex_unlock(&state->mutex);
2022                 return 0;
2023         }
2024
2025         if (!port->suspended) {
2026                 disable_irq_wake(port->irq);
2027                 mutex_unlock(&state->mutex);
2028                 return 0;
2029         }
2030         port->suspended = 0;
2031
2032         uart_change_pm(state, 0);
2033
2034         /*
2035          * Re-enable the console device after suspending.
2036          */
2037         if (uart_console(port)) {
2038                 struct ktermios termios;
2039
2040                 /*
2041                  * First try to use the console cflag setting.
2042                  */
2043                 memset(&termios, 0, sizeof(struct ktermios));
2044                 termios.c_cflag = port->cons->cflag;
2045
2046                 /*
2047                  * If that's unset, use the tty termios setting.
2048                  */
2049                 if (state->info && state->info->tty && termios.c_cflag == 0)
2050                         termios = *state->info->tty->termios;
2051
2052                 port->ops->set_termios(port, &termios, NULL);
2053                 console_start(port->cons);
2054         }
2055
2056         if (state->info && state->info->flags & UIF_SUSPENDED) {
2057                 const struct uart_ops *ops = port->ops;
2058                 int ret;
2059
2060                 ops->set_mctrl(port, 0);
2061                 ret = ops->startup(port);
2062                 if (ret == 0) {
2063                         uart_change_speed(state, NULL);
2064                         spin_lock_irq(&port->lock);
2065                         ops->set_mctrl(port, port->mctrl);
2066                         ops->start_tx(port);
2067                         spin_unlock_irq(&port->lock);
2068                         state->info->flags |= UIF_INITIALIZED;
2069                 } else {
2070                         /*
2071                          * Failed to resume - maybe hardware went away?
2072                          * Clear the "initialized" flag so we won't try
2073                          * to call the low level drivers shutdown method.
2074                          */
2075                         uart_shutdown(state);
2076                 }
2077
2078                 state->info->flags &= ~UIF_SUSPENDED;
2079         }
2080
2081         mutex_unlock(&state->mutex);
2082
2083         return 0;
2084 }
2085
2086 static inline void
2087 uart_report_port(struct uart_driver *drv, struct uart_port *port)
2088 {
2089         char address[64];
2090
2091         switch (port->iotype) {
2092         case UPIO_PORT:
2093                 snprintf(address, sizeof(address),
2094                          "I/O 0x%x", port->iobase);
2095                 break;
2096         case UPIO_HUB6:
2097                 snprintf(address, sizeof(address),
2098                          "I/O 0x%x offset 0x%x", port->iobase, port->hub6);
2099                 break;
2100         case UPIO_MEM:
2101         case UPIO_MEM32:
2102         case UPIO_AU:
2103         case UPIO_TSI:
2104         case UPIO_DWAPB:
2105                 snprintf(address, sizeof(address),
2106                          "MMIO 0x%llx", (unsigned long long)port->mapbase);
2107                 break;
2108         default:
2109                 strlcpy(address, "*unknown*", sizeof(address));
2110                 break;
2111         }
2112
2113         printk(KERN_INFO "%s%s%s%d at %s (irq = %d) is a %s\n",
2114                port->dev ? port->dev->bus_id : "",
2115                port->dev ? ": " : "",
2116                drv->dev_name, port->line, address, port->irq, uart_type(port));
2117 }
2118
2119 static void
2120 uart_configure_port(struct uart_driver *drv, struct uart_state *state,
2121                     struct uart_port *port)
2122 {
2123         unsigned int flags;
2124
2125         /*
2126          * If there isn't a port here, don't do anything further.
2127          */
2128         if (!port->iobase && !port->mapbase && !port->membase)
2129                 return;
2130
2131         /*
2132          * Now do the auto configuration stuff.  Note that config_port
2133          * is expected to claim the resources and map the port for us.
2134          */
2135         flags = UART_CONFIG_TYPE;
2136         if (port->flags & UPF_AUTO_IRQ)
2137                 flags |= UART_CONFIG_IRQ;
2138         if (port->flags & UPF_BOOT_AUTOCONF) {
2139                 port->type = PORT_UNKNOWN;
2140                 port->ops->config_port(port, flags);
2141         }
2142
2143         if (port->type != PORT_UNKNOWN) {
2144                 unsigned long flags;
2145
2146                 uart_report_port(drv, port);
2147
2148                 /* Power up port for set_mctrl() */
2149                 uart_change_pm(state, 0);
2150
2151                 /*
2152                  * Ensure that the modem control lines are de-activated.
2153                  * We probably don't need a spinlock around this, but
2154                  */
2155                 spin_lock_irqsave(&port->lock, flags);
2156                 port->ops->set_mctrl(port, 0);
2157                 spin_unlock_irqrestore(&port->lock, flags);
2158
2159                 /*
2160                  * If this driver supports console, and it hasn't been
2161                  * successfully registered yet, try to re-register it.
2162                  * It may be that the port was not available.
2163                  */
2164                 if (port->cons && !(port->cons->flags & CON_ENABLED))
2165                         register_console(port->cons);
2166
2167                 /*
2168                  * Power down all ports by default, except the
2169                  * console if we have one.
2170                  */
2171                 if (!uart_console(port))
2172                         uart_change_pm(state, 3);
2173         }
2174 }
2175
2176 static const struct tty_operations uart_ops = {
2177         .open           = uart_open,
2178         .close          = uart_close,
2179         .write          = uart_write,
2180         .put_char       = uart_put_char,
2181         .flush_chars    = uart_flush_chars,
2182         .write_room     = uart_write_room,
2183         .chars_in_buffer= uart_chars_in_buffer,
2184         .flush_buffer   = uart_flush_buffer,
2185         .ioctl          = uart_ioctl,
2186         .throttle       = uart_throttle,
2187         .unthrottle     = uart_unthrottle,
2188         .send_xchar     = uart_send_xchar,
2189         .set_termios    = uart_set_termios,
2190         .stop           = uart_stop,
2191         .start          = uart_start,
2192         .hangup         = uart_hangup,
2193         .break_ctl      = uart_break_ctl,
2194         .wait_until_sent= uart_wait_until_sent,
2195 #ifdef CONFIG_PROC_FS
2196         .read_proc      = uart_read_proc,
2197 #endif
2198         .tiocmget       = uart_tiocmget,
2199         .tiocmset       = uart_tiocmset,
2200 };
2201
2202 /**
2203  *      uart_register_driver - register a driver with the uart core layer
2204  *      @drv: low level driver structure
2205  *
2206  *      Register a uart driver with the core driver.  We in turn register
2207  *      with the tty layer, and initialise the core driver per-port state.
2208  *
2209  *      We have a proc file in /proc/tty/driver which is named after the
2210  *      normal driver.
2211  *
2212  *      drv->port should be NULL, and the per-port structures should be
2213  *      registered using uart_add_one_port after this call has succeeded.
2214  */
2215 int uart_register_driver(struct uart_driver *drv)
2216 {
2217         struct tty_driver *normal = NULL;
2218         int i, retval;
2219
2220         BUG_ON(drv->state);
2221
2222         /*
2223          * Maybe we should be using a slab cache for this, especially if
2224          * we have a large number of ports to handle.
2225          */
2226         drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
2227         retval = -ENOMEM;
2228         if (!drv->state)
2229                 goto out;
2230
2231         normal  = alloc_tty_driver(drv->nr);
2232         if (!normal)
2233                 goto out;
2234
2235         drv->tty_driver = normal;
2236
2237         normal->owner           = drv->owner;
2238         normal->driver_name     = drv->driver_name;
2239         normal->name            = drv->dev_name;
2240         normal->major           = drv->major;
2241         normal->minor_start     = drv->minor;
2242         normal->type            = TTY_DRIVER_TYPE_SERIAL;
2243         normal->subtype         = SERIAL_TYPE_NORMAL;
2244         normal->init_termios    = tty_std_termios;
2245         normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2246         normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
2247         normal->flags           = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
2248         normal->driver_state    = drv;
2249         tty_set_operations(normal, &uart_ops);
2250
2251         /*
2252          * Initialise the UART state(s).
2253          */
2254         for (i = 0; i < drv->nr; i++) {
2255                 struct uart_state *state = drv->state + i;
2256
2257                 state->close_delay     = 500;   /* .5 seconds */
2258                 state->closing_wait    = 30000; /* 30 seconds */
2259
2260                 mutex_init(&state->mutex);
2261         }
2262
2263         retval = tty_register_driver(normal);
2264  out:
2265         if (retval < 0) {
2266                 put_tty_driver(normal);
2267                 kfree(drv->state);
2268         }
2269         return retval;
2270 }
2271
2272 /**
2273  *      uart_unregister_driver - remove a driver from the uart core layer
2274  *      @drv: low level driver structure
2275  *
2276  *      Remove all references to a driver from the core driver.  The low
2277  *      level driver must have removed all its ports via the
2278  *      uart_remove_one_port() if it registered them with uart_add_one_port().
2279  *      (ie, drv->port == NULL)
2280  */
2281 void uart_unregister_driver(struct uart_driver *drv)
2282 {
2283         struct tty_driver *p = drv->tty_driver;
2284         tty_unregister_driver(p);
2285         put_tty_driver(p);
2286         kfree(drv->state);
2287         drv->tty_driver = NULL;
2288 }
2289
2290 struct tty_driver *uart_console_device(struct console *co, int *index)
2291 {
2292         struct uart_driver *p = co->data;
2293         *index = co->index;
2294         return p->tty_driver;
2295 }
2296
2297 /**
2298  *      uart_add_one_port - attach a driver-defined port structure
2299  *      @drv: pointer to the uart low level driver structure for this port
2300  *      @port: uart port structure to use for this port.
2301  *
2302  *      This allows the driver to register its own uart_port structure
2303  *      with the core driver.  The main purpose is to allow the low
2304  *      level uart drivers to expand uart_port, rather than having yet
2305  *      more levels of structures.
2306  */
2307 int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)
2308 {
2309         struct uart_state *state;
2310         int ret = 0;
2311         struct device *tty_dev;
2312
2313         BUG_ON(in_interrupt());
2314
2315         if (port->line >= drv->nr)
2316                 return -EINVAL;
2317
2318         state = drv->state + port->line;
2319
2320         mutex_lock(&port_mutex);
2321         mutex_lock(&state->mutex);
2322         if (state->port) {
2323                 ret = -EINVAL;
2324                 goto out;
2325         }
2326
2327         state->port = port;
2328         state->pm_state = -1;
2329
2330         port->cons = drv->cons;
2331         port->info = state->info;
2332
2333         /*
2334          * If this port is a console, then the spinlock is already
2335          * initialised.
2336          */
2337         if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) {
2338                 spin_lock_init(&port->lock);
2339                 lockdep_set_class(&port->lock, &port_lock_key);
2340         }
2341
2342         uart_configure_port(drv, state, port);
2343
2344         /*
2345          * Register the port whether it's detected or not.  This allows
2346          * setserial to be used to alter this ports parameters.
2347          */
2348         tty_dev = tty_register_device(drv->tty_driver, port->line, port->dev);
2349         if (likely(!IS_ERR(tty_dev))) {
2350                 device_can_wakeup(tty_dev) = 1;
2351                 device_set_wakeup_enable(tty_dev, 0);
2352         } else
2353                 printk(KERN_ERR "Cannot register tty device on line %d\n",
2354                        port->line);
2355
2356         /*
2357          * Ensure UPF_DEAD is not set.
2358          */
2359         port->flags &= ~UPF_DEAD;
2360
2361  out:
2362         mutex_unlock(&state->mutex);
2363         mutex_unlock(&port_mutex);
2364
2365         return ret;
2366 }
2367
2368 /**
2369  *      uart_remove_one_port - detach a driver defined port structure
2370  *      @drv: pointer to the uart low level driver structure for this port
2371  *      @port: uart port structure for this port
2372  *
2373  *      This unhooks (and hangs up) the specified port structure from the
2374  *      core driver.  No further calls will be made to the low-level code
2375  *      for this port.
2376  */
2377 int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
2378 {
2379         struct uart_state *state = drv->state + port->line;
2380         struct uart_info *info;
2381
2382         BUG_ON(in_interrupt());
2383
2384         if (state->port != port)
2385                 printk(KERN_ALERT "Removing wrong port: %p != %p\n",
2386                         state->port, port);
2387
2388         mutex_lock(&port_mutex);
2389
2390         /*
2391          * Mark the port "dead" - this prevents any opens from
2392          * succeeding while we shut down the port.
2393          */
2394         mutex_lock(&state->mutex);
2395         port->flags |= UPF_DEAD;
2396         mutex_unlock(&state->mutex);
2397
2398         /*
2399          * Remove the devices from the tty layer
2400          */
2401         tty_unregister_device(drv->tty_driver, port->line);
2402
2403         info = state->info;
2404         if (info && info->tty)
2405                 tty_vhangup(info->tty);
2406
2407         /*
2408          * All users of this port should now be disconnected from
2409          * this driver, and the port shut down.  We should be the
2410          * only thread fiddling with this port from now on.
2411          */
2412         state->info = NULL;
2413
2414         /*
2415          * Free the port IO and memory resources, if any.
2416          */
2417         if (port->type != PORT_UNKNOWN)
2418                 port->ops->release_port(port);
2419
2420         /*
2421          * Indicate that there isn't a port here anymore.
2422          */
2423         port->type = PORT_UNKNOWN;
2424
2425         /*
2426          * Kill the tasklet, and free resources.
2427          */
2428         if (info) {
2429                 tasklet_kill(&info->tlet);
2430                 kfree(info);
2431         }
2432
2433         state->port = NULL;
2434         mutex_unlock(&port_mutex);
2435
2436         return 0;
2437 }
2438
2439 /*
2440  *      Are the two ports equivalent?
2441  */
2442 int uart_match_port(struct uart_port *port1, struct uart_port *port2)
2443 {
2444         if (port1->iotype != port2->iotype)
2445                 return 0;
2446
2447         switch (port1->iotype) {
2448         case UPIO_PORT:
2449                 return (port1->iobase == port2->iobase);
2450         case UPIO_HUB6:
2451                 return (port1->iobase == port2->iobase) &&
2452                        (port1->hub6   == port2->hub6);
2453         case UPIO_MEM:
2454         case UPIO_MEM32:
2455         case UPIO_AU:
2456         case UPIO_TSI:
2457         case UPIO_DWAPB:
2458                 return (port1->mapbase == port2->mapbase);
2459         }
2460         return 0;
2461 }
2462 EXPORT_SYMBOL(uart_match_port);
2463
2464 EXPORT_SYMBOL(uart_write_wakeup);
2465 EXPORT_SYMBOL(uart_register_driver);
2466 EXPORT_SYMBOL(uart_unregister_driver);
2467 EXPORT_SYMBOL(uart_suspend_port);
2468 EXPORT_SYMBOL(uart_resume_port);
2469 EXPORT_SYMBOL(uart_add_one_port);
2470 EXPORT_SYMBOL(uart_remove_one_port);
2471
2472 MODULE_DESCRIPTION("Serial driver core");
2473 MODULE_LICENSE("GPL");