/* * Start receiving - port is in process of being closed. */ static void atmel_start_rx(struct uart_port *port) { struct atmel_uart_port *atmel_port = (struct atmel_uart_port *) port; if (atmel_port->use_dma_rx) { UART_PUT_PTCR(port, ATMEL_PDC_RXTEN); /* enable PDC receive */ UART_PUT_IER(port, ATMEL_US_ENDRX | ATMEL_US_TIMEOUT); } else UART_PUT_IER(port, ATMEL_US_RXRDY); }
/* * Start transmitting. */ static void atmel_start_tx(struct uart_port *port) { struct atmel_uart_port *atmel_port = (struct atmel_uart_port *) port; if (atmel_port->use_dma_tx) { if (UART_GET_PTSR(port) & ATMEL_PDC_TXTEN) /* The transmitter is already running. Yes, we really need this.*/ return; UART_PUT_IER(port, ATMEL_US_ENDTX | ATMEL_US_TXBUFE); UART_PUT_PTCR(port, ATMEL_PDC_TXTEN); /* re-enable PDC transmit */ } else UART_PUT_IER(port, ATMEL_US_TXRDY); }
static void ambauart_enable_ms(struct uart_port *port) { #if DEBUG printk("ambauart_enable_ms() called\n"); #endif UART_PUT_IER(port, UART_GET_IER(port) | KS8695_INT_ENABLE_MODEM); }
static void ambauart_stop_rx(struct uart_port *port) { unsigned int ier; #if DEBUG printk("ambauart_stop_rx() called\n"); #endif ier = UART_GET_IER(port); ier &= ~KS8695_INT_ENABLE_RX; UART_PUT_IER(port, ier); }
static void ssauart_stop_rx (struct uart_port *port) { unsigned int ier; unsigned long flags; local_irq_save (flags); /* AMcCurdy: added paranoid irq protection */ ier = UART_GET_IER(port); ier &= ~(1 << 0); /* disable Rx interrupts */ UART_PUT_IER(port, ier); local_irq_restore (flags); }
static int ambauart_startup(struct uart_port *port) { int retval; #if DEBUG printk("ambauart_startup ier=%x\n",UART_GET_IER(port)); #endif /* * Allocate the IRQ, let IRQ KS8695_INT_UART_RX, KS8695_INT_UART_TX comes to same * routine */ UART_PUT_IER(port, UART_GET_IER(port) & 0xFFFFF0FF); retval = request_irq(KS8695_INT_UART_TX, ambauart_int, SA_SHIRQ | SA_INTERRUPT, "amba", port); if (retval) return retval; retval = request_irq(KS8695_INT_UART_RX, ambauart_int, SA_SHIRQ | SA_INTERRUPT, "amba", port); if (retval) return retval; retval = request_irq(KS8695_INT_UART_LINE_ERR, ambauart_int, SA_SHIRQ | SA_INTERRUPT, "amba", port); if (retval) return retval; retval = request_irq(KS8695_INT_UART_MODEMS, ambauart_int, SA_SHIRQ | SA_INTERRUPT, "amba", port); if (retval) return retval; /* * Finally, enable interrupts */ UART_PUT_IER(port, ((UART_GET_IER(port) & 0xFFFFF0FF) | KS8695_INT_ENABLE_RX | 0x800 | 0x400)); return 0; }
static int ssauart_startup (struct uart_port *port) { int retval; #if 1 if ((retval = request_irq (port->irq, ssauart_int, 0, "uart", port))) return (retval); #else if ((retval = request_irq (port->irq, ssauart_int, SA_INTERRUPT, "uart", port))) return (retval); #endif UART_PUT_IER(port, 0x03); /* enable Tx and Rx ints only (modem status enabled elsewhere ?) */ return 0; }
static void ssauart_start_tx (struct uart_port *port, unsigned int from_tty) { unsigned int ier; unsigned long flags; local_irq_save (flags); /* AMcCurdy: added paranoid irq protection */ ier = UART_GET_IER(port); ier |= (1 << 1); /* enable Tx interrupts */ UART_PUT_IER(port, ier); /* We may have something in the buffer already */ ssauart_tx_one_char (port); local_irq_restore (flags); }
static void ssauart_enable_ms (struct uart_port *port) { #if 0 unsigned int ier; unsigned long flags; local_irq_save (flags); /* AMcCurdy: added paranoid irq protection */ ier = UART_GET_IER(port); ier |= (1 << 3); /* enable Modem Status interrupts */ UART_PUT_IER(port, ier); local_irq_restore (flags); #endif }
static void ambauart_start_tx(struct uart_port *port, unsigned int tty_start) { unsigned int ier; #if DEBUG printk("ambauart_start_tx() called\n"); #endif ier = UART_GET_IER(port); if ( ier & KS8695_INT_ENABLE_TX ) return; else { ier |= KS8695_INT_ENABLE_TX; UART_PUT_IER(port, ier); } }
/* * Perform initialization and enable port for reception */ static int atmel_startup(struct uart_port *port) { struct atmel_uart_port *atmel_port = (struct atmel_uart_port *) port; int retval; /* * Ensure that no interrupts are enabled otherwise when * request_irq() is called we could get stuck trying to * handle an unexpected interrupt */ UART_PUT_IDR(port, -1); /* * Allocate the IRQ */ retval = request_irq(port->irq, atmel_interrupt, IRQF_SHARED, "atmel_serial", port); if (retval) { printk("atmel_serial: atmel_startup - Can't get irq\n"); return retval; } /* * If there is a specific "open" function (to register * control line interrupts) */ if (atmel_open_hook) { retval = atmel_open_hook(port); if (retval) { free_irq(port->irq, port); return retval; } } /* * Finally, enable the serial port */ UART_PUT_CR(port, ATMEL_US_RSTSTA | ATMEL_US_RSTRX); UART_PUT_CR(port, ATMEL_US_TXEN | ATMEL_US_RXEN); /* enable xmit & rcvr */ UART_PUT_IER(port, ATMEL_US_RXRDY); /* enable receive only */ return 0; }
/* * Perform initialization and enable port for reception */ static int at91_startup(struct uart_port *port) { int retval; /* * Ensure that no interrupts are enabled otherwise when * request_irq() is called we could get stuck trying to * handle an unexpected interrupt */ UART_PUT_IDR(port, -1); /* * Allocate the IRQ */ retval = request_irq(port->irq, at91_interrupt, SA_SHIRQ, "at91_serial", port); if (retval) { printk("at91_serial: at91_startup - Can't get irq\n"); return retval; } /* * If there is a specific "open" function (to register * control line interrupts) */ if (at91_open) { retval = at91_open(port); if (retval) { free_irq(port->irq, port); return retval; } } port->read_status_mask = AT91_US_RXRDY | AT91_US_TXRDY | AT91_US_OVRE | AT91_US_FRAME | AT91_US_PARE | AT91_US_RXBRK; /* * Finally, enable the serial port */ UART_PUT_CR(port, AT91_US_RSTSTA | AT91_US_RSTRX); UART_PUT_CR(port, AT91_US_TXEN | AT91_US_RXEN); /* enable xmit & rcvr */ UART_PUT_IER(port, AT91_US_RXRDY); /* do receive only */ return 0; }
static void ambauart_shutdown(struct uart_port *port) { #if DEBUG printk("ambauart_shutdown\n"); #endif /* * disable all interrupts, disable the port */ UART_PUT_IER(port, UART_GET_IER(port) & 0xFFFFF0FF); /* disable break condition and fifos */ UART_PUT_LCR(port, UART_GET_LCR(port) & ~KS8695_UART_LINEC_BRK); UART_PUT_FCR(port, UART_GET_FCR(port) & ~KS8695_UART_FIFO_FEN); free_irq(KS8695_INT_UART_RX, port); free_irq(KS8695_INT_UART_TX, port); free_irq(KS8695_INT_UART_MODEMS, port); free_irq(KS8695_INT_UART_LINE_ERR, port); }
/* * Interrupts are disabled on entering */ static void atmel_console_write(struct console *co, const char *s, u_int count) { struct uart_port *port = &atmel_ports[co->index].uart; unsigned int status, imr; /* * First, save IMR and then disable interrupts */ imr = UART_GET_IMR(port); /* get interrupt mask */ UART_PUT_IDR(port, ATMEL_US_RXRDY | ATMEL_US_TXRDY); uart_console_write(port, s, count, atmel_console_putchar); /* * Finally, wait for transmitter to become empty * and restore IMR */ do { status = UART_GET_CSR(port); } while (!(status & ATMEL_US_TXRDY)); UART_PUT_IER(port, imr); /* set interrupts back the way they were */ }
/* * Interrupts are disabled on entering */ static void at91_console_write(struct console *co, const char *s, u_int count) { struct uart_port *port = at91_ports + co->index; unsigned int status, i, imr; /* * First, save IMR and then disable interrupts */ imr = UART_GET_IMR(port); /* get interrupt mask */ UART_PUT_IDR(port, AT91_US_RXRDY | AT91_US_TXRDY); /* * Now, do each character */ for (i = 0; i < count; i++) { do { status = UART_GET_CSR(port); } while (!(status & AT91_US_TXRDY)); UART_PUT_CHAR(port, s[i]); if (s[i] == '\n') { do { status = UART_GET_CSR(port); } while (!(status & AT91_US_TXRDY)); UART_PUT_CHAR(port, '\r'); } } /* * Finally, wait for transmitter to become empty * and restore IMR */ do { status = UART_GET_CSR(port); } while (!(status & AT91_US_TXRDY)); UART_PUT_IER(port, imr); /* set interrupts back the way they were */ }
static void ambauart_change_speed(struct uart_port *port, u_int cflag, u_int iflag, u_int quot) { u_int lcr, old_ier, fcr=0; unsigned long flags; #if DEBUG printk("ambauart_set_cflag(0x%x) called\n", cflag); #endif //printk("ambauart_change_speed\n"); /* byte size and parity */ switch (cflag & CSIZE) { case CS5: lcr = KS8695_UART_LINEC_WLEN5; break; case CS6: lcr = KS8695_UART_LINEC_WLEN6; break; case CS7: lcr = KS8695_UART_LINEC_WLEN7; break; default: lcr = KS8695_UART_LINEC_WLEN8; break; // CS8 } if (cflag & CSTOPB) lcr |= KS8695_UART_LINEC_STP2; if (cflag & PARENB) { lcr |= KS8695_UART_LINEC_PEN; if (!(cflag & PARODD)) lcr |= KS8695_UART_LINEC_EPS; } if (port->fifosize > 1) fcr = KS8695_UART_FIFO_TRIG04 | KS8695_UART_FIFO_TXRST | KS8695_UART_FIFO_RXRST | KS8695_UART_FIFO_FEN; port->read_status_mask = KS8695_UART_LINES_OE; if (iflag & INPCK) port->read_status_mask |= (KS8695_UART_LINES_FE | KS8695_UART_LINES_PE); if (iflag & (BRKINT | PARMRK)) port->read_status_mask |= KS8695_UART_LINES_BE; /* * Characters to ignore */ port->ignore_status_mask = 0; if (iflag & IGNPAR) port->ignore_status_mask |= (KS8695_UART_LINES_FE | KS8695_UART_LINES_PE); if (iflag & IGNBRK) { port->ignore_status_mask |= KS8695_UART_LINES_BE; /* * If we're ignoring parity and break indicators, * ignore overruns too (for real raw support). */ if (iflag & IGNPAR) port->ignore_status_mask |= KS8695_UART_LINES_OE; } /* * Ignore all characters if CREAD is not set. */ if ((cflag & CREAD) == 0) port->ignore_status_mask |= UART_DUMMY_LSR_RX; /* first, disable everything */ save_flags(flags); cli(); old_ier = UART_GET_IER(port); UART_PUT_IER(port, old_ier & 0xFFFFF0FF); old_ier &= ~KS8695_INT_ENABLE_MODEM; if ((port->flags & ASYNC_HARDPPS_CD) || (cflag & CRTSCTS) || !(cflag & CLOCAL)) old_ier |= KS8695_INT_ENABLE_MODEM; /* Set baud rate */ // UART_PUT_BRDR(port, port->uartclk / quot); UART_PUT_BRDR(port, 0x28B); UART_PUT_LCR(port, lcr); UART_PUT_FCR(port, fcr); UART_PUT_IER(port, old_ier & 0xFFFFFEFF); restore_flags(flags); }
/* * Start transmitting. */ static void atmel_start_tx(struct uart_port *port) { struct atmel_uart_port *atmel_port = (struct atmel_uart_port *) port; UART_PUT_IER(port, ATMEL_US_TXRDY); }
/* * Change the port parameters */ static void atmel_set_termios(struct uart_port *port, struct ktermios * termios, struct ktermios * old) { struct atmel_uart_port *atmel_port = (struct atmel_uart_port *) port; unsigned long flags; unsigned int mode, imr, quot, baud; /* Get current mode register */ mode = UART_GET_MR(port) & ~(ATMEL_US_USCLKS | ATMEL_US_CHRL | ATMEL_US_NBSTOP | ATMEL_US_PAR); baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16); quot = uart_get_divisor(port, baud); if (quot > 65535) { /* BRGR is 16-bit, so switch to slower clock */ quot /= 8; mode |= ATMEL_US_USCLKS_MCK_DIV8; } /* byte size */ switch (termios->c_cflag & CSIZE) { case CS5: mode |= ATMEL_US_CHRL_5; break; case CS6: mode |= ATMEL_US_CHRL_6; break; case CS7: mode |= ATMEL_US_CHRL_7; break; default: mode |= ATMEL_US_CHRL_8; break; } /* stop bits */ if (termios->c_cflag & CSTOPB) mode |= ATMEL_US_NBSTOP_2; /* parity */ if (termios->c_cflag & PARENB) { if (termios->c_cflag & CMSPAR) { /* Mark or Space parity */ if (termios->c_cflag & PARODD) mode |= ATMEL_US_PAR_MARK; else mode |= ATMEL_US_PAR_SPACE; } else if (termios->c_cflag & PARODD) mode |= ATMEL_US_PAR_ODD; else mode |= ATMEL_US_PAR_EVEN; } else mode |= ATMEL_US_PAR_NONE; spin_lock_irqsave(&port->lock, flags); port->read_status_mask = ATMEL_US_OVRE; if (termios->c_iflag & INPCK) port->read_status_mask |= (ATMEL_US_FRAME | ATMEL_US_PARE); if (termios->c_iflag & (BRKINT | PARMRK)) port->read_status_mask |= ATMEL_US_RXBRK; if (atmel_port->use_dma_rx) /* need to enable error interrupts */ UART_PUT_IER(port, port->read_status_mask); /* * Characters to ignore */ port->ignore_status_mask = 0; if (termios->c_iflag & IGNPAR) port->ignore_status_mask |= (ATMEL_US_FRAME | ATMEL_US_PARE); if (termios->c_iflag & IGNBRK) { port->ignore_status_mask |= ATMEL_US_RXBRK; /* * If we're ignoring parity and break indicators, * ignore overruns too (for real raw support). */ if (termios->c_iflag & IGNPAR) port->ignore_status_mask |= ATMEL_US_OVRE; } // TODO: Ignore all characters if CREAD is set. /* update the per-port timeout */ uart_update_timeout(port, termios->c_cflag, baud); /* disable interrupts and drain transmitter */ imr = UART_GET_IMR(port); /* get interrupt mask */ UART_PUT_IDR(port, -1); /* disable all interrupts */ while (!(UART_GET_CSR(port) & ATMEL_US_TXEMPTY)) cpu_relax(); /* disable receiver and transmitter */ UART_PUT_CR(port, ATMEL_US_TXDIS | ATMEL_US_RXDIS); /* set the parity, stop bits and data size */ UART_PUT_MR(port, mode); /* set the baud rate */ UART_PUT_BRGR(port, quot); UART_PUT_CR(port, ATMEL_US_RSTSTA | ATMEL_US_RSTRX); UART_PUT_CR(port, ATMEL_US_TXEN | ATMEL_US_RXEN); /* restore interrupts */ UART_PUT_IER(port, imr); /* CTS flow-control and modem-status interrupts */ if (UART_ENABLE_MS(port, termios->c_cflag)) port->ops->enable_ms(port); spin_unlock_irqrestore(&port->lock, flags); }
/* * Perform initialization and enable port for reception */ static int atmel_startup(struct uart_port *port) { struct atmel_uart_port *atmel_port = (struct atmel_uart_port *) port; int retval; /* * Ensure that no interrupts are enabled otherwise when * request_irq() is called we could get stuck trying to * handle an unexpected interrupt */ UART_PUT_IDR(port, -1); /* * Allocate the IRQ */ retval = request_irq(port->irq, atmel_interrupt, IRQF_SHARED, "atmel_serial", port); if (retval) { printk("atmel_serial: atmel_startup - Can't get irq\n"); return retval; } /* * Initialize DMA (if necessary) */ if (atmel_port->use_dma_rx) { int i; u32 pdc_buffer_size; #ifdef INFRAD_NO_PDC_SUPPORT struct tty_struct *tty = port->info->tty; printk ("petworm: serial open index is %d.\n", tty->index); if (tty->index == 2) { printk ("petworm: DMA buffer is 16.\n"); pdc_buffer_size = 16; } else pdc_buffer_size = PDC_BUFFER_SIZE; #else pdc_buffer_size = PDC_BUFFER_SIZE; #endif for (i = 0; i < 2; i++) { struct atmel_dma_buffer *pdc = &atmel_port->pdc_rx[i]; pdc->buf = kmalloc(pdc_buffer_size, GFP_KERNEL); if (pdc->buf == NULL) { if (i != 0) { dma_unmap_single(port->dev, atmel_port->pdc_rx[0].dma_addr, pdc_buffer_size, DMA_FROM_DEVICE); kfree(atmel_port->pdc_rx[0].buf); } free_irq(port->irq, port); return -ENOMEM; } pdc->dma_addr = dma_map_single(port->dev, pdc->buf, pdc_buffer_size, DMA_FROM_DEVICE); pdc->dma_size = pdc_buffer_size; pdc->ofs = 0; } atmel_port->pdc_rx_idx = 0; UART_PUT_RPR(port, atmel_port->pdc_rx[0].dma_addr); UART_PUT_RCR(port, pdc_buffer_size); UART_PUT_RNPR(port, atmel_port->pdc_rx[1].dma_addr); UART_PUT_RNCR(port, pdc_buffer_size); } if (atmel_port->use_dma_tx) { struct atmel_dma_buffer *pdc = &atmel_port->pdc_tx; struct circ_buf *xmit = &port->info->xmit; pdc->buf = xmit->buf; pdc->dma_addr = dma_map_single(port->dev, pdc->buf, SERIAL_XMIT_SIZE, DMA_TO_DEVICE); pdc->dma_size = SERIAL_XMIT_SIZE; pdc->ofs = 0; } /* * If there is a specific "open" function (to register * control line interrupts) */ if (atmel_open_hook) { retval = atmel_open_hook(port); if (retval) { free_irq(port->irq, port); return retval; } } /* * Finally, enable the serial port */ UART_PUT_CR(port, ATMEL_US_RSTSTA | ATMEL_US_RSTRX); UART_PUT_CR(port, ATMEL_US_TXEN | ATMEL_US_RXEN); /* enable xmit & rcvr */ if (atmel_port->use_dma_rx) { UART_PUT_RTOR(port, PDC_RX_TIMEOUT); /* set UART timeout */ UART_PUT_CR(port, ATMEL_US_STTTO); UART_PUT_IER(port, ATMEL_US_ENDRX | ATMEL_US_TIMEOUT); UART_PUT_PTCR(port, ATMEL_PDC_RXTEN); /* enable PDC controller */ } else UART_PUT_IER(port, ATMEL_US_RXRDY); /* enable receive only */ return 0; }
/* * Characters received (called from interrupt handler) */ static void atmel_rx_chars(struct uart_port *port) { struct atmel_uart_port *atmel_port = (struct atmel_uart_port *) port; struct tty_struct *tty = port->info->tty; unsigned int status, ch, flg; status = UART_GET_CSR(port); while (status & ATMEL_US_RXRDY) { ch = UART_GET_CHAR(port); port->icount.rx++; flg = TTY_NORMAL; /* * note that the error handling code is * out of the main execution path */ if (unlikely(status & (ATMEL_US_PARE | ATMEL_US_FRAME | ATMEL_US_OVRE | ATMEL_US_RXBRK) || atmel_port->break_active)) { UART_PUT_CR(port, ATMEL_US_RSTSTA); /* clear error */ if (status & ATMEL_US_RXBRK && !atmel_port->break_active) { status &= ~(ATMEL_US_PARE | ATMEL_US_FRAME); /* ignore side-effect */ port->icount.brk++; atmel_port->break_active = 1; UART_PUT_IER(port, ATMEL_US_RXBRK); if (uart_handle_break(port)) goto ignore_char; } else { /* * This is either the end-of-break * condition or we've received at * least one character without RXBRK * being set. In both cases, the next * RXBRK will indicate start-of-break. */ UART_PUT_IDR(port, ATMEL_US_RXBRK); status &= ~ATMEL_US_RXBRK; atmel_port->break_active = 0; } if (status & ATMEL_US_PARE) port->icount.parity++; if (status & ATMEL_US_FRAME) port->icount.frame++; if (status & ATMEL_US_OVRE) port->icount.overrun++; status &= port->read_status_mask; if (status & ATMEL_US_RXBRK) flg = TTY_BREAK; else if (status & ATMEL_US_PARE) flg = TTY_PARITY; else if (status & ATMEL_US_FRAME) flg = TTY_FRAME; } if (uart_handle_sysrq_char(port, ch)) goto ignore_char; uart_insert_char(port, status, ATMEL_US_OVRE, ch, flg); ignore_char: status = UART_GET_CSR(port); } tty_flip_buffer_push(tty); }
/* * Enable modem status interrupts */ static void atmel_enable_ms(struct uart_port *port) { UART_PUT_IER(port, ATMEL_US_RIIC | ATMEL_US_DSRIC | ATMEL_US_DCDIC | ATMEL_US_CTSIC); }
static void ambauart_int(int irq, void *dev_id, struct pt_regs *regs) { struct uart_port *port = dev_id; struct uart_info *info = port->info; unsigned int status, ier, old_ier, count, lsr; old_ier = UART_GET_IER(port); UART_PUT_IER(port, (old_ier & 0xFFFFF0FF)); status = UART_GET_INT_STATUS(port); lsr = UART_GET_LSR(port); /* KS8695_INTMASK_UART_RX is not set during breakpoint as it should (looks * like a HW bug), so we specifically check for a breakpoint condition in * the UART line status register. * Some bits from the UART line status register are cleared only when they * are read by CPU. That is why we cannot read the line status register * twice, and should pass the first read as argument to ambauart_rx_chars. * Refer to CENTAUR KS8695PX's Register Description document: * KS8695PX_REG_DESCP_v1.0.pdf, page 58: "UART Line Status Register". */ if (status & KS8695_INTMASK_UART_RX || lsr & KS8695_UART_LINES_BE) { #ifdef SUPPORT_SYSRQ ambauart_rx_chars(port, regs, lsr); #else ambauart_rx_chars(port, lsr); #endif } if (status & KS8695_INTMASK_UART_TX) { if (port->x_char) { UART_CLR_INT_STATUS(port, KS8695_INTMASK_UART_TX); UART_PUT_CHAR(port, (u_int) port->x_char); port->icount.tx++; port->x_char = 0; ier = UART_GET_IER(port); ier &= 0xFFFFFEFF; UART_PUT_IER(port, ier); printk("XOn/Off sent\n"); return; } for ( count = 0; count < 16; count++) { if (info->xmit.head == info->xmit.tail) { /*ier = UART_GET_IER(port); ier &= 0xFFFFFEFF; UART_PUT_IER(port, ier);*/ break; } UART_CLR_INT_STATUS(port, KS8695_INTMASK_UART_TX); UART_PUT_CHAR(port, (u_int) (info->xmit.buf[info->xmit.tail])); info->xmit.tail = (info->xmit.tail + 1) & (UART_XMIT_SIZE - 1); port->icount.tx++; }; if (CIRC_CNT(info->xmit.head, info->xmit.tail, UART_XMIT_SIZE) < WAKEUP_CHARS) uart_write_wakeup(port); if (info->xmit.head == info->xmit.tail) { ier = UART_GET_IER(port); ier &= 0xFFFFFEFF; UART_PUT_IER(port, ier); } } if (status & KS8695_INTMASK_UART_MODEMS) { ambauart_modem_status(port); } if (status & KS8695_INTMASK_UART_MODEMS) { ambauart_modem_status(port); } if ( status & KS8695_INTMASK_UART_LINE_ERR) { UART_GET_LSR(port); } if (info->xmit.head == info->xmit.tail) UART_PUT_IER(port, (old_ier & 0xFFFFFEFF)); else UART_PUT_IER(port, old_ier | KS8695_INTMASK_UART_TX); }
/* * Enable modem status interrupts */ static void at91_enable_ms(struct uart_port *port) { port->read_status_mask |= (AT91_US_RIIC | AT91_US_DSRIC | AT91_US_DCDIC | AT91_US_CTSIC); UART_PUT_IER(port, AT91_US_RIIC | AT91_US_DSRIC | AT91_US_DCDIC | AT91_US_CTSIC); }
static void ssauart_shutdown (struct uart_port *port) { UART_PUT_IER (port, 0x00); /* disable all interrupts */ free_irq (port->irq, port); }
/* * Start transmitting. */ static void at91_start_tx(struct uart_port *port) { port->read_status_mask |= AT91_US_TXRDY; UART_PUT_IER(port, AT91_US_TXRDY); }