mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-30 03:27:44 -04:00
Merge branch 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc
* 'next' of git://git.kernel.org/pub/scm/linux/kernel/git/benh/powerpc: (99 commits) drivers/virt: add missing linux/interrupt.h to fsl_hypervisor.c powerpc/85xx: fix mpic configuration in CAMP mode powerpc: Copy back TIF flags on return from softirq stack powerpc/64: Make server perfmon only built on ppc64 server devices powerpc/pseries: Fix hvc_vio.c build due to recent changes powerpc: Exporting boot_cpuid_phys powerpc: Add CFAR to oops output hvc_console: Add kdb support powerpc/pseries: Fix hvterm_raw_get_chars to accept < 16 chars, fixing xmon powerpc/irq: Quieten irq mapping printks powerpc: Enable lockup and hung task detectors in pseries and ppc64 defeconfigs powerpc: Add mpt2sas driver to pseries and ppc64 defconfig powerpc: Disable IRQs off tracer in ppc64 defconfig powerpc: Sync pseries and ppc64 defconfigs powerpc/pseries/hvconsole: Fix dropped console output hvc_console: Improve tty/console put_chars handling powerpc/kdump: Fix timeout in crash_kexec_wait_realmode powerpc/mm: Fix output of total_ram. powerpc/cpufreq: Add cpufreq driver for Momentum Maple boards powerpc: Correct annotations of pmu registration functions ... Fix up trivial Kconfig/Makefile conflicts in arch/powerpc, drivers, and drivers/cpufreq
This commit is contained in:
Linus Torvalds
commit
184475029a
152 changed files with 10498 additions and 1441 deletions
|
|
@ -19,6 +19,11 @@ config HVC_CONSOLE
|
|||
console. This driver allows each pSeries partition to have a console
|
||||
which is accessed via the HMC.
|
||||
|
||||
config HVC_OLD_HVSI
|
||||
bool "Old driver for pSeries serial port (/dev/hvsi*)"
|
||||
depends on HVC_CONSOLE
|
||||
default n
|
||||
|
||||
config HVC_ISERIES
|
||||
bool "iSeries Hypervisor Virtual Console support"
|
||||
depends on PPC_ISERIES
|
||||
|
|
|
|||
|
|
@ -1,4 +1,5 @@
|
|||
obj-$(CONFIG_HVC_CONSOLE) += hvc_vio.o hvsi.o
|
||||
obj-$(CONFIG_HVC_CONSOLE) += hvc_vio.o hvsi_lib.o
|
||||
obj-$(CONFIG_HVC_OLD_HVSI) += hvsi.o
|
||||
obj-$(CONFIG_HVC_ISERIES) += hvc_iseries.o
|
||||
obj-$(CONFIG_HVC_RTAS) += hvc_rtas.o
|
||||
obj-$(CONFIG_HVC_TILE) += hvc_tile.o
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@
|
|||
#include <linux/delay.h>
|
||||
#include <linux/freezer.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/serial_core.h>
|
||||
|
||||
#include <asm/uaccess.h>
|
||||
|
||||
|
|
@ -163,8 +164,10 @@ static void hvc_console_print(struct console *co, const char *b,
|
|||
} else {
|
||||
r = cons_ops[index]->put_chars(vtermnos[index], c, i);
|
||||
if (r <= 0) {
|
||||
/* throw away chars on error */
|
||||
i = 0;
|
||||
/* throw away characters on error
|
||||
* but spin in case of -EAGAIN */
|
||||
if (r != -EAGAIN)
|
||||
i = 0;
|
||||
} else if (r > 0) {
|
||||
i -= r;
|
||||
if (i > 0)
|
||||
|
|
@ -184,7 +187,7 @@ static struct tty_driver *hvc_console_device(struct console *c, int *index)
|
|||
}
|
||||
|
||||
static int __init hvc_console_setup(struct console *co, char *options)
|
||||
{
|
||||
{
|
||||
if (co->index < 0 || co->index >= MAX_NR_HVC_CONSOLES)
|
||||
return -ENODEV;
|
||||
|
||||
|
|
@ -448,7 +451,7 @@ static int hvc_push(struct hvc_struct *hp)
|
|||
|
||||
n = hp->ops->put_chars(hp->vtermno, hp->outbuf, hp->n_outbuf);
|
||||
if (n <= 0) {
|
||||
if (n == 0) {
|
||||
if (n == 0 || n == -EAGAIN) {
|
||||
hp->do_wakeup = 1;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -745,6 +748,58 @@ static int khvcd(void *unused)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int hvc_tiocmget(struct tty_struct *tty)
|
||||
{
|
||||
struct hvc_struct *hp = tty->driver_data;
|
||||
|
||||
if (!hp || !hp->ops->tiocmget)
|
||||
return -EINVAL;
|
||||
return hp->ops->tiocmget(hp);
|
||||
}
|
||||
|
||||
static int hvc_tiocmset(struct tty_struct *tty,
|
||||
unsigned int set, unsigned int clear)
|
||||
{
|
||||
struct hvc_struct *hp = tty->driver_data;
|
||||
|
||||
if (!hp || !hp->ops->tiocmset)
|
||||
return -EINVAL;
|
||||
return hp->ops->tiocmset(hp, set, clear);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_CONSOLE_POLL
|
||||
int hvc_poll_init(struct tty_driver *driver, int line, char *options)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int hvc_poll_get_char(struct tty_driver *driver, int line)
|
||||
{
|
||||
struct tty_struct *tty = driver->ttys[0];
|
||||
struct hvc_struct *hp = tty->driver_data;
|
||||
int n;
|
||||
char ch;
|
||||
|
||||
n = hp->ops->get_chars(hp->vtermno, &ch, 1);
|
||||
|
||||
if (n == 0)
|
||||
return NO_POLL_CHAR;
|
||||
|
||||
return ch;
|
||||
}
|
||||
|
||||
static void hvc_poll_put_char(struct tty_driver *driver, int line, char ch)
|
||||
{
|
||||
struct tty_struct *tty = driver->ttys[0];
|
||||
struct hvc_struct *hp = tty->driver_data;
|
||||
int n;
|
||||
|
||||
do {
|
||||
n = hp->ops->put_chars(hp->vtermno, &ch, 1);
|
||||
} while (n <= 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
static const struct tty_operations hvc_ops = {
|
||||
.open = hvc_open,
|
||||
.close = hvc_close,
|
||||
|
|
@ -753,6 +808,13 @@ static const struct tty_operations hvc_ops = {
|
|||
.unthrottle = hvc_unthrottle,
|
||||
.write_room = hvc_write_room,
|
||||
.chars_in_buffer = hvc_chars_in_buffer,
|
||||
.tiocmget = hvc_tiocmget,
|
||||
.tiocmset = hvc_tiocmset,
|
||||
#ifdef CONFIG_CONSOLE_POLL
|
||||
.poll_init = hvc_poll_init,
|
||||
.poll_get_char = hvc_poll_get_char,
|
||||
.poll_put_char = hvc_poll_put_char,
|
||||
#endif
|
||||
};
|
||||
|
||||
struct hvc_struct *hvc_alloc(uint32_t vtermno, int data,
|
||||
|
|
|
|||
|
|
@ -73,6 +73,10 @@ struct hv_ops {
|
|||
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);
|
||||
|
||||
/* tiocmget/set implementation */
|
||||
int (*tiocmget)(struct hvc_struct *hp);
|
||||
int (*tiocmset)(struct hvc_struct *hp, unsigned int set, unsigned int clear);
|
||||
};
|
||||
|
||||
/* Register a vterm and a slot index for use as a console (console_init) */
|
||||
|
|
|
|||
|
|
@ -27,15 +27,27 @@
|
|||
* 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
|
||||
*
|
||||
* TODO:
|
||||
*
|
||||
* - handle error in sending hvsi protocol packets
|
||||
* - retry nego on subsequent sends ?
|
||||
*/
|
||||
|
||||
#undef DEBUG
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/console.h>
|
||||
|
||||
#include <asm/hvconsole.h>
|
||||
#include <asm/vio.h>
|
||||
#include <asm/prom.h>
|
||||
#include <asm/firmware.h>
|
||||
#include <asm/hvsi.h>
|
||||
#include <asm/udbg.h>
|
||||
|
||||
#include "hvc_console.h"
|
||||
|
||||
|
|
@ -43,59 +55,236 @@ static const char hvc_driver_name[] = "hvc_console";
|
|||
|
||||
static struct vio_device_id hvc_driver_table[] __devinitdata = {
|
||||
{"serial", "hvterm1"},
|
||||
#ifndef HVC_OLD_HVSI
|
||||
{"serial", "hvterm-protocol"},
|
||||
#endif
|
||||
{ "", "" }
|
||||
};
|
||||
MODULE_DEVICE_TABLE(vio, hvc_driver_table);
|
||||
|
||||
static int filtered_get_chars(uint32_t vtermno, char *buf, int count)
|
||||
typedef enum hv_protocol {
|
||||
HV_PROTOCOL_RAW,
|
||||
HV_PROTOCOL_HVSI
|
||||
} hv_protocol_t;
|
||||
|
||||
struct hvterm_priv {
|
||||
u32 termno; /* HV term number */
|
||||
hv_protocol_t proto; /* Raw data or HVSI packets */
|
||||
struct hvsi_priv hvsi; /* HVSI specific data */
|
||||
spinlock_t buf_lock;
|
||||
char buf[SIZE_VIO_GET_CHARS];
|
||||
int left;
|
||||
int offset;
|
||||
};
|
||||
static struct hvterm_priv *hvterm_privs[MAX_NR_HVC_CONSOLES];
|
||||
/* For early boot console */
|
||||
static struct hvterm_priv hvterm_priv0;
|
||||
|
||||
static int hvterm_raw_get_chars(uint32_t vtermno, char *buf, int count)
|
||||
{
|
||||
unsigned long got;
|
||||
int i;
|
||||
struct hvterm_priv *pv = hvterm_privs[vtermno];
|
||||
unsigned long i;
|
||||
unsigned long flags;
|
||||
int got;
|
||||
|
||||
/*
|
||||
* 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;
|
||||
if (WARN_ON(!pv))
|
||||
return 0;
|
||||
|
||||
got = hvc_get_chars(vtermno, buf, count);
|
||||
spin_lock_irqsave(&pv->buf_lock, flags);
|
||||
|
||||
/*
|
||||
* 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);
|
||||
if (pv->left == 0) {
|
||||
pv->offset = 0;
|
||||
pv->left = hvc_get_chars(pv->termno, pv->buf, count);
|
||||
|
||||
/*
|
||||
* Work around a HV bug where it gives us a null
|
||||
* after every \r. -- paulus
|
||||
*/
|
||||
for (i = 1; i < pv->left; ++i) {
|
||||
if (pv->buf[i] == 0 && pv->buf[i-1] == '\r') {
|
||||
--pv->left;
|
||||
if (i < pv->left) {
|
||||
memmove(&pv->buf[i], &pv->buf[i+1],
|
||||
pv->left - i);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
got = min(count, pv->left);
|
||||
memcpy(buf, &pv->buf[pv->offset], got);
|
||||
pv->offset += got;
|
||||
pv->left -= got;
|
||||
|
||||
spin_unlock_irqrestore(&pv->buf_lock, flags);
|
||||
|
||||
return got;
|
||||
}
|
||||
|
||||
static const struct hv_ops hvc_get_put_ops = {
|
||||
.get_chars = filtered_get_chars,
|
||||
.put_chars = hvc_put_chars,
|
||||
static int hvterm_raw_put_chars(uint32_t vtermno, const char *buf, int count)
|
||||
{
|
||||
struct hvterm_priv *pv = hvterm_privs[vtermno];
|
||||
|
||||
if (WARN_ON(!pv))
|
||||
return 0;
|
||||
|
||||
return hvc_put_chars(pv->termno, buf, count);
|
||||
}
|
||||
|
||||
static const struct hv_ops hvterm_raw_ops = {
|
||||
.get_chars = hvterm_raw_get_chars,
|
||||
.put_chars = hvterm_raw_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)
|
||||
static int hvterm_hvsi_get_chars(uint32_t vtermno, char *buf, int count)
|
||||
{
|
||||
struct hvterm_priv *pv = hvterm_privs[vtermno];
|
||||
|
||||
if (WARN_ON(!pv))
|
||||
return 0;
|
||||
|
||||
return hvsilib_get_chars(&pv->hvsi, buf, count);
|
||||
}
|
||||
|
||||
static int hvterm_hvsi_put_chars(uint32_t vtermno, const char *buf, int count)
|
||||
{
|
||||
struct hvterm_priv *pv = hvterm_privs[vtermno];
|
||||
|
||||
if (WARN_ON(!pv))
|
||||
return 0;
|
||||
|
||||
return hvsilib_put_chars(&pv->hvsi, buf, count);
|
||||
}
|
||||
|
||||
static int hvterm_hvsi_open(struct hvc_struct *hp, int data)
|
||||
{
|
||||
struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
|
||||
int rc;
|
||||
|
||||
pr_devel("HVSI@%x: open !\n", pv->termno);
|
||||
|
||||
rc = notifier_add_irq(hp, data);
|
||||
if (rc)
|
||||
return rc;
|
||||
|
||||
return hvsilib_open(&pv->hvsi, hp);
|
||||
}
|
||||
|
||||
static void hvterm_hvsi_close(struct hvc_struct *hp, int data)
|
||||
{
|
||||
struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
|
||||
|
||||
pr_devel("HVSI@%x: do close !\n", pv->termno);
|
||||
|
||||
hvsilib_close(&pv->hvsi, hp);
|
||||
|
||||
notifier_del_irq(hp, data);
|
||||
}
|
||||
|
||||
void hvterm_hvsi_hangup(struct hvc_struct *hp, int data)
|
||||
{
|
||||
struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
|
||||
|
||||
pr_devel("HVSI@%x: do hangup !\n", pv->termno);
|
||||
|
||||
hvsilib_close(&pv->hvsi, hp);
|
||||
|
||||
notifier_hangup_irq(hp, data);
|
||||
}
|
||||
|
||||
static int hvterm_hvsi_tiocmget(struct hvc_struct *hp)
|
||||
{
|
||||
struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
|
||||
|
||||
if (!pv)
|
||||
return -EINVAL;
|
||||
return pv->hvsi.mctrl;
|
||||
}
|
||||
|
||||
static int hvterm_hvsi_tiocmset(struct hvc_struct *hp, unsigned int set,
|
||||
unsigned int clear)
|
||||
{
|
||||
struct hvterm_priv *pv = hvterm_privs[hp->vtermno];
|
||||
|
||||
pr_devel("HVSI@%x: Set modem control, set=%x,clr=%x\n",
|
||||
pv->termno, set, clear);
|
||||
|
||||
if (set & TIOCM_DTR)
|
||||
hvsilib_write_mctrl(&pv->hvsi, 1);
|
||||
else if (clear & TIOCM_DTR)
|
||||
hvsilib_write_mctrl(&pv->hvsi, 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct hv_ops hvterm_hvsi_ops = {
|
||||
.get_chars = hvterm_hvsi_get_chars,
|
||||
.put_chars = hvterm_hvsi_put_chars,
|
||||
.notifier_add = hvterm_hvsi_open,
|
||||
.notifier_del = hvterm_hvsi_close,
|
||||
.notifier_hangup = hvterm_hvsi_hangup,
|
||||
.tiocmget = hvterm_hvsi_tiocmget,
|
||||
.tiocmset = hvterm_hvsi_tiocmset,
|
||||
};
|
||||
|
||||
static int __devinit hvc_vio_probe(struct vio_dev *vdev,
|
||||
const struct vio_device_id *id)
|
||||
{
|
||||
const struct hv_ops *ops;
|
||||
struct hvc_struct *hp;
|
||||
struct hvterm_priv *pv;
|
||||
hv_protocol_t proto;
|
||||
int i, termno = -1;
|
||||
|
||||
/* 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 (of_device_is_compatible(vdev->dev.of_node, "hvterm1")) {
|
||||
proto = HV_PROTOCOL_RAW;
|
||||
ops = &hvterm_raw_ops;
|
||||
} else if (of_device_is_compatible(vdev->dev.of_node, "hvterm-protocol")) {
|
||||
proto = HV_PROTOCOL_HVSI;
|
||||
ops = &hvterm_hvsi_ops;
|
||||
} else {
|
||||
pr_err("hvc_vio: Unkown protocol for %s\n", vdev->dev.of_node->full_name);
|
||||
return -ENXIO;
|
||||
}
|
||||
|
||||
pr_devel("hvc_vio_probe() device %s, using %s protocol\n",
|
||||
vdev->dev.of_node->full_name,
|
||||
proto == HV_PROTOCOL_RAW ? "raw" : "hvsi");
|
||||
|
||||
/* Is it our boot one ? */
|
||||
if (hvterm_privs[0] == &hvterm_priv0 &&
|
||||
vdev->unit_address == hvterm_priv0.termno) {
|
||||
pv = hvterm_privs[0];
|
||||
termno = 0;
|
||||
pr_devel("->boot console, using termno 0\n");
|
||||
}
|
||||
/* nope, allocate a new one */
|
||||
else {
|
||||
for (i = 0; i < MAX_NR_HVC_CONSOLES && termno < 0; i++)
|
||||
if (!hvterm_privs[i])
|
||||
termno = i;
|
||||
pr_devel("->non-boot console, using termno %d\n", termno);
|
||||
if (termno < 0)
|
||||
return -ENODEV;
|
||||
pv = kzalloc(sizeof(struct hvterm_priv), GFP_KERNEL);
|
||||
if (!pv)
|
||||
return -ENOMEM;
|
||||
pv->termno = vdev->unit_address;
|
||||
pv->proto = proto;
|
||||
spin_lock_init(&pv->buf_lock);
|
||||
hvterm_privs[termno] = pv;
|
||||
hvsilib_init(&pv->hvsi, hvc_get_chars, hvc_put_chars,
|
||||
pv->termno, 0);
|
||||
}
|
||||
|
||||
hp = hvc_alloc(termno, vdev->irq, ops, MAX_VIO_PUT_CHARS);
|
||||
if (IS_ERR(hp))
|
||||
return PTR_ERR(hp);
|
||||
dev_set_drvdata(&vdev->dev, hp);
|
||||
|
|
@ -106,8 +295,16 @@ static int __devinit hvc_vio_probe(struct vio_dev *vdev,
|
|||
static int __devexit hvc_vio_remove(struct vio_dev *vdev)
|
||||
{
|
||||
struct hvc_struct *hp = dev_get_drvdata(&vdev->dev);
|
||||
int rc, termno;
|
||||
|
||||
return hvc_remove(hp);
|
||||
termno = hp->vtermno;
|
||||
rc = hvc_remove(hp);
|
||||
if (rc == 0) {
|
||||
if (hvterm_privs[termno] != &hvterm_priv0)
|
||||
kfree(hvterm_privs[termno]);
|
||||
hvterm_privs[termno] = NULL;
|
||||
}
|
||||
return rc;
|
||||
}
|
||||
|
||||
static struct vio_driver hvc_vio_driver = {
|
||||
|
|
@ -140,34 +337,149 @@ static void __exit hvc_vio_exit(void)
|
|||
}
|
||||
module_exit(hvc_vio_exit);
|
||||
|
||||
/* the device tree order defines our numbering */
|
||||
static int hvc_find_vtys(void)
|
||||
static void udbg_hvc_putc(char c)
|
||||
{
|
||||
struct device_node *vty;
|
||||
int num_found = 0;
|
||||
int count = -1;
|
||||
|
||||
for (vty = of_find_node_by_name(NULL, "vty"); vty != NULL;
|
||||
vty = of_find_node_by_name(vty, "vty")) {
|
||||
const uint32_t *vtermno;
|
||||
if (c == '\n')
|
||||
udbg_hvc_putc('\r');
|
||||
|
||||
/* We have statically defined space for only a certain number
|
||||
* of console adapters.
|
||||
*/
|
||||
if (num_found >= MAX_NR_HVC_CONSOLES) {
|
||||
of_node_put(vty);
|
||||
do {
|
||||
switch(hvterm_priv0.proto) {
|
||||
case HV_PROTOCOL_RAW:
|
||||
count = hvterm_raw_put_chars(0, &c, 1);
|
||||
break;
|
||||
case HV_PROTOCOL_HVSI:
|
||||
count = hvterm_hvsi_put_chars(0, &c, 1);
|
||||
break;
|
||||
}
|
||||
} while(count == 0);
|
||||
}
|
||||
|
||||
vtermno = of_get_property(vty, "reg", NULL);
|
||||
if (!vtermno)
|
||||
continue;
|
||||
static int udbg_hvc_getc_poll(void)
|
||||
{
|
||||
int rc = 0;
|
||||
char c;
|
||||
|
||||
if (of_device_is_compatible(vty, "hvterm1")) {
|
||||
hvc_instantiate(*vtermno, num_found, &hvc_get_put_ops);
|
||||
++num_found;
|
||||
switch(hvterm_priv0.proto) {
|
||||
case HV_PROTOCOL_RAW:
|
||||
rc = hvterm_raw_get_chars(0, &c, 1);
|
||||
break;
|
||||
case HV_PROTOCOL_HVSI:
|
||||
rc = hvterm_hvsi_get_chars(0, &c, 1);
|
||||
break;
|
||||
}
|
||||
if (!rc)
|
||||
return -1;
|
||||
return c;
|
||||
}
|
||||
|
||||
static int udbg_hvc_getc(void)
|
||||
{
|
||||
int ch;
|
||||
for (;;) {
|
||||
ch = udbg_hvc_getc_poll();
|
||||
if (ch == -1) {
|
||||
/* This shouldn't be needed...but... */
|
||||
volatile unsigned long delay;
|
||||
for (delay=0; delay < 2000000; delay++)
|
||||
;
|
||||
} else {
|
||||
return ch;
|
||||
}
|
||||
}
|
||||
|
||||
return num_found;
|
||||
}
|
||||
console_initcall(hvc_find_vtys);
|
||||
|
||||
void __init hvc_vio_init_early(void)
|
||||
{
|
||||
struct device_node *stdout_node;
|
||||
const u32 *termno;
|
||||
const char *name;
|
||||
const struct hv_ops *ops;
|
||||
|
||||
/* find the boot console from /chosen/stdout */
|
||||
if (!of_chosen)
|
||||
return;
|
||||
name = of_get_property(of_chosen, "linux,stdout-path", NULL);
|
||||
if (name == NULL)
|
||||
return;
|
||||
stdout_node = of_find_node_by_path(name);
|
||||
if (!stdout_node)
|
||||
return;
|
||||
name = of_get_property(stdout_node, "name", NULL);
|
||||
if (!name) {
|
||||
printk(KERN_WARNING "stdout node missing 'name' property!\n");
|
||||
goto out;
|
||||
}
|
||||
|
||||
/* Check if it's a virtual terminal */
|
||||
if (strncmp(name, "vty", 3) != 0)
|
||||
goto out;
|
||||
termno = of_get_property(stdout_node, "reg", NULL);
|
||||
if (termno == NULL)
|
||||
goto out;
|
||||
hvterm_priv0.termno = *termno;
|
||||
spin_lock_init(&hvterm_priv0.buf_lock);
|
||||
hvterm_privs[0] = &hvterm_priv0;
|
||||
|
||||
/* Check the protocol */
|
||||
if (of_device_is_compatible(stdout_node, "hvterm1")) {
|
||||
hvterm_priv0.proto = HV_PROTOCOL_RAW;
|
||||
ops = &hvterm_raw_ops;
|
||||
}
|
||||
else if (of_device_is_compatible(stdout_node, "hvterm-protocol")) {
|
||||
hvterm_priv0.proto = HV_PROTOCOL_HVSI;
|
||||
ops = &hvterm_hvsi_ops;
|
||||
hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
|
||||
hvterm_priv0.termno, 1);
|
||||
/* HVSI, perform the handshake now */
|
||||
hvsilib_establish(&hvterm_priv0.hvsi);
|
||||
} else
|
||||
goto out;
|
||||
udbg_putc = udbg_hvc_putc;
|
||||
udbg_getc = udbg_hvc_getc;
|
||||
udbg_getc_poll = udbg_hvc_getc_poll;
|
||||
#ifdef HVC_OLD_HVSI
|
||||
/* When using the old HVSI driver don't register the HVC
|
||||
* backend for HVSI, only do udbg
|
||||
*/
|
||||
if (hvterm_priv0.proto == HV_PROTOCOL_HVSI)
|
||||
goto out;
|
||||
#endif
|
||||
add_preferred_console("hvc", 0, NULL);
|
||||
hvc_instantiate(0, 0, ops);
|
||||
out:
|
||||
of_node_put(stdout_node);
|
||||
}
|
||||
|
||||
/* call this from early_init() for a working debug console on
|
||||
* vterm capable LPAR machines
|
||||
*/
|
||||
#ifdef CONFIG_PPC_EARLY_DEBUG_LPAR
|
||||
void __init udbg_init_debug_lpar(void)
|
||||
{
|
||||
hvterm_privs[0] = &hvterm_priv0;
|
||||
hvterm_priv0.termno = 0;
|
||||
hvterm_priv0.proto = HV_PROTOCOL_RAW;
|
||||
spin_lock_init(&hvterm_priv0.buf_lock);
|
||||
udbg_putc = udbg_hvc_putc;
|
||||
udbg_getc = udbg_hvc_getc;
|
||||
udbg_getc_poll = udbg_hvc_getc_poll;
|
||||
}
|
||||
#endif /* CONFIG_PPC_EARLY_DEBUG_LPAR */
|
||||
|
||||
#ifdef CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI
|
||||
void __init udbg_init_debug_lpar_hvsi(void)
|
||||
{
|
||||
hvterm_privs[0] = &hvterm_priv0;
|
||||
hvterm_priv0.termno = CONFIG_PPC_EARLY_DEBUG_HVSI_VTERMNO;
|
||||
hvterm_priv0.proto = HV_PROTOCOL_HVSI;
|
||||
spin_lock_init(&hvterm_priv0.buf_lock);
|
||||
udbg_putc = udbg_hvc_putc;
|
||||
udbg_getc = udbg_hvc_getc;
|
||||
udbg_getc_poll = udbg_hvc_getc_poll;
|
||||
hvsilib_init(&hvterm_priv0.hvsi, hvc_get_chars, hvc_put_chars,
|
||||
hvterm_priv0.termno, 1);
|
||||
hvsilib_establish(&hvterm_priv0.hvsi);
|
||||
}
|
||||
#endif /* CONFIG_PPC_EARLY_DEBUG_LPAR_HVSI */
|
||||
|
|
|
|||
|
|
@ -49,6 +49,7 @@
|
|||
#include <asm/uaccess.h>
|
||||
#include <asm/vio.h>
|
||||
#include <asm/param.h>
|
||||
#include <asm/hvsi.h>
|
||||
|
||||
#define HVSI_MAJOR 229
|
||||
#define HVSI_MINOR 128
|
||||
|
|
@ -109,68 +110,6 @@ enum HVSI_PROTOCOL_STATE {
|
|||
};
|
||||
#define HVSI_CONSOLE 0x1
|
||||
|
||||
#define VS_DATA_PACKET_HEADER 0xff
|
||||
#define VS_CONTROL_PACKET_HEADER 0xfe
|
||||
#define VS_QUERY_PACKET_HEADER 0xfd
|
||||
#define VS_QUERY_RESPONSE_PACKET_HEADER 0xfc
|
||||
|
||||
/* control verbs */
|
||||
#define VSV_SET_MODEM_CTL 1 /* to service processor only */
|
||||
#define VSV_MODEM_CTL_UPDATE 2 /* from service processor only */
|
||||
#define VSV_CLOSE_PROTOCOL 3
|
||||
|
||||
/* query verbs */
|
||||
#define VSV_SEND_VERSION_NUMBER 1
|
||||
#define VSV_SEND_MODEM_CTL_STATUS 2
|
||||
|
||||
/* yes, these masks are not consecutive. */
|
||||
#define HVSI_TSDTR 0x01
|
||||
#define HVSI_TSCD 0x20
|
||||
|
||||
struct hvsi_header {
|
||||
uint8_t type;
|
||||
uint8_t len;
|
||||
uint16_t seqno;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct hvsi_data {
|
||||
uint8_t type;
|
||||
uint8_t len;
|
||||
uint16_t seqno;
|
||||
uint8_t data[HVSI_MAX_OUTGOING_DATA];
|
||||
} __attribute__((packed));
|
||||
|
||||
struct hvsi_control {
|
||||
uint8_t type;
|
||||
uint8_t len;
|
||||
uint16_t seqno;
|
||||
uint16_t verb;
|
||||
/* optional depending on verb: */
|
||||
uint32_t word;
|
||||
uint32_t mask;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct hvsi_query {
|
||||
uint8_t type;
|
||||
uint8_t len;
|
||||
uint16_t seqno;
|
||||
uint16_t verb;
|
||||
} __attribute__((packed));
|
||||
|
||||
struct hvsi_query_response {
|
||||
uint8_t type;
|
||||
uint8_t len;
|
||||
uint16_t seqno;
|
||||
uint16_t verb;
|
||||
uint16_t query_seqno;
|
||||
union {
|
||||
uint8_t version;
|
||||
uint32_t mctrl_word;
|
||||
} u;
|
||||
} __attribute__((packed));
|
||||
|
||||
|
||||
|
||||
static inline int is_console(struct hvsi_struct *hp)
|
||||
{
|
||||
return hp->flags & HVSI_CONSOLE;
|
||||
|
|
@ -356,18 +295,18 @@ static int hvsi_version_respond(struct hvsi_struct *hp, uint16_t query_seqno)
|
|||
struct hvsi_query_response packet __ALIGNED__;
|
||||
int wrote;
|
||||
|
||||
packet.type = VS_QUERY_RESPONSE_PACKET_HEADER;
|
||||
packet.len = sizeof(struct hvsi_query_response);
|
||||
packet.seqno = atomic_inc_return(&hp->seqno);
|
||||
packet.hdr.type = VS_QUERY_RESPONSE_PACKET_HEADER;
|
||||
packet.hdr.len = sizeof(struct hvsi_query_response);
|
||||
packet.hdr.seqno = atomic_inc_return(&hp->seqno);
|
||||
packet.verb = VSV_SEND_VERSION_NUMBER;
|
||||
packet.u.version = HVSI_VERSION;
|
||||
packet.query_seqno = query_seqno+1;
|
||||
|
||||
pr_debug("%s: sending %i bytes\n", __func__, packet.len);
|
||||
dbg_dump_hex((uint8_t*)&packet, packet.len);
|
||||
pr_debug("%s: sending %i bytes\n", __func__, packet.hdr.len);
|
||||
dbg_dump_hex((uint8_t*)&packet, packet.hdr.len);
|
||||
|
||||
wrote = hvc_put_chars(hp->vtermno, (char *)&packet, packet.len);
|
||||
if (wrote != packet.len) {
|
||||
wrote = hvc_put_chars(hp->vtermno, (char *)&packet, packet.hdr.len);
|
||||
if (wrote != packet.hdr.len) {
|
||||
printk(KERN_ERR "hvsi%i: couldn't send query response!\n",
|
||||
hp->index);
|
||||
return -EIO;
|
||||
|
|
@ -382,7 +321,7 @@ static void hvsi_recv_query(struct hvsi_struct *hp, uint8_t *packet)
|
|||
|
||||
switch (hp->state) {
|
||||
case HVSI_WAIT_FOR_VER_QUERY:
|
||||
hvsi_version_respond(hp, query->seqno);
|
||||
hvsi_version_respond(hp, query->hdr.seqno);
|
||||
__set_state(hp, HVSI_OPEN);
|
||||
break;
|
||||
default:
|
||||
|
|
@ -640,16 +579,16 @@ static int hvsi_query(struct hvsi_struct *hp, uint16_t verb)
|
|||
struct hvsi_query packet __ALIGNED__;
|
||||
int wrote;
|
||||
|
||||
packet.type = VS_QUERY_PACKET_HEADER;
|
||||
packet.len = sizeof(struct hvsi_query);
|
||||
packet.seqno = atomic_inc_return(&hp->seqno);
|
||||
packet.hdr.type = VS_QUERY_PACKET_HEADER;
|
||||
packet.hdr.len = sizeof(struct hvsi_query);
|
||||
packet.hdr.seqno = atomic_inc_return(&hp->seqno);
|
||||
packet.verb = verb;
|
||||
|
||||
pr_debug("%s: sending %i bytes\n", __func__, packet.len);
|
||||
dbg_dump_hex((uint8_t*)&packet, packet.len);
|
||||
pr_debug("%s: sending %i bytes\n", __func__, packet.hdr.len);
|
||||
dbg_dump_hex((uint8_t*)&packet, packet.hdr.len);
|
||||
|
||||
wrote = hvc_put_chars(hp->vtermno, (char *)&packet, packet.len);
|
||||
if (wrote != packet.len) {
|
||||
wrote = hvc_put_chars(hp->vtermno, (char *)&packet, packet.hdr.len);
|
||||
if (wrote != packet.hdr.len) {
|
||||
printk(KERN_ERR "hvsi%i: couldn't send query (%i)!\n", hp->index,
|
||||
wrote);
|
||||
return -EIO;
|
||||
|
|
@ -683,20 +622,20 @@ static int hvsi_set_mctrl(struct hvsi_struct *hp, uint16_t mctrl)
|
|||
struct hvsi_control packet __ALIGNED__;
|
||||
int wrote;
|
||||
|
||||
packet.type = VS_CONTROL_PACKET_HEADER,
|
||||
packet.seqno = atomic_inc_return(&hp->seqno);
|
||||
packet.len = sizeof(struct hvsi_control);
|
||||
packet.hdr.type = VS_CONTROL_PACKET_HEADER,
|
||||
packet.hdr.seqno = atomic_inc_return(&hp->seqno);
|
||||
packet.hdr.len = sizeof(struct hvsi_control);
|
||||
packet.verb = VSV_SET_MODEM_CTL;
|
||||
packet.mask = HVSI_TSDTR;
|
||||
|
||||
if (mctrl & TIOCM_DTR)
|
||||
packet.word = HVSI_TSDTR;
|
||||
|
||||
pr_debug("%s: sending %i bytes\n", __func__, packet.len);
|
||||
dbg_dump_hex((uint8_t*)&packet, packet.len);
|
||||
pr_debug("%s: sending %i bytes\n", __func__, packet.hdr.len);
|
||||
dbg_dump_hex((uint8_t*)&packet, packet.hdr.len);
|
||||
|
||||
wrote = hvc_put_chars(hp->vtermno, (char *)&packet, packet.len);
|
||||
if (wrote != packet.len) {
|
||||
wrote = hvc_put_chars(hp->vtermno, (char *)&packet, packet.hdr.len);
|
||||
if (wrote != packet.hdr.len) {
|
||||
printk(KERN_ERR "hvsi%i: couldn't set DTR!\n", hp->index);
|
||||
return -EIO;
|
||||
}
|
||||
|
|
@ -766,13 +705,13 @@ static int hvsi_put_chars(struct hvsi_struct *hp, const char *buf, int count)
|
|||
|
||||
BUG_ON(count > HVSI_MAX_OUTGOING_DATA);
|
||||
|
||||
packet.type = VS_DATA_PACKET_HEADER;
|
||||
packet.seqno = atomic_inc_return(&hp->seqno);
|
||||
packet.len = count + sizeof(struct hvsi_header);
|
||||
packet.hdr.type = VS_DATA_PACKET_HEADER;
|
||||
packet.hdr.seqno = atomic_inc_return(&hp->seqno);
|
||||
packet.hdr.len = count + sizeof(struct hvsi_header);
|
||||
memcpy(&packet.data, buf, count);
|
||||
|
||||
ret = hvc_put_chars(hp->vtermno, (char *)&packet, packet.len);
|
||||
if (ret == packet.len) {
|
||||
ret = hvc_put_chars(hp->vtermno, (char *)&packet, packet.hdr.len);
|
||||
if (ret == packet.hdr.len) {
|
||||
/* return the number of chars written, not the packet length */
|
||||
return count;
|
||||
}
|
||||
|
|
@ -783,15 +722,15 @@ static void hvsi_close_protocol(struct hvsi_struct *hp)
|
|||
{
|
||||
struct hvsi_control packet __ALIGNED__;
|
||||
|
||||
packet.type = VS_CONTROL_PACKET_HEADER;
|
||||
packet.seqno = atomic_inc_return(&hp->seqno);
|
||||
packet.len = 6;
|
||||
packet.hdr.type = VS_CONTROL_PACKET_HEADER;
|
||||
packet.hdr.seqno = atomic_inc_return(&hp->seqno);
|
||||
packet.hdr.len = 6;
|
||||
packet.verb = VSV_CLOSE_PROTOCOL;
|
||||
|
||||
pr_debug("%s: sending %i bytes\n", __func__, packet.len);
|
||||
dbg_dump_hex((uint8_t*)&packet, packet.len);
|
||||
pr_debug("%s: sending %i bytes\n", __func__, packet.hdr.len);
|
||||
dbg_dump_hex((uint8_t*)&packet, packet.hdr.len);
|
||||
|
||||
hvc_put_chars(hp->vtermno, (char *)&packet, packet.len);
|
||||
hvc_put_chars(hp->vtermno, (char *)&packet, packet.hdr.len);
|
||||
}
|
||||
|
||||
static int hvsi_open(struct tty_struct *tty, struct file *filp)
|
||||
|
|
|
|||
426
drivers/tty/hvc/hvsi_lib.c
Normal file
426
drivers/tty/hvc/hvsi_lib.c
Normal file
|
|
@ -0,0 +1,426 @@
|
|||
#include <linux/types.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/delay.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/console.h>
|
||||
#include <asm/hvsi.h>
|
||||
|
||||
#include "hvc_console.h"
|
||||
|
||||
static int hvsi_send_packet(struct hvsi_priv *pv, struct hvsi_header *packet)
|
||||
{
|
||||
packet->seqno = atomic_inc_return(&pv->seqno);
|
||||
|
||||
/* Assumes that always succeeds, works in practice */
|
||||
return pv->put_chars(pv->termno, (char *)packet, packet->len);
|
||||
}
|
||||
|
||||
static void hvsi_start_handshake(struct hvsi_priv *pv)
|
||||
{
|
||||
struct hvsi_query q;
|
||||
|
||||
/* Reset state */
|
||||
pv->established = 0;
|
||||
atomic_set(&pv->seqno, 0);
|
||||
|
||||
pr_devel("HVSI@%x: Handshaking started\n", pv->termno);
|
||||
|
||||
/* Send version query */
|
||||
q.hdr.type = VS_QUERY_PACKET_HEADER;
|
||||
q.hdr.len = sizeof(struct hvsi_query);
|
||||
q.verb = VSV_SEND_VERSION_NUMBER;
|
||||
hvsi_send_packet(pv, &q.hdr);
|
||||
}
|
||||
|
||||
static int hvsi_send_close(struct hvsi_priv *pv)
|
||||
{
|
||||
struct hvsi_control ctrl;
|
||||
|
||||
pv->established = 0;
|
||||
|
||||
ctrl.hdr.type = VS_CONTROL_PACKET_HEADER;
|
||||
ctrl.hdr.len = sizeof(struct hvsi_control);
|
||||
ctrl.verb = VSV_CLOSE_PROTOCOL;
|
||||
return hvsi_send_packet(pv, &ctrl.hdr);
|
||||
}
|
||||
|
||||
static void hvsi_cd_change(struct hvsi_priv *pv, int cd)
|
||||
{
|
||||
if (cd)
|
||||
pv->mctrl |= TIOCM_CD;
|
||||
else {
|
||||
pv->mctrl &= ~TIOCM_CD;
|
||||
|
||||
/* We copy the existing hvsi driver semantics
|
||||
* here which are to trigger a hangup when
|
||||
* we get a carrier loss.
|
||||
* Closing our connection to the server will
|
||||
* do just that.
|
||||
*/
|
||||
if (!pv->is_console && pv->opened) {
|
||||
pr_devel("HVSI@%x Carrier lost, hanging up !\n",
|
||||
pv->termno);
|
||||
hvsi_send_close(pv);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void hvsi_got_control(struct hvsi_priv *pv)
|
||||
{
|
||||
struct hvsi_control *pkt = (struct hvsi_control *)pv->inbuf;
|
||||
|
||||
switch (pkt->verb) {
|
||||
case VSV_CLOSE_PROTOCOL:
|
||||
/* We restart the handshaking */
|
||||
hvsi_start_handshake(pv);
|
||||
break;
|
||||
case VSV_MODEM_CTL_UPDATE:
|
||||
/* Transition of carrier detect */
|
||||
hvsi_cd_change(pv, pkt->word & HVSI_TSCD);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void hvsi_got_query(struct hvsi_priv *pv)
|
||||
{
|
||||
struct hvsi_query *pkt = (struct hvsi_query *)pv->inbuf;
|
||||
struct hvsi_query_response r;
|
||||
|
||||
/* We only handle version queries */
|
||||
if (pkt->verb != VSV_SEND_VERSION_NUMBER)
|
||||
return;
|
||||
|
||||
pr_devel("HVSI@%x: Got version query, sending response...\n",
|
||||
pv->termno);
|
||||
|
||||
/* Send version response */
|
||||
r.hdr.type = VS_QUERY_RESPONSE_PACKET_HEADER;
|
||||
r.hdr.len = sizeof(struct hvsi_query_response);
|
||||
r.verb = VSV_SEND_VERSION_NUMBER;
|
||||
r.u.version = HVSI_VERSION;
|
||||
r.query_seqno = pkt->hdr.seqno;
|
||||
hvsi_send_packet(pv, &r.hdr);
|
||||
|
||||
/* Assume protocol is open now */
|
||||
pv->established = 1;
|
||||
}
|
||||
|
||||
static void hvsi_got_response(struct hvsi_priv *pv)
|
||||
{
|
||||
struct hvsi_query_response *r =
|
||||
(struct hvsi_query_response *)pv->inbuf;
|
||||
|
||||
switch(r->verb) {
|
||||
case VSV_SEND_MODEM_CTL_STATUS:
|
||||
hvsi_cd_change(pv, r->u.mctrl_word & HVSI_TSCD);
|
||||
pv->mctrl_update = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static int hvsi_check_packet(struct hvsi_priv *pv)
|
||||
{
|
||||
u8 len, type;
|
||||
|
||||
/* Check header validity. If it's invalid, we ditch
|
||||
* the whole buffer and hope we eventually resync
|
||||
*/
|
||||
if (pv->inbuf[0] < 0xfc) {
|
||||
pv->inbuf_len = pv->inbuf_pktlen = 0;
|
||||
return 0;
|
||||
}
|
||||
type = pv->inbuf[0];
|
||||
len = pv->inbuf[1];
|
||||
|
||||
/* Packet incomplete ? */
|
||||
if (pv->inbuf_len < len)
|
||||
return 0;
|
||||
|
||||
pr_devel("HVSI@%x: Got packet type %x len %d bytes:\n",
|
||||
pv->termno, type, len);
|
||||
|
||||
/* We have a packet, yay ! Handle it */
|
||||
switch(type) {
|
||||
case VS_DATA_PACKET_HEADER:
|
||||
pv->inbuf_pktlen = len - 4;
|
||||
pv->inbuf_cur = 4;
|
||||
return 1;
|
||||
case VS_CONTROL_PACKET_HEADER:
|
||||
hvsi_got_control(pv);
|
||||
break;
|
||||
case VS_QUERY_PACKET_HEADER:
|
||||
hvsi_got_query(pv);
|
||||
break;
|
||||
case VS_QUERY_RESPONSE_PACKET_HEADER:
|
||||
hvsi_got_response(pv);
|
||||
break;
|
||||
}
|
||||
|
||||
/* Swallow packet and retry */
|
||||
pv->inbuf_len -= len;
|
||||
memmove(pv->inbuf, &pv->inbuf[len], pv->inbuf_len);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static int hvsi_get_packet(struct hvsi_priv *pv)
|
||||
{
|
||||
/* If we have room in the buffer, ask HV for more */
|
||||
if (pv->inbuf_len < HVSI_INBUF_SIZE)
|
||||
pv->inbuf_len += pv->get_chars(pv->termno,
|
||||
&pv->inbuf[pv->inbuf_len],
|
||||
HVSI_INBUF_SIZE - pv->inbuf_len);
|
||||
/*
|
||||
* If we have at least 4 bytes in the buffer, check for
|
||||
* a full packet and retry
|
||||
*/
|
||||
if (pv->inbuf_len >= 4)
|
||||
return hvsi_check_packet(pv);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int hvsilib_get_chars(struct hvsi_priv *pv, char *buf, int count)
|
||||
{
|
||||
unsigned int tries, read = 0;
|
||||
|
||||
if (WARN_ON(!pv))
|
||||
return 0;
|
||||
|
||||
/* If we aren't open, don't do anything in order to avoid races
|
||||
* with connection establishment. The hvc core will call this
|
||||
* before we have returned from notifier_add(), and we need to
|
||||
* avoid multiple users playing with the receive buffer
|
||||
*/
|
||||
if (!pv->opened)
|
||||
return 0;
|
||||
|
||||
/* We try twice, once with what data we have and once more
|
||||
* after we try to fetch some more from the hypervisor
|
||||
*/
|
||||
for (tries = 1; count && tries < 2; tries++) {
|
||||
/* Consume existing data packet */
|
||||
if (pv->inbuf_pktlen) {
|
||||
unsigned int l = min(count, (int)pv->inbuf_pktlen);
|
||||
memcpy(&buf[read], &pv->inbuf[pv->inbuf_cur], l);
|
||||
pv->inbuf_cur += l;
|
||||
pv->inbuf_pktlen -= l;
|
||||
count -= l;
|
||||
read += l;
|
||||
}
|
||||
if (count == 0)
|
||||
break;
|
||||
|
||||
/* Data packet fully consumed, move down remaning data */
|
||||
if (pv->inbuf_cur) {
|
||||
pv->inbuf_len -= pv->inbuf_cur;
|
||||
memmove(pv->inbuf, &pv->inbuf[pv->inbuf_cur],
|
||||
pv->inbuf_len);
|
||||
pv->inbuf_cur = 0;
|
||||
}
|
||||
|
||||
/* Try to get another packet */
|
||||
if (hvsi_get_packet(pv))
|
||||
tries--;
|
||||
}
|
||||
if (!pv->established) {
|
||||
pr_devel("HVSI@%x: returning -EPIPE\n", pv->termno);
|
||||
return -EPIPE;
|
||||
}
|
||||
return read;
|
||||
}
|
||||
|
||||
int hvsilib_put_chars(struct hvsi_priv *pv, const char *buf, int count)
|
||||
{
|
||||
struct hvsi_data dp;
|
||||
int rc, adjcount = min(count, HVSI_MAX_OUTGOING_DATA);
|
||||
|
||||
if (WARN_ON(!pv))
|
||||
return 0;
|
||||
|
||||
dp.hdr.type = VS_DATA_PACKET_HEADER;
|
||||
dp.hdr.len = adjcount + sizeof(struct hvsi_header);
|
||||
memcpy(dp.data, buf, adjcount);
|
||||
rc = hvsi_send_packet(pv, &dp.hdr);
|
||||
if (rc <= 0)
|
||||
return rc;
|
||||
return adjcount;
|
||||
}
|
||||
|
||||
static void maybe_msleep(unsigned long ms)
|
||||
{
|
||||
/* During early boot, IRQs are disabled, use mdelay */
|
||||
if (irqs_disabled())
|
||||
mdelay(ms);
|
||||
else
|
||||
msleep(ms);
|
||||
}
|
||||
|
||||
int hvsilib_read_mctrl(struct hvsi_priv *pv)
|
||||
{
|
||||
struct hvsi_query q;
|
||||
int rc, timeout;
|
||||
|
||||
pr_devel("HVSI@%x: Querying modem control status...\n",
|
||||
pv->termno);
|
||||
|
||||
pv->mctrl_update = 0;
|
||||
q.hdr.type = VS_QUERY_PACKET_HEADER;
|
||||
q.hdr.len = sizeof(struct hvsi_query);
|
||||
q.hdr.seqno = atomic_inc_return(&pv->seqno);
|
||||
q.verb = VSV_SEND_MODEM_CTL_STATUS;
|
||||
rc = hvsi_send_packet(pv, &q.hdr);
|
||||
if (rc <= 0) {
|
||||
pr_devel("HVSI@%x: Error %d...\n", pv->termno, rc);
|
||||
return rc;
|
||||
}
|
||||
|
||||
/* Try for up to 200ms */
|
||||
for (timeout = 0; timeout < 20; timeout++) {
|
||||
if (!pv->established)
|
||||
return -ENXIO;
|
||||
if (pv->mctrl_update)
|
||||
return 0;
|
||||
if (!hvsi_get_packet(pv))
|
||||
maybe_msleep(10);
|
||||
}
|
||||
return -EIO;
|
||||
}
|
||||
|
||||
int hvsilib_write_mctrl(struct hvsi_priv *pv, int dtr)
|
||||
{
|
||||
struct hvsi_control ctrl;
|
||||
unsigned short mctrl;
|
||||
|
||||
mctrl = pv->mctrl;
|
||||
if (dtr)
|
||||
mctrl |= TIOCM_DTR;
|
||||
else
|
||||
mctrl &= ~TIOCM_DTR;
|
||||
if (mctrl == pv->mctrl)
|
||||
return 0;
|
||||
pv->mctrl = mctrl;
|
||||
|
||||
pr_devel("HVSI@%x: %s DTR...\n", pv->termno,
|
||||
dtr ? "Setting" : "Clearing");
|
||||
|
||||
ctrl.hdr.type = VS_CONTROL_PACKET_HEADER,
|
||||
ctrl.hdr.len = sizeof(struct hvsi_control);
|
||||
ctrl.verb = VSV_SET_MODEM_CTL;
|
||||
ctrl.mask = HVSI_TSDTR;
|
||||
ctrl.word = dtr ? HVSI_TSDTR : 0;
|
||||
return hvsi_send_packet(pv, &ctrl.hdr);
|
||||
}
|
||||
|
||||
void hvsilib_establish(struct hvsi_priv *pv)
|
||||
{
|
||||
int timeout;
|
||||
|
||||
pr_devel("HVSI@%x: Establishing...\n", pv->termno);
|
||||
|
||||
/* Try for up to 200ms, there can be a packet to
|
||||
* start the process waiting for us...
|
||||
*/
|
||||
for (timeout = 0; timeout < 20; timeout++) {
|
||||
if (pv->established)
|
||||
goto established;
|
||||
if (!hvsi_get_packet(pv))
|
||||
maybe_msleep(10);
|
||||
}
|
||||
|
||||
/* Failed, send a close connection packet just
|
||||
* in case
|
||||
*/
|
||||
pr_devel("HVSI@%x: ... sending close\n", pv->termno);
|
||||
|
||||
hvsi_send_close(pv);
|
||||
|
||||
/* Then restart handshake */
|
||||
|
||||
pr_devel("HVSI@%x: ... restarting handshake\n", pv->termno);
|
||||
|
||||
hvsi_start_handshake(pv);
|
||||
|
||||
pr_devel("HVSI@%x: ... waiting handshake\n", pv->termno);
|
||||
|
||||
/* Try for up to 200s */
|
||||
for (timeout = 0; timeout < 20; timeout++) {
|
||||
if (pv->established)
|
||||
goto established;
|
||||
if (!hvsi_get_packet(pv))
|
||||
maybe_msleep(10);
|
||||
}
|
||||
|
||||
if (!pv->established) {
|
||||
pr_devel("HVSI@%x: Timeout handshaking, giving up !\n",
|
||||
pv->termno);
|
||||
return;
|
||||
}
|
||||
established:
|
||||
/* Query modem control lines */
|
||||
|
||||
pr_devel("HVSI@%x: ... established, reading mctrl\n", pv->termno);
|
||||
|
||||
hvsilib_read_mctrl(pv);
|
||||
|
||||
/* Set our own DTR */
|
||||
|
||||
pr_devel("HVSI@%x: ... setting mctrl\n", pv->termno);
|
||||
|
||||
hvsilib_write_mctrl(pv, 1);
|
||||
|
||||
/* Set the opened flag so reads are allowed */
|
||||
wmb();
|
||||
pv->opened = 1;
|
||||
}
|
||||
|
||||
int hvsilib_open(struct hvsi_priv *pv, struct hvc_struct *hp)
|
||||
{
|
||||
pr_devel("HVSI@%x: open !\n", pv->termno);
|
||||
|
||||
/* Keep track of the tty data structure */
|
||||
pv->tty = tty_kref_get(hp->tty);
|
||||
|
||||
hvsilib_establish(pv);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void hvsilib_close(struct hvsi_priv *pv, struct hvc_struct *hp)
|
||||
{
|
||||
unsigned long flags;
|
||||
|
||||
pr_devel("HVSI@%x: close !\n", pv->termno);
|
||||
|
||||
if (!pv->is_console) {
|
||||
pr_devel("HVSI@%x: Not a console, tearing down\n",
|
||||
pv->termno);
|
||||
|
||||
/* Clear opened, synchronize with khvcd */
|
||||
spin_lock_irqsave(&hp->lock, flags);
|
||||
pv->opened = 0;
|
||||
spin_unlock_irqrestore(&hp->lock, flags);
|
||||
|
||||
/* Clear our own DTR */
|
||||
if (!pv->tty || (pv->tty->termios->c_cflag & HUPCL))
|
||||
hvsilib_write_mctrl(pv, 0);
|
||||
|
||||
/* Tear down the connection */
|
||||
hvsi_send_close(pv);
|
||||
}
|
||||
|
||||
if (pv->tty)
|
||||
tty_kref_put(pv->tty);
|
||||
pv->tty = NULL;
|
||||
}
|
||||
|
||||
void hvsilib_init(struct hvsi_priv *pv,
|
||||
int (*get_chars)(uint32_t termno, char *buf, int count),
|
||||
int (*put_chars)(uint32_t termno, const char *buf,
|
||||
int count),
|
||||
int termno, int is_console)
|
||||
{
|
||||
memset(pv, 0, sizeof(*pv));
|
||||
pv->get_chars = get_chars;
|
||||
pv->put_chars = put_chars;
|
||||
pv->termno = termno;
|
||||
pv->is_console = is_console;
|
||||
}
|
||||
Loading…
Reference in a new issue