4 files changed, 332 insertions, 145 deletions

diff --git a/drivers/serial/8250.c b/drivers/serial/8250.c
index 48e259a0167d..c84dab083a85 100644
--- a/drivers/serial/8250.c
+++ b/drivers/serial/8250.c
@@ -894,7 +894,7 @@ static void autoconfig_16550a(struct uart_8250_port *up)
                         quot = serial_dl_read(up);
                         quot <<= 3;
 
-                        status1 = serial_in(up, 0x04); /* EXCR1 */
+                        status1 = serial_in(up, 0x04); /* EXCR2 */
                         status1 &= ~0xB0; /* Disable LOCK, mask out PRESL[01] */
                         status1 |= 0x10;  /* 1.625 divisor for baud_base --> 921600 */
                         serial_outp(up, 0x04, status1);
@@ -2617,7 +2617,22 @@ void serial8250_suspend_port(int line)
  */
 void serial8250_resume_port(int line)
 {
-        uart_resume_port(&serial8250_reg, &serial8250_ports[line].port);
+        struct uart_8250_port *up = &serial8250_ports[line];
+
+        if (up->capabilities & UART_NATSEMI) {
+                unsigned char tmp;
+
+                /* Ensure it's still in high speed mode */
+                serial_outp(up, UART_LCR, 0xE0);
+
+                tmp = serial_in(up, 0x04); /* EXCR2 */
+                tmp &= ~0xB0; /* Disable LOCK, mask out PRESL[01] */
+                tmp |= 0x10;  /* 1.625 divisor for baud_base --> 921600 */
+                serial_outp(up, 0x04, tmp);
+
+                serial_outp(up, UART_LCR, 0);
+        }
+        uart_resume_port(&serial8250_reg, &up->port);
 }
 
 /*
@@ -2694,7 +2709,7 @@ static int serial8250_resume(struct platform_device *dev)
                 struct uart_8250_port *up = &serial8250_ports[i];
 
                 if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
-                        uart_resume_port(&serial8250_reg, &up->port);
+                        serial8250_resume_port(i);
         }
 
         return 0;
diff --git a/drivers/serial/bfin_5xx.c b/drivers/serial/bfin_5xx.c
index 408390f93db9..787dc7168f3e 100644
--- a/drivers/serial/bfin_5xx.c
+++ b/drivers/serial/bfin_5xx.c
@@ -6,8 +6,6 @@
  * Created:
  * Description:  Driver for blackfin 5xx serial ports
  *
- * Rev:          $Id: bfin_5xx.c,v 1.19 2006/09/24 02:33:53 aubrey Exp $
- *
  * Modified:
  *               Copyright 2006 Analog Devices Inc.
  *
@@ -152,7 +150,7 @@ static void local_put_char(struct bfin_serial_port *uart, char ch)
 
 static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
 {
-        struct tty_struct *tty = uart->port.info?uart->port.info->tty:0;
+        struct tty_struct *tty = uart->port.info->tty;
         unsigned int status, ch, flg;
 #ifdef BF533_FAMILY
         static int in_break = 0;
@@ -173,8 +171,10 @@ static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
                 if (ch != 0) {
                         in_break = 0;
                         ch = UART_GET_CHAR(uart);
-                }
-                return;
+                        if (bfin_revid() < 5)
+                                return;
+                } else
+                        return;
         }
 #endif
 
@@ -185,27 +185,32 @@ static void bfin_serial_rx_chars(struct bfin_serial_port *uart)
                 uart->port.icount.brk++;
                 if (uart_handle_break(&uart->port))
                         goto ignore_char;
-                flg = TTY_BREAK;
-        } else if (status & PE) {
-                flg = TTY_PARITY;
+        }
+        if (status & PE)
                 uart->port.icount.parity++;
-        } else if (status & OE) {
-                flg = TTY_OVERRUN;
+        if (status & OE)
                 uart->port.icount.overrun++;
-        } else if (status & FE) {
-                flg = TTY_FRAME;
+        if (status & FE)
                 uart->port.icount.frame++;
-        } else
+
+        status &= uart->port.read_status_mask;
+
+        if (status & BI)
+                flg = TTY_BREAK;
+        else if (status & PE)
+                flg = TTY_PARITY;
+        else if (status & FE)
+                flg = TTY_FRAME;
+        else
                 flg = TTY_NORMAL;
 
         if (uart_handle_sysrq_char(&uart->port, ch))
                 goto ignore_char;
-        if (tty)
-                uart_insert_char(&uart->port, status, 2, ch, flg);
 
-ignore_char:
-        if (tty)
-                tty_flip_buffer_push(tty);
+        uart_insert_char(&uart->port, status, OE, ch, flg);
+
+ ignore_char:
+        tty_flip_buffer_push(tty);
 }
 
 static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
@@ -240,24 +245,29 @@ static void bfin_serial_tx_chars(struct bfin_serial_port *uart)
                 bfin_serial_stop_tx(&uart->port);
 }
 
-static irqreturn_t bfin_serial_int(int irq, void *dev_id)
+static irqreturn_t bfin_serial_rx_int(int irq, void *dev_id)
 {
         struct bfin_serial_port *uart = dev_id;
-        unsigned short status;
 
         spin_lock(&uart->port.lock);
-        status = UART_GET_IIR(uart);
-        do {
-                if ((status & IIR_STATUS) == IIR_TX_READY)
-                        bfin_serial_tx_chars(uart);
-                if ((status & IIR_STATUS) == IIR_RX_READY)
-                        bfin_serial_rx_chars(uart);
-                status = UART_GET_IIR(uart);
-        } while (status & (IIR_TX_READY | IIR_RX_READY));
+        while ((UART_GET_IIR(uart) & IIR_STATUS) == IIR_RX_READY)
+                bfin_serial_rx_chars(uart);
         spin_unlock(&uart->port.lock);
         return IRQ_HANDLED;
 }
 
+static irqreturn_t bfin_serial_tx_int(int irq, void *dev_id)
+{
+        struct bfin_serial_port *uart = dev_id;
+
+        spin_lock(&uart->port.lock);
+        while ((UART_GET_IIR(uart) & IIR_STATUS) == IIR_TX_READY)
+                bfin_serial_tx_chars(uart);
+        spin_unlock(&uart->port.lock);
+        return IRQ_HANDLED;
+}
+
+
 static void bfin_serial_do_work(struct work_struct *work)
 {
         struct bfin_serial_port *uart = container_of(work, struct bfin_serial_port, cts_workqueue);
@@ -319,7 +329,7 @@ static void bfin_serial_dma_tx_chars(struct bfin_serial_port *uart)
         spin_unlock_irqrestore(&uart->port.lock, flags);
 }
 
-static void bfin_serial_dma_rx_chars(struct bfin_serial_port * uart)
+static void bfin_serial_dma_rx_chars(struct bfin_serial_port *uart)
 {
         struct tty_struct *tty = uart->port.info->tty;
         int i, flg, status;
@@ -331,25 +341,32 @@ static void bfin_serial_dma_rx_chars(struct bfin_serial_port * uart)
                 uart->port.icount.brk++;
                 if (uart_handle_break(&uart->port))
                         goto dma_ignore_char;
-                flg = TTY_BREAK;
-        } else if (status & PE) {
-                flg = TTY_PARITY;
+        }
+        if (status & PE)
                 uart->port.icount.parity++;
-        } else if (status & OE) {
-                flg = TTY_OVERRUN;
+        if (status & OE)
                 uart->port.icount.overrun++;
-        } else if (status & FE) {
-                flg = TTY_FRAME;
+        if (status & FE)
                 uart->port.icount.frame++;
-        } else
+
+        status &= uart->port.read_status_mask;
+
+        if (status & BI)
+                flg = TTY_BREAK;
+        else if (status & PE)
+                flg = TTY_PARITY;
+        else if (status & FE)
+                flg = TTY_FRAME;
+        else
                 flg = TTY_NORMAL;
 
         for (i = uart->rx_dma_buf.head; i < uart->rx_dma_buf.tail; i++) {
                 if (uart_handle_sysrq_char(&uart->port, uart->rx_dma_buf.buf[i]))
                         goto dma_ignore_char;
-                uart_insert_char(&uart->port, status, 2, uart->rx_dma_buf.buf[i], flg);
+                uart_insert_char(&uart->port, status, OE, uart->rx_dma_buf.buf[i], flg);
         }
-dma_ignore_char:
+
+ dma_ignore_char:
         tty_flip_buffer_push(tty);
 }
 
@@ -545,14 +562,14 @@ static int bfin_serial_startup(struct uart_port *port)
         add_timer(&(uart->rx_dma_timer));
 #else
         if (request_irq
-            (uart->port.irq, bfin_serial_int, IRQF_DISABLED,
+            (uart->port.irq, bfin_serial_rx_int, IRQF_DISABLED,
              "BFIN_UART_RX", uart)) {
                 printk(KERN_NOTICE "Unable to attach BlackFin UART RX interrupt\n");
                 return -EBUSY;
         }
 
         if (request_irq
-            (uart->port.irq+1, bfin_serial_int, IRQF_DISABLED,
+            (uart->port.irq+1, bfin_serial_tx_int, IRQF_DISABLED,
              "BFIN_UART_TX", uart)) {
                 printk(KERN_NOTICE "Unable to attach BlackFin UART TX interrupt\n");
                 free_irq(uart->port.irq, uart);
@@ -614,13 +631,27 @@ bfin_serial_set_termios(struct uart_port *port, struct ktermios *termios,
                         lcr |= EPS;
         }
 
-        /* These controls are not implemented for this port */
-        termios->c_iflag |= INPCK | BRKINT | PARMRK;
-        termios->c_iflag &= ~(IGNPAR | IGNBRK);
+        port->read_status_mask = OE;
+        if (termios->c_iflag & INPCK)
+                port->read_status_mask |= (FE | PE);
+        if (termios->c_iflag & (BRKINT | PARMRK))
+                port->read_status_mask |= BI;
 
-        /* These controls are not implemented for this port */
-        termios->c_iflag |= INPCK | BRKINT | PARMRK;
-        termios->c_iflag &= ~(IGNPAR | IGNBRK);
+        /*
+         * Characters to ignore
+         */
+        port->ignore_status_mask = 0;
+        if (termios->c_iflag & IGNPAR)
+                port->ignore_status_mask |= FE | PE;
+        if (termios->c_iflag & IGNBRK) {
+                port->ignore_status_mask |= BI;
+                /*
+                 * If we're ignoring parity and break indicators,
+                 * ignore overruns too (for real raw support).
+                 */
+                if (termios->c_iflag & IGNPAR)
+                        port->ignore_status_mask |= OE;
+        }
 
         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
         quot = uart_get_divisor(port, baud);
diff --git a/drivers/serial/icom.c b/drivers/serial/icom.c
index 6202995e8211..9d3105b64a7a 100644
--- a/drivers/serial/icom.c
+++ b/drivers/serial/icom.c
@@ -69,33 +69,40 @@
 
 static const struct pci_device_id icom_pci_table[] = {
         {
-              .vendor = PCI_VENDOR_ID_IBM,
-              .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_1,
-              .subvendor = PCI_ANY_ID,
-              .subdevice = PCI_ANY_ID,
-              .driver_data = ADAPTER_V1,
-         },
+                .vendor = PCI_VENDOR_ID_IBM,
+                .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_1,
+                .subvendor = PCI_ANY_ID,
+                .subdevice = PCI_ANY_ID,
+                .driver_data = ADAPTER_V1,
+        },
         {
-              .vendor = PCI_VENDOR_ID_IBM,
-              .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
-              .subvendor = PCI_VENDOR_ID_IBM,
-              .subdevice = PCI_DEVICE_ID_IBM_ICOM_V2_TWO_PORTS_RVX,
-              .driver_data = ADAPTER_V2,
-         },
+                .vendor = PCI_VENDOR_ID_IBM,
+                .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
+                .subvendor = PCI_VENDOR_ID_IBM,
+                .subdevice = PCI_DEVICE_ID_IBM_ICOM_V2_TWO_PORTS_RVX,
+                .driver_data = ADAPTER_V2,
+        },
         {
-              .vendor = PCI_VENDOR_ID_IBM,
-              .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
-              .subvendor = PCI_VENDOR_ID_IBM,
-              .subdevice = PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM,
-              .driver_data = ADAPTER_V2,
-         },
+                .vendor = PCI_VENDOR_ID_IBM,
+                .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
+                .subvendor = PCI_VENDOR_ID_IBM,
+                .subdevice = PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM,
+                .driver_data = ADAPTER_V2,
+        },
         {
-              .vendor = PCI_VENDOR_ID_IBM,
-              .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
-              .subvendor = PCI_VENDOR_ID_IBM,
-              .subdevice = PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL,
-              .driver_data = ADAPTER_V2,
-         },
+                .vendor = PCI_VENDOR_ID_IBM,
+                .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
+                .subvendor = PCI_VENDOR_ID_IBM,
+                .subdevice = PCI_DEVICE_ID_IBM_ICOM_FOUR_PORT_MODEL,
+                .driver_data = ADAPTER_V2,
+        },
+        {
+                .vendor = PCI_VENDOR_ID_IBM,
+                .device = PCI_DEVICE_ID_IBM_ICOM_DEV_ID_2,
+                .subvendor = PCI_VENDOR_ID_IBM,
+                .subdevice = PCI_DEVICE_ID_IBM_ICOM_V2_ONE_PORT_RVX_ONE_PORT_MDM_PCIE,
+                .driver_data = ADAPTER_V2,
+        },
         {}
 };
 
diff --git a/drivers/serial/sunhv.c b/drivers/serial/sunhv.c
index c3a6bd2e7950..96557e6dba60 100644
--- a/drivers/serial/sunhv.c
+++ b/drivers/serial/sunhv.c
@@ -1,6 +1,6 @@
 /* sunhv.c: Serial driver for SUN4V hypervisor console.
  *
- * Copyright (C) 2006 David S. Miller (davem@davemloft.net)
+ * Copyright (C) 2006, 2007 David S. Miller (davem@davemloft.net)
  */
 
 #include <linux/module.h>
@@ -35,57 +35,51 @@
 #define CON_BREAK       ((long)-1)
 #define CON_HUP         ((long)-2)
 
-static inline long hypervisor_con_getchar(long *status)
-{
-        register unsigned long func asm("%o5");
-        register unsigned long arg0 asm("%o0");
-        register unsigned long arg1 asm("%o1");
-
-        func = HV_FAST_CONS_GETCHAR;
-        arg0 = 0;
-        arg1 = 0;
-        __asm__ __volatile__("ta        %6"
-                             : "=&r" (func), "=&r" (arg0), "=&r" (arg1)
-                             : "0" (func), "1" (arg0), "2" (arg1),
-                               "i" (HV_FAST_TRAP));
+#define IGNORE_BREAK    0x1
+#define IGNORE_ALL      0x2
 
-        *status = arg0;
+static char *con_write_page;
+static char *con_read_page;
 
-        return (long) arg1;
-}
+static int hung_up = 0;
 
-static inline long hypervisor_con_putchar(long ch)
+static void transmit_chars_putchar(struct uart_port *port, struct circ_buf *xmit)
 {
-        register unsigned long func asm("%o5");
-        register unsigned long arg0 asm("%o0");
+        while (!uart_circ_empty(xmit)) {
+                long status = sun4v_con_putchar(xmit->buf[xmit->tail]);
 
-        func = HV_FAST_CONS_PUTCHAR;
-        arg0 = ch;
-        __asm__ __volatile__("ta        %4"
-                             : "=&r" (func), "=&r" (arg0)
-                             : "0" (func), "1" (arg0), "i" (HV_FAST_TRAP));
+                if (status != HV_EOK)
+                        break;
 
-        return (long) arg0;
+                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
+                port->icount.tx++;
+        }
 }
 
-#define IGNORE_BREAK    0x1
-#define IGNORE_ALL      0x2
+static void transmit_chars_write(struct uart_port *port, struct circ_buf *xmit)
+{
+        while (!uart_circ_empty(xmit)) {
+                unsigned long ra = __pa(xmit->buf + xmit->tail);
+                unsigned long len, status, sent;
 
-static int hung_up = 0;
+                len = CIRC_CNT_TO_END(xmit->head, xmit->tail,
+                                      UART_XMIT_SIZE);
+                status = sun4v_con_write(ra, len, &sent);
+                if (status != HV_EOK)
+                        break;
+                xmit->tail = (xmit->tail + sent) & (UART_XMIT_SIZE - 1);
+                port->icount.tx += sent;
+        }
+}
 
-static struct tty_struct *receive_chars(struct uart_port *port)
+static int receive_chars_getchar(struct uart_port *port, struct tty_struct *tty)
 {
-        struct tty_struct *tty = NULL;
         int saw_console_brk = 0;
         int limit = 10000;
 
-        if (port->info != NULL)         /* Unopened serial console */
-                tty = port->info->tty;
-
         while (limit-- > 0) {
                 long status;
-                long c = hypervisor_con_getchar(&status);
-                unsigned char flag;
+                long c = sun4v_con_getchar(&status);
 
                 if (status == HV_EWOULDBLOCK)
                         break;
@@ -110,27 +104,90 @@ static struct tty_struct *receive_chars(struct uart_port *port)
                         continue;
                 }
 
-                flag = TTY_NORMAL;
                 port->icount.rx++;
-                if (c == CON_BREAK) {
-                        port->icount.brk++;
-                        if (uart_handle_break(port))
-                                continue;
-                        flag = TTY_BREAK;
-                }
 
                 if (uart_handle_sysrq_char(port, c))
                         continue;
 
-                if ((port->ignore_status_mask & IGNORE_ALL) ||
-                    ((port->ignore_status_mask & IGNORE_BREAK) &&
-                     (c == CON_BREAK)))
+                tty_insert_flip_char(tty, c, TTY_NORMAL);
+        }
+
+        return saw_console_brk;
+}
+
+static int receive_chars_read(struct uart_port *port, struct tty_struct *tty)
+{
+        int saw_console_brk = 0;
+        int limit = 10000;
+
+        while (limit-- > 0) {
+                unsigned long ra = __pa(con_read_page);
+                unsigned long bytes_read, i;
+                long stat = sun4v_con_read(ra, PAGE_SIZE, &bytes_read);
+
+                if (stat != HV_EOK) {
+                        bytes_read = 0;
+
+                        if (stat == CON_BREAK) {
+                                if (uart_handle_break(port))
+                                        continue;
+                                saw_console_brk = 1;
+                                *con_read_page = 0;
+                                bytes_read = 1;
+                        } else if (stat == CON_HUP) {
+                                hung_up = 1;
+                                uart_handle_dcd_change(port, 0);
+                                continue;
+                        } else {
+                                /* HV_EWOULDBLOCK, etc.  */
+                                break;
+                        }
+                }
+
+                if (hung_up) {
+                        hung_up = 0;
+                        uart_handle_dcd_change(port, 1);
+                }
+
+                for (i = 0; i < bytes_read; i++)
+                        uart_handle_sysrq_char(port, con_read_page[i]);
+
+                if (tty == NULL)
                         continue;
 
-                tty_insert_flip_char(tty, c, flag);
+                port->icount.rx += bytes_read;
+
+                tty_insert_flip_string(tty, con_read_page, bytes_read);
         }
 
-        if (saw_console_brk)
+        return saw_console_brk;
+}
+
+struct sunhv_ops {
+        void (*transmit_chars)(struct uart_port *port, struct circ_buf *xmit);
+        int (*receive_chars)(struct uart_port *port, struct tty_struct *tty);
+};
+
+static struct sunhv_ops bychar_ops = {
+        .transmit_chars = transmit_chars_putchar,
+        .receive_chars = receive_chars_getchar,
+};
+
+static struct sunhv_ops bywrite_ops = {
+        .transmit_chars = transmit_chars_write,
+        .receive_chars = receive_chars_read,
+};
+
+static struct sunhv_ops *sunhv_ops = &bychar_ops;
+
+static struct tty_struct *receive_chars(struct uart_port *port)
+{
+        struct tty_struct *tty = NULL;
+
+        if (port->info != NULL)         /* Unopened serial console */
+                tty = port->info->tty;
+
+        if (sunhv_ops->receive_chars(port, tty))
                 sun_do_break();
 
         return tty;
@@ -147,15 +204,7 @@ static void transmit_chars(struct uart_port *port)
         if (uart_circ_empty(xmit) || uart_tx_stopped(port))
                 return;
 
-        while (!uart_circ_empty(xmit)) {
-                long status = hypervisor_con_putchar(xmit->buf[xmit->tail]);
-
-                if (status != HV_EOK)
-                        break;
-
-                xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
-                port->icount.tx++;
-        }
+        sunhv_ops->transmit_chars(port, xmit);
 
         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
                 uart_write_wakeup(port);
@@ -212,7 +261,7 @@ static void sunhv_start_tx(struct uart_port *port)
         struct circ_buf *xmit = &port->info->xmit;
 
         while (!uart_circ_empty(xmit)) {
-                long status = hypervisor_con_putchar(xmit->buf[xmit->tail]);
+                long status = sun4v_con_putchar(xmit->buf[xmit->tail]);
 
                 if (status != HV_EOK)
                         break;
@@ -231,9 +280,10 @@ static void sunhv_send_xchar(struct uart_port *port, char ch)
         spin_lock_irqsave(&port->lock, flags);
 
         while (limit-- > 0) {
-                long status = hypervisor_con_putchar(ch);
+                long status = sun4v_con_putchar(ch);
                 if (status == HV_EOK)
                         break;
+                udelay(1);
         }
 
         spin_unlock_irqrestore(&port->lock, flags);
@@ -254,15 +304,15 @@ static void sunhv_break_ctl(struct uart_port *port, int break_state)
 {
         if (break_state) {
                 unsigned long flags;
-                int limit = 1000000;
+                int limit = 10000;
 
                 spin_lock_irqsave(&port->lock, flags);
 
                 while (limit-- > 0) {
-                        long status = hypervisor_con_putchar(CON_BREAK);
+                        long status = sun4v_con_putchar(CON_BREAK);
                         if (status == HV_EOK)
                                 break;
-                        udelay(2);
+                        udelay(1);
                 }
 
                 spin_unlock_irqrestore(&port->lock, flags);
@@ -359,38 +409,99 @@ static struct uart_driver sunhv_reg = {
 
 static struct uart_port *sunhv_port;
 
-static inline void sunhv_console_putchar(struct uart_port *port, char c)
+/* Copy 's' into the con_write_page, decoding "\n" into
+ * "\r\n" along the way.  We have to return two lengths
+ * because the caller needs to know how much to advance
+ * 's' and also how many bytes to output via con_write_page.
+ */
+static int fill_con_write_page(const char *s, unsigned int n,
+                               unsigned long *page_bytes)
+{
+        const char *orig_s = s;
+        char *p = con_write_page;
+        int left = PAGE_SIZE;
+
+        while (n--) {
+                if (*s == '\n') {
+                        if (left < 2)
+                                break;
+                        *p++ = '\r';
+                        left--;
+                } else if (left < 1)
+                        break;
+                *p++ = *s++;
+                left--;
+        }
+        *page_bytes = p - con_write_page;
+        return s - orig_s;
+}
+
+static void sunhv_console_write_paged(struct console *con, const char *s, unsigned n)
 {
+        struct uart_port *port = sunhv_port;
         unsigned long flags;
-        int limit = 1000000;
 
         spin_lock_irqsave(&port->lock, flags);
+        while (n > 0) {
+                unsigned long ra = __pa(con_write_page);
+                unsigned long page_bytes;
+                unsigned int cpy = fill_con_write_page(s, n,
+                                                       &page_bytes);
+
+                n -= cpy;
+                s += cpy;
+                while (page_bytes > 0) {
+                        unsigned long written;
+                        int limit = 1000000;
+
+                        while (limit--) {
+                                unsigned long stat;
+
+                                stat = sun4v_con_write(ra, page_bytes,
+                                                       &written);
+                                if (stat == HV_EOK)
+                                        break;
+                                udelay(1);
+                        }
+                        if (limit <= 0)
+                                break;
+                        page_bytes -= written;
+                        ra += written;
+                }
+        }
+        spin_unlock_irqrestore(&port->lock, flags);
+}
+
+static inline void sunhv_console_putchar(struct uart_port *port, char c)
+{
+        int limit = 1000000;
 
         while (limit-- > 0) {
-                long status = hypervisor_con_putchar(c);
+                long status = sun4v_con_putchar(c);
                 if (status == HV_EOK)
                         break;
-                udelay(2);
+                udelay(1);
         }
-
-        spin_unlock_irqrestore(&port->lock, flags);
 }
 
-static void sunhv_console_write(struct console *con, const char *s, unsigned n)
+static void sunhv_console_write_bychar(struct console *con, const char *s, unsigned n)
 {
         struct uart_port *port = sunhv_port;
+        unsigned long flags;
         int i;
 
+        spin_lock_irqsave(&port->lock, flags);
         for (i = 0; i < n; i++) {
                 if (*s == '\n')
                         sunhv_console_putchar(port, '\r');
                 sunhv_console_putchar(port, *s++);
         }
+        spin_unlock_irqrestore(&port->lock, flags);
 }
 
 static struct console sunhv_console = {
         .name   =       "ttyHV",
-        .write  =       sunhv_console_write,
+        .write  =       sunhv_console_write_bychar,
         .device =       uart_console_device,
         .flags  =       CON_PRINTBUFFER,
         .index  =       -1,
@@ -410,6 +521,7 @@ static inline struct console *SUNHV_CONSOLE(void)
 static int __devinit hv_probe(struct of_device *op, const struct of_device_id *match)
 {
         struct uart_port *port;
+        unsigned long minor;
         int err;
 
         if (op->irqs[0] == 0xffffffff)
@@ -419,6 +531,22 @@ static int __devinit hv_probe(struct of_device *op, const struct of_device_id *m
         if (unlikely(!port))
                 return -ENOMEM;
 
+        minor = 1;
+        if (sun4v_hvapi_register(HV_GRP_CORE, 1, &minor) == 0 &&
+            minor >= 1) {
+                err = -ENOMEM;
+                con_write_page = kzalloc(PAGE_SIZE, GFP_KERNEL);
+                if (!con_write_page)
+                        goto out_free_port;
+
+                con_read_page = kzalloc(PAGE_SIZE, GFP_KERNEL);
+                if (!con_read_page)
+                        goto out_free_con_write_page;
+
+                sunhv_console.write = sunhv_console_write_paged;
+                sunhv_ops = &bywrite_ops;
+        }
+
         sunhv_port = port;
 
         port->line = 0;
@@ -437,7 +565,7 @@ static int __devinit hv_probe(struct of_device *op, const struct of_device_id *m
 
         err = uart_register_driver(&sunhv_reg);
         if (err)
-                goto out_free_port;
+                goto out_free_con_read_page;
 
         sunhv_reg.tty_driver->name_base = sunhv_reg.minor - 64;
         sunserial_current_minor += 1;
@@ -463,6 +591,12 @@ out_unregister_driver:
         sunserial_current_minor -= 1;
         uart_unregister_driver(&sunhv_reg);
 
+out_free_con_read_page:
+        kfree(con_read_page);
+
+out_free_con_write_page:
+        kfree(con_write_page);
+
 out_free_port:
         kfree(port);
         sunhv_port = NULL;