mirror of
https://github.com/torvalds/linux
synced 2024-10-08 20:34:15 +00:00
2331e06865
Declare uart_ops structures as const as they are only stored in the ops field of an uart_port structure. This field is of type const, so uart_ops structures having this property can be made const too. File size details before and after patching. First line of every .o file shows the file size before patching and second line shows the size after patching. text data bss dec hex filename 2977 456 64 3497 da9 drivers/tty/serial/amba-pl010.o 3169 272 64 3505 db1 drivers/tty/serial/amba-pl010.o 3109 456 0 3565 ded drivers/tty/serial/efm32-uart.o 3301 272 0 3573 df5 drivers/tty/serial/efm32-uart.o 10668 753 1 11422 2c9e drivers/tty/serial/icom.o 10860 561 1 11422 2c9e drivers/tty/serial/icom.o 23904 408 8 24320 5f00 drivers/tty/serial/ioc3_serial.o 24088 224 8 24320 5f00 drivers/tty/serial/ioc3_serial.o 10516 560 4 11080 2b48 drivers/tty/serial/ioc4_serial.o 10709 368 4 11081 2b49 drivers/tty/serial/ioc4_serial.o 7853 648 1216 9717 25f5 drivers/tty/serial/mpsc.o 8037 456 1216 9709 25ed drivers/tty/serial/mpsc.o 10248 456 0 10704 29d0 drivers/tty/serial/omap-serial.o 10440 272 0 10712 29d8 drivers/tty/serial/omap-serial.o 8122 532 1984 10638 298e drivers/tty/serial/pmac_zilog.o 8306 340 1984 10630 2986 drivers/tty/serial/pmac_zilog.o 3808 456 0 4264 10a8 drivers/tty/serial/pxa.o 4000 264 0 4264 10a8 drivers/tty/serial/pxa.o 21781 3864 0 25645 642d drivers/tty/serial/serial-tegra.o 22037 3608 0 25645 642d drivers/tty/serial/serial-tegra.o 2481 456 96 3033 bd9 drivers/tty/serial/sprd_serial.o 2673 272 96 3041 be1 drivers/tty/serial/sprd_serial.o 5534 300 512 6346 18ca drivers/tty/serial/vr41xx_siu.o 5630 204 512 6346 18ca drivers/tty/serial/vr41xx_siu.o 6730 1576 128 8434 20f2 drivers/tty/serial/vt8500_serial.o 6986 1320 128 8434 20f2 drivers/tty/serial/vt8500_serial.o Cross compiled for mips architecture. 3005 488 0 3493 da5 drivers/tty/serial/pnx8xxx_uart.o 3189 304 0 3493 da5 drivers/tty/serial/pnx8xxx_uart.o 4272 196 1056 5524 1594 drivers/tty/serial/dz.o 4368 100 1056 5524 1594 drivers/tty/serial/dz.o 6551 144 16 6711 1a37 drivers/tty/serial/ip22zilog.o 6647 48 16 6711 1a37 drivers/tty/serial/ip22zilog.o 9612 428 1520 11560 2d28 drivers/tty/serial/serial_txx9.o 9708 332 1520 11560 2d28 drivers/tty/serial/serial_txx9.o 4156 296 16 4468 1174 drivers/tty/serial/ar933x_uart.o 4252 200 16 4468 1174 drivers/tty/serial/ar933x_uart.o Cross compiled for arm archiecture. 11716 1780 44 13540 34e4 drivers/tty/serial/sirfsoc_uart.o 11808 1688 44 13540 34e4 drivers/tty/serial/sirfsoc_uart.o 13352 596 56 14004 36b4 drivers/tty/serial/amba-pl011.o 13444 504 56 14004 36b4 drivers/tty/serial/amba-pl011.o Cross compiled for sparc architecture. 4664 528 32 5224 1468 drivers/tty/serial/sunhv.o 4848 344 32 5224 1468 drivers/tty/serial/sunhv.o 8080 332 28 8440 20f8 drivers/tty/serial/sunzilog.o 8184 228 28 8440 20f8 drivers/tty/serial/sunzilog.o Cross compiled for ia64 architecture. 10226 549 472 11247 2bef drivers/tty/serial/sn_console.o 10414 365 472 11251 2bf3 drivers/tty/serial/sn_console.o The files drivers/tty/serial/zs.o, drivers/tty/serial/lpc32xx_hs.o and drivers/tty/serial/lantiq.o did not compile. Signed-off-by: Bhumika Goyal <bhumirks@gmail.com> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
645 lines
13 KiB
C
645 lines
13 KiB
C
/* sunhv.c: Serial driver for SUN4V hypervisor console.
|
|
*
|
|
* Copyright (C) 2006, 2007 David S. Miller (davem@davemloft.net)
|
|
*/
|
|
|
|
#include <linux/kernel.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/tty.h>
|
|
#include <linux/tty_flip.h>
|
|
#include <linux/major.h>
|
|
#include <linux/circ_buf.h>
|
|
#include <linux/serial.h>
|
|
#include <linux/sysrq.h>
|
|
#include <linux/console.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/init.h>
|
|
#include <linux/of_device.h>
|
|
|
|
#include <asm/hypervisor.h>
|
|
#include <asm/spitfire.h>
|
|
#include <asm/prom.h>
|
|
#include <asm/irq.h>
|
|
#include <asm/setup.h>
|
|
|
|
#if defined(CONFIG_MAGIC_SYSRQ)
|
|
#define SUPPORT_SYSRQ
|
|
#endif
|
|
|
|
#include <linux/serial_core.h>
|
|
#include <linux/sunserialcore.h>
|
|
|
|
#define CON_BREAK ((long)-1)
|
|
#define CON_HUP ((long)-2)
|
|
|
|
#define IGNORE_BREAK 0x1
|
|
#define IGNORE_ALL 0x2
|
|
|
|
static char *con_write_page;
|
|
static char *con_read_page;
|
|
|
|
static int hung_up = 0;
|
|
|
|
static void transmit_chars_putchar(struct uart_port *port, struct circ_buf *xmit)
|
|
{
|
|
while (!uart_circ_empty(xmit)) {
|
|
long status = sun4v_con_putchar(xmit->buf[xmit->tail]);
|
|
|
|
if (status != HV_EOK)
|
|
break;
|
|
|
|
xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
|
|
port->icount.tx++;
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
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 int receive_chars_getchar(struct uart_port *port)
|
|
{
|
|
int saw_console_brk = 0;
|
|
int limit = 10000;
|
|
|
|
while (limit-- > 0) {
|
|
long status;
|
|
long c = sun4v_con_getchar(&status);
|
|
|
|
if (status == HV_EWOULDBLOCK)
|
|
break;
|
|
|
|
if (c == CON_BREAK) {
|
|
if (uart_handle_break(port))
|
|
continue;
|
|
saw_console_brk = 1;
|
|
c = 0;
|
|
}
|
|
|
|
if (c == CON_HUP) {
|
|
hung_up = 1;
|
|
uart_handle_dcd_change(port, 0);
|
|
} else if (hung_up) {
|
|
hung_up = 0;
|
|
uart_handle_dcd_change(port, 1);
|
|
}
|
|
|
|
if (port->state == NULL) {
|
|
uart_handle_sysrq_char(port, c);
|
|
continue;
|
|
}
|
|
|
|
port->icount.rx++;
|
|
|
|
if (uart_handle_sysrq_char(port, c))
|
|
continue;
|
|
|
|
tty_insert_flip_char(&port->state->port, c, TTY_NORMAL);
|
|
}
|
|
|
|
return saw_console_brk;
|
|
}
|
|
|
|
static int receive_chars_read(struct uart_port *port)
|
|
{
|
|
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);
|
|
}
|
|
|
|
if (port->sysrq != 0 && *con_read_page) {
|
|
for (i = 0; i < bytes_read; i++)
|
|
uart_handle_sysrq_char(port, con_read_page[i]);
|
|
}
|
|
|
|
if (port->state == NULL)
|
|
continue;
|
|
|
|
port->icount.rx += bytes_read;
|
|
|
|
tty_insert_flip_string(&port->state->port, con_read_page,
|
|
bytes_read);
|
|
}
|
|
|
|
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);
|
|
};
|
|
|
|
static const struct sunhv_ops bychar_ops = {
|
|
.transmit_chars = transmit_chars_putchar,
|
|
.receive_chars = receive_chars_getchar,
|
|
};
|
|
|
|
static const struct sunhv_ops bywrite_ops = {
|
|
.transmit_chars = transmit_chars_write,
|
|
.receive_chars = receive_chars_read,
|
|
};
|
|
|
|
static const struct sunhv_ops *sunhv_ops = &bychar_ops;
|
|
|
|
static struct tty_port *receive_chars(struct uart_port *port)
|
|
{
|
|
struct tty_port *tport = NULL;
|
|
|
|
if (port->state != NULL) /* Unopened serial console */
|
|
tport = &port->state->port;
|
|
|
|
if (sunhv_ops->receive_chars(port))
|
|
sun_do_break();
|
|
|
|
return tport;
|
|
}
|
|
|
|
static void transmit_chars(struct uart_port *port)
|
|
{
|
|
struct circ_buf *xmit;
|
|
|
|
if (!port->state)
|
|
return;
|
|
|
|
xmit = &port->state->xmit;
|
|
if (uart_circ_empty(xmit) || uart_tx_stopped(port))
|
|
return;
|
|
|
|
sunhv_ops->transmit_chars(port, xmit);
|
|
|
|
if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
|
|
uart_write_wakeup(port);
|
|
}
|
|
|
|
static irqreturn_t sunhv_interrupt(int irq, void *dev_id)
|
|
{
|
|
struct uart_port *port = dev_id;
|
|
struct tty_port *tport;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
tport = receive_chars(port);
|
|
transmit_chars(port);
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
|
|
if (tport)
|
|
tty_flip_buffer_push(tport);
|
|
|
|
return IRQ_HANDLED;
|
|
}
|
|
|
|
/* port->lock is not held. */
|
|
static unsigned int sunhv_tx_empty(struct uart_port *port)
|
|
{
|
|
/* Transmitter is always empty for us. If the circ buffer
|
|
* is non-empty or there is an x_char pending, our caller
|
|
* will do the right thing and ignore what we return here.
|
|
*/
|
|
return TIOCSER_TEMT;
|
|
}
|
|
|
|
/* port->lock held by caller. */
|
|
static void sunhv_set_mctrl(struct uart_port *port, unsigned int mctrl)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* port->lock is held by caller and interrupts are disabled. */
|
|
static unsigned int sunhv_get_mctrl(struct uart_port *port)
|
|
{
|
|
return TIOCM_DSR | TIOCM_CAR | TIOCM_CTS;
|
|
}
|
|
|
|
/* port->lock held by caller. */
|
|
static void sunhv_stop_tx(struct uart_port *port)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* port->lock held by caller. */
|
|
static void sunhv_start_tx(struct uart_port *port)
|
|
{
|
|
transmit_chars(port);
|
|
}
|
|
|
|
/* port->lock is not held. */
|
|
static void sunhv_send_xchar(struct uart_port *port, char ch)
|
|
{
|
|
unsigned long flags;
|
|
int limit = 10000;
|
|
|
|
if (ch == __DISABLED_CHAR)
|
|
return;
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
|
while (limit-- > 0) {
|
|
long status = sun4v_con_putchar(ch);
|
|
if (status == HV_EOK)
|
|
break;
|
|
udelay(1);
|
|
}
|
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
}
|
|
|
|
/* port->lock held by caller. */
|
|
static void sunhv_stop_rx(struct uart_port *port)
|
|
{
|
|
}
|
|
|
|
/* port->lock is not held. */
|
|
static void sunhv_break_ctl(struct uart_port *port, int break_state)
|
|
{
|
|
if (break_state) {
|
|
unsigned long flags;
|
|
int limit = 10000;
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
|
while (limit-- > 0) {
|
|
long status = sun4v_con_putchar(CON_BREAK);
|
|
if (status == HV_EOK)
|
|
break;
|
|
udelay(1);
|
|
}
|
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
}
|
|
}
|
|
|
|
/* port->lock is not held. */
|
|
static int sunhv_startup(struct uart_port *port)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/* port->lock is not held. */
|
|
static void sunhv_shutdown(struct uart_port *port)
|
|
{
|
|
}
|
|
|
|
/* port->lock is not held. */
|
|
static void sunhv_set_termios(struct uart_port *port, struct ktermios *termios,
|
|
struct ktermios *old)
|
|
{
|
|
unsigned int baud = uart_get_baud_rate(port, termios, old, 0, 4000000);
|
|
unsigned int quot = uart_get_divisor(port, baud);
|
|
unsigned int iflag, cflag;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
|
iflag = termios->c_iflag;
|
|
cflag = termios->c_cflag;
|
|
|
|
port->ignore_status_mask = 0;
|
|
if (iflag & IGNBRK)
|
|
port->ignore_status_mask |= IGNORE_BREAK;
|
|
if ((cflag & CREAD) == 0)
|
|
port->ignore_status_mask |= IGNORE_ALL;
|
|
|
|
/* XXX */
|
|
uart_update_timeout(port, cflag,
|
|
(port->uartclk / (16 * quot)));
|
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
}
|
|
|
|
static const char *sunhv_type(struct uart_port *port)
|
|
{
|
|
return "SUN4V HCONS";
|
|
}
|
|
|
|
static void sunhv_release_port(struct uart_port *port)
|
|
{
|
|
}
|
|
|
|
static int sunhv_request_port(struct uart_port *port)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static void sunhv_config_port(struct uart_port *port, int flags)
|
|
{
|
|
}
|
|
|
|
static int sunhv_verify_port(struct uart_port *port, struct serial_struct *ser)
|
|
{
|
|
return -EINVAL;
|
|
}
|
|
|
|
static const struct uart_ops sunhv_pops = {
|
|
.tx_empty = sunhv_tx_empty,
|
|
.set_mctrl = sunhv_set_mctrl,
|
|
.get_mctrl = sunhv_get_mctrl,
|
|
.stop_tx = sunhv_stop_tx,
|
|
.start_tx = sunhv_start_tx,
|
|
.send_xchar = sunhv_send_xchar,
|
|
.stop_rx = sunhv_stop_rx,
|
|
.break_ctl = sunhv_break_ctl,
|
|
.startup = sunhv_startup,
|
|
.shutdown = sunhv_shutdown,
|
|
.set_termios = sunhv_set_termios,
|
|
.type = sunhv_type,
|
|
.release_port = sunhv_release_port,
|
|
.request_port = sunhv_request_port,
|
|
.config_port = sunhv_config_port,
|
|
.verify_port = sunhv_verify_port,
|
|
};
|
|
|
|
static struct uart_driver sunhv_reg = {
|
|
.owner = THIS_MODULE,
|
|
.driver_name = "sunhv",
|
|
.dev_name = "ttyS",
|
|
.major = TTY_MAJOR,
|
|
};
|
|
|
|
static struct uart_port *sunhv_port;
|
|
|
|
/* 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 locked = 1;
|
|
|
|
if (port->sysrq || oops_in_progress)
|
|
locked = spin_trylock_irqsave(&port->lock, flags);
|
|
else
|
|
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;
|
|
}
|
|
}
|
|
|
|
if (locked)
|
|
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 = sun4v_con_putchar(c);
|
|
if (status == HV_EOK)
|
|
break;
|
|
udelay(1);
|
|
}
|
|
}
|
|
|
|
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, locked = 1;
|
|
|
|
if (port->sysrq || oops_in_progress)
|
|
locked = spin_trylock_irqsave(&port->lock, flags);
|
|
else
|
|
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++);
|
|
}
|
|
|
|
if (locked)
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
}
|
|
|
|
static struct console sunhv_console = {
|
|
.name = "ttyHV",
|
|
.write = sunhv_console_write_bychar,
|
|
.device = uart_console_device,
|
|
.flags = CON_PRINTBUFFER,
|
|
.index = -1,
|
|
.data = &sunhv_reg,
|
|
};
|
|
|
|
static int hv_probe(struct platform_device *op)
|
|
{
|
|
struct uart_port *port;
|
|
unsigned long minor;
|
|
int err;
|
|
|
|
if (op->archdata.irqs[0] == 0xffffffff)
|
|
return -ENODEV;
|
|
|
|
port = kzalloc(sizeof(struct uart_port), GFP_KERNEL);
|
|
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;
|
|
port->ops = &sunhv_pops;
|
|
port->type = PORT_SUNHV;
|
|
port->uartclk = ( 29491200 / 16 ); /* arbitrary */
|
|
|
|
port->membase = (unsigned char __iomem *) __pa(port);
|
|
|
|
port->irq = op->archdata.irqs[0];
|
|
|
|
port->dev = &op->dev;
|
|
|
|
err = sunserial_register_minors(&sunhv_reg, 1);
|
|
if (err)
|
|
goto out_free_con_read_page;
|
|
|
|
sunserial_console_match(&sunhv_console, op->dev.of_node,
|
|
&sunhv_reg, port->line, false);
|
|
|
|
err = uart_add_one_port(&sunhv_reg, port);
|
|
if (err)
|
|
goto out_unregister_driver;
|
|
|
|
err = request_irq(port->irq, sunhv_interrupt, 0, "hvcons", port);
|
|
if (err)
|
|
goto out_remove_port;
|
|
|
|
platform_set_drvdata(op, port);
|
|
|
|
return 0;
|
|
|
|
out_remove_port:
|
|
uart_remove_one_port(&sunhv_reg, port);
|
|
|
|
out_unregister_driver:
|
|
sunserial_unregister_minors(&sunhv_reg, 1);
|
|
|
|
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;
|
|
return err;
|
|
}
|
|
|
|
static int hv_remove(struct platform_device *dev)
|
|
{
|
|
struct uart_port *port = platform_get_drvdata(dev);
|
|
|
|
free_irq(port->irq, port);
|
|
|
|
uart_remove_one_port(&sunhv_reg, port);
|
|
|
|
sunserial_unregister_minors(&sunhv_reg, 1);
|
|
kfree(con_read_page);
|
|
kfree(con_write_page);
|
|
kfree(port);
|
|
sunhv_port = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct of_device_id hv_match[] = {
|
|
{
|
|
.name = "console",
|
|
.compatible = "qcn",
|
|
},
|
|
{
|
|
.name = "console",
|
|
.compatible = "SUNW,sun4v-console",
|
|
},
|
|
{},
|
|
};
|
|
|
|
static struct platform_driver hv_driver = {
|
|
.driver = {
|
|
.name = "hv",
|
|
.of_match_table = hv_match,
|
|
},
|
|
.probe = hv_probe,
|
|
.remove = hv_remove,
|
|
};
|
|
|
|
static int __init sunhv_init(void)
|
|
{
|
|
if (tlb_type != hypervisor)
|
|
return -ENODEV;
|
|
|
|
return platform_driver_register(&hv_driver);
|
|
}
|
|
device_initcall(sunhv_init);
|
|
|
|
#if 0 /* ...def MODULE ; never supported as such */
|
|
MODULE_AUTHOR("David S. Miller");
|
|
MODULE_DESCRIPTION("SUN4V Hypervisor console driver");
|
|
MODULE_VERSION("2.0");
|
|
MODULE_LICENSE("GPL");
|
|
#endif
|