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