2 * Serial driver for the amiga builtin port.
4 * This code was created by taking serial.c version 4.30 from kernel
5 * release 2.3.22, replacing all hardware related stuff with the
6 * corresponding amiga hardware actions, and removing all irrelevant
7 * code. As a consequence, it uses many of the constants and names
8 * associated with the registers and bits of 16550 compatible UARTS -
9 * but only to keep track of status, etc in the state variables. It
10 * was done this was to make it easier to keep the code in line with
11 * (non hardware specific) changes to serial.c.
13 * The port is registered with the tty driver as minor device 64, and
14 * therefore other ports should should only use 65 upwards.
16 * Richard Lucock 28/12/99
18 * Copyright (C) 1991, 1992 Linus Torvalds
19 * Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997,
20 * 1998, 1999 Theodore Ts'o
25 * Serial driver configuration section. Here are the various options:
27 * SERIAL_PARANOIA_CHECK
28 * Check the magic number for the async_structure where
32 #include <linux/delay.h>
34 #undef SERIAL_PARANOIA_CHECK
35 #define SERIAL_DO_RESTART
37 /* Set of debugging defines */
39 #undef SERIAL_DEBUG_INTR
40 #undef SERIAL_DEBUG_OPEN
41 #undef SERIAL_DEBUG_FLOW
42 #undef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
46 #if defined(MODULE) && defined(SERIAL_DEBUG_MCOUNT)
47 #define DBG_CNT(s) printk("(%s): [%x] refc=%d, serc=%d, ttyc=%d -> %s\n", \
48 tty->name, (info->tport.flags), serial_driver->refcount,info->count,tty->count,s)
54 * End of serial driver configuration section.
57 #include <linux/module.h>
59 #include <linux/types.h>
60 #include <linux/serial.h>
61 #include <linux/serial_reg.h>
62 static char *serial_version
= "4.30";
64 #include <linux/errno.h>
65 #include <linux/signal.h>
66 #include <linux/sched.h>
67 #include <linux/kernel.h>
68 #include <linux/timer.h>
69 #include <linux/interrupt.h>
70 #include <linux/tty.h>
71 #include <linux/tty_flip.h>
72 #include <linux/circ_buf.h>
73 #include <linux/console.h>
74 #include <linux/major.h>
75 #include <linux/string.h>
76 #include <linux/fcntl.h>
77 #include <linux/ptrace.h>
78 #include <linux/ioport.h>
80 #include <linux/seq_file.h>
81 #include <linux/slab.h>
82 #include <linux/init.h>
83 #include <linux/bitops.h>
84 #include <linux/platform_device.h>
86 #include <asm/setup.h>
91 #include <asm/amigahw.h>
92 #include <asm/amigaints.h>
95 struct tty_port tport
;
97 struct async_icount icount
;
103 int read_status_mask
;
104 int ignore_status_mask
;
107 int IER
; /* Interrupt Enable Register */
108 int MCR
; /* Modem control register */
109 int x_char
; /* xon/xoff character */
112 #define custom amiga_custom
113 static char *serial_name
= "Amiga-builtin serial driver";
115 static struct tty_driver
*serial_driver
;
117 /* number of characters left in xmit buffer before we ask for more */
118 #define WAKEUP_CHARS 256
120 static unsigned char current_ctl_bits
;
122 static void change_speed(struct tty_struct
*tty
, struct serial_state
*info
,
123 struct ktermios
*old
);
124 static void rs_wait_until_sent(struct tty_struct
*tty
, int timeout
);
127 static struct serial_state rs_table
[1];
129 #define NR_PORTS ARRAY_SIZE(rs_table)
131 #include <asm/uaccess.h>
133 #define serial_isroot() (capable(CAP_SYS_ADMIN))
136 static inline int serial_paranoia_check(struct serial_state
*info
,
137 char *name
, const char *routine
)
139 #ifdef SERIAL_PARANOIA_CHECK
140 static const char *badmagic
=
141 "Warning: bad magic number for serial struct (%s) in %s\n";
142 static const char *badinfo
=
143 "Warning: null async_struct for (%s) in %s\n";
146 printk(badinfo
, name
, routine
);
149 if (info
->magic
!= SERIAL_MAGIC
) {
150 printk(badmagic
, name
, routine
);
157 /* some serial hardware definitions */
158 #define SDR_OVRUN (1<<15)
159 #define SDR_RBF (1<<14)
160 #define SDR_TBE (1<<13)
161 #define SDR_TSRE (1<<12)
163 #define SERPER_PARENB (1<<15)
165 #define AC_SETCLR (1<<15)
166 #define AC_UARTBRK (1<<11)
168 #define SER_DTR (1<<7)
169 #define SER_RTS (1<<6)
170 #define SER_DCD (1<<5)
171 #define SER_CTS (1<<4)
172 #define SER_DSR (1<<3)
174 static __inline__
void rtsdtr_ctrl(int bits
)
176 ciab
.pra
= ((bits
& (SER_RTS
| SER_DTR
)) ^ (SER_RTS
| SER_DTR
)) | (ciab
.pra
& ~(SER_RTS
| SER_DTR
));
180 * ------------------------------------------------------------
181 * rs_stop() and rs_start()
183 * This routines are called before setting or resetting tty->stopped.
184 * They enable or disable transmitter interrupts, as necessary.
185 * ------------------------------------------------------------
187 static void rs_stop(struct tty_struct
*tty
)
189 struct serial_state
*info
= tty
->driver_data
;
192 if (serial_paranoia_check(info
, tty
->name
, "rs_stop"))
195 local_irq_save(flags
);
196 if (info
->IER
& UART_IER_THRI
) {
197 info
->IER
&= ~UART_IER_THRI
;
198 /* disable Tx interrupt and remove any pending interrupts */
199 custom
.intena
= IF_TBE
;
201 custom
.intreq
= IF_TBE
;
204 local_irq_restore(flags
);
207 static void rs_start(struct tty_struct
*tty
)
209 struct serial_state
*info
= tty
->driver_data
;
212 if (serial_paranoia_check(info
, tty
->name
, "rs_start"))
215 local_irq_save(flags
);
216 if (info
->xmit
.head
!= info
->xmit
.tail
218 && !(info
->IER
& UART_IER_THRI
)) {
219 info
->IER
|= UART_IER_THRI
;
220 custom
.intena
= IF_SETCLR
| IF_TBE
;
222 /* set a pending Tx Interrupt, transmitter should restart now */
223 custom
.intreq
= IF_SETCLR
| IF_TBE
;
226 local_irq_restore(flags
);
230 * ----------------------------------------------------------------------
232 * Here starts the interrupt handling routines. All of the following
233 * subroutines are declared as inline and are folded into
234 * rs_interrupt(). They were separated out for readability's sake.
236 * Note: rs_interrupt() is a "fast" interrupt, which means that it
237 * runs with interrupts turned off. People who may want to modify
238 * rs_interrupt() should try to keep the interrupt handler as fast as
239 * possible. After you are done making modifications, it is not a bad
242 * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c
244 * and look at the resulting assemble code in serial.s.
246 * - Ted Ts'o (tytso@mit.edu), 7-Mar-93
247 * -----------------------------------------------------------------------
250 static void receive_chars(struct serial_state
*info
)
254 struct tty_struct
*tty
= info
->tport
.tty
;
255 unsigned char ch
, flag
;
256 struct async_icount
*icount
;
259 icount
= &info
->icount
;
261 status
= UART_LSR_DR
; /* We obviously have a character! */
262 serdatr
= custom
.serdatr
;
264 custom
.intreq
= IF_RBF
;
267 if((serdatr
& 0x1ff) == 0)
268 status
|= UART_LSR_BI
;
269 if(serdatr
& SDR_OVRUN
)
270 status
|= UART_LSR_OE
;
275 #ifdef SERIAL_DEBUG_INTR
276 printk("DR%02x:%02x...", ch
, status
);
281 * We don't handle parity or frame errors - but I have left
282 * the code in, since I'm not sure that the errors can't be
286 if (status
& (UART_LSR_BI
| UART_LSR_PE
|
287 UART_LSR_FE
| UART_LSR_OE
)) {
289 * For statistics only
291 if (status
& UART_LSR_BI
) {
292 status
&= ~(UART_LSR_FE
| UART_LSR_PE
);
294 } else if (status
& UART_LSR_PE
)
296 else if (status
& UART_LSR_FE
)
298 if (status
& UART_LSR_OE
)
302 * Now check to see if character should be
303 * ignored, and mask off conditions which
306 if (status
& info
->ignore_status_mask
)
309 status
&= info
->read_status_mask
;
311 if (status
& (UART_LSR_BI
)) {
312 #ifdef SERIAL_DEBUG_INTR
313 printk("handling break....");
316 if (info
->tport
.flags
& ASYNC_SAK
)
318 } else if (status
& UART_LSR_PE
)
320 else if (status
& UART_LSR_FE
)
322 if (status
& UART_LSR_OE
) {
324 * Overrun is special, since it's
325 * reported immediately, and doesn't
326 * affect the current character
331 tty_insert_flip_char(tty
, ch
, flag
);
333 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
334 tty_flip_buffer_push(tty
);
339 static void transmit_chars(struct serial_state
*info
)
341 custom
.intreq
= IF_TBE
;
344 custom
.serdat
= info
->x_char
| 0x100;
350 if (info
->xmit
.head
== info
->xmit
.tail
351 || info
->tport
.tty
->stopped
352 || info
->tport
.tty
->hw_stopped
) {
353 info
->IER
&= ~UART_IER_THRI
;
354 custom
.intena
= IF_TBE
;
359 custom
.serdat
= info
->xmit
.buf
[info
->xmit
.tail
++] | 0x100;
361 info
->xmit
.tail
= info
->xmit
.tail
& (SERIAL_XMIT_SIZE
-1);
364 if (CIRC_CNT(info
->xmit
.head
,
366 SERIAL_XMIT_SIZE
) < WAKEUP_CHARS
)
367 tty_wakeup(info
->tport
.tty
);
369 #ifdef SERIAL_DEBUG_INTR
372 if (info
->xmit
.head
== info
->xmit
.tail
) {
373 custom
.intena
= IF_TBE
;
375 info
->IER
&= ~UART_IER_THRI
;
379 static void check_modem_status(struct serial_state
*info
)
381 struct tty_port
*port
= &info
->tport
;
382 unsigned char status
= ciab
.pra
& (SER_DCD
| SER_CTS
| SER_DSR
);
383 unsigned char dstatus
;
384 struct async_icount
*icount
;
386 /* Determine bits that have changed */
387 dstatus
= status
^ current_ctl_bits
;
388 current_ctl_bits
= status
;
391 icount
= &info
->icount
;
392 /* update input line counters */
393 if (dstatus
& SER_DSR
)
395 if (dstatus
& SER_DCD
) {
397 #ifdef CONFIG_HARD_PPS
398 if ((port
->flags
& ASYNC_HARDPPS_CD
) &&
403 if (dstatus
& SER_CTS
)
405 wake_up_interruptible(&port
->delta_msr_wait
);
408 if ((port
->flags
& ASYNC_CHECK_CD
) && (dstatus
& SER_DCD
)) {
409 #if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
410 printk("ttyS%d CD now %s...", info
->line
,
411 (!(status
& SER_DCD
)) ? "on" : "off");
413 if (!(status
& SER_DCD
))
414 wake_up_interruptible(&port
->open_wait
);
416 #ifdef SERIAL_DEBUG_OPEN
417 printk("doing serial hangup...");
420 tty_hangup(port
->tty
);
423 if (port
->flags
& ASYNC_CTS_FLOW
) {
424 if (port
->tty
->hw_stopped
) {
425 if (!(status
& SER_CTS
)) {
426 #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
427 printk("CTS tx start...");
429 port
->tty
->hw_stopped
= 0;
430 info
->IER
|= UART_IER_THRI
;
431 custom
.intena
= IF_SETCLR
| IF_TBE
;
433 /* set a pending Tx Interrupt, transmitter should restart now */
434 custom
.intreq
= IF_SETCLR
| IF_TBE
;
436 tty_wakeup(port
->tty
);
440 if ((status
& SER_CTS
)) {
441 #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
442 printk("CTS tx stop...");
444 port
->tty
->hw_stopped
= 1;
445 info
->IER
&= ~UART_IER_THRI
;
446 /* disable Tx interrupt and remove any pending interrupts */
447 custom
.intena
= IF_TBE
;
449 custom
.intreq
= IF_TBE
;
456 static irqreturn_t
ser_vbl_int( int irq
, void *data
)
458 /* vbl is just a periodic interrupt we tie into to update modem status */
459 struct serial_state
*info
= data
;
461 * TBD - is it better to unregister from this interrupt or to
462 * ignore it if MSI is clear ?
464 if(info
->IER
& UART_IER_MSI
)
465 check_modem_status(info
);
469 static irqreturn_t
ser_rx_int(int irq
, void *dev_id
)
471 struct serial_state
*info
= dev_id
;
473 #ifdef SERIAL_DEBUG_INTR
474 printk("ser_rx_int...");
477 if (!info
->tport
.tty
)
481 #ifdef SERIAL_DEBUG_INTR
487 static irqreturn_t
ser_tx_int(int irq
, void *dev_id
)
489 struct serial_state
*info
= dev_id
;
491 if (custom
.serdatr
& SDR_TBE
) {
492 #ifdef SERIAL_DEBUG_INTR
493 printk("ser_tx_int...");
496 if (!info
->tport
.tty
)
499 transmit_chars(info
);
500 #ifdef SERIAL_DEBUG_INTR
508 * -------------------------------------------------------------------
509 * Here ends the serial interrupt routines.
510 * -------------------------------------------------------------------
514 * ---------------------------------------------------------------
515 * Low level utility subroutines for the serial driver: routines to
516 * figure out the appropriate timeout for an interrupt chain, routines
517 * to initialize and startup a serial port, and routines to shutdown a
518 * serial port. Useful stuff like that.
519 * ---------------------------------------------------------------
522 static int startup(struct tty_struct
*tty
, struct serial_state
*info
)
524 struct tty_port
*port
= &info
->tport
;
529 page
= get_zeroed_page(GFP_KERNEL
);
533 local_irq_save(flags
);
535 if (port
->flags
& ASYNC_INITIALIZED
) {
543 info
->xmit
.buf
= (unsigned char *) page
;
545 #ifdef SERIAL_DEBUG_OPEN
546 printk("starting up ttys%d ...", info
->line
);
549 /* Clear anything in the input buffer */
551 custom
.intreq
= IF_RBF
;
554 retval
= request_irq(IRQ_AMIGA_VERTB
, ser_vbl_int
, 0, "serial status", info
);
556 if (serial_isroot()) {
557 set_bit(TTY_IO_ERROR
, &tty
->flags
);
563 /* enable both Rx and Tx interrupts */
564 custom
.intena
= IF_SETCLR
| IF_RBF
| IF_TBE
;
566 info
->IER
= UART_IER_MSI
;
568 /* remember current state of the DCD and CTS bits */
569 current_ctl_bits
= ciab
.pra
& (SER_DCD
| SER_CTS
| SER_DSR
);
573 info
->MCR
= SER_DTR
| SER_RTS
;
574 rtsdtr_ctrl(info
->MCR
);
576 clear_bit(TTY_IO_ERROR
, &tty
->flags
);
577 info
->xmit
.head
= info
->xmit
.tail
= 0;
580 * Set up the tty->alt_speed kludge
582 if ((port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_HI
)
583 tty
->alt_speed
= 57600;
584 if ((port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_VHI
)
585 tty
->alt_speed
= 115200;
586 if ((port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_SHI
)
587 tty
->alt_speed
= 230400;
588 if ((port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_WARP
)
589 tty
->alt_speed
= 460800;
592 * and set the speed of the serial port
594 change_speed(tty
, info
, NULL
);
596 port
->flags
|= ASYNC_INITIALIZED
;
597 local_irq_restore(flags
);
601 local_irq_restore(flags
);
606 * This routine will shutdown a serial port; interrupts are disabled, and
607 * DTR is dropped if the hangup on close termio flag is on.
609 static void shutdown(struct tty_struct
*tty
, struct serial_state
*info
)
612 struct serial_state
*state
;
614 if (!(info
->tport
.flags
& ASYNC_INITIALIZED
))
619 #ifdef SERIAL_DEBUG_OPEN
620 printk("Shutting down serial port %d ....\n", info
->line
);
623 local_irq_save(flags
); /* Disable interrupts */
626 * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
627 * here so the queue might never be waken up
629 wake_up_interruptible(&info
->tport
.delta_msr_wait
);
632 * Free the IRQ, if necessary
634 free_irq(IRQ_AMIGA_VERTB
, info
);
636 if (info
->xmit
.buf
) {
637 free_page((unsigned long) info
->xmit
.buf
);
638 info
->xmit
.buf
= NULL
;
642 custom
.intena
= IF_RBF
| IF_TBE
;
645 /* disable break condition */
646 custom
.adkcon
= AC_UARTBRK
;
649 if (tty
->termios
->c_cflag
& HUPCL
)
650 info
->MCR
&= ~(SER_DTR
|SER_RTS
);
651 rtsdtr_ctrl(info
->MCR
);
653 set_bit(TTY_IO_ERROR
, &tty
->flags
);
655 info
->tport
.flags
&= ~ASYNC_INITIALIZED
;
656 local_irq_restore(flags
);
661 * This routine is called to set the UART divisor registers to match
662 * the specified baud rate for a serial port.
664 static void change_speed(struct tty_struct
*tty
, struct serial_state
*info
,
665 struct ktermios
*old_termios
)
667 struct tty_port
*port
= &info
->tport
;
668 int quot
= 0, baud_base
, baud
;
669 unsigned cflag
, cval
= 0;
673 cflag
= tty
->termios
->c_cflag
;
675 /* Byte size is always 8 bits plus parity bit if requested */
678 if (cflag
& CSTOPB
) {
682 if (cflag
& PARENB
) {
683 cval
|= UART_LCR_PARITY
;
686 if (!(cflag
& PARODD
))
687 cval
|= UART_LCR_EPAR
;
690 cval
|= UART_LCR_SPAR
;
693 /* Determine divisor based on baud rate */
694 baud
= tty_get_baud_rate(tty
);
696 baud
= 9600; /* B0 transition handled in rs_set_termios */
697 baud_base
= info
->baud_base
;
698 if (baud
== 38400 && (port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_CUST
)
699 quot
= info
->custom_divisor
;
702 /* Special case since 134 is really 134.5 */
703 quot
= (2*baud_base
/ 269);
705 quot
= baud_base
/ baud
;
707 /* If the quotient is zero refuse the change */
708 if (!quot
&& old_termios
) {
709 /* FIXME: Will need updating for new tty in the end */
710 tty
->termios
->c_cflag
&= ~CBAUD
;
711 tty
->termios
->c_cflag
|= (old_termios
->c_cflag
& CBAUD
);
712 baud
= tty_get_baud_rate(tty
);
716 (port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_CUST
)
717 quot
= info
->custom_divisor
;
720 /* Special case since 134 is really 134.5 */
721 quot
= (2*baud_base
/ 269);
723 quot
= baud_base
/ baud
;
726 /* As a last resort, if the quotient is zero, default to 9600 bps */
728 quot
= baud_base
/ 9600;
730 info
->timeout
= ((info
->xmit_fifo_size
*HZ
*bits
*quot
) / baud_base
);
731 info
->timeout
+= HZ
/50; /* Add .02 seconds of slop */
733 /* CTS flow control flag and modem status interrupts */
734 info
->IER
&= ~UART_IER_MSI
;
735 if (port
->flags
& ASYNC_HARDPPS_CD
)
736 info
->IER
|= UART_IER_MSI
;
737 if (cflag
& CRTSCTS
) {
738 port
->flags
|= ASYNC_CTS_FLOW
;
739 info
->IER
|= UART_IER_MSI
;
741 port
->flags
&= ~ASYNC_CTS_FLOW
;
743 port
->flags
&= ~ASYNC_CHECK_CD
;
745 port
->flags
|= ASYNC_CHECK_CD
;
746 info
->IER
|= UART_IER_MSI
;
749 * Does clearing IER_MSI imply that we should disable the VBL interrupt ?
753 * Set up parity check flag
756 info
->read_status_mask
= UART_LSR_OE
| UART_LSR_DR
;
758 info
->read_status_mask
|= UART_LSR_FE
| UART_LSR_PE
;
759 if (I_BRKINT(tty
) || I_PARMRK(tty
))
760 info
->read_status_mask
|= UART_LSR_BI
;
763 * Characters to ignore
765 info
->ignore_status_mask
= 0;
767 info
->ignore_status_mask
|= UART_LSR_PE
| UART_LSR_FE
;
769 info
->ignore_status_mask
|= UART_LSR_BI
;
771 * If we're ignore parity and break indicators, ignore
772 * overruns too. (For real raw support).
775 info
->ignore_status_mask
|= UART_LSR_OE
;
778 * !!! ignore all characters if CREAD is not set
780 if ((cflag
& CREAD
) == 0)
781 info
->ignore_status_mask
|= UART_LSR_DR
;
782 local_irq_save(flags
);
787 /* Set up the baud rate */
790 /* Enable or disable parity bit */
792 if(cval
& UART_LCR_PARITY
)
793 serper
|= (SERPER_PARENB
);
795 custom
.serper
= serper
;
799 local_irq_restore(flags
);
802 static int rs_put_char(struct tty_struct
*tty
, unsigned char ch
)
804 struct serial_state
*info
;
807 info
= tty
->driver_data
;
809 if (serial_paranoia_check(info
, tty
->name
, "rs_put_char"))
815 local_irq_save(flags
);
816 if (CIRC_SPACE(info
->xmit
.head
,
818 SERIAL_XMIT_SIZE
) == 0) {
819 local_irq_restore(flags
);
823 info
->xmit
.buf
[info
->xmit
.head
++] = ch
;
824 info
->xmit
.head
&= SERIAL_XMIT_SIZE
-1;
825 local_irq_restore(flags
);
829 static void rs_flush_chars(struct tty_struct
*tty
)
831 struct serial_state
*info
= tty
->driver_data
;
834 if (serial_paranoia_check(info
, tty
->name
, "rs_flush_chars"))
837 if (info
->xmit
.head
== info
->xmit
.tail
843 local_irq_save(flags
);
844 info
->IER
|= UART_IER_THRI
;
845 custom
.intena
= IF_SETCLR
| IF_TBE
;
847 /* set a pending Tx Interrupt, transmitter should restart now */
848 custom
.intreq
= IF_SETCLR
| IF_TBE
;
850 local_irq_restore(flags
);
853 static int rs_write(struct tty_struct
* tty
, const unsigned char *buf
, int count
)
856 struct serial_state
*info
= tty
->driver_data
;
859 if (serial_paranoia_check(info
, tty
->name
, "rs_write"))
865 local_irq_save(flags
);
867 c
= CIRC_SPACE_TO_END(info
->xmit
.head
,
875 memcpy(info
->xmit
.buf
+ info
->xmit
.head
, buf
, c
);
876 info
->xmit
.head
= ((info
->xmit
.head
+ c
) &
877 (SERIAL_XMIT_SIZE
-1));
882 local_irq_restore(flags
);
884 if (info
->xmit
.head
!= info
->xmit
.tail
887 && !(info
->IER
& UART_IER_THRI
)) {
888 info
->IER
|= UART_IER_THRI
;
890 custom
.intena
= IF_SETCLR
| IF_TBE
;
892 /* set a pending Tx Interrupt, transmitter should restart now */
893 custom
.intreq
= IF_SETCLR
| IF_TBE
;
895 local_irq_restore(flags
);
900 static int rs_write_room(struct tty_struct
*tty
)
902 struct serial_state
*info
= tty
->driver_data
;
904 if (serial_paranoia_check(info
, tty
->name
, "rs_write_room"))
906 return CIRC_SPACE(info
->xmit
.head
, info
->xmit
.tail
, SERIAL_XMIT_SIZE
);
909 static int rs_chars_in_buffer(struct tty_struct
*tty
)
911 struct serial_state
*info
= tty
->driver_data
;
913 if (serial_paranoia_check(info
, tty
->name
, "rs_chars_in_buffer"))
915 return CIRC_CNT(info
->xmit
.head
, info
->xmit
.tail
, SERIAL_XMIT_SIZE
);
918 static void rs_flush_buffer(struct tty_struct
*tty
)
920 struct serial_state
*info
= tty
->driver_data
;
923 if (serial_paranoia_check(info
, tty
->name
, "rs_flush_buffer"))
925 local_irq_save(flags
);
926 info
->xmit
.head
= info
->xmit
.tail
= 0;
927 local_irq_restore(flags
);
932 * This function is used to send a high-priority XON/XOFF character to
935 static void rs_send_xchar(struct tty_struct
*tty
, char ch
)
937 struct serial_state
*info
= tty
->driver_data
;
940 if (serial_paranoia_check(info
, tty
->name
, "rs_send_char"))
945 /* Make sure transmit interrupts are on */
948 local_irq_save(flags
);
949 if(!(custom
.intenar
& IF_TBE
)) {
950 custom
.intena
= IF_SETCLR
| IF_TBE
;
952 /* set a pending Tx Interrupt, transmitter should restart now */
953 custom
.intreq
= IF_SETCLR
| IF_TBE
;
956 local_irq_restore(flags
);
958 info
->IER
|= UART_IER_THRI
;
963 * ------------------------------------------------------------
966 * This routine is called by the upper-layer tty layer to signal that
967 * incoming characters should be throttled.
968 * ------------------------------------------------------------
970 static void rs_throttle(struct tty_struct
* tty
)
972 struct serial_state
*info
= tty
->driver_data
;
974 #ifdef SERIAL_DEBUG_THROTTLE
977 printk("throttle %s: %d....\n", tty_name(tty
, buf
),
978 tty
->ldisc
.chars_in_buffer(tty
));
981 if (serial_paranoia_check(info
, tty
->name
, "rs_throttle"))
985 rs_send_xchar(tty
, STOP_CHAR(tty
));
987 if (tty
->termios
->c_cflag
& CRTSCTS
)
988 info
->MCR
&= ~SER_RTS
;
990 local_irq_save(flags
);
991 rtsdtr_ctrl(info
->MCR
);
992 local_irq_restore(flags
);
995 static void rs_unthrottle(struct tty_struct
* tty
)
997 struct serial_state
*info
= tty
->driver_data
;
999 #ifdef SERIAL_DEBUG_THROTTLE
1002 printk("unthrottle %s: %d....\n", tty_name(tty
, buf
),
1003 tty
->ldisc
.chars_in_buffer(tty
));
1006 if (serial_paranoia_check(info
, tty
->name
, "rs_unthrottle"))
1013 rs_send_xchar(tty
, START_CHAR(tty
));
1015 if (tty
->termios
->c_cflag
& CRTSCTS
)
1016 info
->MCR
|= SER_RTS
;
1017 local_irq_save(flags
);
1018 rtsdtr_ctrl(info
->MCR
);
1019 local_irq_restore(flags
);
1023 * ------------------------------------------------------------
1024 * rs_ioctl() and friends
1025 * ------------------------------------------------------------
1028 static int get_serial_info(struct tty_struct
*tty
, struct serial_state
*state
,
1029 struct serial_struct __user
* retinfo
)
1031 struct serial_struct tmp
;
1035 memset(&tmp
, 0, sizeof(tmp
));
1037 tmp
.line
= tty
->index
;
1038 tmp
.port
= state
->port
;
1039 tmp
.flags
= state
->tport
.flags
;
1040 tmp
.xmit_fifo_size
= state
->xmit_fifo_size
;
1041 tmp
.baud_base
= state
->baud_base
;
1042 tmp
.close_delay
= state
->tport
.close_delay
;
1043 tmp
.closing_wait
= state
->tport
.closing_wait
;
1044 tmp
.custom_divisor
= state
->custom_divisor
;
1046 if (copy_to_user(retinfo
,&tmp
,sizeof(*retinfo
)))
1051 static int set_serial_info(struct tty_struct
*tty
, struct serial_state
*state
,
1052 struct serial_struct __user
* new_info
)
1054 struct tty_port
*port
= &state
->tport
;
1055 struct serial_struct new_serial
;
1059 if (copy_from_user(&new_serial
,new_info
,sizeof(new_serial
)))
1063 change_spd
= ((new_serial
.flags
^ port
->flags
) & ASYNC_SPD_MASK
) ||
1064 new_serial
.custom_divisor
!= state
->custom_divisor
;
1065 if (new_serial
.irq
|| new_serial
.port
!= state
->port
||
1066 new_serial
.xmit_fifo_size
!= state
->xmit_fifo_size
) {
1071 if (!serial_isroot()) {
1072 if ((new_serial
.baud_base
!= state
->baud_base
) ||
1073 (new_serial
.close_delay
!= port
->close_delay
) ||
1074 (new_serial
.xmit_fifo_size
!= state
->xmit_fifo_size
) ||
1075 ((new_serial
.flags
& ~ASYNC_USR_MASK
) !=
1076 (port
->flags
& ~ASYNC_USR_MASK
)))
1078 port
->flags
= ((port
->flags
& ~ASYNC_USR_MASK
) |
1079 (new_serial
.flags
& ASYNC_USR_MASK
));
1080 state
->custom_divisor
= new_serial
.custom_divisor
;
1081 goto check_and_exit
;
1084 if (new_serial
.baud_base
< 9600) {
1090 * OK, past this point, all the error checking has been done.
1091 * At this point, we start making changes.....
1094 state
->baud_base
= new_serial
.baud_base
;
1095 port
->flags
= ((port
->flags
& ~ASYNC_FLAGS
) |
1096 (new_serial
.flags
& ASYNC_FLAGS
));
1097 state
->custom_divisor
= new_serial
.custom_divisor
;
1098 port
->close_delay
= new_serial
.close_delay
* HZ
/100;
1099 port
->closing_wait
= new_serial
.closing_wait
* HZ
/100;
1100 tty
->low_latency
= (port
->flags
& ASYNC_LOW_LATENCY
) ? 1 : 0;
1103 if (port
->flags
& ASYNC_INITIALIZED
) {
1105 if ((port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_HI
)
1106 tty
->alt_speed
= 57600;
1107 if ((port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_VHI
)
1108 tty
->alt_speed
= 115200;
1109 if ((port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_SHI
)
1110 tty
->alt_speed
= 230400;
1111 if ((port
->flags
& ASYNC_SPD_MASK
) == ASYNC_SPD_WARP
)
1112 tty
->alt_speed
= 460800;
1113 change_speed(tty
, state
, NULL
);
1116 retval
= startup(tty
, state
);
1123 * get_lsr_info - get line status register info
1125 * Purpose: Let user call ioctl() to get info when the UART physically
1126 * is emptied. On bus types like RS485, the transmitter must
1127 * release the bus after transmitting. This must be done when
1128 * the transmit shift register is empty, not be done when the
1129 * transmit holding register is empty. This functionality
1130 * allows an RS485 driver to be written in user space.
1132 static int get_lsr_info(struct serial_state
*info
, unsigned int __user
*value
)
1134 unsigned char status
;
1135 unsigned int result
;
1136 unsigned long flags
;
1138 local_irq_save(flags
);
1139 status
= custom
.serdatr
;
1141 local_irq_restore(flags
);
1142 result
= ((status
& SDR_TSRE
) ? TIOCSER_TEMT
: 0);
1143 if (copy_to_user(value
, &result
, sizeof(int)))
1149 static int rs_tiocmget(struct tty_struct
*tty
)
1151 struct serial_state
*info
= tty
->driver_data
;
1152 unsigned char control
, status
;
1153 unsigned long flags
;
1155 if (serial_paranoia_check(info
, tty
->name
, "rs_ioctl"))
1157 if (tty
->flags
& (1 << TTY_IO_ERROR
))
1160 control
= info
->MCR
;
1161 local_irq_save(flags
);
1163 local_irq_restore(flags
);
1164 return ((control
& SER_RTS
) ? TIOCM_RTS
: 0)
1165 | ((control
& SER_DTR
) ? TIOCM_DTR
: 0)
1166 | (!(status
& SER_DCD
) ? TIOCM_CAR
: 0)
1167 | (!(status
& SER_DSR
) ? TIOCM_DSR
: 0)
1168 | (!(status
& SER_CTS
) ? TIOCM_CTS
: 0);
1171 static int rs_tiocmset(struct tty_struct
*tty
, unsigned int set
,
1174 struct serial_state
*info
= tty
->driver_data
;
1175 unsigned long flags
;
1177 if (serial_paranoia_check(info
, tty
->name
, "rs_ioctl"))
1179 if (tty
->flags
& (1 << TTY_IO_ERROR
))
1182 local_irq_save(flags
);
1183 if (set
& TIOCM_RTS
)
1184 info
->MCR
|= SER_RTS
;
1185 if (set
& TIOCM_DTR
)
1186 info
->MCR
|= SER_DTR
;
1187 if (clear
& TIOCM_RTS
)
1188 info
->MCR
&= ~SER_RTS
;
1189 if (clear
& TIOCM_DTR
)
1190 info
->MCR
&= ~SER_DTR
;
1191 rtsdtr_ctrl(info
->MCR
);
1192 local_irq_restore(flags
);
1197 * rs_break() --- routine which turns the break handling on or off
1199 static int rs_break(struct tty_struct
*tty
, int break_state
)
1201 struct serial_state
*info
= tty
->driver_data
;
1202 unsigned long flags
;
1204 if (serial_paranoia_check(info
, tty
->name
, "rs_break"))
1207 local_irq_save(flags
);
1208 if (break_state
== -1)
1209 custom
.adkcon
= AC_SETCLR
| AC_UARTBRK
;
1211 custom
.adkcon
= AC_UARTBRK
;
1213 local_irq_restore(flags
);
1218 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1219 * Return: write counters to the user passed counter struct
1220 * NB: both 1->0 and 0->1 transitions are counted except for
1221 * RI where only 0->1 is counted.
1223 static int rs_get_icount(struct tty_struct
*tty
,
1224 struct serial_icounter_struct
*icount
)
1226 struct serial_state
*info
= tty
->driver_data
;
1227 struct async_icount cnow
;
1228 unsigned long flags
;
1230 local_irq_save(flags
);
1231 cnow
= info
->icount
;
1232 local_irq_restore(flags
);
1233 icount
->cts
= cnow
.cts
;
1234 icount
->dsr
= cnow
.dsr
;
1235 icount
->rng
= cnow
.rng
;
1236 icount
->dcd
= cnow
.dcd
;
1237 icount
->rx
= cnow
.rx
;
1238 icount
->tx
= cnow
.tx
;
1239 icount
->frame
= cnow
.frame
;
1240 icount
->overrun
= cnow
.overrun
;
1241 icount
->parity
= cnow
.parity
;
1242 icount
->brk
= cnow
.brk
;
1243 icount
->buf_overrun
= cnow
.buf_overrun
;
1248 static int rs_ioctl(struct tty_struct
*tty
,
1249 unsigned int cmd
, unsigned long arg
)
1251 struct serial_state
*info
= tty
->driver_data
;
1252 struct async_icount cprev
, cnow
; /* kernel counter temps */
1253 void __user
*argp
= (void __user
*)arg
;
1254 unsigned long flags
;
1256 if (serial_paranoia_check(info
, tty
->name
, "rs_ioctl"))
1259 if ((cmd
!= TIOCGSERIAL
) && (cmd
!= TIOCSSERIAL
) &&
1260 (cmd
!= TIOCSERCONFIG
) && (cmd
!= TIOCSERGSTRUCT
) &&
1261 (cmd
!= TIOCMIWAIT
) && (cmd
!= TIOCGICOUNT
)) {
1262 if (tty
->flags
& (1 << TTY_IO_ERROR
))
1268 return get_serial_info(tty
, info
, argp
);
1270 return set_serial_info(tty
, info
, argp
);
1274 case TIOCSERGETLSR
: /* Get line status register */
1275 return get_lsr_info(info
, argp
);
1277 case TIOCSERGSTRUCT
:
1278 if (copy_to_user(argp
,
1279 info
, sizeof(struct serial_state
)))
1284 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
1285 * - mask passed in arg for lines of interest
1286 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
1287 * Caller should use TIOCGICOUNT to see which one it was
1290 local_irq_save(flags
);
1291 /* note the counters on entry */
1292 cprev
= info
->icount
;
1293 local_irq_restore(flags
);
1295 interruptible_sleep_on(&info
->tport
.delta_msr_wait
);
1296 /* see if a signal did it */
1297 if (signal_pending(current
))
1298 return -ERESTARTSYS
;
1299 local_irq_save(flags
);
1300 cnow
= info
->icount
; /* atomic copy */
1301 local_irq_restore(flags
);
1302 if (cnow
.rng
== cprev
.rng
&& cnow
.dsr
== cprev
.dsr
&&
1303 cnow
.dcd
== cprev
.dcd
&& cnow
.cts
== cprev
.cts
)
1304 return -EIO
; /* no change => error */
1305 if ( ((arg
& TIOCM_RNG
) && (cnow
.rng
!= cprev
.rng
)) ||
1306 ((arg
& TIOCM_DSR
) && (cnow
.dsr
!= cprev
.dsr
)) ||
1307 ((arg
& TIOCM_CD
) && (cnow
.dcd
!= cprev
.dcd
)) ||
1308 ((arg
& TIOCM_CTS
) && (cnow
.cts
!= cprev
.cts
)) ) {
1317 /* "setserial -W" is called in Debian boot */
1318 printk ("TIOCSER?WILD ioctl obsolete, ignored.\n");
1322 return -ENOIOCTLCMD
;
1327 static void rs_set_termios(struct tty_struct
*tty
, struct ktermios
*old_termios
)
1329 struct serial_state
*info
= tty
->driver_data
;
1330 unsigned long flags
;
1331 unsigned int cflag
= tty
->termios
->c_cflag
;
1333 change_speed(tty
, info
, old_termios
);
1335 /* Handle transition to B0 status */
1336 if ((old_termios
->c_cflag
& CBAUD
) &&
1338 info
->MCR
&= ~(SER_DTR
|SER_RTS
);
1339 local_irq_save(flags
);
1340 rtsdtr_ctrl(info
->MCR
);
1341 local_irq_restore(flags
);
1344 /* Handle transition away from B0 status */
1345 if (!(old_termios
->c_cflag
& CBAUD
) &&
1347 info
->MCR
|= SER_DTR
;
1348 if (!(tty
->termios
->c_cflag
& CRTSCTS
) ||
1349 !test_bit(TTY_THROTTLED
, &tty
->flags
)) {
1350 info
->MCR
|= SER_RTS
;
1352 local_irq_save(flags
);
1353 rtsdtr_ctrl(info
->MCR
);
1354 local_irq_restore(flags
);
1357 /* Handle turning off CRTSCTS */
1358 if ((old_termios
->c_cflag
& CRTSCTS
) &&
1359 !(tty
->termios
->c_cflag
& CRTSCTS
)) {
1360 tty
->hw_stopped
= 0;
1366 * No need to wake up processes in open wait, since they
1367 * sample the CLOCAL flag once, and don't recheck it.
1368 * XXX It's not clear whether the current behavior is correct
1369 * or not. Hence, this may change.....
1371 if (!(old_termios
->c_cflag
& CLOCAL
) &&
1372 (tty
->termios
->c_cflag
& CLOCAL
))
1373 wake_up_interruptible(&info
->open_wait
);
1378 * ------------------------------------------------------------
1381 * This routine is called when the serial port gets closed. First, we
1382 * wait for the last remaining data to be sent. Then, we unlink its
1383 * async structure from the interrupt chain if necessary, and we free
1384 * that IRQ if nothing is left in the chain.
1385 * ------------------------------------------------------------
1387 static void rs_close(struct tty_struct
*tty
, struct file
* filp
)
1389 struct serial_state
*state
= tty
->driver_data
;
1390 struct tty_port
*port
= &state
->tport
;
1392 if (serial_paranoia_check(state
, tty
->name
, "rs_close"))
1395 if (tty_port_close_start(port
, tty
, filp
) == 0)
1399 * At this point we stop accepting input. To do this, we
1400 * disable the receive line status interrupts, and tell the
1401 * interrupt driver to stop checking the data ready bit in the
1402 * line status register.
1404 state
->read_status_mask
&= ~UART_LSR_DR
;
1405 if (port
->flags
& ASYNC_INITIALIZED
) {
1406 /* disable receive interrupts */
1407 custom
.intena
= IF_RBF
;
1409 /* clear any pending receive interrupt */
1410 custom
.intreq
= IF_RBF
;
1414 * Before we drop DTR, make sure the UART transmitter
1415 * has completely drained; this is especially
1416 * important if there is a transmit FIFO!
1418 rs_wait_until_sent(tty
, state
->timeout
);
1420 shutdown(tty
, state
);
1421 rs_flush_buffer(tty
);
1423 tty_ldisc_flush(tty
);
1426 tty_port_close_end(port
, tty
);
1430 * rs_wait_until_sent() --- wait until the transmitter is empty
1432 static void rs_wait_until_sent(struct tty_struct
*tty
, int timeout
)
1434 struct serial_state
*info
= tty
->driver_data
;
1435 unsigned long orig_jiffies
, char_time
;
1438 if (serial_paranoia_check(info
, tty
->name
, "rs_wait_until_sent"))
1441 if (info
->xmit_fifo_size
== 0)
1442 return; /* Just in case.... */
1444 orig_jiffies
= jiffies
;
1447 * Set the check interval to be 1/5 of the estimated time to
1448 * send a single character, and make it at least 1. The check
1449 * interval should also be less than the timeout.
1451 * Note: we have to use pretty tight timings here to satisfy
1454 char_time
= (info
->timeout
- HZ
/50) / info
->xmit_fifo_size
;
1455 char_time
= char_time
/ 5;
1459 char_time
= min_t(unsigned long, char_time
, timeout
);
1461 * If the transmitter hasn't cleared in twice the approximate
1462 * amount of time to send the entire FIFO, it probably won't
1463 * ever clear. This assumes the UART isn't doing flow
1464 * control, which is currently the case. Hence, if it ever
1465 * takes longer than info->timeout, this is probably due to a
1466 * UART bug of some kind. So, we clamp the timeout parameter at
1469 if (!timeout
|| timeout
> 2*info
->timeout
)
1470 timeout
= 2*info
->timeout
;
1471 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1472 printk("In rs_wait_until_sent(%d) check=%lu...", timeout
, char_time
);
1473 printk("jiff=%lu...", jiffies
);
1475 while(!((lsr
= custom
.serdatr
) & SDR_TSRE
)) {
1476 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1477 printk("serdatr = %d (jiff=%lu)...", lsr
, jiffies
);
1479 msleep_interruptible(jiffies_to_msecs(char_time
));
1480 if (signal_pending(current
))
1482 if (timeout
&& time_after(jiffies
, orig_jiffies
+ timeout
))
1485 __set_current_state(TASK_RUNNING
);
1487 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1488 printk("lsr = %d (jiff=%lu)...done\n", lsr
, jiffies
);
1493 * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
1495 static void rs_hangup(struct tty_struct
*tty
)
1497 struct serial_state
*info
= tty
->driver_data
;
1499 if (serial_paranoia_check(info
, tty
->name
, "rs_hangup"))
1502 rs_flush_buffer(tty
);
1503 shutdown(tty
, info
);
1504 info
->tport
.count
= 0;
1505 info
->tport
.flags
&= ~ASYNC_NORMAL_ACTIVE
;
1506 info
->tport
.tty
= NULL
;
1507 wake_up_interruptible(&info
->tport
.open_wait
);
1511 * This routine is called whenever a serial port is opened. It
1512 * enables interrupts for a serial port, linking in its async structure into
1513 * the IRQ chain. It also performs the serial-specific
1514 * initialization for the tty structure.
1516 static int rs_open(struct tty_struct
*tty
, struct file
* filp
)
1518 struct serial_state
*info
= rs_table
+ tty
->index
;
1519 struct tty_port
*port
= &info
->tport
;
1524 tty
->driver_data
= info
;
1526 if (serial_paranoia_check(info
, tty
->name
, "rs_open"))
1529 tty
->low_latency
= (port
->flags
& ASYNC_LOW_LATENCY
) ? 1 : 0;
1531 retval
= startup(tty
, info
);
1536 return tty_port_block_til_ready(port
, tty
, filp
);
1540 * /proc fs routines....
1543 static inline void line_info(struct seq_file
*m
, int line
,
1544 struct serial_state
*state
)
1546 char stat_buf
[30], control
, status
;
1547 unsigned long flags
;
1549 seq_printf(m
, "%d: uart:amiga_builtin", line
);
1551 local_irq_save(flags
);
1553 control
= (state
->tport
.flags
& ASYNC_INITIALIZED
) ? state
->MCR
: status
;
1554 local_irq_restore(flags
);
1558 if(!(control
& SER_RTS
))
1559 strcat(stat_buf
, "|RTS");
1560 if(!(status
& SER_CTS
))
1561 strcat(stat_buf
, "|CTS");
1562 if(!(control
& SER_DTR
))
1563 strcat(stat_buf
, "|DTR");
1564 if(!(status
& SER_DSR
))
1565 strcat(stat_buf
, "|DSR");
1566 if(!(status
& SER_DCD
))
1567 strcat(stat_buf
, "|CD");
1570 seq_printf(m
, " baud:%d", state
->baud_base
/ state
->quot
);
1572 seq_printf(m
, " tx:%d rx:%d", state
->icount
.tx
, state
->icount
.rx
);
1574 if (state
->icount
.frame
)
1575 seq_printf(m
, " fe:%d", state
->icount
.frame
);
1577 if (state
->icount
.parity
)
1578 seq_printf(m
, " pe:%d", state
->icount
.parity
);
1580 if (state
->icount
.brk
)
1581 seq_printf(m
, " brk:%d", state
->icount
.brk
);
1583 if (state
->icount
.overrun
)
1584 seq_printf(m
, " oe:%d", state
->icount
.overrun
);
1587 * Last thing is the RS-232 status lines
1589 seq_printf(m
, " %s\n", stat_buf
+1);
1592 static int rs_proc_show(struct seq_file
*m
, void *v
)
1594 seq_printf(m
, "serinfo:1.0 driver:%s\n", serial_version
);
1595 line_info(m
, 0, &rs_table
[0]);
1599 static int rs_proc_open(struct inode
*inode
, struct file
*file
)
1601 return single_open(file
, rs_proc_show
, NULL
);
1604 static const struct file_operations rs_proc_fops
= {
1605 .owner
= THIS_MODULE
,
1606 .open
= rs_proc_open
,
1608 .llseek
= seq_lseek
,
1609 .release
= single_release
,
1613 * ---------------------------------------------------------------------
1614 * rs_init() and friends
1616 * rs_init() is called at boot-time to initialize the serial driver.
1617 * ---------------------------------------------------------------------
1621 * This routine prints out the appropriate serial driver version
1622 * number, and identifies which options were configured into this
1625 static void show_serial_version(void)
1627 printk(KERN_INFO
"%s version %s\n", serial_name
, serial_version
);
1631 static const struct tty_operations serial_ops
= {
1635 .put_char
= rs_put_char
,
1636 .flush_chars
= rs_flush_chars
,
1637 .write_room
= rs_write_room
,
1638 .chars_in_buffer
= rs_chars_in_buffer
,
1639 .flush_buffer
= rs_flush_buffer
,
1641 .throttle
= rs_throttle
,
1642 .unthrottle
= rs_unthrottle
,
1643 .set_termios
= rs_set_termios
,
1646 .hangup
= rs_hangup
,
1647 .break_ctl
= rs_break
,
1648 .send_xchar
= rs_send_xchar
,
1649 .wait_until_sent
= rs_wait_until_sent
,
1650 .tiocmget
= rs_tiocmget
,
1651 .tiocmset
= rs_tiocmset
,
1652 .get_icount
= rs_get_icount
,
1653 .proc_fops
= &rs_proc_fops
,
1656 static int amiga_carrier_raised(struct tty_port
*port
)
1658 return !(ciab
.pra
& SER_DCD
);
1661 static void amiga_dtr_rts(struct tty_port
*port
, int raise
)
1663 struct serial_state
*info
= container_of(port
, struct serial_state
,
1665 unsigned long flags
;
1668 info
->MCR
|= SER_DTR
|SER_RTS
;
1670 info
->MCR
&= ~(SER_DTR
|SER_RTS
);
1672 local_irq_save(flags
);
1673 rtsdtr_ctrl(info
->MCR
);
1674 local_irq_restore(flags
);
1677 static const struct tty_port_operations amiga_port_ops
= {
1678 .carrier_raised
= amiga_carrier_raised
,
1679 .dtr_rts
= amiga_dtr_rts
,
1683 * The serial driver boot-time initialization code!
1685 static int __init
amiga_serial_probe(struct platform_device
*pdev
)
1687 unsigned long flags
;
1688 struct serial_state
* state
;
1691 serial_driver
= alloc_tty_driver(NR_PORTS
);
1695 show_serial_version();
1697 /* Initialize the tty_driver structure */
1699 serial_driver
->driver_name
= "amiserial";
1700 serial_driver
->name
= "ttyS";
1701 serial_driver
->major
= TTY_MAJOR
;
1702 serial_driver
->minor_start
= 64;
1703 serial_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
1704 serial_driver
->subtype
= SERIAL_TYPE_NORMAL
;
1705 serial_driver
->init_termios
= tty_std_termios
;
1706 serial_driver
->init_termios
.c_cflag
=
1707 B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1708 serial_driver
->flags
= TTY_DRIVER_REAL_RAW
;
1709 tty_set_operations(serial_driver
, &serial_ops
);
1711 error
= tty_register_driver(serial_driver
);
1713 goto fail_put_tty_driver
;
1716 state
->port
= (int)&custom
.serdatr
; /* Just to give it a value */
1717 state
->custom_divisor
= 0;
1718 state
->icount
.cts
= state
->icount
.dsr
=
1719 state
->icount
.rng
= state
->icount
.dcd
= 0;
1720 state
->icount
.rx
= state
->icount
.tx
= 0;
1721 state
->icount
.frame
= state
->icount
.parity
= 0;
1722 state
->icount
.overrun
= state
->icount
.brk
= 0;
1723 tty_port_init(&state
->tport
);
1724 state
->tport
.ops
= &amiga_port_ops
;
1726 printk(KERN_INFO
"ttyS0 is the amiga builtin serial port\n");
1728 /* Hardware set up */
1730 state
->baud_base
= amiga_colorclock
;
1731 state
->xmit_fifo_size
= 1;
1733 /* set ISRs, and then disable the rx interrupts */
1734 error
= request_irq(IRQ_AMIGA_TBE
, ser_tx_int
, 0, "serial TX", state
);
1736 goto fail_unregister
;
1738 error
= request_irq(IRQ_AMIGA_RBF
, ser_rx_int
, 0,
1739 "serial RX", state
);
1743 local_irq_save(flags
);
1745 /* turn off Rx and Tx interrupts */
1746 custom
.intena
= IF_RBF
| IF_TBE
;
1749 /* clear any pending interrupt */
1750 custom
.intreq
= IF_RBF
| IF_TBE
;
1753 local_irq_restore(flags
);
1756 * set the appropriate directions for the modem control flags,
1757 * and clear RTS and DTR
1759 ciab
.ddra
|= (SER_DTR
| SER_RTS
); /* outputs */
1760 ciab
.ddra
&= ~(SER_DCD
| SER_CTS
| SER_DSR
); /* inputs */
1762 platform_set_drvdata(pdev
, state
);
1767 free_irq(IRQ_AMIGA_TBE
, state
);
1769 tty_unregister_driver(serial_driver
);
1770 fail_put_tty_driver
:
1771 put_tty_driver(serial_driver
);
1775 static int __exit
amiga_serial_remove(struct platform_device
*pdev
)
1778 struct serial_state
*state
= platform_get_drvdata(pdev
);
1780 /* printk("Unloading %s: version %s\n", serial_name, serial_version); */
1781 if ((error
= tty_unregister_driver(serial_driver
)))
1782 printk("SERIAL: failed to unregister serial driver (%d)\n",
1784 put_tty_driver(serial_driver
);
1786 free_irq(IRQ_AMIGA_TBE
, state
);
1787 free_irq(IRQ_AMIGA_RBF
, state
);
1789 platform_set_drvdata(pdev
, NULL
);
1794 static struct platform_driver amiga_serial_driver
= {
1795 .remove
= __exit_p(amiga_serial_remove
),
1797 .name
= "amiga-serial",
1798 .owner
= THIS_MODULE
,
1802 static int __init
amiga_serial_init(void)
1804 return platform_driver_probe(&amiga_serial_driver
, amiga_serial_probe
);
1807 module_init(amiga_serial_init
);
1809 static void __exit
amiga_serial_exit(void)
1811 platform_driver_unregister(&amiga_serial_driver
);
1814 module_exit(amiga_serial_exit
);
1817 #if defined(CONFIG_SERIAL_CONSOLE) && !defined(MODULE)
1820 * ------------------------------------------------------------
1821 * Serial console driver
1822 * ------------------------------------------------------------
1825 static void amiga_serial_putc(char c
)
1827 custom
.serdat
= (unsigned char)c
| 0x100;
1828 while (!(custom
.serdatr
& 0x2000))
1833 * Print a string to the serial port trying not to disturb
1834 * any possible real use of the port...
1836 * The console must be locked when we get here.
1838 static void serial_console_write(struct console
*co
, const char *s
,
1841 unsigned short intena
= custom
.intenar
;
1843 custom
.intena
= IF_TBE
;
1847 amiga_serial_putc('\r');
1848 amiga_serial_putc(*s
++);
1851 custom
.intena
= IF_SETCLR
| (intena
& IF_TBE
);
1854 static struct tty_driver
*serial_console_device(struct console
*c
, int *index
)
1857 return serial_driver
;
1860 static struct console sercons
= {
1862 .write
= serial_console_write
,
1863 .device
= serial_console_device
,
1864 .flags
= CON_PRINTBUFFER
,
1871 static int __init
amiserial_console_init(void)
1873 register_console(&sercons
);
1876 console_initcall(amiserial_console_init
);
1878 #endif /* CONFIG_SERIAL_CONSOLE && !MODULE */
1880 MODULE_LICENSE("GPL");
1881 MODULE_ALIAS("platform:amiga-serial");