You've already forked linux-apfs
mirror of
https://github.com/linux-apfs/linux-apfs.git
synced 2026-05-01 15:00:59 -07:00
Merge branch 'tty-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty-2.6
* 'tty-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty-2.6: tty: update MAINTAINERS file due to driver movement tty: move drivers/serial/ to drivers/tty/serial/ tty: move hvc drivers to drivers/tty/hvc/
This commit is contained in:
Linus Torvalds
@@ -426,7 +426,7 @@ config SGI_MBCS
|
||||
If you have an SGI Altix with an attached SABrick
|
||||
say Y or M here, otherwise say N.
|
||||
|
||||
source "drivers/serial/Kconfig"
|
||||
source "drivers/tty/serial/Kconfig"
|
||||
|
||||
config UNIX98_PTYS
|
||||
bool "Unix98 PTY support" if EMBEDDED
|
||||
|
||||
@@ -30,25 +30,12 @@ obj-$(CONFIG_SYNCLINK_GT) += synclink_gt.o
|
||||
obj-$(CONFIG_AMIGA_BUILTIN_SERIAL) += amiserial.o
|
||||
obj-$(CONFIG_SX) += sx.o generic_serial.o
|
||||
obj-$(CONFIG_RIO) += rio/ generic_serial.o
|
||||
obj-$(CONFIG_HVC_CONSOLE) += hvc_vio.o hvsi.o
|
||||
obj-$(CONFIG_HVC_ISERIES) += hvc_iseries.o
|
||||
obj-$(CONFIG_HVC_RTAS) += hvc_rtas.o
|
||||
obj-$(CONFIG_HVC_TILE) += hvc_tile.o
|
||||
obj-$(CONFIG_HVC_DCC) += hvc_dcc.o
|
||||
obj-$(CONFIG_HVC_BEAT) += hvc_beat.o
|
||||
obj-$(CONFIG_HVC_DRIVER) += hvc_console.o
|
||||
obj-$(CONFIG_HVC_IRQ) += hvc_irq.o
|
||||
obj-$(CONFIG_HVC_XEN) += hvc_xen.o
|
||||
obj-$(CONFIG_HVC_IUCV) += hvc_iucv.o
|
||||
obj-$(CONFIG_HVC_UDBG) += hvc_udbg.o
|
||||
obj-$(CONFIG_VIRTIO_CONSOLE) += virtio_console.o
|
||||
obj-$(CONFIG_RAW_DRIVER) += raw.o
|
||||
obj-$(CONFIG_SGI_SNSC) += snsc.o snsc_event.o
|
||||
obj-$(CONFIG_MSPEC) += mspec.o
|
||||
obj-$(CONFIG_MMTIMER) += mmtimer.o
|
||||
obj-$(CONFIG_UV_MMTIMER) += uv_mmtimer.o
|
||||
obj-$(CONFIG_VIOTAPE) += viotape.o
|
||||
obj-$(CONFIG_HVCS) += hvcs.o
|
||||
obj-$(CONFIG_IBM_BSR) += bsr.o
|
||||
obj-$(CONFIG_SGI_MBCS) += mbcs.o
|
||||
obj-$(CONFIG_BRIQ_PANEL) += briq_panel.o
|
||||
|
||||
@@ -1,134 +0,0 @@
|
||||
/*
|
||||
* Beat hypervisor console driver
|
||||
*
|
||||
* (C) Copyright 2006 TOSHIBA CORPORATION
|
||||
*
|
||||
* This code is based on drivers/char/hvc_rtas.c:
|
||||
* (C) Copyright IBM Corporation 2001-2005
|
||||
* (C) Copyright Red Hat, Inc. 2005
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/console.h>
|
||||
#include <asm/prom.h>
|
||||
#include <asm/hvconsole.h>
|
||||
#include <asm/firmware.h>
|
||||
|
||||
#include "hvc_console.h"
|
||||
|
||||
extern int64_t beat_get_term_char(uint64_t, uint64_t *, uint64_t *, uint64_t *);
|
||||
extern int64_t beat_put_term_char(uint64_t, uint64_t, uint64_t, uint64_t);
|
||||
|
||||
struct hvc_struct *hvc_beat_dev = NULL;
|
||||
|
||||
/* bug: only one queue is available regardless of vtermno */
|
||||
static int hvc_beat_get_chars(uint32_t vtermno, char *buf, int cnt)
|
||||
{
|
||||
static unsigned char q[sizeof(unsigned long) * 2]
|
||||
__attribute__((aligned(sizeof(unsigned long))));
|
||||
static int qlen = 0;
|
||||
u64 got;
|
||||
|
||||
again:
|
||||
if (qlen) {
|
||||
if (qlen > cnt) {
|
||||
memcpy(buf, q, cnt);
|
||||
qlen -= cnt;
|
||||
memmove(q + cnt, q, qlen);
|
||||
return cnt;
|
||||
} else { /* qlen <= cnt */
|
||||
int r;
|
||||
|
||||
memcpy(buf, q, qlen);
|
||||
r = qlen;
|
||||
qlen = 0;
|
||||
return r;
|
||||
}
|
||||
}
|
||||
if (beat_get_term_char(vtermno, &got,
|
||||
((u64 *)q), ((u64 *)q) + 1) == 0) {
|
||||
qlen = got;
|
||||
goto again;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int hvc_beat_put_chars(uint32_t vtermno, const char *buf, int cnt)
|
||||
{
|
||||
unsigned long kb[2];
|
||||
int rest, nlen;
|
||||
|
||||
for (rest = cnt; rest > 0; rest -= nlen) {
|
||||
nlen = (rest > 16) ? 16 : rest;
|
||||
memcpy(kb, buf, nlen);
|
||||
beat_put_term_char(vtermno, nlen, kb[0], kb[1]);
|
||||
buf += nlen;
|
||||
}
|
||||
return cnt;
|
||||
}
|
||||
|
||||
static const struct hv_ops hvc_beat_get_put_ops = {
|
||||
.get_chars = hvc_beat_get_chars,
|
||||
.put_chars = hvc_beat_put_chars,
|
||||
};
|
||||
|
||||
static int hvc_beat_useit = 1;
|
||||
|
||||
static int hvc_beat_config(char *p)
|
||||
{
|
||||
hvc_beat_useit = simple_strtoul(p, NULL, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __init hvc_beat_console_init(void)
|
||||
{
|
||||
if (hvc_beat_useit && of_machine_is_compatible("Beat")) {
|
||||
hvc_instantiate(0, 0, &hvc_beat_get_put_ops);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* temp */
|
||||
static int __init hvc_beat_init(void)
|
||||
{
|
||||
struct hvc_struct *hp;
|
||||
|
||||
if (!firmware_has_feature(FW_FEATURE_BEAT))
|
||||
return -ENODEV;
|
||||
|
||||
hp = hvc_alloc(0, NO_IRQ, &hvc_beat_get_put_ops, 16);
|
||||
if (IS_ERR(hp))
|
||||
return PTR_ERR(hp);
|
||||
hvc_beat_dev = hp;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void __exit hvc_beat_exit(void)
|
||||
{
|
||||
if (hvc_beat_dev)
|
||||
hvc_remove(hvc_beat_dev);
|
||||
}
|
||||
|
||||
module_init(hvc_beat_init);
|
||||
module_exit(hvc_beat_exit);
|
||||
|
||||
__setup("hvc_beat=", hvc_beat_config);
|
||||
|
||||
console_initcall(hvc_beat_console_init);
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,119 +0,0 @@
|
||||
/*
|
||||
* hvc_console.h
|
||||
* Copyright (C) 2005 IBM Corporation
|
||||
*
|
||||
* Author(s):
|
||||
* Ryan S. Arnold <rsa@us.ibm.com>
|
||||
*
|
||||
* hvc_console header information:
|
||||
* moved here from arch/powerpc/include/asm/hvconsole.h
|
||||
* and drivers/char/hvc_console.c
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#ifndef HVC_CONSOLE_H
|
||||
#define HVC_CONSOLE_H
|
||||
#include <linux/kref.h>
|
||||
#include <linux/tty.h>
|
||||
#include <linux/spinlock.h>
|
||||
|
||||
/*
|
||||
* This is the max number of console adapters that can/will be found as
|
||||
* console devices on first stage console init. Any number beyond this range
|
||||
* can't be used as a console device but is still a valid tty device.
|
||||
*/
|
||||
#define MAX_NR_HVC_CONSOLES 16
|
||||
|
||||
/*
|
||||
* The Linux TTY code does not support dynamic addition of tty derived devices
|
||||
* so we need to know how many tty devices we might need when space is allocated
|
||||
* for the tty device. Since this driver supports hotplug of vty adapters we
|
||||
* need to make sure we have enough allocated.
|
||||
*/
|
||||
#define HVC_ALLOC_TTY_ADAPTERS 8
|
||||
|
||||
struct hvc_struct {
|
||||
spinlock_t lock;
|
||||
int index;
|
||||
struct tty_struct *tty;
|
||||
int count;
|
||||
int do_wakeup;
|
||||
char *outbuf;
|
||||
int outbuf_size;
|
||||
int n_outbuf;
|
||||
uint32_t vtermno;
|
||||
const struct hv_ops *ops;
|
||||
int irq_requested;
|
||||
int data;
|
||||
struct winsize ws;
|
||||
struct work_struct tty_resize;
|
||||
struct list_head next;
|
||||
struct kref kref; /* ref count & hvc_struct lifetime */
|
||||
};
|
||||
|
||||
/* implemented by a low level driver */
|
||||
struct hv_ops {
|
||||
int (*get_chars)(uint32_t vtermno, char *buf, int count);
|
||||
int (*put_chars)(uint32_t vtermno, const char *buf, int count);
|
||||
|
||||
/* Callbacks for notification. Called in open, close and hangup */
|
||||
int (*notifier_add)(struct hvc_struct *hp, int irq);
|
||||
void (*notifier_del)(struct hvc_struct *hp, int irq);
|
||||
void (*notifier_hangup)(struct hvc_struct *hp, int irq);
|
||||
};
|
||||
|
||||
/* Register a vterm and a slot index for use as a console (console_init) */
|
||||
extern int hvc_instantiate(uint32_t vtermno, int index,
|
||||
const struct hv_ops *ops);
|
||||
|
||||
/* register a vterm for hvc tty operation (module_init or hotplug add) */
|
||||
extern struct hvc_struct * hvc_alloc(uint32_t vtermno, int data,
|
||||
const struct hv_ops *ops, int outbuf_size);
|
||||
/* remove a vterm from hvc tty operation (module_exit or hotplug remove) */
|
||||
extern int hvc_remove(struct hvc_struct *hp);
|
||||
|
||||
/* data available */
|
||||
int hvc_poll(struct hvc_struct *hp);
|
||||
void hvc_kick(void);
|
||||
|
||||
/* Resize hvc tty terminal window */
|
||||
extern void __hvc_resize(struct hvc_struct *hp, struct winsize ws);
|
||||
|
||||
static inline void hvc_resize(struct hvc_struct *hp, struct winsize ws)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&hp->lock, flags);
|
||||
__hvc_resize(hp, ws);
|
||||
spin_unlock_irqrestore(&hp->lock, flags);
|
||||
}
|
||||
|
||||
/* default notifier for irq based notification */
|
||||
extern int notifier_add_irq(struct hvc_struct *hp, int data);
|
||||
extern void notifier_del_irq(struct hvc_struct *hp, int data);
|
||||
extern void notifier_hangup_irq(struct hvc_struct *hp, int data);
|
||||
|
||||
|
||||
#if defined(CONFIG_XMON) && defined(CONFIG_SMP)
|
||||
#include <asm/xmon.h>
|
||||
#else
|
||||
static inline int cpus_are_in_xmon(void)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // HVC_CONSOLE_H
|
||||
@@ -1,133 +0,0 @@
|
||||
/* Copyright (c) 2010, Code Aurora Forum. All rights reserved.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 and
|
||||
* only version 2 as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
||||
* 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <linux/console.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/moduleparam.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
#include <asm/processor.h>
|
||||
|
||||
#include "hvc_console.h"
|
||||
|
||||
/* DCC Status Bits */
|
||||
#define DCC_STATUS_RX (1 << 30)
|
||||
#define DCC_STATUS_TX (1 << 29)
|
||||
|
||||
static inline u32 __dcc_getstatus(void)
|
||||
{
|
||||
u32 __ret;
|
||||
|
||||
asm("mrc p14, 0, %0, c0, c1, 0 @ read comms ctrl reg"
|
||||
: "=r" (__ret) : : "cc");
|
||||
|
||||
return __ret;
|
||||
}
|
||||
|
||||
|
||||
#if defined(CONFIG_CPU_V7)
|
||||
static inline char __dcc_getchar(void)
|
||||
{
|
||||
char __c;
|
||||
|
||||
asm("get_wait: mrc p14, 0, pc, c0, c1, 0 \n\
|
||||
bne get_wait \n\
|
||||
mrc p14, 0, %0, c0, c5, 0 @ read comms data reg"
|
||||
: "=r" (__c) : : "cc");
|
||||
|
||||
return __c;
|
||||
}
|
||||
#else
|
||||
static inline char __dcc_getchar(void)
|
||||
{
|
||||
char __c;
|
||||
|
||||
asm("mrc p14, 0, %0, c0, c5, 0 @ read comms data reg"
|
||||
: "=r" (__c));
|
||||
|
||||
return __c;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(CONFIG_CPU_V7)
|
||||
static inline void __dcc_putchar(char c)
|
||||
{
|
||||
asm("put_wait: mrc p14, 0, pc, c0, c1, 0 \n\
|
||||
bcs put_wait \n\
|
||||
mcr p14, 0, %0, c0, c5, 0 "
|
||||
: : "r" (c) : "cc");
|
||||
}
|
||||
#else
|
||||
static inline void __dcc_putchar(char c)
|
||||
{
|
||||
asm("mcr p14, 0, %0, c0, c5, 0 @ write a char"
|
||||
: /* no output register */
|
||||
: "r" (c));
|
||||
}
|
||||
#endif
|
||||
|
||||
static int hvc_dcc_put_chars(uint32_t vt, const char *buf, int count)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
while (__dcc_getstatus() & DCC_STATUS_TX)
|
||||
cpu_relax();
|
||||
|
||||
__dcc_putchar((char)(buf[i] & 0xFF));
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
static int hvc_dcc_get_chars(uint32_t vt, char *buf, int count)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < count; ++i) {
|
||||
int c = -1;
|
||||
|
||||
if (__dcc_getstatus() & DCC_STATUS_RX)
|
||||
c = __dcc_getchar();
|
||||
if (c < 0)
|
||||
break;
|
||||
buf[i] = c;
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
static const struct hv_ops hvc_dcc_get_put_ops = {
|
||||
.get_chars = hvc_dcc_get_chars,
|
||||
.put_chars = hvc_dcc_put_chars,
|
||||
};
|
||||
|
||||
static int __init hvc_dcc_console_init(void)
|
||||
{
|
||||
hvc_instantiate(0, 0, &hvc_dcc_get_put_ops);
|
||||
return 0;
|
||||
}
|
||||
console_initcall(hvc_dcc_console_init);
|
||||
|
||||
static int __init hvc_dcc_init(void)
|
||||
{
|
||||
hvc_alloc(0, 0, &hvc_dcc_get_put_ops, 128);
|
||||
return 0;
|
||||
}
|
||||
device_initcall(hvc_dcc_init);
|
||||
@@ -1,49 +0,0 @@
|
||||
/*
|
||||
* Copyright IBM Corp. 2001,2008
|
||||
*
|
||||
* This file contains the IRQ specific code for hvc_console
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/interrupt.h>
|
||||
|
||||
#include "hvc_console.h"
|
||||
|
||||
static irqreturn_t hvc_handle_interrupt(int irq, void *dev_instance)
|
||||
{
|
||||
/* if hvc_poll request a repoll, then kick the hvcd thread */
|
||||
if (hvc_poll(dev_instance))
|
||||
hvc_kick();
|
||||
return IRQ_HANDLED;
|
||||
}
|
||||
|
||||
/*
|
||||
* For IRQ based systems these callbacks can be used
|
||||
*/
|
||||
int notifier_add_irq(struct hvc_struct *hp, int irq)
|
||||
{
|
||||
int rc;
|
||||
|
||||
if (!irq) {
|
||||
hp->irq_requested = 0;
|
||||
return 0;
|
||||
}
|
||||
rc = request_irq(irq, hvc_handle_interrupt, IRQF_DISABLED,
|
||||
"hvc_console", hp);
|
||||
if (!rc)
|
||||
hp->irq_requested = 1;
|
||||
return rc;
|
||||
}
|
||||
|
||||
void notifier_del_irq(struct hvc_struct *hp, int irq)
|
||||
{
|
||||
if (!hp->irq_requested)
|
||||
return;
|
||||
free_irq(irq, hp);
|
||||
hp->irq_requested = 0;
|
||||
}
|
||||
|
||||
void notifier_hangup_irq(struct hvc_struct *hp, int irq)
|
||||
{
|
||||
notifier_del_irq(hp, irq);
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,133 +0,0 @@
|
||||
/*
|
||||
* IBM RTAS driver interface to hvc_console.c
|
||||
*
|
||||
* (C) Copyright IBM Corporation 2001-2005
|
||||
* (C) Copyright Red Hat, Inc. 2005
|
||||
*
|
||||
* Author(s): Maximino Augilar <IBM STI Design Center>
|
||||
* : Ryan S. Arnold <rsa@us.ibm.com>
|
||||
* : Utz Bacher <utz.bacher@de.ibm.com>
|
||||
* : David Woodhouse <dwmw2@infradead.org>
|
||||
*
|
||||
* inspired by drivers/char/hvc_console.c
|
||||
* written by Anton Blanchard and Paul Mackerras
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <linux/console.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/moduleparam.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
#include <asm/irq.h>
|
||||
#include <asm/rtas.h>
|
||||
#include "hvc_console.h"
|
||||
|
||||
#define hvc_rtas_cookie 0x67781e15
|
||||
struct hvc_struct *hvc_rtas_dev;
|
||||
|
||||
static int rtascons_put_char_token = RTAS_UNKNOWN_SERVICE;
|
||||
static int rtascons_get_char_token = RTAS_UNKNOWN_SERVICE;
|
||||
|
||||
static inline int hvc_rtas_write_console(uint32_t vtermno, const char *buf,
|
||||
int count)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
if (rtas_call(rtascons_put_char_token, 1, 1, NULL, buf[i]))
|
||||
break;
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
static int hvc_rtas_read_console(uint32_t vtermno, char *buf, int count)
|
||||
{
|
||||
int i, c;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
if (rtas_call(rtascons_get_char_token, 0, 2, &c))
|
||||
break;
|
||||
|
||||
buf[i] = c;
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
static const struct hv_ops hvc_rtas_get_put_ops = {
|
||||
.get_chars = hvc_rtas_read_console,
|
||||
.put_chars = hvc_rtas_write_console,
|
||||
};
|
||||
|
||||
static int __init hvc_rtas_init(void)
|
||||
{
|
||||
struct hvc_struct *hp;
|
||||
|
||||
if (rtascons_put_char_token == RTAS_UNKNOWN_SERVICE)
|
||||
rtascons_put_char_token = rtas_token("put-term-char");
|
||||
if (rtascons_put_char_token == RTAS_UNKNOWN_SERVICE)
|
||||
return -EIO;
|
||||
|
||||
if (rtascons_get_char_token == RTAS_UNKNOWN_SERVICE)
|
||||
rtascons_get_char_token = rtas_token("get-term-char");
|
||||
if (rtascons_get_char_token == RTAS_UNKNOWN_SERVICE)
|
||||
return -EIO;
|
||||
|
||||
BUG_ON(hvc_rtas_dev);
|
||||
|
||||
/* Allocate an hvc_struct for the console device we instantiated
|
||||
* earlier. Save off hp so that we can return it on exit */
|
||||
hp = hvc_alloc(hvc_rtas_cookie, NO_IRQ, &hvc_rtas_get_put_ops, 16);
|
||||
if (IS_ERR(hp))
|
||||
return PTR_ERR(hp);
|
||||
|
||||
hvc_rtas_dev = hp;
|
||||
|
||||
return 0;
|
||||
}
|
||||
module_init(hvc_rtas_init);
|
||||
|
||||
/* This will tear down the tty portion of the driver */
|
||||
static void __exit hvc_rtas_exit(void)
|
||||
{
|
||||
/* Really the fun isn't over until the worker thread breaks down and
|
||||
* the tty cleans up */
|
||||
if (hvc_rtas_dev)
|
||||
hvc_remove(hvc_rtas_dev);
|
||||
}
|
||||
module_exit(hvc_rtas_exit);
|
||||
|
||||
/* This will happen prior to module init. There is no tty at this time? */
|
||||
static int __init hvc_rtas_console_init(void)
|
||||
{
|
||||
rtascons_put_char_token = rtas_token("put-term-char");
|
||||
if (rtascons_put_char_token == RTAS_UNKNOWN_SERVICE)
|
||||
return -EIO;
|
||||
|
||||
rtascons_get_char_token = rtas_token("get-term-char");
|
||||
if (rtascons_get_char_token == RTAS_UNKNOWN_SERVICE)
|
||||
return -EIO;
|
||||
|
||||
hvc_instantiate(hvc_rtas_cookie, 0, &hvc_rtas_get_put_ops);
|
||||
add_preferred_console("hvc", 0, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
console_initcall(hvc_rtas_console_init);
|
||||
@@ -1,68 +0,0 @@
|
||||
/*
|
||||
* Copyright 2010 Tilera Corporation. All Rights Reserved.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or
|
||||
* modify it under the terms of the GNU General Public License
|
||||
* as published by the Free Software Foundation, version 2.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful, but
|
||||
* WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or
|
||||
* NON INFRINGEMENT. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* Tilera TILE Processor hypervisor console
|
||||
*/
|
||||
|
||||
#include <linux/console.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/moduleparam.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
#include <hv/hypervisor.h>
|
||||
|
||||
#include "hvc_console.h"
|
||||
|
||||
static int hvc_tile_put_chars(uint32_t vt, const char *buf, int count)
|
||||
{
|
||||
return hv_console_write((HV_VirtAddr)buf, count);
|
||||
}
|
||||
|
||||
static int hvc_tile_get_chars(uint32_t vt, char *buf, int count)
|
||||
{
|
||||
int i, c;
|
||||
|
||||
for (i = 0; i < count; ++i) {
|
||||
c = hv_console_read_if_ready();
|
||||
if (c < 0)
|
||||
break;
|
||||
buf[i] = c;
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
static const struct hv_ops hvc_tile_get_put_ops = {
|
||||
.get_chars = hvc_tile_get_chars,
|
||||
.put_chars = hvc_tile_put_chars,
|
||||
};
|
||||
|
||||
static int __init hvc_tile_console_init(void)
|
||||
{
|
||||
extern void disable_early_printk(void);
|
||||
hvc_instantiate(0, 0, &hvc_tile_get_put_ops);
|
||||
add_preferred_console("hvc", 0, NULL);
|
||||
disable_early_printk();
|
||||
return 0;
|
||||
}
|
||||
console_initcall(hvc_tile_console_init);
|
||||
|
||||
static int __init hvc_tile_init(void)
|
||||
{
|
||||
struct hvc_struct *s;
|
||||
s = hvc_alloc(0, 0, &hvc_tile_get_put_ops, 128);
|
||||
return IS_ERR(s) ? PTR_ERR(s) : 0;
|
||||
}
|
||||
device_initcall(hvc_tile_init);
|
||||
@@ -1,96 +0,0 @@
|
||||
/*
|
||||
* udbg interface to hvc_console.c
|
||||
*
|
||||
* (C) Copyright David Gibson, IBM Corporation 2008.
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <linux/console.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/moduleparam.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/irq.h>
|
||||
|
||||
#include <asm/udbg.h>
|
||||
|
||||
#include "hvc_console.h"
|
||||
|
||||
struct hvc_struct *hvc_udbg_dev;
|
||||
|
||||
static int hvc_udbg_put(uint32_t vtermno, const char *buf, int count)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < count; i++)
|
||||
udbg_putc(buf[i]);
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
static int hvc_udbg_get(uint32_t vtermno, char *buf, int count)
|
||||
{
|
||||
int i, c;
|
||||
|
||||
if (!udbg_getc_poll)
|
||||
return 0;
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
if ((c = udbg_getc_poll()) == -1)
|
||||
break;
|
||||
buf[i] = c;
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
static const struct hv_ops hvc_udbg_ops = {
|
||||
.get_chars = hvc_udbg_get,
|
||||
.put_chars = hvc_udbg_put,
|
||||
};
|
||||
|
||||
static int __init hvc_udbg_init(void)
|
||||
{
|
||||
struct hvc_struct *hp;
|
||||
|
||||
BUG_ON(hvc_udbg_dev);
|
||||
|
||||
hp = hvc_alloc(0, NO_IRQ, &hvc_udbg_ops, 16);
|
||||
if (IS_ERR(hp))
|
||||
return PTR_ERR(hp);
|
||||
|
||||
hvc_udbg_dev = hp;
|
||||
|
||||
return 0;
|
||||
}
|
||||
module_init(hvc_udbg_init);
|
||||
|
||||
static void __exit hvc_udbg_exit(void)
|
||||
{
|
||||
if (hvc_udbg_dev)
|
||||
hvc_remove(hvc_udbg_dev);
|
||||
}
|
||||
module_exit(hvc_udbg_exit);
|
||||
|
||||
static int __init hvc_udbg_console_init(void)
|
||||
{
|
||||
hvc_instantiate(0, 0, &hvc_udbg_ops);
|
||||
add_preferred_console("hvc", 0, NULL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
console_initcall(hvc_udbg_console_init);
|
||||
@@ -1,173 +0,0 @@
|
||||
/*
|
||||
* vio driver interface to hvc_console.c
|
||||
*
|
||||
* This code was moved here to allow the remaing code to be reused as a
|
||||
* generic polling mode with semi-reliable transport driver core to the
|
||||
* console and tty subsystems.
|
||||
*
|
||||
*
|
||||
* Copyright (C) 2001 Anton Blanchard <anton@au.ibm.com>, IBM
|
||||
* Copyright (C) 2001 Paul Mackerras <paulus@au.ibm.com>, IBM
|
||||
* Copyright (C) 2004 Benjamin Herrenschmidt <benh@kernel.crashing.org>, IBM Corp.
|
||||
* Copyright (C) 2004 IBM Corporation
|
||||
*
|
||||
* Additional Author(s):
|
||||
* Ryan S. Arnold <rsa@us.ibm.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/init.h>
|
||||
|
||||
#include <asm/hvconsole.h>
|
||||
#include <asm/vio.h>
|
||||
#include <asm/prom.h>
|
||||
#include <asm/firmware.h>
|
||||
|
||||
#include "hvc_console.h"
|
||||
|
||||
static const char hvc_driver_name[] = "hvc_console";
|
||||
|
||||
static struct vio_device_id hvc_driver_table[] __devinitdata = {
|
||||
{"serial", "hvterm1"},
|
||||
{ "", "" }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(vio, hvc_driver_table);
|
||||
|
||||
static int filtered_get_chars(uint32_t vtermno, char *buf, int count)
|
||||
{
|
||||
unsigned long got;
|
||||
int i;
|
||||
|
||||
/*
|
||||
* Vio firmware will read up to SIZE_VIO_GET_CHARS at its own discretion
|
||||
* so we play safe and avoid the situation where got > count which could
|
||||
* overload the flip buffer.
|
||||
*/
|
||||
if (count < SIZE_VIO_GET_CHARS)
|
||||
return -EAGAIN;
|
||||
|
||||
got = hvc_get_chars(vtermno, buf, count);
|
||||
|
||||
/*
|
||||
* Work around a HV bug where it gives us a null
|
||||
* after every \r. -- paulus
|
||||
*/
|
||||
for (i = 1; i < got; ++i) {
|
||||
if (buf[i] == 0 && buf[i-1] == '\r') {
|
||||
--got;
|
||||
if (i < got)
|
||||
memmove(&buf[i], &buf[i+1],
|
||||
got - i);
|
||||
}
|
||||
}
|
||||
return got;
|
||||
}
|
||||
|
||||
static const struct hv_ops hvc_get_put_ops = {
|
||||
.get_chars = filtered_get_chars,
|
||||
.put_chars = hvc_put_chars,
|
||||
.notifier_add = notifier_add_irq,
|
||||
.notifier_del = notifier_del_irq,
|
||||
.notifier_hangup = notifier_hangup_irq,
|
||||
};
|
||||
|
||||
static int __devinit hvc_vio_probe(struct vio_dev *vdev,
|
||||
const struct vio_device_id *id)
|
||||
{
|
||||
struct hvc_struct *hp;
|
||||
|
||||
/* probed with invalid parameters. */
|
||||
if (!vdev || !id)
|
||||
return -EPERM;
|
||||
|
||||
hp = hvc_alloc(vdev->unit_address, vdev->irq, &hvc_get_put_ops,
|
||||
MAX_VIO_PUT_CHARS);
|
||||
if (IS_ERR(hp))
|
||||
return PTR_ERR(hp);
|
||||
dev_set_drvdata(&vdev->dev, hp);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int __devexit hvc_vio_remove(struct vio_dev *vdev)
|
||||
{
|
||||
struct hvc_struct *hp = dev_get_drvdata(&vdev->dev);
|
||||
|
||||
return hvc_remove(hp);
|
||||
}
|
||||
|
||||
static struct vio_driver hvc_vio_driver = {
|
||||
.id_table = hvc_driver_table,
|
||||
.probe = hvc_vio_probe,
|
||||
.remove = __devexit_p(hvc_vio_remove),
|
||||
.driver = {
|
||||
.name = hvc_driver_name,
|
||||
.owner = THIS_MODULE,
|
||||
}
|
||||
};
|
||||
|
||||
static int __init hvc_vio_init(void)
|
||||
{
|
||||
int rc;
|
||||
|
||||
if (firmware_has_feature(FW_FEATURE_ISERIES))
|
||||
return -EIO;
|
||||
|
||||
/* Register as a vio device to receive callbacks */
|
||||
rc = vio_register_driver(&hvc_vio_driver);
|
||||
|
||||
return rc;
|
||||
}
|
||||
module_init(hvc_vio_init); /* after drivers/char/hvc_console.c */
|
||||
|
||||
static void __exit hvc_vio_exit(void)
|
||||
{
|
||||
vio_unregister_driver(&hvc_vio_driver);
|
||||
}
|
||||
module_exit(hvc_vio_exit);
|
||||
|
||||
/* the device tree order defines our numbering */
|
||||
static int hvc_find_vtys(void)
|
||||
{
|
||||
struct device_node *vty;
|
||||
int num_found = 0;
|
||||
|
||||
for (vty = of_find_node_by_name(NULL, "vty"); vty != NULL;
|
||||
vty = of_find_node_by_name(vty, "vty")) {
|
||||
const uint32_t *vtermno;
|
||||
|
||||
/* We have statically defined space for only a certain number
|
||||
* of console adapters.
|
||||
*/
|
||||
if (num_found >= MAX_NR_HVC_CONSOLES) {
|
||||
of_node_put(vty);
|
||||
break;
|
||||
}
|
||||
|
||||
vtermno = of_get_property(vty, "reg", NULL);
|
||||
if (!vtermno)
|
||||
continue;
|
||||
|
||||
if (of_device_is_compatible(vty, "hvterm1")) {
|
||||
hvc_instantiate(*vtermno, num_found, &hvc_get_put_ops);
|
||||
++num_found;
|
||||
}
|
||||
}
|
||||
|
||||
return num_found;
|
||||
}
|
||||
console_initcall(hvc_find_vtys);
|
||||
@@ -1,271 +0,0 @@
|
||||
/*
|
||||
* xen console driver interface to hvc_console.c
|
||||
*
|
||||
* (c) 2007 Gerd Hoffmann <kraxel@suse.de>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||||
*/
|
||||
|
||||
#include <linux/console.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/types.h>
|
||||
|
||||
#include <asm/xen/hypervisor.h>
|
||||
|
||||
#include <xen/xen.h>
|
||||
#include <xen/page.h>
|
||||
#include <xen/events.h>
|
||||
#include <xen/interface/io/console.h>
|
||||
#include <xen/hvc-console.h>
|
||||
|
||||
#include "hvc_console.h"
|
||||
|
||||
#define HVC_COOKIE 0x58656e /* "Xen" in hex */
|
||||
|
||||
static struct hvc_struct *hvc;
|
||||
static int xencons_irq;
|
||||
|
||||
/* ------------------------------------------------------------------ */
|
||||
|
||||
static unsigned long console_pfn = ~0ul;
|
||||
|
||||
static inline struct xencons_interface *xencons_interface(void)
|
||||
{
|
||||
if (console_pfn == ~0ul)
|
||||
return mfn_to_virt(xen_start_info->console.domU.mfn);
|
||||
else
|
||||
return __va(console_pfn << PAGE_SHIFT);
|
||||
}
|
||||
|
||||
static inline void notify_daemon(void)
|
||||
{
|
||||
/* Use evtchn: this is called early, before irq is set up. */
|
||||
notify_remote_via_evtchn(xen_start_info->console.domU.evtchn);
|
||||
}
|
||||
|
||||
static int __write_console(const char *data, int len)
|
||||
{
|
||||
struct xencons_interface *intf = xencons_interface();
|
||||
XENCONS_RING_IDX cons, prod;
|
||||
int sent = 0;
|
||||
|
||||
cons = intf->out_cons;
|
||||
prod = intf->out_prod;
|
||||
mb(); /* update queue values before going on */
|
||||
BUG_ON((prod - cons) > sizeof(intf->out));
|
||||
|
||||
while ((sent < len) && ((prod - cons) < sizeof(intf->out)))
|
||||
intf->out[MASK_XENCONS_IDX(prod++, intf->out)] = data[sent++];
|
||||
|
||||
wmb(); /* write ring before updating pointer */
|
||||
intf->out_prod = prod;
|
||||
|
||||
if (sent)
|
||||
notify_daemon();
|
||||
return sent;
|
||||
}
|
||||
|
||||
static int domU_write_console(uint32_t vtermno, const char *data, int len)
|
||||
{
|
||||
int ret = len;
|
||||
|
||||
/*
|
||||
* Make sure the whole buffer is emitted, polling if
|
||||
* necessary. We don't ever want to rely on the hvc daemon
|
||||
* because the most interesting console output is when the
|
||||
* kernel is crippled.
|
||||
*/
|
||||
while (len) {
|
||||
int sent = __write_console(data, len);
|
||||
|
||||
data += sent;
|
||||
len -= sent;
|
||||
|
||||
if (unlikely(len))
|
||||
HYPERVISOR_sched_op(SCHEDOP_yield, NULL);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int domU_read_console(uint32_t vtermno, char *buf, int len)
|
||||
{
|
||||
struct xencons_interface *intf = xencons_interface();
|
||||
XENCONS_RING_IDX cons, prod;
|
||||
int recv = 0;
|
||||
|
||||
cons = intf->in_cons;
|
||||
prod = intf->in_prod;
|
||||
mb(); /* get pointers before reading ring */
|
||||
BUG_ON((prod - cons) > sizeof(intf->in));
|
||||
|
||||
while (cons != prod && recv < len)
|
||||
buf[recv++] = intf->in[MASK_XENCONS_IDX(cons++, intf->in)];
|
||||
|
||||
mb(); /* read ring before consuming */
|
||||
intf->in_cons = cons;
|
||||
|
||||
notify_daemon();
|
||||
return recv;
|
||||
}
|
||||
|
||||
static struct hv_ops domU_hvc_ops = {
|
||||
.get_chars = domU_read_console,
|
||||
.put_chars = domU_write_console,
|
||||
.notifier_add = notifier_add_irq,
|
||||
.notifier_del = notifier_del_irq,
|
||||
.notifier_hangup = notifier_hangup_irq,
|
||||
};
|
||||
|
||||
static int dom0_read_console(uint32_t vtermno, char *buf, int len)
|
||||
{
|
||||
return HYPERVISOR_console_io(CONSOLEIO_read, len, buf);
|
||||
}
|
||||
|
||||
/*
|
||||
* Either for a dom0 to write to the system console, or a domU with a
|
||||
* debug version of Xen
|
||||
*/
|
||||
static int dom0_write_console(uint32_t vtermno, const char *str, int len)
|
||||
{
|
||||
int rc = HYPERVISOR_console_io(CONSOLEIO_write, len, (char *)str);
|
||||
if (rc < 0)
|
||||
return 0;
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
static struct hv_ops dom0_hvc_ops = {
|
||||
.get_chars = dom0_read_console,
|
||||
.put_chars = dom0_write_console,
|
||||
.notifier_add = notifier_add_irq,
|
||||
.notifier_del = notifier_del_irq,
|
||||
.notifier_hangup = notifier_hangup_irq,
|
||||
};
|
||||
|
||||
static int __init xen_hvc_init(void)
|
||||
{
|
||||
struct hvc_struct *hp;
|
||||
struct hv_ops *ops;
|
||||
|
||||
if (!xen_pv_domain())
|
||||
return -ENODEV;
|
||||
|
||||
if (xen_initial_domain()) {
|
||||
ops = &dom0_hvc_ops;
|
||||
xencons_irq = bind_virq_to_irq(VIRQ_CONSOLE, 0);
|
||||
} else {
|
||||
if (!xen_start_info->console.domU.evtchn)
|
||||
return -ENODEV;
|
||||
|
||||
ops = &domU_hvc_ops;
|
||||
xencons_irq = bind_evtchn_to_irq(xen_start_info->console.domU.evtchn);
|
||||
}
|
||||
if (xencons_irq < 0)
|
||||
xencons_irq = 0; /* NO_IRQ */
|
||||
|
||||
hp = hvc_alloc(HVC_COOKIE, xencons_irq, ops, 256);
|
||||
if (IS_ERR(hp))
|
||||
return PTR_ERR(hp);
|
||||
|
||||
hvc = hp;
|
||||
|
||||
console_pfn = mfn_to_pfn(xen_start_info->console.domU.mfn);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void xen_console_resume(void)
|
||||
{
|
||||
if (xencons_irq)
|
||||
rebind_evtchn_irq(xen_start_info->console.domU.evtchn, xencons_irq);
|
||||
}
|
||||
|
||||
static void __exit xen_hvc_fini(void)
|
||||
{
|
||||
if (hvc)
|
||||
hvc_remove(hvc);
|
||||
}
|
||||
|
||||
static int xen_cons_init(void)
|
||||
{
|
||||
struct hv_ops *ops;
|
||||
|
||||
if (!xen_pv_domain())
|
||||
return 0;
|
||||
|
||||
if (xen_initial_domain())
|
||||
ops = &dom0_hvc_ops;
|
||||
else
|
||||
ops = &domU_hvc_ops;
|
||||
|
||||
hvc_instantiate(HVC_COOKIE, 0, ops);
|
||||
return 0;
|
||||
}
|
||||
|
||||
module_init(xen_hvc_init);
|
||||
module_exit(xen_hvc_fini);
|
||||
console_initcall(xen_cons_init);
|
||||
|
||||
#ifdef CONFIG_EARLY_PRINTK
|
||||
static void xenboot_write_console(struct console *console, const char *string,
|
||||
unsigned len)
|
||||
{
|
||||
unsigned int linelen, off = 0;
|
||||
const char *pos;
|
||||
|
||||
dom0_write_console(0, string, len);
|
||||
|
||||
if (xen_initial_domain())
|
||||
return;
|
||||
|
||||
domU_write_console(0, "(early) ", 8);
|
||||
while (off < len && NULL != (pos = strchr(string+off, '\n'))) {
|
||||
linelen = pos-string+off;
|
||||
if (off + linelen > len)
|
||||
break;
|
||||
domU_write_console(0, string+off, linelen);
|
||||
domU_write_console(0, "\r\n", 2);
|
||||
off += linelen + 1;
|
||||
}
|
||||
if (off < len)
|
||||
domU_write_console(0, string+off, len-off);
|
||||
}
|
||||
|
||||
struct console xenboot_console = {
|
||||
.name = "xenboot",
|
||||
.write = xenboot_write_console,
|
||||
.flags = CON_PRINTBUFFER | CON_BOOT | CON_ANYTIME,
|
||||
};
|
||||
#endif /* CONFIG_EARLY_PRINTK */
|
||||
|
||||
void xen_raw_console_write(const char *str)
|
||||
{
|
||||
dom0_write_console(0, str, strlen(str));
|
||||
}
|
||||
|
||||
void xen_raw_printk(const char *fmt, ...)
|
||||
{
|
||||
static char buf[512];
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
vsnprintf(buf, sizeof(buf), fmt, ap);
|
||||
va_end(ap);
|
||||
|
||||
xen_raw_console_write(buf);
|
||||
}
|
||||
-1604
File diff suppressed because it is too large
Load Diff
-1314
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user