2 * linux/drivers/char/amiserial.c
4 * Serial driver for the amiga builtin port.
6 * This code was created by taking serial.c version 4.30 from kernel
7 * release 2.3.22, replacing all hardware related stuff with the
8 * corresponding amiga hardware actions, and removing all irrelevant
9 * code. As a consequence, it uses many of the constants and names
10 * associated with the registers and bits of 16550 compatible UARTS -
11 * but only to keep track of status, etc in the state variables. It
12 * was done this was to make it easier to keep the code in line with
13 * (non hardware specific) changes to serial.c.
15 * The port is registered with the tty driver as minor device 64, and
16 * therefore other ports should should only use 65 upwards.
18 * Richard Lucock 28/12/99
20 * Copyright (C) 1991, 1992 Linus Torvalds
21 * Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997,
22 * 1998, 1999 Theodore Ts'o
27 * Serial driver configuration section. Here are the various options:
29 * SERIAL_PARANOIA_CHECK
30 * Check the magic number for the async_structure where
34 #include <linux/delay.h>
36 #undef SERIAL_PARANOIA_CHECK
37 #define SERIAL_DO_RESTART
39 /* Set of debugging defines */
41 #undef SERIAL_DEBUG_INTR
42 #undef SERIAL_DEBUG_OPEN
43 #undef SERIAL_DEBUG_FLOW
44 #undef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
48 #if defined(MODULE) && defined(SERIAL_DEBUG_MCOUNT)
49 #define DBG_CNT(s) printk("(%s): [%x] refc=%d, serc=%d, ttyc=%d -> %s\n", \
50 tty->name, (info->flags), serial_driver->refcount,info->count,tty->count,s)
56 * End of serial driver configuration section.
59 #include <linux/module.h>
61 #include <linux/types.h>
62 #include <linux/serial.h>
63 #include <linux/serialP.h>
64 #include <linux/serial_reg.h>
65 static char *serial_version
= "4.30";
67 #include <linux/errno.h>
68 #include <linux/signal.h>
69 #include <linux/sched.h>
70 #include <linux/kernel.h>
71 #include <linux/timer.h>
72 #include <linux/interrupt.h>
73 #include <linux/tty.h>
74 #include <linux/tty_flip.h>
75 #include <linux/console.h>
76 #include <linux/major.h>
77 #include <linux/string.h>
78 #include <linux/fcntl.h>
79 #include <linux/ptrace.h>
80 #include <linux/ioport.h>
82 #include <linux/seq_file.h>
83 #include <linux/slab.h>
84 #include <linux/smp_lock.h>
85 #include <linux/init.h>
86 #include <linux/bitops.h>
87 #include <linux/platform_device.h>
89 #include <asm/setup.h>
91 #include <asm/system.h>
95 #include <asm/amigahw.h>
96 #include <asm/amigaints.h>
98 #define custom amiga_custom
99 static char *serial_name
= "Amiga-builtin serial driver";
101 static struct tty_driver
*serial_driver
;
103 /* number of characters left in xmit buffer before we ask for more */
104 #define WAKEUP_CHARS 256
106 static struct async_struct
*IRQ_ports
;
108 static unsigned char current_ctl_bits
;
110 static void change_speed(struct async_struct
*info
, struct ktermios
*old
);
111 static void rs_wait_until_sent(struct tty_struct
*tty
, int timeout
);
114 static struct serial_state rs_table
[1];
116 #define NR_PORTS ARRAY_SIZE(rs_table)
118 #include <asm/uaccess.h>
120 #define serial_isroot() (capable(CAP_SYS_ADMIN))
123 static inline int serial_paranoia_check(struct async_struct
*info
,
124 char *name
, const char *routine
)
126 #ifdef SERIAL_PARANOIA_CHECK
127 static const char *badmagic
=
128 "Warning: bad magic number for serial struct (%s) in %s\n";
129 static const char *badinfo
=
130 "Warning: null async_struct for (%s) in %s\n";
133 printk(badinfo
, name
, routine
);
136 if (info
->magic
!= SERIAL_MAGIC
) {
137 printk(badmagic
, name
, routine
);
144 /* some serial hardware definitions */
145 #define SDR_OVRUN (1<<15)
146 #define SDR_RBF (1<<14)
147 #define SDR_TBE (1<<13)
148 #define SDR_TSRE (1<<12)
150 #define SERPER_PARENB (1<<15)
152 #define AC_SETCLR (1<<15)
153 #define AC_UARTBRK (1<<11)
155 #define SER_DTR (1<<7)
156 #define SER_RTS (1<<6)
157 #define SER_DCD (1<<5)
158 #define SER_CTS (1<<4)
159 #define SER_DSR (1<<3)
161 static __inline__
void rtsdtr_ctrl(int bits
)
163 ciab
.pra
= ((bits
& (SER_RTS
| SER_DTR
)) ^ (SER_RTS
| SER_DTR
)) | (ciab
.pra
& ~(SER_RTS
| SER_DTR
));
167 * ------------------------------------------------------------
168 * rs_stop() and rs_start()
170 * This routines are called before setting or resetting tty->stopped.
171 * They enable or disable transmitter interrupts, as necessary.
172 * ------------------------------------------------------------
174 static void rs_stop(struct tty_struct
*tty
)
176 struct async_struct
*info
= tty
->driver_data
;
179 if (serial_paranoia_check(info
, tty
->name
, "rs_stop"))
182 local_irq_save(flags
);
183 if (info
->IER
& UART_IER_THRI
) {
184 info
->IER
&= ~UART_IER_THRI
;
185 /* disable Tx interrupt and remove any pending interrupts */
186 custom
.intena
= IF_TBE
;
188 custom
.intreq
= IF_TBE
;
191 local_irq_restore(flags
);
194 static void rs_start(struct tty_struct
*tty
)
196 struct async_struct
*info
= tty
->driver_data
;
199 if (serial_paranoia_check(info
, tty
->name
, "rs_start"))
202 local_irq_save(flags
);
203 if (info
->xmit
.head
!= info
->xmit
.tail
205 && !(info
->IER
& UART_IER_THRI
)) {
206 info
->IER
|= UART_IER_THRI
;
207 custom
.intena
= IF_SETCLR
| IF_TBE
;
209 /* set a pending Tx Interrupt, transmitter should restart now */
210 custom
.intreq
= IF_SETCLR
| IF_TBE
;
213 local_irq_restore(flags
);
217 * ----------------------------------------------------------------------
219 * Here starts the interrupt handling routines. All of the following
220 * subroutines are declared as inline and are folded into
221 * rs_interrupt(). They were separated out for readability's sake.
223 * Note: rs_interrupt() is a "fast" interrupt, which means that it
224 * runs with interrupts turned off. People who may want to modify
225 * rs_interrupt() should try to keep the interrupt handler as fast as
226 * possible. After you are done making modifications, it is not a bad
229 * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
231 * and look at the resulting assemble code in serial.s.
233 * - Ted Ts'o (tytso@mit.edu), 7-Mar-93
234 * -----------------------------------------------------------------------
238 * This routine is used by the interrupt handler to schedule
239 * processing in the software interrupt portion of the driver.
241 static void rs_sched_event(struct async_struct
*info
,
244 info
->event
|= 1 << event
;
245 tasklet_schedule(&info
->tlet
);
248 static void receive_chars(struct async_struct
*info
)
252 struct tty_struct
*tty
= info
->tty
;
253 unsigned char ch
, flag
;
254 struct async_icount
*icount
;
257 icount
= &info
->state
->icount
;
259 status
= UART_LSR_DR
; /* We obviously have a character! */
260 serdatr
= custom
.serdatr
;
262 custom
.intreq
= IF_RBF
;
265 if((serdatr
& 0x1ff) == 0)
266 status
|= UART_LSR_BI
;
267 if(serdatr
& SDR_OVRUN
)
268 status
|= UART_LSR_OE
;
273 #ifdef SERIAL_DEBUG_INTR
274 printk("DR%02x:%02x...", ch
, status
);
279 * We don't handle parity or frame errors - but I have left
280 * the code in, since I'm not sure that the errors can't be
284 if (status
& (UART_LSR_BI
| UART_LSR_PE
|
285 UART_LSR_FE
| UART_LSR_OE
)) {
287 * For statistics only
289 if (status
& UART_LSR_BI
) {
290 status
&= ~(UART_LSR_FE
| UART_LSR_PE
);
292 } else if (status
& UART_LSR_PE
)
294 else if (status
& UART_LSR_FE
)
296 if (status
& UART_LSR_OE
)
300 * Now check to see if character should be
301 * ignored, and mask off conditions which
304 if (status
& info
->ignore_status_mask
)
307 status
&= info
->read_status_mask
;
309 if (status
& (UART_LSR_BI
)) {
310 #ifdef SERIAL_DEBUG_INTR
311 printk("handling break....");
314 if (info
->flags
& ASYNC_SAK
)
316 } else if (status
& UART_LSR_PE
)
318 else if (status
& UART_LSR_FE
)
320 if (status
& UART_LSR_OE
) {
322 * Overrun is special, since it's
323 * reported immediately, and doesn't
324 * affect the current character
329 tty_insert_flip_char(tty
, ch
, flag
);
331 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
332 tty_flip_buffer_push(tty
);
337 static void transmit_chars(struct async_struct
*info
)
339 custom
.intreq
= IF_TBE
;
342 custom
.serdat
= info
->x_char
| 0x100;
344 info
->state
->icount
.tx
++;
348 if (info
->xmit
.head
== info
->xmit
.tail
349 || info
->tty
->stopped
350 || info
->tty
->hw_stopped
) {
351 info
->IER
&= ~UART_IER_THRI
;
352 custom
.intena
= IF_TBE
;
357 custom
.serdat
= info
->xmit
.buf
[info
->xmit
.tail
++] | 0x100;
359 info
->xmit
.tail
= info
->xmit
.tail
& (SERIAL_XMIT_SIZE
-1);
360 info
->state
->icount
.tx
++;
362 if (CIRC_CNT(info
->xmit
.head
,
364 SERIAL_XMIT_SIZE
) < WAKEUP_CHARS
)
365 rs_sched_event(info
, RS_EVENT_WRITE_WAKEUP
);
367 #ifdef SERIAL_DEBUG_INTR
370 if (info
->xmit
.head
== info
->xmit
.tail
) {
371 custom
.intena
= IF_TBE
;
373 info
->IER
&= ~UART_IER_THRI
;
377 static void check_modem_status(struct async_struct
*info
)
379 unsigned char status
= ciab
.pra
& (SER_DCD
| SER_CTS
| SER_DSR
);
380 unsigned char dstatus
;
381 struct async_icount
*icount
;
383 /* Determine bits that have changed */
384 dstatus
= status
^ current_ctl_bits
;
385 current_ctl_bits
= status
;
388 icount
= &info
->state
->icount
;
389 /* update input line counters */
390 if (dstatus
& SER_DSR
)
392 if (dstatus
& SER_DCD
) {
394 #ifdef CONFIG_HARD_PPS
395 if ((info
->flags
& ASYNC_HARDPPS_CD
) &&
400 if (dstatus
& SER_CTS
)
402 wake_up_interruptible(&info
->delta_msr_wait
);
405 if ((info
->flags
& ASYNC_CHECK_CD
) && (dstatus
& SER_DCD
)) {
406 #if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
407 printk("ttyS%d CD now %s...", info
->line
,
408 (!(status
& SER_DCD
)) ? "on" : "off");
410 if (!(status
& SER_DCD
))
411 wake_up_interruptible(&info
->open_wait
);
413 #ifdef SERIAL_DEBUG_OPEN
414 printk("doing serial hangup...");
417 tty_hangup(info
->tty
);
420 if (info
->flags
& ASYNC_CTS_FLOW
) {
421 if (info
->tty
->hw_stopped
) {
422 if (!(status
& SER_CTS
)) {
423 #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
424 printk("CTS tx start...");
426 info
->tty
->hw_stopped
= 0;
427 info
->IER
|= UART_IER_THRI
;
428 custom
.intena
= IF_SETCLR
| IF_TBE
;
430 /* set a pending Tx Interrupt, transmitter should restart now */
431 custom
.intreq
= IF_SETCLR
| IF_TBE
;
433 rs_sched_event(info
, RS_EVENT_WRITE_WAKEUP
);
437 if ((status
& SER_CTS
)) {
438 #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
439 printk("CTS tx stop...");
441 info
->tty
->hw_stopped
= 1;
442 info
->IER
&= ~UART_IER_THRI
;
443 /* disable Tx interrupt and remove any pending interrupts */
444 custom
.intena
= IF_TBE
;
446 custom
.intreq
= IF_TBE
;
453 static irqreturn_t
ser_vbl_int( int irq
, void *data
)
455 /* vbl is just a periodic interrupt we tie into to update modem status */
456 struct async_struct
* info
= IRQ_ports
;
458 * TBD - is it better to unregister from this interrupt or to
459 * ignore it if MSI is clear ?
461 if(info
->IER
& UART_IER_MSI
)
462 check_modem_status(info
);
466 static irqreturn_t
ser_rx_int(int irq
, void *dev_id
)
468 struct async_struct
* info
;
470 #ifdef SERIAL_DEBUG_INTR
471 printk("ser_rx_int...");
475 if (!info
|| !info
->tty
)
479 info
->last_active
= jiffies
;
480 #ifdef SERIAL_DEBUG_INTR
486 static irqreturn_t
ser_tx_int(int irq
, void *dev_id
)
488 struct async_struct
* info
;
490 if (custom
.serdatr
& SDR_TBE
) {
491 #ifdef SERIAL_DEBUG_INTR
492 printk("ser_tx_int...");
496 if (!info
|| !info
->tty
)
499 transmit_chars(info
);
500 info
->last_active
= jiffies
;
501 #ifdef SERIAL_DEBUG_INTR
509 * -------------------------------------------------------------------
510 * Here ends the serial interrupt routines.
511 * -------------------------------------------------------------------
515 * This routine is used to handle the "bottom half" processing for the
516 * serial driver, known also the "software interrupt" processing.
517 * This processing is done at the kernel interrupt level, after the
518 * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON. This
519 * is where time-consuming activities which can not be done in the
520 * interrupt driver proper are done; the interrupt driver schedules
521 * them using rs_sched_event(), and they get done here.
524 static void do_softint(unsigned long private_
)
526 struct async_struct
*info
= (struct async_struct
*) private_
;
527 struct tty_struct
*tty
;
533 if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP
, &info
->event
))
538 * ---------------------------------------------------------------
539 * Low level utility subroutines for the serial driver: routines to
540 * figure out the appropriate timeout for an interrupt chain, routines
541 * to initialize and startup a serial port, and routines to shutdown a
542 * serial port. Useful stuff like that.
543 * ---------------------------------------------------------------
546 static int startup(struct async_struct
* info
)
552 page
= get_zeroed_page(GFP_KERNEL
);
556 local_irq_save(flags
);
558 if (info
->flags
& ASYNC_INITIALIZED
) {
566 info
->xmit
.buf
= (unsigned char *) page
;
568 #ifdef SERIAL_DEBUG_OPEN
569 printk("starting up ttys%d ...", info
->line
);
572 /* Clear anything in the input buffer */
574 custom
.intreq
= IF_RBF
;
577 retval
= request_irq(IRQ_AMIGA_VERTB
, ser_vbl_int
, 0, "serial status", info
);
579 if (serial_isroot()) {
581 set_bit(TTY_IO_ERROR
,
588 /* enable both Rx and Tx interrupts */
589 custom
.intena
= IF_SETCLR
| IF_RBF
| IF_TBE
;
591 info
->IER
= UART_IER_MSI
;
593 /* remember current state of the DCD and CTS bits */
594 current_ctl_bits
= ciab
.pra
& (SER_DCD
| SER_CTS
| SER_DSR
);
599 if (info
->tty
->termios
->c_cflag
& CBAUD
)
600 info
->MCR
= SER_DTR
| SER_RTS
;
601 rtsdtr_ctrl(info
->MCR
);
604 clear_bit(TTY_IO_ERROR
, &info
->tty
->flags
);
605 info
->xmit
.head
= info
->xmit
.tail
= 0;
608 * Set up the tty->alt_speed kludge
611 if ((info
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_HI
)
612 info
->tty
->alt_speed
= 57600;
613 if ((info
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_VHI
)
614 info
->tty
->alt_speed
= 115200;
615 if ((info
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_SHI
)
616 info
->tty
->alt_speed
= 230400;
617 if ((info
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_WARP
)
618 info
->tty
->alt_speed
= 460800;
622 * and set the speed of the serial port
624 change_speed(info
, NULL
);
626 info
->flags
|= ASYNC_INITIALIZED
;
627 local_irq_restore(flags
);
631 local_irq_restore(flags
);
636 * This routine will shutdown a serial port; interrupts are disabled, and
637 * DTR is dropped if the hangup on close termio flag is on.
639 static void shutdown(struct async_struct
* info
)
642 struct serial_state
*state
;
644 if (!(info
->flags
& ASYNC_INITIALIZED
))
649 #ifdef SERIAL_DEBUG_OPEN
650 printk("Shutting down serial port %d ....\n", info
->line
);
653 local_irq_save(flags
); /* Disable interrupts */
656 * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
657 * here so the queue might never be waken up
659 wake_up_interruptible(&info
->delta_msr_wait
);
664 * Free the IRQ, if necessary
666 free_irq(IRQ_AMIGA_VERTB
, info
);
668 if (info
->xmit
.buf
) {
669 free_page((unsigned long) info
->xmit
.buf
);
670 info
->xmit
.buf
= NULL
;
674 custom
.intena
= IF_RBF
| IF_TBE
;
677 /* disable break condition */
678 custom
.adkcon
= AC_UARTBRK
;
681 if (!info
->tty
|| (info
->tty
->termios
->c_cflag
& HUPCL
))
682 info
->MCR
&= ~(SER_DTR
|SER_RTS
);
683 rtsdtr_ctrl(info
->MCR
);
686 set_bit(TTY_IO_ERROR
, &info
->tty
->flags
);
688 info
->flags
&= ~ASYNC_INITIALIZED
;
689 local_irq_restore(flags
);
694 * This routine is called to set the UART divisor registers to match
695 * the specified baud rate for a serial port.
697 static void change_speed(struct async_struct
*info
,
698 struct ktermios
*old_termios
)
700 int quot
= 0, baud_base
, baud
;
701 unsigned cflag
, cval
= 0;
705 if (!info
->tty
|| !info
->tty
->termios
)
707 cflag
= info
->tty
->termios
->c_cflag
;
709 /* Byte size is always 8 bits plus parity bit if requested */
712 if (cflag
& CSTOPB
) {
716 if (cflag
& PARENB
) {
717 cval
|= UART_LCR_PARITY
;
720 if (!(cflag
& PARODD
))
721 cval
|= UART_LCR_EPAR
;
724 cval
|= UART_LCR_SPAR
;
727 /* Determine divisor based on baud rate */
728 baud
= tty_get_baud_rate(info
->tty
);
730 baud
= 9600; /* B0 transition handled in rs_set_termios */
731 baud_base
= info
->state
->baud_base
;
733 ((info
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_CUST
))
734 quot
= info
->state
->custom_divisor
;
737 /* Special case since 134 is really 134.5 */
738 quot
= (2*baud_base
/ 269);
740 quot
= baud_base
/ baud
;
742 /* If the quotient is zero refuse the change */
743 if (!quot
&& old_termios
) {
744 /* FIXME: Will need updating for new tty in the end */
745 info
->tty
->termios
->c_cflag
&= ~CBAUD
;
746 info
->tty
->termios
->c_cflag
|= (old_termios
->c_cflag
& CBAUD
);
747 baud
= tty_get_baud_rate(info
->tty
);
751 ((info
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_CUST
))
752 quot
= info
->state
->custom_divisor
;
755 /* Special case since 134 is really 134.5 */
756 quot
= (2*baud_base
/ 269);
758 quot
= baud_base
/ baud
;
761 /* As a last resort, if the quotient is zero, default to 9600 bps */
763 quot
= baud_base
/ 9600;
765 info
->timeout
= ((info
->xmit_fifo_size
*HZ
*bits
*quot
) / baud_base
);
766 info
->timeout
+= HZ
/50; /* Add .02 seconds of slop */
768 /* CTS flow control flag and modem status interrupts */
769 info
->IER
&= ~UART_IER_MSI
;
770 if (info
->flags
& ASYNC_HARDPPS_CD
)
771 info
->IER
|= UART_IER_MSI
;
772 if (cflag
& CRTSCTS
) {
773 info
->flags
|= ASYNC_CTS_FLOW
;
774 info
->IER
|= UART_IER_MSI
;
776 info
->flags
&= ~ASYNC_CTS_FLOW
;
778 info
->flags
&= ~ASYNC_CHECK_CD
;
780 info
->flags
|= ASYNC_CHECK_CD
;
781 info
->IER
|= UART_IER_MSI
;
784 * Does clearing IER_MSI imply that we should disable the VBL interrupt ?
788 * Set up parity check flag
791 info
->read_status_mask
= UART_LSR_OE
| UART_LSR_DR
;
792 if (I_INPCK(info
->tty
))
793 info
->read_status_mask
|= UART_LSR_FE
| UART_LSR_PE
;
794 if (I_BRKINT(info
->tty
) || I_PARMRK(info
->tty
))
795 info
->read_status_mask
|= UART_LSR_BI
;
798 * Characters to ignore
800 info
->ignore_status_mask
= 0;
801 if (I_IGNPAR(info
->tty
))
802 info
->ignore_status_mask
|= UART_LSR_PE
| UART_LSR_FE
;
803 if (I_IGNBRK(info
->tty
)) {
804 info
->ignore_status_mask
|= UART_LSR_BI
;
806 * If we're ignore parity and break indicators, ignore
807 * overruns too. (For real raw support).
809 if (I_IGNPAR(info
->tty
))
810 info
->ignore_status_mask
|= UART_LSR_OE
;
813 * !!! ignore all characters if CREAD is not set
815 if ((cflag
& CREAD
) == 0)
816 info
->ignore_status_mask
|= UART_LSR_DR
;
817 local_irq_save(flags
);
822 /* Set up the baud rate */
825 /* Enable or disable parity bit */
827 if(cval
& UART_LCR_PARITY
)
828 serper
|= (SERPER_PARENB
);
830 custom
.serper
= serper
;
834 info
->LCR
= cval
; /* Save LCR */
835 local_irq_restore(flags
);
838 static int rs_put_char(struct tty_struct
*tty
, unsigned char ch
)
840 struct async_struct
*info
;
843 info
= tty
->driver_data
;
845 if (serial_paranoia_check(info
, tty
->name
, "rs_put_char"))
851 local_irq_save(flags
);
852 if (CIRC_SPACE(info
->xmit
.head
,
854 SERIAL_XMIT_SIZE
) == 0) {
855 local_irq_restore(flags
);
859 info
->xmit
.buf
[info
->xmit
.head
++] = ch
;
860 info
->xmit
.head
&= SERIAL_XMIT_SIZE
-1;
861 local_irq_restore(flags
);
865 static void rs_flush_chars(struct tty_struct
*tty
)
867 struct async_struct
*info
= tty
->driver_data
;
870 if (serial_paranoia_check(info
, tty
->name
, "rs_flush_chars"))
873 if (info
->xmit
.head
== info
->xmit
.tail
879 local_irq_save(flags
);
880 info
->IER
|= UART_IER_THRI
;
881 custom
.intena
= IF_SETCLR
| IF_TBE
;
883 /* set a pending Tx Interrupt, transmitter should restart now */
884 custom
.intreq
= IF_SETCLR
| IF_TBE
;
886 local_irq_restore(flags
);
889 static int rs_write(struct tty_struct
* tty
, const unsigned char *buf
, int count
)
892 struct async_struct
*info
;
895 info
= tty
->driver_data
;
897 if (serial_paranoia_check(info
, tty
->name
, "rs_write"))
903 local_irq_save(flags
);
905 c
= CIRC_SPACE_TO_END(info
->xmit
.head
,
913 memcpy(info
->xmit
.buf
+ info
->xmit
.head
, buf
, c
);
914 info
->xmit
.head
= ((info
->xmit
.head
+ c
) &
915 (SERIAL_XMIT_SIZE
-1));
920 local_irq_restore(flags
);
922 if (info
->xmit
.head
!= info
->xmit
.tail
925 && !(info
->IER
& UART_IER_THRI
)) {
926 info
->IER
|= UART_IER_THRI
;
928 custom
.intena
= IF_SETCLR
| IF_TBE
;
930 /* set a pending Tx Interrupt, transmitter should restart now */
931 custom
.intreq
= IF_SETCLR
| IF_TBE
;
933 local_irq_restore(flags
);
938 static int rs_write_room(struct tty_struct
*tty
)
940 struct async_struct
*info
= tty
->driver_data
;
942 if (serial_paranoia_check(info
, tty
->name
, "rs_write_room"))
944 return CIRC_SPACE(info
->xmit
.head
, info
->xmit
.tail
, SERIAL_XMIT_SIZE
);
947 static int rs_chars_in_buffer(struct tty_struct
*tty
)
949 struct async_struct
*info
= tty
->driver_data
;
951 if (serial_paranoia_check(info
, tty
->name
, "rs_chars_in_buffer"))
953 return CIRC_CNT(info
->xmit
.head
, info
->xmit
.tail
, SERIAL_XMIT_SIZE
);
956 static void rs_flush_buffer(struct tty_struct
*tty
)
958 struct async_struct
*info
= tty
->driver_data
;
961 if (serial_paranoia_check(info
, tty
->name
, "rs_flush_buffer"))
963 local_irq_save(flags
);
964 info
->xmit
.head
= info
->xmit
.tail
= 0;
965 local_irq_restore(flags
);
970 * This function is used to send a high-priority XON/XOFF character to
973 static void rs_send_xchar(struct tty_struct
*tty
, char ch
)
975 struct async_struct
*info
= tty
->driver_data
;
978 if (serial_paranoia_check(info
, tty
->name
, "rs_send_char"))
983 /* Make sure transmit interrupts are on */
986 local_irq_save(flags
);
987 if(!(custom
.intenar
& IF_TBE
)) {
988 custom
.intena
= IF_SETCLR
| IF_TBE
;
990 /* set a pending Tx Interrupt, transmitter should restart now */
991 custom
.intreq
= IF_SETCLR
| IF_TBE
;
994 local_irq_restore(flags
);
996 info
->IER
|= UART_IER_THRI
;
1001 * ------------------------------------------------------------
1004 * This routine is called by the upper-layer tty layer to signal that
1005 * incoming characters should be throttled.
1006 * ------------------------------------------------------------
1008 static void rs_throttle(struct tty_struct
* tty
)
1010 struct async_struct
*info
= tty
->driver_data
;
1011 unsigned long flags
;
1012 #ifdef SERIAL_DEBUG_THROTTLE
1015 printk("throttle %s: %d....\n", tty_name(tty
, buf
),
1016 tty
->ldisc
.chars_in_buffer(tty
));
1019 if (serial_paranoia_check(info
, tty
->name
, "rs_throttle"))
1023 rs_send_xchar(tty
, STOP_CHAR(tty
));
1025 if (tty
->termios
->c_cflag
& CRTSCTS
)
1026 info
->MCR
&= ~SER_RTS
;
1028 local_irq_save(flags
);
1029 rtsdtr_ctrl(info
->MCR
);
1030 local_irq_restore(flags
);
1033 static void rs_unthrottle(struct tty_struct
* tty
)
1035 struct async_struct
*info
= tty
->driver_data
;
1036 unsigned long flags
;
1037 #ifdef SERIAL_DEBUG_THROTTLE
1040 printk("unthrottle %s: %d....\n", tty_name(tty
, buf
),
1041 tty
->ldisc
.chars_in_buffer(tty
));
1044 if (serial_paranoia_check(info
, tty
->name
, "rs_unthrottle"))
1051 rs_send_xchar(tty
, START_CHAR(tty
));
1053 if (tty
->termios
->c_cflag
& CRTSCTS
)
1054 info
->MCR
|= SER_RTS
;
1055 local_irq_save(flags
);
1056 rtsdtr_ctrl(info
->MCR
);
1057 local_irq_restore(flags
);
1061 * ------------------------------------------------------------
1062 * rs_ioctl() and friends
1063 * ------------------------------------------------------------
1066 static int get_serial_info(struct async_struct
* info
,
1067 struct serial_struct __user
* retinfo
)
1069 struct serial_struct tmp
;
1070 struct serial_state
*state
= info
->state
;
1074 memset(&tmp
, 0, sizeof(tmp
));
1076 tmp
.type
= state
->type
;
1077 tmp
.line
= state
->line
;
1078 tmp
.port
= state
->port
;
1079 tmp
.irq
= state
->irq
;
1080 tmp
.flags
= state
->flags
;
1081 tmp
.xmit_fifo_size
= state
->xmit_fifo_size
;
1082 tmp
.baud_base
= state
->baud_base
;
1083 tmp
.close_delay
= state
->close_delay
;
1084 tmp
.closing_wait
= state
->closing_wait
;
1085 tmp
.custom_divisor
= state
->custom_divisor
;
1087 if (copy_to_user(retinfo
,&tmp
,sizeof(*retinfo
)))
1092 static int set_serial_info(struct async_struct
* info
,
1093 struct serial_struct __user
* new_info
)
1095 struct serial_struct new_serial
;
1096 struct serial_state old_state
, *state
;
1097 unsigned int change_irq
,change_port
;
1100 if (copy_from_user(&new_serial
,new_info
,sizeof(new_serial
)))
1104 state
= info
->state
;
1107 change_irq
= new_serial
.irq
!= state
->irq
;
1108 change_port
= (new_serial
.port
!= state
->port
);
1109 if(change_irq
|| change_port
|| (new_serial
.xmit_fifo_size
!= state
->xmit_fifo_size
)) {
1114 if (!serial_isroot()) {
1115 if ((new_serial
.baud_base
!= state
->baud_base
) ||
1116 (new_serial
.close_delay
!= state
->close_delay
) ||
1117 (new_serial
.xmit_fifo_size
!= state
->xmit_fifo_size
) ||
1118 ((new_serial
.flags
& ~ASYNC_USR_MASK
) !=
1119 (state
->flags
& ~ASYNC_USR_MASK
)))
1121 state
->flags
= ((state
->flags
& ~ASYNC_USR_MASK
) |
1122 (new_serial
.flags
& ASYNC_USR_MASK
));
1123 info
->flags
= ((info
->flags
& ~ASYNC_USR_MASK
) |
1124 (new_serial
.flags
& ASYNC_USR_MASK
));
1125 state
->custom_divisor
= new_serial
.custom_divisor
;
1126 goto check_and_exit
;
1129 if (new_serial
.baud_base
< 9600) {
1135 * OK, past this point, all the error checking has been done.
1136 * At this point, we start making changes.....
1139 state
->baud_base
= new_serial
.baud_base
;
1140 state
->flags
= ((state
->flags
& ~ASYNC_FLAGS
) |
1141 (new_serial
.flags
& ASYNC_FLAGS
));
1142 info
->flags
= ((state
->flags
& ~ASYNC_INTERNAL_FLAGS
) |
1143 (info
->flags
& ASYNC_INTERNAL_FLAGS
));
1144 state
->custom_divisor
= new_serial
.custom_divisor
;
1145 state
->close_delay
= new_serial
.close_delay
* HZ
/100;
1146 state
->closing_wait
= new_serial
.closing_wait
* HZ
/100;
1147 info
->tty
->low_latency
= (info
->flags
& ASYNC_LOW_LATENCY
) ? 1 : 0;
1150 if (info
->flags
& ASYNC_INITIALIZED
) {
1151 if (((old_state
.flags
& ASYNC_SPD_MASK
) !=
1152 (state
->flags
& ASYNC_SPD_MASK
)) ||
1153 (old_state
.custom_divisor
!= state
->custom_divisor
)) {
1154 if ((state
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_HI
)
1155 info
->tty
->alt_speed
= 57600;
1156 if ((state
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_VHI
)
1157 info
->tty
->alt_speed
= 115200;
1158 if ((state
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_SHI
)
1159 info
->tty
->alt_speed
= 230400;
1160 if ((state
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_WARP
)
1161 info
->tty
->alt_speed
= 460800;
1162 change_speed(info
, NULL
);
1165 retval
= startup(info
);
1172 * get_lsr_info - get line status register info
1174 * Purpose: Let user call ioctl() to get info when the UART physically
1175 * is emptied. On bus types like RS485, the transmitter must
1176 * release the bus after transmitting. This must be done when
1177 * the transmit shift register is empty, not be done when the
1178 * transmit holding register is empty. This functionality
1179 * allows an RS485 driver to be written in user space.
1181 static int get_lsr_info(struct async_struct
* info
, unsigned int __user
*value
)
1183 unsigned char status
;
1184 unsigned int result
;
1185 unsigned long flags
;
1187 local_irq_save(flags
);
1188 status
= custom
.serdatr
;
1190 local_irq_restore(flags
);
1191 result
= ((status
& SDR_TSRE
) ? TIOCSER_TEMT
: 0);
1192 if (copy_to_user(value
, &result
, sizeof(int)))
1198 static int rs_tiocmget(struct tty_struct
*tty
, struct file
*file
)
1200 struct async_struct
* info
= tty
->driver_data
;
1201 unsigned char control
, status
;
1202 unsigned long flags
;
1204 if (serial_paranoia_check(info
, tty
->name
, "rs_ioctl"))
1206 if (tty
->flags
& (1 << TTY_IO_ERROR
))
1209 control
= info
->MCR
;
1210 local_irq_save(flags
);
1212 local_irq_restore(flags
);
1213 return ((control
& SER_RTS
) ? TIOCM_RTS
: 0)
1214 | ((control
& SER_DTR
) ? TIOCM_DTR
: 0)
1215 | (!(status
& SER_DCD
) ? TIOCM_CAR
: 0)
1216 | (!(status
& SER_DSR
) ? TIOCM_DSR
: 0)
1217 | (!(status
& SER_CTS
) ? TIOCM_CTS
: 0);
1220 static int rs_tiocmset(struct tty_struct
*tty
, struct file
*file
,
1221 unsigned int set
, unsigned int clear
)
1223 struct async_struct
* info
= tty
->driver_data
;
1224 unsigned long flags
;
1226 if (serial_paranoia_check(info
, tty
->name
, "rs_ioctl"))
1228 if (tty
->flags
& (1 << TTY_IO_ERROR
))
1231 local_irq_save(flags
);
1232 if (set
& TIOCM_RTS
)
1233 info
->MCR
|= SER_RTS
;
1234 if (set
& TIOCM_DTR
)
1235 info
->MCR
|= SER_DTR
;
1236 if (clear
& TIOCM_RTS
)
1237 info
->MCR
&= ~SER_RTS
;
1238 if (clear
& TIOCM_DTR
)
1239 info
->MCR
&= ~SER_DTR
;
1240 rtsdtr_ctrl(info
->MCR
);
1241 local_irq_restore(flags
);
1246 * rs_break() --- routine which turns the break handling on or off
1248 static int rs_break(struct tty_struct
*tty
, int break_state
)
1250 struct async_struct
* info
= tty
->driver_data
;
1251 unsigned long flags
;
1253 if (serial_paranoia_check(info
, tty
->name
, "rs_break"))
1256 local_irq_save(flags
);
1257 if (break_state
== -1)
1258 custom
.adkcon
= AC_SETCLR
| AC_UARTBRK
;
1260 custom
.adkcon
= AC_UARTBRK
;
1262 local_irq_restore(flags
);
1267 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1268 * Return: write counters to the user passed counter struct
1269 * NB: both 1->0 and 0->1 transitions are counted except for
1270 * RI where only 0->1 is counted.
1272 static int rs_get_icount(struct tty_struct
*tty
,
1273 struct serial_icounter_struct
*icount
)
1275 struct async_struct
*info
= tty
->driver_data
;
1276 struct async_icount cnow
;
1277 unsigned long flags
;
1279 local_irq_save(flags
);
1280 cnow
= info
->state
->icount
;
1281 local_irq_restore(flags
);
1282 icount
->cts
= cnow
.cts
;
1283 icount
->dsr
= cnow
.dsr
;
1284 icount
->rng
= cnow
.rng
;
1285 icount
->dcd
= cnow
.dcd
;
1286 icount
->rx
= cnow
.rx
;
1287 icount
->tx
= cnow
.tx
;
1288 icount
->frame
= cnow
.frame
;
1289 icount
->overrun
= cnow
.overrun
;
1290 icount
->parity
= cnow
.parity
;
1291 icount
->brk
= cnow
.brk
;
1292 icount
->buf_overrun
= cnow
.buf_overrun
;
1297 static int rs_ioctl(struct tty_struct
*tty
, struct file
* file
,
1298 unsigned int cmd
, unsigned long arg
)
1300 struct async_struct
* info
= tty
->driver_data
;
1301 struct async_icount cprev
, cnow
; /* kernel counter temps */
1302 struct serial_icounter_struct icount
;
1303 void __user
*argp
= (void __user
*)arg
;
1304 unsigned long flags
;
1306 if (serial_paranoia_check(info
, tty
->name
, "rs_ioctl"))
1309 if ((cmd
!= TIOCGSERIAL
) && (cmd
!= TIOCSSERIAL
) &&
1310 (cmd
!= TIOCSERCONFIG
) && (cmd
!= TIOCSERGSTRUCT
) &&
1311 (cmd
!= TIOCMIWAIT
) && (cmd
!= TIOCGICOUNT
)) {
1312 if (tty
->flags
& (1 << TTY_IO_ERROR
))
1318 return get_serial_info(info
, argp
);
1320 return set_serial_info(info
, argp
);
1324 case TIOCSERGETLSR
: /* Get line status register */
1325 return get_lsr_info(info
, argp
);
1327 case TIOCSERGSTRUCT
:
1328 if (copy_to_user(argp
,
1329 info
, sizeof(struct async_struct
)))
1334 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
1335 * - mask passed in arg for lines of interest
1336 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
1337 * Caller should use TIOCGICOUNT to see which one it was
1340 local_irq_save(flags
);
1341 /* note the counters on entry */
1342 cprev
= info
->state
->icount
;
1343 local_irq_restore(flags
);
1345 interruptible_sleep_on(&info
->delta_msr_wait
);
1346 /* see if a signal did it */
1347 if (signal_pending(current
))
1348 return -ERESTARTSYS
;
1349 local_irq_save(flags
);
1350 cnow
= info
->state
->icount
; /* atomic copy */
1351 local_irq_restore(flags
);
1352 if (cnow
.rng
== cprev
.rng
&& cnow
.dsr
== cprev
.dsr
&&
1353 cnow
.dcd
== cprev
.dcd
&& cnow
.cts
== cprev
.cts
)
1354 return -EIO
; /* no change => error */
1355 if ( ((arg
& TIOCM_RNG
) && (cnow
.rng
!= cprev
.rng
)) ||
1356 ((arg
& TIOCM_DSR
) && (cnow
.dsr
!= cprev
.dsr
)) ||
1357 ((arg
& TIOCM_CD
) && (cnow
.dcd
!= cprev
.dcd
)) ||
1358 ((arg
& TIOCM_CTS
) && (cnow
.cts
!= cprev
.cts
)) ) {
1367 /* "setserial -W" is called in Debian boot */
1368 printk ("TIOCSER?WILD ioctl obsolete, ignored.\n");
1372 return -ENOIOCTLCMD
;
1377 static void rs_set_termios(struct tty_struct
*tty
, struct ktermios
*old_termios
)
1379 struct async_struct
*info
= tty
->driver_data
;
1380 unsigned long flags
;
1381 unsigned int cflag
= tty
->termios
->c_cflag
;
1383 change_speed(info
, old_termios
);
1385 /* Handle transition to B0 status */
1386 if ((old_termios
->c_cflag
& CBAUD
) &&
1388 info
->MCR
&= ~(SER_DTR
|SER_RTS
);
1389 local_irq_save(flags
);
1390 rtsdtr_ctrl(info
->MCR
);
1391 local_irq_restore(flags
);
1394 /* Handle transition away from B0 status */
1395 if (!(old_termios
->c_cflag
& CBAUD
) &&
1397 info
->MCR
|= SER_DTR
;
1398 if (!(tty
->termios
->c_cflag
& CRTSCTS
) ||
1399 !test_bit(TTY_THROTTLED
, &tty
->flags
)) {
1400 info
->MCR
|= SER_RTS
;
1402 local_irq_save(flags
);
1403 rtsdtr_ctrl(info
->MCR
);
1404 local_irq_restore(flags
);
1407 /* Handle turning off CRTSCTS */
1408 if ((old_termios
->c_cflag
& CRTSCTS
) &&
1409 !(tty
->termios
->c_cflag
& CRTSCTS
)) {
1410 tty
->hw_stopped
= 0;
1416 * No need to wake up processes in open wait, since they
1417 * sample the CLOCAL flag once, and don't recheck it.
1418 * XXX It's not clear whether the current behavior is correct
1419 * or not. Hence, this may change.....
1421 if (!(old_termios
->c_cflag
& CLOCAL
) &&
1422 (tty
->termios
->c_cflag
& CLOCAL
))
1423 wake_up_interruptible(&info
->open_wait
);
1428 * ------------------------------------------------------------
1431 * This routine is called when the serial port gets closed. First, we
1432 * wait for the last remaining data to be sent. Then, we unlink its
1433 * async structure from the interrupt chain if necessary, and we free
1434 * that IRQ if nothing is left in the chain.
1435 * ------------------------------------------------------------
1437 static void rs_close(struct tty_struct
*tty
, struct file
* filp
)
1439 struct async_struct
* info
= tty
->driver_data
;
1440 struct serial_state
*state
;
1441 unsigned long flags
;
1443 if (!info
|| serial_paranoia_check(info
, tty
->name
, "rs_close"))
1446 state
= info
->state
;
1448 local_irq_save(flags
);
1450 if (tty_hung_up_p(filp
)) {
1451 DBG_CNT("before DEC-hung");
1452 local_irq_restore(flags
);
1456 #ifdef SERIAL_DEBUG_OPEN
1457 printk("rs_close ttys%d, count = %d\n", info
->line
, state
->count
);
1459 if ((tty
->count
== 1) && (state
->count
!= 1)) {
1461 * Uh, oh. tty->count is 1, which means that the tty
1462 * structure will be freed. state->count should always
1463 * be one in these conditions. If it's greater than
1464 * one, we've got real problems, since it means the
1465 * serial port won't be shutdown.
1467 printk("rs_close: bad serial port count; tty->count is 1, "
1468 "state->count is %d\n", state
->count
);
1471 if (--state
->count
< 0) {
1472 printk("rs_close: bad serial port count for ttys%d: %d\n",
1473 info
->line
, state
->count
);
1477 DBG_CNT("before DEC-2");
1478 local_irq_restore(flags
);
1481 info
->flags
|= ASYNC_CLOSING
;
1483 * Now we wait for the transmit buffer to clear; and we notify
1484 * the line discipline to only process XON/XOFF characters.
1487 if (info
->closing_wait
!= ASYNC_CLOSING_WAIT_NONE
)
1488 tty_wait_until_sent(tty
, info
->closing_wait
);
1490 * At this point we stop accepting input. To do this, we
1491 * disable the receive line status interrupts, and tell the
1492 * interrupt driver to stop checking the data ready bit in the
1493 * line status register.
1495 info
->read_status_mask
&= ~UART_LSR_DR
;
1496 if (info
->flags
& ASYNC_INITIALIZED
) {
1497 /* disable receive interrupts */
1498 custom
.intena
= IF_RBF
;
1500 /* clear any pending receive interrupt */
1501 custom
.intreq
= IF_RBF
;
1505 * Before we drop DTR, make sure the UART transmitter
1506 * has completely drained; this is especially
1507 * important if there is a transmit FIFO!
1509 rs_wait_until_sent(tty
, info
->timeout
);
1512 rs_flush_buffer(tty
);
1514 tty_ldisc_flush(tty
);
1518 if (info
->blocked_open
) {
1519 if (info
->close_delay
) {
1520 msleep_interruptible(jiffies_to_msecs(info
->close_delay
));
1522 wake_up_interruptible(&info
->open_wait
);
1524 info
->flags
&= ~(ASYNC_NORMAL_ACTIVE
|ASYNC_CLOSING
);
1525 wake_up_interruptible(&info
->close_wait
);
1526 local_irq_restore(flags
);
1530 * rs_wait_until_sent() --- wait until the transmitter is empty
1532 static void rs_wait_until_sent(struct tty_struct
*tty
, int timeout
)
1534 struct async_struct
* info
= tty
->driver_data
;
1535 unsigned long orig_jiffies
, char_time
;
1536 int tty_was_locked
= tty_locked();
1539 if (serial_paranoia_check(info
, tty
->name
, "rs_wait_until_sent"))
1542 if (info
->xmit_fifo_size
== 0)
1543 return; /* Just in case.... */
1545 orig_jiffies
= jiffies
;
1548 * tty_wait_until_sent is called from lots of places,
1549 * with or without the BTM.
1551 if (!tty_was_locked
)
1554 * Set the check interval to be 1/5 of the estimated time to
1555 * send a single character, and make it at least 1. The check
1556 * interval should also be less than the timeout.
1558 * Note: we have to use pretty tight timings here to satisfy
1561 char_time
= (info
->timeout
- HZ
/50) / info
->xmit_fifo_size
;
1562 char_time
= char_time
/ 5;
1566 char_time
= min_t(unsigned long, char_time
, timeout
);
1568 * If the transmitter hasn't cleared in twice the approximate
1569 * amount of time to send the entire FIFO, it probably won't
1570 * ever clear. This assumes the UART isn't doing flow
1571 * control, which is currently the case. Hence, if it ever
1572 * takes longer than info->timeout, this is probably due to a
1573 * UART bug of some kind. So, we clamp the timeout parameter at
1576 if (!timeout
|| timeout
> 2*info
->timeout
)
1577 timeout
= 2*info
->timeout
;
1578 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1579 printk("In rs_wait_until_sent(%d) check=%lu...", timeout
, char_time
);
1580 printk("jiff=%lu...", jiffies
);
1582 while(!((lsr
= custom
.serdatr
) & SDR_TSRE
)) {
1583 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1584 printk("serdatr = %d (jiff=%lu)...", lsr
, jiffies
);
1586 msleep_interruptible(jiffies_to_msecs(char_time
));
1587 if (signal_pending(current
))
1589 if (timeout
&& time_after(jiffies
, orig_jiffies
+ timeout
))
1592 __set_current_state(TASK_RUNNING
);
1593 if (!tty_was_locked
)
1595 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1596 printk("lsr = %d (jiff=%lu)...done\n", lsr
, jiffies
);
1601 * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
1603 static void rs_hangup(struct tty_struct
*tty
)
1605 struct async_struct
* info
= tty
->driver_data
;
1606 struct serial_state
*state
= info
->state
;
1608 if (serial_paranoia_check(info
, tty
->name
, "rs_hangup"))
1611 state
= info
->state
;
1613 rs_flush_buffer(tty
);
1617 info
->flags
&= ~ASYNC_NORMAL_ACTIVE
;
1619 wake_up_interruptible(&info
->open_wait
);
1623 * ------------------------------------------------------------
1624 * rs_open() and friends
1625 * ------------------------------------------------------------
1627 static int block_til_ready(struct tty_struct
*tty
, struct file
* filp
,
1628 struct async_struct
*info
)
1630 #ifdef DECLARE_WAITQUEUE
1631 DECLARE_WAITQUEUE(wait
, current
);
1633 struct wait_queue wait
= { current
, NULL
};
1635 struct serial_state
*state
= info
->state
;
1637 int do_clocal
= 0, extra_count
= 0;
1638 unsigned long flags
;
1641 * If the device is in the middle of being closed, then block
1642 * until it's done, and then try again.
1644 if (tty_hung_up_p(filp
) ||
1645 (info
->flags
& ASYNC_CLOSING
)) {
1646 if (info
->flags
& ASYNC_CLOSING
)
1647 interruptible_sleep_on(&info
->close_wait
);
1648 #ifdef SERIAL_DO_RESTART
1649 return ((info
->flags
& ASYNC_HUP_NOTIFY
) ?
1650 -EAGAIN
: -ERESTARTSYS
);
1657 * If non-blocking mode is set, or the port is not enabled,
1658 * then make the check up front and then exit.
1660 if ((filp
->f_flags
& O_NONBLOCK
) ||
1661 (tty
->flags
& (1 << TTY_IO_ERROR
))) {
1662 info
->flags
|= ASYNC_NORMAL_ACTIVE
;
1666 if (tty
->termios
->c_cflag
& CLOCAL
)
1670 * Block waiting for the carrier detect and the line to become
1671 * free (i.e., not in use by the callout). While we are in
1672 * this loop, state->count is dropped by one, so that
1673 * rs_close() knows when to free things. We restore it upon
1674 * exit, either normal or abnormal.
1677 add_wait_queue(&info
->open_wait
, &wait
);
1678 #ifdef SERIAL_DEBUG_OPEN
1679 printk("block_til_ready before block: ttys%d, count = %d\n",
1680 state
->line
, state
->count
);
1682 local_irq_save(flags
);
1683 if (!tty_hung_up_p(filp
)) {
1687 local_irq_restore(flags
);
1688 info
->blocked_open
++;
1690 local_irq_save(flags
);
1691 if (tty
->termios
->c_cflag
& CBAUD
)
1692 rtsdtr_ctrl(SER_DTR
|SER_RTS
);
1693 local_irq_restore(flags
);
1694 set_current_state(TASK_INTERRUPTIBLE
);
1695 if (tty_hung_up_p(filp
) ||
1696 !(info
->flags
& ASYNC_INITIALIZED
)) {
1697 #ifdef SERIAL_DO_RESTART
1698 if (info
->flags
& ASYNC_HUP_NOTIFY
)
1701 retval
= -ERESTARTSYS
;
1707 if (!(info
->flags
& ASYNC_CLOSING
) &&
1708 (do_clocal
|| (!(ciab
.pra
& SER_DCD
)) ))
1710 if (signal_pending(current
)) {
1711 retval
= -ERESTARTSYS
;
1714 #ifdef SERIAL_DEBUG_OPEN
1715 printk("block_til_ready blocking: ttys%d, count = %d\n",
1716 info
->line
, state
->count
);
1722 __set_current_state(TASK_RUNNING
);
1723 remove_wait_queue(&info
->open_wait
, &wait
);
1726 info
->blocked_open
--;
1727 #ifdef SERIAL_DEBUG_OPEN
1728 printk("block_til_ready after blocking: ttys%d, count = %d\n",
1729 info
->line
, state
->count
);
1733 info
->flags
|= ASYNC_NORMAL_ACTIVE
;
1737 static int get_async_struct(int line
, struct async_struct
**ret_info
)
1739 struct async_struct
*info
;
1740 struct serial_state
*sstate
;
1742 sstate
= rs_table
+ line
;
1745 *ret_info
= sstate
->info
;
1748 info
= kzalloc(sizeof(struct async_struct
), GFP_KERNEL
);
1753 #ifdef DECLARE_WAITQUEUE
1754 init_waitqueue_head(&info
->open_wait
);
1755 init_waitqueue_head(&info
->close_wait
);
1756 init_waitqueue_head(&info
->delta_msr_wait
);
1758 info
->magic
= SERIAL_MAGIC
;
1759 info
->port
= sstate
->port
;
1760 info
->flags
= sstate
->flags
;
1761 info
->xmit_fifo_size
= sstate
->xmit_fifo_size
;
1763 tasklet_init(&info
->tlet
, do_softint
, (unsigned long)info
);
1764 info
->state
= sstate
;
1767 *ret_info
= sstate
->info
;
1770 *ret_info
= sstate
->info
= info
;
1775 * This routine is called whenever a serial port is opened. It
1776 * enables interrupts for a serial port, linking in its async structure into
1777 * the IRQ chain. It also performs the serial-specific
1778 * initialization for the tty structure.
1780 static int rs_open(struct tty_struct
*tty
, struct file
* filp
)
1782 struct async_struct
*info
;
1786 if ((line
< 0) || (line
>= NR_PORTS
)) {
1789 retval
= get_async_struct(line
, &info
);
1793 tty
->driver_data
= info
;
1795 if (serial_paranoia_check(info
, tty
->name
, "rs_open"))
1798 #ifdef SERIAL_DEBUG_OPEN
1799 printk("rs_open %s, count = %d\n", tty
->name
, info
->state
->count
);
1801 info
->tty
->low_latency
= (info
->flags
& ASYNC_LOW_LATENCY
) ? 1 : 0;
1804 * If the port is the middle of closing, bail out now
1806 if (tty_hung_up_p(filp
) ||
1807 (info
->flags
& ASYNC_CLOSING
)) {
1808 if (info
->flags
& ASYNC_CLOSING
)
1809 interruptible_sleep_on(&info
->close_wait
);
1810 #ifdef SERIAL_DO_RESTART
1811 return ((info
->flags
& ASYNC_HUP_NOTIFY
) ?
1812 -EAGAIN
: -ERESTARTSYS
);
1819 * Start up serial port
1821 retval
= startup(info
);
1826 retval
= block_til_ready(tty
, filp
, info
);
1828 #ifdef SERIAL_DEBUG_OPEN
1829 printk("rs_open returning after block_til_ready with %d\n",
1835 #ifdef SERIAL_DEBUG_OPEN
1836 printk("rs_open %s successful...", tty
->name
);
1842 * /proc fs routines....
1845 static inline void line_info(struct seq_file
*m
, struct serial_state
*state
)
1847 struct async_struct
*info
= state
->info
, scr_info
;
1848 char stat_buf
[30], control
, status
;
1849 unsigned long flags
;
1851 seq_printf(m
, "%d: uart:amiga_builtin",state
->line
);
1854 * Figure out the current RS-232 lines
1857 info
= &scr_info
; /* This is just for serial_{in,out} */
1859 info
->magic
= SERIAL_MAGIC
;
1860 info
->flags
= state
->flags
;
1864 local_irq_save(flags
);
1866 control
= info
? info
->MCR
: status
;
1867 local_irq_restore(flags
);
1871 if(!(control
& SER_RTS
))
1872 strcat(stat_buf
, "|RTS");
1873 if(!(status
& SER_CTS
))
1874 strcat(stat_buf
, "|CTS");
1875 if(!(control
& SER_DTR
))
1876 strcat(stat_buf
, "|DTR");
1877 if(!(status
& SER_DSR
))
1878 strcat(stat_buf
, "|DSR");
1879 if(!(status
& SER_DCD
))
1880 strcat(stat_buf
, "|CD");
1883 seq_printf(m
, " baud:%d", state
->baud_base
/ info
->quot
);
1886 seq_printf(m
, " tx:%d rx:%d", state
->icount
.tx
, state
->icount
.rx
);
1888 if (state
->icount
.frame
)
1889 seq_printf(m
, " fe:%d", state
->icount
.frame
);
1891 if (state
->icount
.parity
)
1892 seq_printf(m
, " pe:%d", state
->icount
.parity
);
1894 if (state
->icount
.brk
)
1895 seq_printf(m
, " brk:%d", state
->icount
.brk
);
1897 if (state
->icount
.overrun
)
1898 seq_printf(m
, " oe:%d", state
->icount
.overrun
);
1901 * Last thing is the RS-232 status lines
1903 seq_printf(m
, " %s\n", stat_buf
+1);
1906 static int rs_proc_show(struct seq_file
*m
, void *v
)
1908 seq_printf(m
, "serinfo:1.0 driver:%s\n", serial_version
);
1909 line_info(m
, &rs_table
[0]);
1913 static int rs_proc_open(struct inode
*inode
, struct file
*file
)
1915 return single_open(file
, rs_proc_show
, NULL
);
1918 static const struct file_operations rs_proc_fops
= {
1919 .owner
= THIS_MODULE
,
1920 .open
= rs_proc_open
,
1922 .llseek
= seq_lseek
,
1923 .release
= single_release
,
1927 * ---------------------------------------------------------------------
1928 * rs_init() and friends
1930 * rs_init() is called at boot-time to initialize the serial driver.
1931 * ---------------------------------------------------------------------
1935 * This routine prints out the appropriate serial driver version
1936 * number, and identifies which options were configured into this
1939 static void show_serial_version(void)
1941 printk(KERN_INFO
"%s version %s\n", serial_name
, serial_version
);
1945 static const struct tty_operations serial_ops
= {
1949 .put_char
= rs_put_char
,
1950 .flush_chars
= rs_flush_chars
,
1951 .write_room
= rs_write_room
,
1952 .chars_in_buffer
= rs_chars_in_buffer
,
1953 .flush_buffer
= rs_flush_buffer
,
1955 .throttle
= rs_throttle
,
1956 .unthrottle
= rs_unthrottle
,
1957 .set_termios
= rs_set_termios
,
1960 .hangup
= rs_hangup
,
1961 .break_ctl
= rs_break
,
1962 .send_xchar
= rs_send_xchar
,
1963 .wait_until_sent
= rs_wait_until_sent
,
1964 .tiocmget
= rs_tiocmget
,
1965 .tiocmset
= rs_tiocmset
,
1966 .get_icount
= rs_get_icount
,
1967 .proc_fops
= &rs_proc_fops
,
1971 * The serial driver boot-time initialization code!
1973 static int __init
amiga_serial_probe(struct platform_device
*pdev
)
1975 unsigned long flags
;
1976 struct serial_state
* state
;
1979 serial_driver
= alloc_tty_driver(1);
1985 show_serial_version();
1987 /* Initialize the tty_driver structure */
1989 serial_driver
->owner
= THIS_MODULE
;
1990 serial_driver
->driver_name
= "amiserial";
1991 serial_driver
->name
= "ttyS";
1992 serial_driver
->major
= TTY_MAJOR
;
1993 serial_driver
->minor_start
= 64;
1994 serial_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
1995 serial_driver
->subtype
= SERIAL_TYPE_NORMAL
;
1996 serial_driver
->init_termios
= tty_std_termios
;
1997 serial_driver
->init_termios
.c_cflag
=
1998 B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1999 serial_driver
->flags
= TTY_DRIVER_REAL_RAW
;
2000 tty_set_operations(serial_driver
, &serial_ops
);
2002 error
= tty_register_driver(serial_driver
);
2004 goto fail_put_tty_driver
;
2007 state
->magic
= SSTATE_MAGIC
;
2008 state
->port
= (int)&custom
.serdatr
; /* Just to give it a value */
2010 state
->custom_divisor
= 0;
2011 state
->close_delay
= 5*HZ
/10;
2012 state
->closing_wait
= 30*HZ
;
2013 state
->icount
.cts
= state
->icount
.dsr
=
2014 state
->icount
.rng
= state
->icount
.dcd
= 0;
2015 state
->icount
.rx
= state
->icount
.tx
= 0;
2016 state
->icount
.frame
= state
->icount
.parity
= 0;
2017 state
->icount
.overrun
= state
->icount
.brk
= 0;
2019 printk(KERN_INFO
"ttyS%d is the amiga builtin serial port\n",
2022 /* Hardware set up */
2024 state
->baud_base
= amiga_colorclock
;
2025 state
->xmit_fifo_size
= 1;
2027 /* set ISRs, and then disable the rx interrupts */
2028 error
= request_irq(IRQ_AMIGA_TBE
, ser_tx_int
, 0, "serial TX", state
);
2030 goto fail_unregister
;
2032 error
= request_irq(IRQ_AMIGA_RBF
, ser_rx_int
, IRQF_DISABLED
,
2033 "serial RX", state
);
2037 local_irq_save(flags
);
2039 /* turn off Rx and Tx interrupts */
2040 custom
.intena
= IF_RBF
| IF_TBE
;
2043 /* clear any pending interrupt */
2044 custom
.intreq
= IF_RBF
| IF_TBE
;
2047 local_irq_restore(flags
);
2050 * set the appropriate directions for the modem control flags,
2051 * and clear RTS and DTR
2053 ciab
.ddra
|= (SER_DTR
| SER_RTS
); /* outputs */
2054 ciab
.ddra
&= ~(SER_DCD
| SER_CTS
| SER_DSR
); /* inputs */
2056 platform_set_drvdata(pdev
, state
);
2061 free_irq(IRQ_AMIGA_TBE
, state
);
2063 tty_unregister_driver(serial_driver
);
2064 fail_put_tty_driver
:
2065 put_tty_driver(serial_driver
);
2069 static int __exit
amiga_serial_remove(struct platform_device
*pdev
)
2072 struct serial_state
*state
= platform_get_drvdata(pdev
);
2073 struct async_struct
*info
= state
->info
;
2075 /* printk("Unloading %s: version %s\n", serial_name, serial_version); */
2076 tasklet_kill(&info
->tlet
);
2077 if ((error
= tty_unregister_driver(serial_driver
)))
2078 printk("SERIAL: failed to unregister serial driver (%d)\n",
2080 put_tty_driver(serial_driver
);
2082 rs_table
[0].info
= NULL
;
2085 free_irq(IRQ_AMIGA_TBE
, rs_table
);
2086 free_irq(IRQ_AMIGA_RBF
, rs_table
);
2088 platform_set_drvdata(pdev
, NULL
);
2093 static struct platform_driver amiga_serial_driver
= {
2094 .remove
= __exit_p(amiga_serial_remove
),
2096 .name
= "amiga-serial",
2097 .owner
= THIS_MODULE
,
2101 static int __init
amiga_serial_init(void)
2103 return platform_driver_probe(&amiga_serial_driver
, amiga_serial_probe
);
2106 module_init(amiga_serial_init
);
2108 static void __exit
amiga_serial_exit(void)
2110 platform_driver_unregister(&amiga_serial_driver
);
2113 module_exit(amiga_serial_exit
);
2116 #if defined(CONFIG_SERIAL_CONSOLE) && !defined(MODULE)
2119 * ------------------------------------------------------------
2120 * Serial console driver
2121 * ------------------------------------------------------------
2124 static void amiga_serial_putc(char c
)
2126 custom
.serdat
= (unsigned char)c
| 0x100;
2127 while (!(custom
.serdatr
& 0x2000))
2132 * Print a string to the serial port trying not to disturb
2133 * any possible real use of the port...
2135 * The console must be locked when we get here.
2137 static void serial_console_write(struct console
*co
, const char *s
,
2140 unsigned short intena
= custom
.intenar
;
2142 custom
.intena
= IF_TBE
;
2146 amiga_serial_putc('\r');
2147 amiga_serial_putc(*s
++);
2150 custom
.intena
= IF_SETCLR
| (intena
& IF_TBE
);
2153 static struct tty_driver
*serial_console_device(struct console
*c
, int *index
)
2156 return serial_driver
;
2159 static struct console sercons
= {
2161 .write
= serial_console_write
,
2162 .device
= serial_console_device
,
2163 .flags
= CON_PRINTBUFFER
,
2170 static int __init
amiserial_console_init(void)
2172 register_console(&sercons
);
2175 console_initcall(amiserial_console_init
);
2177 #endif /* CONFIG_SERIAL_CONSOLE && !MODULE */
2179 MODULE_LICENSE("GPL");
2180 MODULE_ALIAS("platform:amiga-serial");