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);
}