static void __init serial_putc(struct uart_port *port, int c) { wait_for_xmitr(port); serial_out(port, UART_TX, c); }
static void vt8500_console_putchar(struct uart_port *port, int c) { wait_for_xmitr(port); writeb(c, port->membase + VT8500_TXFIFO); }
static void handle_tx(struct uart_port *port) { struct circ_buf *xmit = &port->state->xmit; int sent_tx; int tx_count; int x; unsigned int tf_pointer = 0; tx_count = uart_circ_chars_pending(xmit); if (tx_count > (UART_XMIT_SIZE - xmit->tail)) tx_count = UART_XMIT_SIZE - xmit->tail; if (tx_count >= port->fifosize) tx_count = port->fifosize; /* Handle x_char */ if (port->x_char) { wait_for_xmitr(port, UARTDM_ISR_TX_READY_BMSK); msm_hsl_write(port, tx_count + 1, UARTDM_NCF_TX_ADDR); msm_hsl_write(port, port->x_char, UARTDM_TF_ADDR); port->icount.tx++; port->x_char = 0; } else if (tx_count) { wait_for_xmitr(port, UARTDM_ISR_TX_READY_BMSK); msm_hsl_write(port, tx_count, UARTDM_NCF_TX_ADDR); } if (!tx_count) { msm_hsl_stop_tx(port); return; } while (tf_pointer < tx_count) { if (unlikely(!(msm_hsl_read(port, UARTDM_SR_ADDR) & UARTDM_SR_TXRDY_BMSK))) continue; switch (tx_count - tf_pointer) { case 1: { x = xmit->buf[xmit->tail]; port->icount.tx++; break; } case 2: { x = xmit->buf[xmit->tail] | xmit->buf[xmit->tail+1] << 8; port->icount.tx += 2; break; } case 3: { x = xmit->buf[xmit->tail] | xmit->buf[xmit->tail+1] << 8 | xmit->buf[xmit->tail + 2] << 16; port->icount.tx += 3; break; } default: { x = *((int *)&(xmit->buf[xmit->tail])); port->icount.tx += 4; break; } } msm_hsl_write(port, x, UARTDM_TF_ADDR); xmit->tail = ((tx_count - tf_pointer < 4) ? (tx_count - tf_pointer + xmit->tail) : (xmit->tail + 4)) & (UART_XMIT_SIZE - 1); tf_pointer += 4; sent_tx = 1; } if (uart_circ_empty(xmit)) msm_hsl_stop_tx(port); if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) uart_write_wakeup(port); }
static void sprd_console_putchar(struct uart_port *port, int ch) { wait_for_xmitr(port); serial_out(port, SPRD_TXD, ch); }
static void serial_omap_poll_put_char(struct uart_port *port, unsigned char ch) { struct uart_omap_port *up = (struct uart_omap_port *)port; wait_for_xmitr(up); serial_out(up, UART_TX, ch); }
static void serial_omap_console_write(struct console *co, const char *s, unsigned int count) { struct uart_omap_port *up = serial_omap_console_ports[co->index]; unsigned long flags; unsigned int ier; int console_lock = 0, locked = 1; if (console_trylock()) console_lock = 1; /* * If console_lock is not available and we are in suspending * state then we can avoid the console usage scenario * as this may introduce recursive prints. * Basically this scenario occurs during boot while * printing debug bootlogs. */ if (!console_lock && up->pdev->dev.power.runtime_status == RPM_SUSPENDING) return; local_irq_save(flags); if (up->port.sysrq) locked = 0; else if (oops_in_progress) locked = spin_trylock(&up->port.lock); else spin_lock(&up->port.lock); serial_omap_port_enable(up); /* * First save the IER then disable the interrupts */ ier = serial_in(up, UART_IER); serial_out(up, UART_IER, 0); uart_console_write(&up->port, s, count, serial_omap_console_putchar); /* * Finally, wait for transmitter to become empty * and restore the IER */ wait_for_xmitr(up); serial_out(up, UART_IER, ier); /* * The receive handling will happen properly because the * receive ready bit will still be set; it is not cleared * on read. However, modem control will not, we must * call it if we have saved something in the saved flags * while processing with interrupts off. */ if (up->msr_saved_flags) check_modem_status(up); if (console_lock) console_unlock(); serial_omap_port_disable(up); if (locked) spin_unlock(&up->port.lock); local_irq_restore(flags); }
static void reset_dm_count(struct uart_port *port) { wait_for_xmitr(port, UART_ISR_TX_READY); msm_write(port, 1, UARTDM_NCF_TX); }
static void mvebu_uart_console_putchar(struct uart_port *port, int ch) { wait_for_xmitr(port); writel(ch, port->membase + UART_TSH); }