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