1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Serial driver for the amiga builtin port.
4 *
5 * This code was created by taking serial.c version 4.30 from kernel
6 * release 2.3.22, replacing all hardware related stuff with the
7 * corresponding amiga hardware actions, and removing all irrelevant
8 * code. As a consequence, it uses many of the constants and names
9 * associated with the registers and bits of 16550 compatible UARTS -
10 * but only to keep track of status, etc in the state variables. It
11 * was done this was to make it easier to keep the code in line with
12 * (non hardware specific) changes to serial.c.
13 *
14 * The port is registered with the tty driver as minor device 64, and
15 * therefore other ports should should only use 65 upwards.
16 *
17 * Richard Lucock 28/12/99
18 *
19 * Copyright (C) 1991, 1992 Linus Torvalds
20 * Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997,
21 * 1998, 1999 Theodore Ts'o
22 *
23 */
24
25 /* Set of debugging defines */
26
27 #undef SERIAL_DEBUG_INTR
28 #undef SERIAL_DEBUG_OPEN
29 #undef SERIAL_DEBUG_FLOW
30 #undef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
31
32 /*
33 * End of serial driver configuration section.
34 */
35
36 #include <linux/bitops.h>
37 #include <linux/circ_buf.h>
38 #include <linux/console.h>
39 #include <linux/delay.h>
40 #include <linux/errno.h>
41 #include <linux/fcntl.h>
42 #include <linux/init.h>
43 #include <linux/interrupt.h>
44 #include <linux/ioport.h>
45 #include <linux/kernel.h>
46 #include <linux/major.h>
47 #include <linux/mm.h>
48 #include <linux/module.h>
49 #include <linux/platform_device.h>
50 #include <linux/ptrace.h>
51 #include <linux/seq_file.h>
52 #include <linux/serial.h>
53 #include <linux/serial_reg.h>
54 #include <linux/sched.h>
55 #include <linux/signal.h>
56 #include <linux/slab.h>
57 #include <linux/string.h>
58 #include <linux/timer.h>
59 #include <linux/tty_flip.h>
60 #include <linux/tty.h>
61 #include <linux/types.h>
62 #include <linux/uaccess.h>
63
64 #include <asm/amigahw.h>
65 #include <asm/amigaints.h>
66 #include <asm/irq.h>
67 #include <asm/setup.h>
68
69 struct serial_state {
70 struct tty_port tport;
71 struct circ_buf xmit;
72 struct async_icount icount;
73
74 unsigned long port;
75 int baud_base;
76 int custom_divisor;
77 int read_status_mask;
78 int ignore_status_mask;
79 int timeout;
80 int quot;
81 int IER; /* Interrupt Enable Register */
82 int MCR; /* Modem control register */
83 int x_char; /* xon/xoff character */
84 };
85
86 static struct tty_driver *serial_driver;
87
88 /* number of characters left in xmit buffer before we ask for more */
89 #define WAKEUP_CHARS 256
90
91 #define XMIT_FIFO_SIZE 1
92
93 static unsigned char current_ctl_bits;
94
95 static void change_speed(struct tty_struct *tty, struct serial_state *info,
96 struct ktermios *old);
97 static void rs_wait_until_sent(struct tty_struct *tty, int timeout);
98
99
100 static struct serial_state serial_state;
101
102 /* some serial hardware definitions */
103 #define SDR_OVRUN (1<<15)
104 #define SDR_RBF (1<<14)
105 #define SDR_TBE (1<<13)
106 #define SDR_TSRE (1<<12)
107
108 #define SERPER_PARENB (1<<15)
109
110 #define AC_SETCLR (1<<15)
111 #define AC_UARTBRK (1<<11)
112
113 #define SER_DTR (1<<7)
114 #define SER_RTS (1<<6)
115 #define SER_DCD (1<<5)
116 #define SER_CTS (1<<4)
117 #define SER_DSR (1<<3)
118
rtsdtr_ctrl(int bits)119 static __inline__ void rtsdtr_ctrl(int bits)
120 {
121 ciab.pra = ((bits & (SER_RTS | SER_DTR)) ^ (SER_RTS | SER_DTR)) | (ciab.pra & ~(SER_RTS | SER_DTR));
122 }
123
124 /*
125 * ------------------------------------------------------------
126 * rs_stop() and rs_start()
127 *
128 * This routines are called before setting or resetting tty->flow.stopped.
129 * They enable or disable transmitter interrupts, as necessary.
130 * ------------------------------------------------------------
131 */
rs_stop(struct tty_struct * tty)132 static void rs_stop(struct tty_struct *tty)
133 {
134 struct serial_state *info = tty->driver_data;
135 unsigned long flags;
136
137 local_irq_save(flags);
138 if (info->IER & UART_IER_THRI) {
139 info->IER &= ~UART_IER_THRI;
140 /* disable Tx interrupt and remove any pending interrupts */
141 amiga_custom.intena = IF_TBE;
142 mb();
143 amiga_custom.intreq = IF_TBE;
144 mb();
145 }
146 local_irq_restore(flags);
147 }
148
rs_start(struct tty_struct * tty)149 static void rs_start(struct tty_struct *tty)
150 {
151 struct serial_state *info = tty->driver_data;
152 unsigned long flags;
153
154 local_irq_save(flags);
155 if (info->xmit.head != info->xmit.tail
156 && info->xmit.buf
157 && !(info->IER & UART_IER_THRI)) {
158 info->IER |= UART_IER_THRI;
159 amiga_custom.intena = IF_SETCLR | IF_TBE;
160 mb();
161 /* set a pending Tx Interrupt, transmitter should restart now */
162 amiga_custom.intreq = IF_SETCLR | IF_TBE;
163 mb();
164 }
165 local_irq_restore(flags);
166 }
167
168 /*
169 * ----------------------------------------------------------------------
170 *
171 * Here start the interrupt handling routines.
172 *
173 * -----------------------------------------------------------------------
174 */
175
receive_chars(struct serial_state * info)176 static void receive_chars(struct serial_state *info)
177 {
178 int status;
179 int serdatr;
180 unsigned char ch, flag;
181 struct async_icount *icount;
182 int oe = 0;
183
184 icount = &info->icount;
185
186 status = UART_LSR_DR; /* We obviously have a character! */
187 serdatr = amiga_custom.serdatr;
188 mb();
189 amiga_custom.intreq = IF_RBF;
190 mb();
191
192 if((serdatr & 0x1ff) == 0)
193 status |= UART_LSR_BI;
194 if(serdatr & SDR_OVRUN)
195 status |= UART_LSR_OE;
196
197 ch = serdatr & 0xff;
198 icount->rx++;
199
200 #ifdef SERIAL_DEBUG_INTR
201 printk("DR%02x:%02x...", ch, status);
202 #endif
203 flag = TTY_NORMAL;
204
205 /*
206 * We don't handle parity or frame errors - but I have left
207 * the code in, since I'm not sure that the errors can't be
208 * detected.
209 */
210
211 if (status & (UART_LSR_BI | UART_LSR_PE |
212 UART_LSR_FE | UART_LSR_OE)) {
213 /*
214 * For statistics only
215 */
216 if (status & UART_LSR_BI) {
217 status &= ~(UART_LSR_FE | UART_LSR_PE);
218 icount->brk++;
219 } else if (status & UART_LSR_PE)
220 icount->parity++;
221 else if (status & UART_LSR_FE)
222 icount->frame++;
223 if (status & UART_LSR_OE)
224 icount->overrun++;
225
226 /*
227 * Now check to see if character should be
228 * ignored, and mask off conditions which
229 * should be ignored.
230 */
231 if (status & info->ignore_status_mask)
232 goto out;
233
234 status &= info->read_status_mask;
235
236 if (status & (UART_LSR_BI)) {
237 #ifdef SERIAL_DEBUG_INTR
238 printk("handling break....");
239 #endif
240 flag = TTY_BREAK;
241 if (info->tport.flags & ASYNC_SAK)
242 do_SAK(info->tport.tty);
243 } else if (status & UART_LSR_PE)
244 flag = TTY_PARITY;
245 else if (status & UART_LSR_FE)
246 flag = TTY_FRAME;
247 if (status & UART_LSR_OE) {
248 /*
249 * Overrun is special, since it's
250 * reported immediately, and doesn't
251 * affect the current character
252 */
253 oe = 1;
254 }
255 }
256 tty_insert_flip_char(&info->tport, ch, flag);
257 if (oe == 1)
258 tty_insert_flip_char(&info->tport, 0, TTY_OVERRUN);
259 tty_flip_buffer_push(&info->tport);
260 out:
261 return;
262 }
263
transmit_chars(struct serial_state * info)264 static void transmit_chars(struct serial_state *info)
265 {
266 amiga_custom.intreq = IF_TBE;
267 mb();
268 if (info->x_char) {
269 amiga_custom.serdat = info->x_char | 0x100;
270 mb();
271 info->icount.tx++;
272 info->x_char = 0;
273 return;
274 }
275 if (info->xmit.head == info->xmit.tail
276 || info->tport.tty->flow.stopped
277 || info->tport.tty->hw_stopped) {
278 info->IER &= ~UART_IER_THRI;
279 amiga_custom.intena = IF_TBE;
280 mb();
281 return;
282 }
283
284 amiga_custom.serdat = info->xmit.buf[info->xmit.tail++] | 0x100;
285 mb();
286 info->xmit.tail = info->xmit.tail & (SERIAL_XMIT_SIZE-1);
287 info->icount.tx++;
288
289 if (CIRC_CNT(info->xmit.head,
290 info->xmit.tail,
291 SERIAL_XMIT_SIZE) < WAKEUP_CHARS)
292 tty_wakeup(info->tport.tty);
293
294 #ifdef SERIAL_DEBUG_INTR
295 printk("THRE...");
296 #endif
297 if (info->xmit.head == info->xmit.tail) {
298 amiga_custom.intena = IF_TBE;
299 mb();
300 info->IER &= ~UART_IER_THRI;
301 }
302 }
303
check_modem_status(struct serial_state * info)304 static void check_modem_status(struct serial_state *info)
305 {
306 struct tty_port *port = &info->tport;
307 unsigned char status = ciab.pra & (SER_DCD | SER_CTS | SER_DSR);
308 unsigned char dstatus;
309 struct async_icount *icount;
310
311 /* Determine bits that have changed */
312 dstatus = status ^ current_ctl_bits;
313 current_ctl_bits = status;
314
315 if (dstatus) {
316 icount = &info->icount;
317 /* update input line counters */
318 if (dstatus & SER_DSR)
319 icount->dsr++;
320 if (dstatus & SER_DCD) {
321 icount->dcd++;
322 }
323 if (dstatus & SER_CTS)
324 icount->cts++;
325 wake_up_interruptible(&port->delta_msr_wait);
326 }
327
328 if (tty_port_check_carrier(port) && (dstatus & SER_DCD)) {
329 #if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR))
330 printk("ttyS%d CD now %s...", info->line,
331 (!(status & SER_DCD)) ? "on" : "off");
332 #endif
333 if (!(status & SER_DCD))
334 wake_up_interruptible(&port->open_wait);
335 else {
336 #ifdef SERIAL_DEBUG_OPEN
337 printk("doing serial hangup...");
338 #endif
339 if (port->tty)
340 tty_hangup(port->tty);
341 }
342 }
343 if (tty_port_cts_enabled(port)) {
344 if (port->tty->hw_stopped) {
345 if (!(status & SER_CTS)) {
346 #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
347 printk("CTS tx start...");
348 #endif
349 port->tty->hw_stopped = 0;
350 info->IER |= UART_IER_THRI;
351 amiga_custom.intena = IF_SETCLR | IF_TBE;
352 mb();
353 /* set a pending Tx Interrupt, transmitter should restart now */
354 amiga_custom.intreq = IF_SETCLR | IF_TBE;
355 mb();
356 tty_wakeup(port->tty);
357 return;
358 }
359 } else {
360 if ((status & SER_CTS)) {
361 #if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW))
362 printk("CTS tx stop...");
363 #endif
364 port->tty->hw_stopped = 1;
365 info->IER &= ~UART_IER_THRI;
366 /* disable Tx interrupt and remove any pending interrupts */
367 amiga_custom.intena = IF_TBE;
368 mb();
369 amiga_custom.intreq = IF_TBE;
370 mb();
371 }
372 }
373 }
374 }
375
ser_vbl_int(int irq,void * data)376 static irqreturn_t ser_vbl_int( int irq, void *data)
377 {
378 /* vbl is just a periodic interrupt we tie into to update modem status */
379 struct serial_state *info = data;
380 /*
381 * TBD - is it better to unregister from this interrupt or to
382 * ignore it if MSI is clear ?
383 */
384 if(info->IER & UART_IER_MSI)
385 check_modem_status(info);
386 return IRQ_HANDLED;
387 }
388
ser_rx_int(int irq,void * dev_id)389 static irqreturn_t ser_rx_int(int irq, void *dev_id)
390 {
391 struct serial_state *info = dev_id;
392
393 #ifdef SERIAL_DEBUG_INTR
394 printk("ser_rx_int...");
395 #endif
396
397 if (!info->tport.tty)
398 return IRQ_NONE;
399
400 receive_chars(info);
401 #ifdef SERIAL_DEBUG_INTR
402 printk("end.\n");
403 #endif
404 return IRQ_HANDLED;
405 }
406
ser_tx_int(int irq,void * dev_id)407 static irqreturn_t ser_tx_int(int irq, void *dev_id)
408 {
409 struct serial_state *info = dev_id;
410
411 if (amiga_custom.serdatr & SDR_TBE) {
412 #ifdef SERIAL_DEBUG_INTR
413 printk("ser_tx_int...");
414 #endif
415
416 if (!info->tport.tty)
417 return IRQ_NONE;
418
419 transmit_chars(info);
420 #ifdef SERIAL_DEBUG_INTR
421 printk("end.\n");
422 #endif
423 }
424 return IRQ_HANDLED;
425 }
426
427 /*
428 * -------------------------------------------------------------------
429 * Here ends the serial interrupt routines.
430 * -------------------------------------------------------------------
431 */
432
433 /*
434 * ---------------------------------------------------------------
435 * Low level utility subroutines for the serial driver: routines to
436 * figure out the appropriate timeout for an interrupt chain, routines
437 * to initialize and startup a serial port, and routines to shutdown a
438 * serial port. Useful stuff like that.
439 * ---------------------------------------------------------------
440 */
441
startup(struct tty_struct * tty,struct serial_state * info)442 static int startup(struct tty_struct *tty, struct serial_state *info)
443 {
444 struct tty_port *port = &info->tport;
445 unsigned long flags;
446 int retval=0;
447 unsigned long page;
448
449 page = get_zeroed_page(GFP_KERNEL);
450 if (!page)
451 return -ENOMEM;
452
453 local_irq_save(flags);
454
455 if (tty_port_initialized(port)) {
456 free_page(page);
457 goto errout;
458 }
459
460 if (info->xmit.buf)
461 free_page(page);
462 else
463 info->xmit.buf = (unsigned char *) page;
464
465 #ifdef SERIAL_DEBUG_OPEN
466 printk("starting up ttys%d ...", info->line);
467 #endif
468
469 /* Clear anything in the input buffer */
470
471 amiga_custom.intreq = IF_RBF;
472 mb();
473
474 retval = request_irq(IRQ_AMIGA_VERTB, ser_vbl_int, 0, "serial status", info);
475 if (retval) {
476 if (capable(CAP_SYS_ADMIN)) {
477 set_bit(TTY_IO_ERROR, &tty->flags);
478 retval = 0;
479 }
480 goto errout;
481 }
482
483 /* enable both Rx and Tx interrupts */
484 amiga_custom.intena = IF_SETCLR | IF_RBF | IF_TBE;
485 mb();
486 info->IER = UART_IER_MSI;
487
488 /* remember current state of the DCD and CTS bits */
489 current_ctl_bits = ciab.pra & (SER_DCD | SER_CTS | SER_DSR);
490
491 info->MCR = 0;
492 if (C_BAUD(tty))
493 info->MCR = SER_DTR | SER_RTS;
494 rtsdtr_ctrl(info->MCR);
495
496 clear_bit(TTY_IO_ERROR, &tty->flags);
497 info->xmit.head = info->xmit.tail = 0;
498
499 /*
500 * and set the speed of the serial port
501 */
502 change_speed(tty, info, NULL);
503
504 tty_port_set_initialized(port, 1);
505 local_irq_restore(flags);
506 return 0;
507
508 errout:
509 local_irq_restore(flags);
510 return retval;
511 }
512
513 /*
514 * This routine will shutdown a serial port; interrupts are disabled, and
515 * DTR is dropped if the hangup on close termio flag is on.
516 */
shutdown(struct tty_struct * tty,struct serial_state * info)517 static void shutdown(struct tty_struct *tty, struct serial_state *info)
518 {
519 unsigned long flags;
520
521 if (!tty_port_initialized(&info->tport))
522 return;
523
524 #ifdef SERIAL_DEBUG_OPEN
525 printk("Shutting down serial port %d ....\n", info->line);
526 #endif
527
528 local_irq_save(flags); /* Disable interrupts */
529
530 /*
531 * clear delta_msr_wait queue to avoid mem leaks: we may free the irq
532 * here so the queue might never be waken up
533 */
534 wake_up_interruptible(&info->tport.delta_msr_wait);
535
536 /*
537 * Free the IRQ, if necessary
538 */
539 free_irq(IRQ_AMIGA_VERTB, info);
540
541 if (info->xmit.buf) {
542 free_page((unsigned long) info->xmit.buf);
543 info->xmit.buf = NULL;
544 }
545
546 info->IER = 0;
547 amiga_custom.intena = IF_RBF | IF_TBE;
548 mb();
549
550 /* disable break condition */
551 amiga_custom.adkcon = AC_UARTBRK;
552 mb();
553
554 if (C_HUPCL(tty))
555 info->MCR &= ~(SER_DTR|SER_RTS);
556 rtsdtr_ctrl(info->MCR);
557
558 set_bit(TTY_IO_ERROR, &tty->flags);
559
560 tty_port_set_initialized(&info->tport, 0);
561 local_irq_restore(flags);
562 }
563
564
565 /*
566 * This routine is called to set the UART divisor registers to match
567 * the specified baud rate for a serial port.
568 */
change_speed(struct tty_struct * tty,struct serial_state * info,struct ktermios * old_termios)569 static void change_speed(struct tty_struct *tty, struct serial_state *info,
570 struct ktermios *old_termios)
571 {
572 struct tty_port *port = &info->tport;
573 int quot = 0, baud_base, baud;
574 unsigned cflag, cval = 0;
575 int bits;
576 unsigned long flags;
577
578 cflag = tty->termios.c_cflag;
579
580 /* Byte size is always 8 bits plus parity bit if requested */
581
582 cval = 3; bits = 10;
583 if (cflag & CSTOPB) {
584 cval |= 0x04;
585 bits++;
586 }
587 if (cflag & PARENB) {
588 cval |= UART_LCR_PARITY;
589 bits++;
590 }
591 if (!(cflag & PARODD))
592 cval |= UART_LCR_EPAR;
593 #ifdef CMSPAR
594 if (cflag & CMSPAR)
595 cval |= UART_LCR_SPAR;
596 #endif
597
598 /* Determine divisor based on baud rate */
599 baud = tty_get_baud_rate(tty);
600 if (!baud)
601 baud = 9600; /* B0 transition handled in rs_set_termios */
602 baud_base = info->baud_base;
603 if (baud == 38400 && (port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
604 quot = info->custom_divisor;
605 else {
606 if (baud == 134)
607 /* Special case since 134 is really 134.5 */
608 quot = (2*baud_base / 269);
609 else if (baud)
610 quot = baud_base / baud;
611 }
612 /* If the quotient is zero refuse the change */
613 if (!quot && old_termios) {
614 /* FIXME: Will need updating for new tty in the end */
615 tty->termios.c_cflag &= ~CBAUD;
616 tty->termios.c_cflag |= (old_termios->c_cflag & CBAUD);
617 baud = tty_get_baud_rate(tty);
618 if (!baud)
619 baud = 9600;
620 if (baud == 38400 &&
621 (port->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)
622 quot = info->custom_divisor;
623 else {
624 if (baud == 134)
625 /* Special case since 134 is really 134.5 */
626 quot = (2*baud_base / 269);
627 else if (baud)
628 quot = baud_base / baud;
629 }
630 }
631 /* As a last resort, if the quotient is zero, default to 9600 bps */
632 if (!quot)
633 quot = baud_base / 9600;
634 info->quot = quot;
635 info->timeout = (XMIT_FIFO_SIZE*HZ*bits*quot) / baud_base;
636 info->timeout += HZ/50; /* Add .02 seconds of slop */
637
638 /* CTS flow control flag and modem status interrupts */
639 info->IER &= ~UART_IER_MSI;
640 if (port->flags & ASYNC_HARDPPS_CD)
641 info->IER |= UART_IER_MSI;
642 tty_port_set_cts_flow(port, cflag & CRTSCTS);
643 if (cflag & CRTSCTS)
644 info->IER |= UART_IER_MSI;
645 tty_port_set_check_carrier(port, ~cflag & CLOCAL);
646 if (~cflag & CLOCAL)
647 info->IER |= UART_IER_MSI;
648 /* TBD:
649 * Does clearing IER_MSI imply that we should disable the VBL interrupt ?
650 */
651
652 /*
653 * Set up parity check flag
654 */
655
656 info->read_status_mask = UART_LSR_OE | UART_LSR_DR;
657 if (I_INPCK(tty))
658 info->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
659 if (I_BRKINT(tty) || I_PARMRK(tty))
660 info->read_status_mask |= UART_LSR_BI;
661
662 /*
663 * Characters to ignore
664 */
665 info->ignore_status_mask = 0;
666 if (I_IGNPAR(tty))
667 info->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
668 if (I_IGNBRK(tty)) {
669 info->ignore_status_mask |= UART_LSR_BI;
670 /*
671 * If we're ignore parity and break indicators, ignore
672 * overruns too. (For real raw support).
673 */
674 if (I_IGNPAR(tty))
675 info->ignore_status_mask |= UART_LSR_OE;
676 }
677 /*
678 * !!! ignore all characters if CREAD is not set
679 */
680 if ((cflag & CREAD) == 0)
681 info->ignore_status_mask |= UART_LSR_DR;
682 local_irq_save(flags);
683
684 {
685 short serper;
686
687 /* Set up the baud rate */
688 serper = quot - 1;
689
690 /* Enable or disable parity bit */
691
692 if(cval & UART_LCR_PARITY)
693 serper |= (SERPER_PARENB);
694
695 amiga_custom.serper = serper;
696 mb();
697 }
698
699 local_irq_restore(flags);
700 }
701
rs_put_char(struct tty_struct * tty,unsigned char ch)702 static int rs_put_char(struct tty_struct *tty, unsigned char ch)
703 {
704 struct serial_state *info;
705 unsigned long flags;
706
707 info = tty->driver_data;
708
709 if (!info->xmit.buf)
710 return 0;
711
712 local_irq_save(flags);
713 if (CIRC_SPACE(info->xmit.head,
714 info->xmit.tail,
715 SERIAL_XMIT_SIZE) == 0) {
716 local_irq_restore(flags);
717 return 0;
718 }
719
720 info->xmit.buf[info->xmit.head++] = ch;
721 info->xmit.head &= SERIAL_XMIT_SIZE-1;
722 local_irq_restore(flags);
723 return 1;
724 }
725
rs_flush_chars(struct tty_struct * tty)726 static void rs_flush_chars(struct tty_struct *tty)
727 {
728 struct serial_state *info = tty->driver_data;
729 unsigned long flags;
730
731 if (info->xmit.head == info->xmit.tail
732 || tty->flow.stopped
733 || tty->hw_stopped
734 || !info->xmit.buf)
735 return;
736
737 local_irq_save(flags);
738 info->IER |= UART_IER_THRI;
739 amiga_custom.intena = IF_SETCLR | IF_TBE;
740 mb();
741 /* set a pending Tx Interrupt, transmitter should restart now */
742 amiga_custom.intreq = IF_SETCLR | IF_TBE;
743 mb();
744 local_irq_restore(flags);
745 }
746
rs_write(struct tty_struct * tty,const unsigned char * buf,int count)747 static int rs_write(struct tty_struct * tty, const unsigned char *buf, int count)
748 {
749 int c, ret = 0;
750 struct serial_state *info = tty->driver_data;
751 unsigned long flags;
752
753 if (!info->xmit.buf)
754 return 0;
755
756 local_irq_save(flags);
757 while (1) {
758 c = CIRC_SPACE_TO_END(info->xmit.head,
759 info->xmit.tail,
760 SERIAL_XMIT_SIZE);
761 if (count < c)
762 c = count;
763 if (c <= 0) {
764 break;
765 }
766 memcpy(info->xmit.buf + info->xmit.head, buf, c);
767 info->xmit.head = ((info->xmit.head + c) &
768 (SERIAL_XMIT_SIZE-1));
769 buf += c;
770 count -= c;
771 ret += c;
772 }
773 local_irq_restore(flags);
774
775 if (info->xmit.head != info->xmit.tail
776 && !tty->flow.stopped
777 && !tty->hw_stopped
778 && !(info->IER & UART_IER_THRI)) {
779 info->IER |= UART_IER_THRI;
780 local_irq_disable();
781 amiga_custom.intena = IF_SETCLR | IF_TBE;
782 mb();
783 /* set a pending Tx Interrupt, transmitter should restart now */
784 amiga_custom.intreq = IF_SETCLR | IF_TBE;
785 mb();
786 local_irq_restore(flags);
787 }
788 return ret;
789 }
790
rs_write_room(struct tty_struct * tty)791 static unsigned int rs_write_room(struct tty_struct *tty)
792 {
793 struct serial_state *info = tty->driver_data;
794
795 return CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
796 }
797
rs_chars_in_buffer(struct tty_struct * tty)798 static unsigned int rs_chars_in_buffer(struct tty_struct *tty)
799 {
800 struct serial_state *info = tty->driver_data;
801
802 return CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE);
803 }
804
rs_flush_buffer(struct tty_struct * tty)805 static void rs_flush_buffer(struct tty_struct *tty)
806 {
807 struct serial_state *info = tty->driver_data;
808 unsigned long flags;
809
810 local_irq_save(flags);
811 info->xmit.head = info->xmit.tail = 0;
812 local_irq_restore(flags);
813 tty_wakeup(tty);
814 }
815
816 /*
817 * This function is used to send a high-priority XON/XOFF character to
818 * the device
819 */
rs_send_xchar(struct tty_struct * tty,char ch)820 static void rs_send_xchar(struct tty_struct *tty, char ch)
821 {
822 struct serial_state *info = tty->driver_data;
823 unsigned long flags;
824
825 info->x_char = ch;
826 if (ch) {
827 /* Make sure transmit interrupts are on */
828
829 /* Check this ! */
830 local_irq_save(flags);
831 if(!(amiga_custom.intenar & IF_TBE)) {
832 amiga_custom.intena = IF_SETCLR | IF_TBE;
833 mb();
834 /* set a pending Tx Interrupt, transmitter should restart now */
835 amiga_custom.intreq = IF_SETCLR | IF_TBE;
836 mb();
837 }
838 local_irq_restore(flags);
839
840 info->IER |= UART_IER_THRI;
841 }
842 }
843
844 /*
845 * ------------------------------------------------------------
846 * rs_throttle()
847 *
848 * This routine is called by the upper-layer tty layer to signal that
849 * incoming characters should be throttled.
850 * ------------------------------------------------------------
851 */
rs_throttle(struct tty_struct * tty)852 static void rs_throttle(struct tty_struct * tty)
853 {
854 struct serial_state *info = tty->driver_data;
855 unsigned long flags;
856 #ifdef SERIAL_DEBUG_THROTTLE
857 printk("throttle %s ....\n", tty_name(tty));
858 #endif
859
860 if (I_IXOFF(tty))
861 rs_send_xchar(tty, STOP_CHAR(tty));
862
863 if (C_CRTSCTS(tty))
864 info->MCR &= ~SER_RTS;
865
866 local_irq_save(flags);
867 rtsdtr_ctrl(info->MCR);
868 local_irq_restore(flags);
869 }
870
rs_unthrottle(struct tty_struct * tty)871 static void rs_unthrottle(struct tty_struct * tty)
872 {
873 struct serial_state *info = tty->driver_data;
874 unsigned long flags;
875 #ifdef SERIAL_DEBUG_THROTTLE
876 printk("unthrottle %s ....\n", tty_name(tty));
877 #endif
878
879 if (I_IXOFF(tty)) {
880 if (info->x_char)
881 info->x_char = 0;
882 else
883 rs_send_xchar(tty, START_CHAR(tty));
884 }
885 if (C_CRTSCTS(tty))
886 info->MCR |= SER_RTS;
887 local_irq_save(flags);
888 rtsdtr_ctrl(info->MCR);
889 local_irq_restore(flags);
890 }
891
892 /*
893 * ------------------------------------------------------------
894 * rs_ioctl() and friends
895 * ------------------------------------------------------------
896 */
897
get_serial_info(struct tty_struct * tty,struct serial_struct * ss)898 static int get_serial_info(struct tty_struct *tty, struct serial_struct *ss)
899 {
900 struct serial_state *state = tty->driver_data;
901 unsigned int close_delay, closing_wait;
902
903 tty_lock(tty);
904 close_delay = jiffies_to_msecs(state->tport.close_delay) / 10;
905 closing_wait = state->tport.closing_wait;
906 if (closing_wait != ASYNC_CLOSING_WAIT_NONE)
907 closing_wait = jiffies_to_msecs(closing_wait) / 10;
908
909 ss->line = tty->index;
910 ss->port = state->port;
911 ss->flags = state->tport.flags;
912 ss->xmit_fifo_size = XMIT_FIFO_SIZE;
913 ss->baud_base = state->baud_base;
914 ss->close_delay = close_delay;
915 ss->closing_wait = closing_wait;
916 ss->custom_divisor = state->custom_divisor;
917 tty_unlock(tty);
918 return 0;
919 }
920
set_serial_info(struct tty_struct * tty,struct serial_struct * ss)921 static int set_serial_info(struct tty_struct *tty, struct serial_struct *ss)
922 {
923 struct serial_state *state = tty->driver_data;
924 struct tty_port *port = &state->tport;
925 bool change_spd;
926 int retval = 0;
927 unsigned int close_delay, closing_wait;
928
929 tty_lock(tty);
930 change_spd = ((ss->flags ^ port->flags) & ASYNC_SPD_MASK) ||
931 ss->custom_divisor != state->custom_divisor;
932 if (ss->irq || ss->port != state->port ||
933 ss->xmit_fifo_size != XMIT_FIFO_SIZE) {
934 tty_unlock(tty);
935 return -EINVAL;
936 }
937
938 close_delay = msecs_to_jiffies(ss->close_delay * 10);
939 closing_wait = ss->closing_wait;
940 if (closing_wait != ASYNC_CLOSING_WAIT_NONE)
941 closing_wait = msecs_to_jiffies(closing_wait * 10);
942
943 if (!capable(CAP_SYS_ADMIN)) {
944 if ((ss->baud_base != state->baud_base) ||
945 (close_delay != port->close_delay) ||
946 (closing_wait != port->closing_wait) ||
947 ((ss->flags & ~ASYNC_USR_MASK) !=
948 (port->flags & ~ASYNC_USR_MASK))) {
949 tty_unlock(tty);
950 return -EPERM;
951 }
952 port->flags = ((port->flags & ~ASYNC_USR_MASK) |
953 (ss->flags & ASYNC_USR_MASK));
954 state->custom_divisor = ss->custom_divisor;
955 goto check_and_exit;
956 }
957
958 if (ss->baud_base < 9600) {
959 tty_unlock(tty);
960 return -EINVAL;
961 }
962
963 /*
964 * OK, past this point, all the error checking has been done.
965 * At this point, we start making changes.....
966 */
967
968 state->baud_base = ss->baud_base;
969 port->flags = ((port->flags & ~ASYNC_FLAGS) |
970 (ss->flags & ASYNC_FLAGS));
971 state->custom_divisor = ss->custom_divisor;
972 port->close_delay = close_delay;
973 port->closing_wait = closing_wait;
974
975 check_and_exit:
976 if (tty_port_initialized(port)) {
977 if (change_spd) {
978 /* warn about deprecation unless clearing */
979 if (ss->flags & ASYNC_SPD_MASK)
980 dev_warn_ratelimited(tty->dev, "use of SPD flags is deprecated\n");
981 change_speed(tty, state, NULL);
982 }
983 } else
984 retval = startup(tty, state);
985 tty_unlock(tty);
986 return retval;
987 }
988
989 /*
990 * get_lsr_info - get line status register info
991 *
992 * Purpose: Let user call ioctl() to get info when the UART physically
993 * is emptied. On bus types like RS485, the transmitter must
994 * release the bus after transmitting. This must be done when
995 * the transmit shift register is empty, not be done when the
996 * transmit holding register is empty. This functionality
997 * allows an RS485 driver to be written in user space.
998 */
get_lsr_info(struct serial_state * info,unsigned int __user * value)999 static int get_lsr_info(struct serial_state *info, unsigned int __user *value)
1000 {
1001 unsigned char status;
1002 unsigned int result;
1003 unsigned long flags;
1004
1005 local_irq_save(flags);
1006 status = amiga_custom.serdatr;
1007 mb();
1008 local_irq_restore(flags);
1009 result = ((status & SDR_TSRE) ? TIOCSER_TEMT : 0);
1010 if (copy_to_user(value, &result, sizeof(int)))
1011 return -EFAULT;
1012 return 0;
1013 }
1014
1015
rs_tiocmget(struct tty_struct * tty)1016 static int rs_tiocmget(struct tty_struct *tty)
1017 {
1018 struct serial_state *info = tty->driver_data;
1019 unsigned char control, status;
1020 unsigned long flags;
1021
1022 if (tty_io_error(tty))
1023 return -EIO;
1024
1025 control = info->MCR;
1026 local_irq_save(flags);
1027 status = ciab.pra;
1028 local_irq_restore(flags);
1029 return ((control & SER_RTS) ? TIOCM_RTS : 0)
1030 | ((control & SER_DTR) ? TIOCM_DTR : 0)
1031 | (!(status & SER_DCD) ? TIOCM_CAR : 0)
1032 | (!(status & SER_DSR) ? TIOCM_DSR : 0)
1033 | (!(status & SER_CTS) ? TIOCM_CTS : 0);
1034 }
1035
rs_tiocmset(struct tty_struct * tty,unsigned int set,unsigned int clear)1036 static int rs_tiocmset(struct tty_struct *tty, unsigned int set,
1037 unsigned int clear)
1038 {
1039 struct serial_state *info = tty->driver_data;
1040 unsigned long flags;
1041
1042 if (tty_io_error(tty))
1043 return -EIO;
1044
1045 local_irq_save(flags);
1046 if (set & TIOCM_RTS)
1047 info->MCR |= SER_RTS;
1048 if (set & TIOCM_DTR)
1049 info->MCR |= SER_DTR;
1050 if (clear & TIOCM_RTS)
1051 info->MCR &= ~SER_RTS;
1052 if (clear & TIOCM_DTR)
1053 info->MCR &= ~SER_DTR;
1054 rtsdtr_ctrl(info->MCR);
1055 local_irq_restore(flags);
1056 return 0;
1057 }
1058
1059 /*
1060 * rs_break() --- routine which turns the break handling on or off
1061 */
rs_break(struct tty_struct * tty,int break_state)1062 static int rs_break(struct tty_struct *tty, int break_state)
1063 {
1064 unsigned long flags;
1065
1066 local_irq_save(flags);
1067 if (break_state == -1)
1068 amiga_custom.adkcon = AC_SETCLR | AC_UARTBRK;
1069 else
1070 amiga_custom.adkcon = AC_UARTBRK;
1071 mb();
1072 local_irq_restore(flags);
1073 return 0;
1074 }
1075
1076 /*
1077 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1078 * Return: write counters to the user passed counter struct
1079 * NB: both 1->0 and 0->1 transitions are counted except for
1080 * RI where only 0->1 is counted.
1081 */
rs_get_icount(struct tty_struct * tty,struct serial_icounter_struct * icount)1082 static int rs_get_icount(struct tty_struct *tty,
1083 struct serial_icounter_struct *icount)
1084 {
1085 struct serial_state *info = tty->driver_data;
1086 struct async_icount cnow;
1087 unsigned long flags;
1088
1089 local_irq_save(flags);
1090 cnow = info->icount;
1091 local_irq_restore(flags);
1092 icount->cts = cnow.cts;
1093 icount->dsr = cnow.dsr;
1094 icount->rng = cnow.rng;
1095 icount->dcd = cnow.dcd;
1096 icount->rx = cnow.rx;
1097 icount->tx = cnow.tx;
1098 icount->frame = cnow.frame;
1099 icount->overrun = cnow.overrun;
1100 icount->parity = cnow.parity;
1101 icount->brk = cnow.brk;
1102 icount->buf_overrun = cnow.buf_overrun;
1103
1104 return 0;
1105 }
1106
rs_ioctl(struct tty_struct * tty,unsigned int cmd,unsigned long arg)1107 static int rs_ioctl(struct tty_struct *tty,
1108 unsigned int cmd, unsigned long arg)
1109 {
1110 struct serial_state *info = tty->driver_data;
1111 struct async_icount cprev, cnow; /* kernel counter temps */
1112 void __user *argp = (void __user *)arg;
1113 unsigned long flags;
1114 DEFINE_WAIT(wait);
1115 int ret;
1116
1117 if ((cmd != TIOCSERCONFIG) &&
1118 (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
1119 if (tty_io_error(tty))
1120 return -EIO;
1121 }
1122
1123 switch (cmd) {
1124 case TIOCSERCONFIG:
1125 return 0;
1126
1127 case TIOCSERGETLSR: /* Get line status register */
1128 return get_lsr_info(info, argp);
1129
1130 /*
1131 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
1132 * - mask passed in arg for lines of interest
1133 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
1134 * Caller should use TIOCGICOUNT to see which one it was
1135 */
1136 case TIOCMIWAIT:
1137 local_irq_save(flags);
1138 /* note the counters on entry */
1139 cprev = info->icount;
1140 local_irq_restore(flags);
1141 while (1) {
1142 prepare_to_wait(&info->tport.delta_msr_wait,
1143 &wait, TASK_INTERRUPTIBLE);
1144 local_irq_save(flags);
1145 cnow = info->icount; /* atomic copy */
1146 local_irq_restore(flags);
1147 if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr &&
1148 cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) {
1149 ret = -EIO; /* no change => error */
1150 break;
1151 }
1152 if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
1153 ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
1154 ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
1155 ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) {
1156 ret = 0;
1157 break;
1158 }
1159 schedule();
1160 /* see if a signal did it */
1161 if (signal_pending(current)) {
1162 ret = -ERESTARTSYS;
1163 break;
1164 }
1165 cprev = cnow;
1166 }
1167 finish_wait(&info->tport.delta_msr_wait, &wait);
1168 return ret;
1169
1170 default:
1171 return -ENOIOCTLCMD;
1172 }
1173 return 0;
1174 }
1175
rs_set_termios(struct tty_struct * tty,struct ktermios * old_termios)1176 static void rs_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
1177 {
1178 struct serial_state *info = tty->driver_data;
1179 unsigned long flags;
1180 unsigned int cflag = tty->termios.c_cflag;
1181
1182 change_speed(tty, info, old_termios);
1183
1184 /* Handle transition to B0 status */
1185 if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD)) {
1186 info->MCR &= ~(SER_DTR|SER_RTS);
1187 local_irq_save(flags);
1188 rtsdtr_ctrl(info->MCR);
1189 local_irq_restore(flags);
1190 }
1191
1192 /* Handle transition away from B0 status */
1193 if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
1194 info->MCR |= SER_DTR;
1195 if (!C_CRTSCTS(tty) || !tty_throttled(tty))
1196 info->MCR |= SER_RTS;
1197 local_irq_save(flags);
1198 rtsdtr_ctrl(info->MCR);
1199 local_irq_restore(flags);
1200 }
1201
1202 /* Handle turning off CRTSCTS */
1203 if ((old_termios->c_cflag & CRTSCTS) && !C_CRTSCTS(tty)) {
1204 tty->hw_stopped = 0;
1205 rs_start(tty);
1206 }
1207
1208 #if 0
1209 /*
1210 * No need to wake up processes in open wait, since they
1211 * sample the CLOCAL flag once, and don't recheck it.
1212 * XXX It's not clear whether the current behavior is correct
1213 * or not. Hence, this may change.....
1214 */
1215 if (!(old_termios->c_cflag & CLOCAL) && C_CLOCAL(tty))
1216 wake_up_interruptible(&info->open_wait);
1217 #endif
1218 }
1219
1220 /*
1221 * ------------------------------------------------------------
1222 * rs_close()
1223 *
1224 * This routine is called when the serial port gets closed. First, we
1225 * wait for the last remaining data to be sent. Then, we unlink its
1226 * async structure from the interrupt chain if necessary, and we free
1227 * that IRQ if nothing is left in the chain.
1228 * ------------------------------------------------------------
1229 */
rs_close(struct tty_struct * tty,struct file * filp)1230 static void rs_close(struct tty_struct *tty, struct file * filp)
1231 {
1232 struct serial_state *state = tty->driver_data;
1233 struct tty_port *port = &state->tport;
1234
1235 if (tty_port_close_start(port, tty, filp) == 0)
1236 return;
1237
1238 /*
1239 * At this point we stop accepting input. To do this, we
1240 * disable the receive line status interrupts, and tell the
1241 * interrupt driver to stop checking the data ready bit in the
1242 * line status register.
1243 */
1244 state->read_status_mask &= ~UART_LSR_DR;
1245 if (tty_port_initialized(port)) {
1246 /* disable receive interrupts */
1247 amiga_custom.intena = IF_RBF;
1248 mb();
1249 /* clear any pending receive interrupt */
1250 amiga_custom.intreq = IF_RBF;
1251 mb();
1252
1253 /*
1254 * Before we drop DTR, make sure the UART transmitter
1255 * has completely drained; this is especially
1256 * important if there is a transmit FIFO!
1257 */
1258 rs_wait_until_sent(tty, state->timeout);
1259 }
1260 shutdown(tty, state);
1261 rs_flush_buffer(tty);
1262
1263 tty_ldisc_flush(tty);
1264 port->tty = NULL;
1265
1266 tty_port_close_end(port, tty);
1267 }
1268
1269 /*
1270 * rs_wait_until_sent() --- wait until the transmitter is empty
1271 */
rs_wait_until_sent(struct tty_struct * tty,int timeout)1272 static void rs_wait_until_sent(struct tty_struct *tty, int timeout)
1273 {
1274 struct serial_state *info = tty->driver_data;
1275 unsigned long orig_jiffies, char_time;
1276 int lsr;
1277
1278 orig_jiffies = jiffies;
1279
1280 /*
1281 * Set the check interval to be 1/5 of the estimated time to
1282 * send a single character, and make it at least 1. The check
1283 * interval should also be less than the timeout.
1284 *
1285 * Note: we have to use pretty tight timings here to satisfy
1286 * the NIST-PCTS.
1287 */
1288 char_time = (info->timeout - HZ/50) / XMIT_FIFO_SIZE;
1289 char_time = char_time / 5;
1290 if (char_time == 0)
1291 char_time = 1;
1292 if (timeout)
1293 char_time = min_t(unsigned long, char_time, timeout);
1294 /*
1295 * If the transmitter hasn't cleared in twice the approximate
1296 * amount of time to send the entire FIFO, it probably won't
1297 * ever clear. This assumes the UART isn't doing flow
1298 * control, which is currently the case. Hence, if it ever
1299 * takes longer than info->timeout, this is probably due to a
1300 * UART bug of some kind. So, we clamp the timeout parameter at
1301 * 2*info->timeout.
1302 */
1303 if (!timeout || timeout > 2*info->timeout)
1304 timeout = 2*info->timeout;
1305 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1306 printk("In rs_wait_until_sent(%d) check=%lu...", timeout, char_time);
1307 printk("jiff=%lu...", jiffies);
1308 #endif
1309 while(!((lsr = amiga_custom.serdatr) & SDR_TSRE)) {
1310 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1311 printk("serdatr = %d (jiff=%lu)...", lsr, jiffies);
1312 #endif
1313 msleep_interruptible(jiffies_to_msecs(char_time));
1314 if (signal_pending(current))
1315 break;
1316 if (timeout && time_after(jiffies, orig_jiffies + timeout))
1317 break;
1318 }
1319 __set_current_state(TASK_RUNNING);
1320
1321 #ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT
1322 printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies);
1323 #endif
1324 }
1325
1326 /*
1327 * rs_hangup() --- called by tty_hangup() when a hangup is signaled.
1328 */
rs_hangup(struct tty_struct * tty)1329 static void rs_hangup(struct tty_struct *tty)
1330 {
1331 struct serial_state *info = tty->driver_data;
1332
1333 rs_flush_buffer(tty);
1334 shutdown(tty, info);
1335 info->tport.count = 0;
1336 tty_port_set_active(&info->tport, 0);
1337 info->tport.tty = NULL;
1338 wake_up_interruptible(&info->tport.open_wait);
1339 }
1340
1341 /*
1342 * This routine is called whenever a serial port is opened. It
1343 * enables interrupts for a serial port, linking in its async structure into
1344 * the IRQ chain. It also performs the serial-specific
1345 * initialization for the tty structure.
1346 */
rs_open(struct tty_struct * tty,struct file * filp)1347 static int rs_open(struct tty_struct *tty, struct file * filp)
1348 {
1349 struct tty_port *port = tty->port;
1350 struct serial_state *info = container_of(port, struct serial_state,
1351 tport);
1352 int retval;
1353
1354 port->count++;
1355 port->tty = tty;
1356 tty->driver_data = info;
1357
1358 retval = startup(tty, info);
1359 if (retval) {
1360 return retval;
1361 }
1362
1363 return tty_port_block_til_ready(port, tty, filp);
1364 }
1365
1366 /*
1367 * /proc fs routines....
1368 */
1369
line_info(struct seq_file * m,int line,struct serial_state * state)1370 static inline void line_info(struct seq_file *m, int line,
1371 struct serial_state *state)
1372 {
1373 char stat_buf[30], control, status;
1374 unsigned long flags;
1375
1376 seq_printf(m, "%d: uart:amiga_builtin", line);
1377
1378 local_irq_save(flags);
1379 status = ciab.pra;
1380 control = tty_port_initialized(&state->tport) ? state->MCR : status;
1381 local_irq_restore(flags);
1382
1383 stat_buf[0] = 0;
1384 stat_buf[1] = 0;
1385 if(!(control & SER_RTS))
1386 strcat(stat_buf, "|RTS");
1387 if(!(status & SER_CTS))
1388 strcat(stat_buf, "|CTS");
1389 if(!(control & SER_DTR))
1390 strcat(stat_buf, "|DTR");
1391 if(!(status & SER_DSR))
1392 strcat(stat_buf, "|DSR");
1393 if(!(status & SER_DCD))
1394 strcat(stat_buf, "|CD");
1395
1396 if (state->quot)
1397 seq_printf(m, " baud:%d", state->baud_base / state->quot);
1398
1399 seq_printf(m, " tx:%d rx:%d", state->icount.tx, state->icount.rx);
1400
1401 if (state->icount.frame)
1402 seq_printf(m, " fe:%d", state->icount.frame);
1403
1404 if (state->icount.parity)
1405 seq_printf(m, " pe:%d", state->icount.parity);
1406
1407 if (state->icount.brk)
1408 seq_printf(m, " brk:%d", state->icount.brk);
1409
1410 if (state->icount.overrun)
1411 seq_printf(m, " oe:%d", state->icount.overrun);
1412
1413 /*
1414 * Last thing is the RS-232 status lines
1415 */
1416 seq_printf(m, " %s\n", stat_buf+1);
1417 }
1418
rs_proc_show(struct seq_file * m,void * v)1419 static int rs_proc_show(struct seq_file *m, void *v)
1420 {
1421 seq_printf(m, "serinfo:1.0 driver:4.30\n");
1422 line_info(m, 0, &serial_state);
1423 return 0;
1424 }
1425
1426 /*
1427 * ---------------------------------------------------------------------
1428 * rs_init() and friends
1429 *
1430 * rs_init() is called at boot-time to initialize the serial driver.
1431 * ---------------------------------------------------------------------
1432 */
1433
1434 static const struct tty_operations serial_ops = {
1435 .open = rs_open,
1436 .close = rs_close,
1437 .write = rs_write,
1438 .put_char = rs_put_char,
1439 .flush_chars = rs_flush_chars,
1440 .write_room = rs_write_room,
1441 .chars_in_buffer = rs_chars_in_buffer,
1442 .flush_buffer = rs_flush_buffer,
1443 .ioctl = rs_ioctl,
1444 .throttle = rs_throttle,
1445 .unthrottle = rs_unthrottle,
1446 .set_termios = rs_set_termios,
1447 .stop = rs_stop,
1448 .start = rs_start,
1449 .hangup = rs_hangup,
1450 .break_ctl = rs_break,
1451 .send_xchar = rs_send_xchar,
1452 .wait_until_sent = rs_wait_until_sent,
1453 .tiocmget = rs_tiocmget,
1454 .tiocmset = rs_tiocmset,
1455 .get_icount = rs_get_icount,
1456 .set_serial = set_serial_info,
1457 .get_serial = get_serial_info,
1458 .proc_show = rs_proc_show,
1459 };
1460
amiga_carrier_raised(struct tty_port * port)1461 static int amiga_carrier_raised(struct tty_port *port)
1462 {
1463 return !(ciab.pra & SER_DCD);
1464 }
1465
amiga_dtr_rts(struct tty_port * port,int raise)1466 static void amiga_dtr_rts(struct tty_port *port, int raise)
1467 {
1468 struct serial_state *info = container_of(port, struct serial_state,
1469 tport);
1470 unsigned long flags;
1471
1472 if (raise)
1473 info->MCR |= SER_DTR|SER_RTS;
1474 else
1475 info->MCR &= ~(SER_DTR|SER_RTS);
1476
1477 local_irq_save(flags);
1478 rtsdtr_ctrl(info->MCR);
1479 local_irq_restore(flags);
1480 }
1481
1482 static const struct tty_port_operations amiga_port_ops = {
1483 .carrier_raised = amiga_carrier_raised,
1484 .dtr_rts = amiga_dtr_rts,
1485 };
1486
1487 /*
1488 * The serial driver boot-time initialization code!
1489 */
amiga_serial_probe(struct platform_device * pdev)1490 static int __init amiga_serial_probe(struct platform_device *pdev)
1491 {
1492 struct serial_state *state = &serial_state;
1493 struct tty_driver *driver;
1494 unsigned long flags;
1495 int error;
1496
1497 driver = tty_alloc_driver(1, TTY_DRIVER_REAL_RAW);
1498 if (IS_ERR(driver))
1499 return PTR_ERR(driver);
1500
1501 /* Initialize the tty_driver structure */
1502
1503 driver->driver_name = "amiserial";
1504 driver->name = "ttyS";
1505 driver->major = TTY_MAJOR;
1506 driver->minor_start = 64;
1507 driver->type = TTY_DRIVER_TYPE_SERIAL;
1508 driver->subtype = SERIAL_TYPE_NORMAL;
1509 driver->init_termios = tty_std_termios;
1510 driver->init_termios.c_cflag =
1511 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1512 tty_set_operations(driver, &serial_ops);
1513
1514 memset(state, 0, sizeof(*state));
1515 state->port = (int)&amiga_custom.serdatr; /* Just to give it a value */
1516 tty_port_init(&state->tport);
1517 state->tport.ops = &amiga_port_ops;
1518 tty_port_link_device(&state->tport, driver, 0);
1519
1520 error = tty_register_driver(driver);
1521 if (error)
1522 goto fail_tty_driver_kref_put;
1523
1524 printk(KERN_INFO "ttyS0 is the amiga builtin serial port\n");
1525
1526 /* Hardware set up */
1527
1528 state->baud_base = amiga_colorclock;
1529
1530 /* set ISRs, and then disable the rx interrupts */
1531 error = request_irq(IRQ_AMIGA_TBE, ser_tx_int, 0, "serial TX", state);
1532 if (error)
1533 goto fail_unregister;
1534
1535 error = request_irq(IRQ_AMIGA_RBF, ser_rx_int, 0,
1536 "serial RX", state);
1537 if (error)
1538 goto fail_free_irq;
1539
1540 local_irq_save(flags);
1541
1542 /* turn off Rx and Tx interrupts */
1543 amiga_custom.intena = IF_RBF | IF_TBE;
1544 mb();
1545
1546 /* clear any pending interrupt */
1547 amiga_custom.intreq = IF_RBF | IF_TBE;
1548 mb();
1549
1550 local_irq_restore(flags);
1551
1552 /*
1553 * set the appropriate directions for the modem control flags,
1554 * and clear RTS and DTR
1555 */
1556 ciab.ddra |= (SER_DTR | SER_RTS); /* outputs */
1557 ciab.ddra &= ~(SER_DCD | SER_CTS | SER_DSR); /* inputs */
1558
1559 platform_set_drvdata(pdev, state);
1560
1561 serial_driver = driver;
1562
1563 return 0;
1564
1565 fail_free_irq:
1566 free_irq(IRQ_AMIGA_TBE, state);
1567 fail_unregister:
1568 tty_unregister_driver(driver);
1569 fail_tty_driver_kref_put:
1570 tty_port_destroy(&state->tport);
1571 tty_driver_kref_put(driver);
1572 return error;
1573 }
1574
amiga_serial_remove(struct platform_device * pdev)1575 static int __exit amiga_serial_remove(struct platform_device *pdev)
1576 {
1577 struct serial_state *state = platform_get_drvdata(pdev);
1578
1579 tty_unregister_driver(serial_driver);
1580 tty_driver_kref_put(serial_driver);
1581 tty_port_destroy(&state->tport);
1582
1583 free_irq(IRQ_AMIGA_TBE, state);
1584 free_irq(IRQ_AMIGA_RBF, state);
1585
1586 return 0;
1587 }
1588
1589 static struct platform_driver amiga_serial_driver = {
1590 .remove = __exit_p(amiga_serial_remove),
1591 .driver = {
1592 .name = "amiga-serial",
1593 },
1594 };
1595
1596 module_platform_driver_probe(amiga_serial_driver, amiga_serial_probe);
1597
1598
1599 #if defined(CONFIG_SERIAL_CONSOLE) && !defined(MODULE)
1600
1601 /*
1602 * ------------------------------------------------------------
1603 * Serial console driver
1604 * ------------------------------------------------------------
1605 */
1606
amiga_serial_putc(char c)1607 static void amiga_serial_putc(char c)
1608 {
1609 amiga_custom.serdat = (unsigned char)c | 0x100;
1610 while (!(amiga_custom.serdatr & 0x2000))
1611 barrier();
1612 }
1613
1614 /*
1615 * Print a string to the serial port trying not to disturb
1616 * any possible real use of the port...
1617 *
1618 * The console must be locked when we get here.
1619 */
serial_console_write(struct console * co,const char * s,unsigned count)1620 static void serial_console_write(struct console *co, const char *s,
1621 unsigned count)
1622 {
1623 unsigned short intena = amiga_custom.intenar;
1624
1625 amiga_custom.intena = IF_TBE;
1626
1627 while (count--) {
1628 if (*s == '\n')
1629 amiga_serial_putc('\r');
1630 amiga_serial_putc(*s++);
1631 }
1632
1633 amiga_custom.intena = IF_SETCLR | (intena & IF_TBE);
1634 }
1635
serial_console_device(struct console * c,int * index)1636 static struct tty_driver *serial_console_device(struct console *c, int *index)
1637 {
1638 *index = 0;
1639 return serial_driver;
1640 }
1641
1642 static struct console sercons = {
1643 .name = "ttyS",
1644 .write = serial_console_write,
1645 .device = serial_console_device,
1646 .flags = CON_PRINTBUFFER,
1647 .index = -1,
1648 };
1649
1650 /*
1651 * Register console.
1652 */
amiserial_console_init(void)1653 static int __init amiserial_console_init(void)
1654 {
1655 if (!MACH_IS_AMIGA)
1656 return -ENODEV;
1657
1658 register_console(&sercons);
1659 return 0;
1660 }
1661 console_initcall(amiserial_console_init);
1662
1663 #endif /* CONFIG_SERIAL_CONSOLE && !MODULE */
1664
1665 MODULE_LICENSE("GPL");
1666 MODULE_ALIAS("platform:amiga-serial");
1667
