772 lines
20 KiB
C
772 lines
20 KiB
C
/* visorinput.c
|
|
*
|
|
* Copyright (C) 2011 - 2015 UNISYS CORPORATION
|
|
* All rights reserved.
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* 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, GOOD TITLE or
|
|
* NON INFRINGEMENT. See the GNU General Public License for more
|
|
* details.
|
|
*/
|
|
|
|
/*
|
|
* This driver lives in a generic guest Linux partition, and registers to
|
|
* receive keyboard and mouse channels from the visorbus driver. It reads
|
|
* inputs from such channels, and delivers it to the Linux OS in the
|
|
* standard way the Linux expects for input drivers.
|
|
*/
|
|
|
|
#include <linux/buffer_head.h>
|
|
#include <linux/fb.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/input.h>
|
|
#include <linux/uaccess.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/uuid.h>
|
|
|
|
#include "visorbus.h"
|
|
#include "ultrainputreport.h"
|
|
|
|
/* Keyboard channel {c73416d0-b0b8-44af-b304-9d2ae99f1b3d} */
|
|
#define SPAR_KEYBOARD_CHANNEL_PROTOCOL_UUID \
|
|
UUID_LE(0xc73416d0, 0xb0b8, 0x44af, \
|
|
0xb3, 0x4, 0x9d, 0x2a, 0xe9, 0x9f, 0x1b, 0x3d)
|
|
#define SPAR_KEYBOARD_CHANNEL_PROTOCOL_UUID_STR "c73416d0-b0b8-44af-b304-9d2ae99f1b3d"
|
|
|
|
/* Mouse channel {addf07d4-94a9-46e2-81c3-61abcdbdbd87} */
|
|
#define SPAR_MOUSE_CHANNEL_PROTOCOL_UUID \
|
|
UUID_LE(0xaddf07d4, 0x94a9, 0x46e2, \
|
|
0x81, 0xc3, 0x61, 0xab, 0xcd, 0xbd, 0xbd, 0x87)
|
|
#define SPAR_MOUSE_CHANNEL_PROTOCOL_UUID_STR \
|
|
"addf07d4-94a9-46e2-81c3-61abcdbdbd87"
|
|
|
|
#define PIXELS_ACROSS_DEFAULT 800
|
|
#define PIXELS_DOWN_DEFAULT 600
|
|
#define KEYCODE_TABLE_BYTES 256
|
|
|
|
enum visorinput_device_type {
|
|
visorinput_keyboard,
|
|
visorinput_mouse,
|
|
};
|
|
|
|
/*
|
|
* This is the private data that we store for each device.
|
|
* A pointer to this struct is maintained via
|
|
* dev_get_drvdata() / dev_set_drvdata() for each struct device.
|
|
*/
|
|
struct visorinput_devdata {
|
|
struct visor_device *dev;
|
|
struct mutex lock_visor_dev; /* lock for dev */
|
|
struct input_dev *visorinput_dev;
|
|
bool paused;
|
|
bool interrupts_enabled;
|
|
unsigned int keycode_table_bytes; /* size of following array */
|
|
/* for keyboard devices: visorkbd_keycode[] + visorkbd_ext_keycode[] */
|
|
unsigned char keycode_table[0];
|
|
};
|
|
|
|
static const uuid_le spar_keyboard_channel_protocol_uuid =
|
|
SPAR_KEYBOARD_CHANNEL_PROTOCOL_UUID;
|
|
static const uuid_le spar_mouse_channel_protocol_uuid =
|
|
SPAR_MOUSE_CHANNEL_PROTOCOL_UUID;
|
|
|
|
/*
|
|
* Borrowed from drivers/input/keyboard/atakbd.c
|
|
* This maps 1-byte scancodes to keycodes.
|
|
*/
|
|
static const unsigned char visorkbd_keycode[KEYCODE_TABLE_BYTES] = {
|
|
/* American layout */
|
|
[0] = KEY_GRAVE,
|
|
[1] = KEY_ESC,
|
|
[2] = KEY_1,
|
|
[3] = KEY_2,
|
|
[4] = KEY_3,
|
|
[5] = KEY_4,
|
|
[6] = KEY_5,
|
|
[7] = KEY_6,
|
|
[8] = KEY_7,
|
|
[9] = KEY_8,
|
|
[10] = KEY_9,
|
|
[11] = KEY_0,
|
|
[12] = KEY_MINUS,
|
|
[13] = KEY_EQUAL,
|
|
[14] = KEY_BACKSPACE,
|
|
[15] = KEY_TAB,
|
|
[16] = KEY_Q,
|
|
[17] = KEY_W,
|
|
[18] = KEY_E,
|
|
[19] = KEY_R,
|
|
[20] = KEY_T,
|
|
[21] = KEY_Y,
|
|
[22] = KEY_U,
|
|
[23] = KEY_I,
|
|
[24] = KEY_O,
|
|
[25] = KEY_P,
|
|
[26] = KEY_LEFTBRACE,
|
|
[27] = KEY_RIGHTBRACE,
|
|
[28] = KEY_ENTER,
|
|
[29] = KEY_LEFTCTRL,
|
|
[30] = KEY_A,
|
|
[31] = KEY_S,
|
|
[32] = KEY_D,
|
|
[33] = KEY_F,
|
|
[34] = KEY_G,
|
|
[35] = KEY_H,
|
|
[36] = KEY_J,
|
|
[37] = KEY_K,
|
|
[38] = KEY_L,
|
|
[39] = KEY_SEMICOLON,
|
|
[40] = KEY_APOSTROPHE,
|
|
[41] = KEY_GRAVE,
|
|
[42] = KEY_LEFTSHIFT,
|
|
[43] = KEY_BACKSLASH,
|
|
[44] = KEY_Z,
|
|
[45] = KEY_X,
|
|
[46] = KEY_C,
|
|
[47] = KEY_V,
|
|
[48] = KEY_B,
|
|
[49] = KEY_N,
|
|
[50] = KEY_M,
|
|
[51] = KEY_COMMA,
|
|
[52] = KEY_DOT,
|
|
[53] = KEY_SLASH,
|
|
[54] = KEY_RIGHTSHIFT,
|
|
[55] = KEY_KPASTERISK,
|
|
[56] = KEY_LEFTALT,
|
|
[57] = KEY_SPACE,
|
|
[58] = KEY_CAPSLOCK,
|
|
[59] = KEY_F1,
|
|
[60] = KEY_F2,
|
|
[61] = KEY_F3,
|
|
[62] = KEY_F4,
|
|
[63] = KEY_F5,
|
|
[64] = KEY_F6,
|
|
[65] = KEY_F7,
|
|
[66] = KEY_F8,
|
|
[67] = KEY_F9,
|
|
[68] = KEY_F10,
|
|
[69] = KEY_NUMLOCK,
|
|
[70] = KEY_SCROLLLOCK,
|
|
[71] = KEY_KP7,
|
|
[72] = KEY_KP8,
|
|
[73] = KEY_KP9,
|
|
[74] = KEY_KPMINUS,
|
|
[75] = KEY_KP4,
|
|
[76] = KEY_KP5,
|
|
[77] = KEY_KP6,
|
|
[78] = KEY_KPPLUS,
|
|
[79] = KEY_KP1,
|
|
[80] = KEY_KP2,
|
|
[81] = KEY_KP3,
|
|
[82] = KEY_KP0,
|
|
[83] = KEY_KPDOT,
|
|
[86] = KEY_102ND, /* enables UK backslash+pipe key,
|
|
* and FR lessthan+greaterthan key
|
|
*/
|
|
[87] = KEY_F11,
|
|
[88] = KEY_F12,
|
|
[90] = KEY_KPLEFTPAREN,
|
|
[91] = KEY_KPRIGHTPAREN,
|
|
[92] = KEY_KPASTERISK,
|
|
[93] = KEY_KPASTERISK,
|
|
[94] = KEY_KPPLUS,
|
|
[95] = KEY_HELP,
|
|
[96] = KEY_KPENTER,
|
|
[97] = KEY_RIGHTCTRL,
|
|
[98] = KEY_KPSLASH,
|
|
[99] = KEY_KPLEFTPAREN,
|
|
[100] = KEY_KPRIGHTPAREN,
|
|
[101] = KEY_KPSLASH,
|
|
[102] = KEY_HOME,
|
|
[103] = KEY_UP,
|
|
[104] = KEY_PAGEUP,
|
|
[105] = KEY_LEFT,
|
|
[106] = KEY_RIGHT,
|
|
[107] = KEY_END,
|
|
[108] = KEY_DOWN,
|
|
[109] = KEY_PAGEDOWN,
|
|
[110] = KEY_INSERT,
|
|
[111] = KEY_DELETE,
|
|
[112] = KEY_MACRO,
|
|
[113] = KEY_MUTE
|
|
};
|
|
|
|
/*
|
|
* This maps the <xx> in extended scancodes of the form "0xE0 <xx>" into
|
|
* keycodes.
|
|
*/
|
|
static const unsigned char visorkbd_ext_keycode[KEYCODE_TABLE_BYTES] = {
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 */
|
|
0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */
|
|
0, 0, 0, 0, KEY_KPENTER, KEY_RIGHTCTRL, 0, 0, /* 0x18 */
|
|
0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */
|
|
KEY_RIGHTALT, 0, 0, 0, 0, 0, 0, 0, /* 0x28 */
|
|
0, 0, 0, 0, 0, 0, 0, 0, /* 0x30 */
|
|
KEY_RIGHTALT /* AltGr */, 0, 0, 0, 0, 0, 0, 0, /* 0x38 */
|
|
0, 0, 0, 0, 0, 0, 0, KEY_HOME, /* 0x40 */
|
|
KEY_UP, KEY_PAGEUP, 0, KEY_LEFT, 0, KEY_RIGHT, 0, KEY_END, /* 0x48 */
|
|
KEY_DOWN, KEY_PAGEDOWN, KEY_INSERT, KEY_DELETE, 0, 0, 0, 0, /* 0x50 */
|
|
0, 0, 0, 0, 0, 0, 0, 0, /* 0x58 */
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x60 */
|
|
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x70 */
|
|
};
|
|
|
|
static int visorinput_open(struct input_dev *visorinput_dev)
|
|
{
|
|
struct visorinput_devdata *devdata = input_get_drvdata(visorinput_dev);
|
|
|
|
if (!devdata) {
|
|
dev_err(&visorinput_dev->dev,
|
|
"%s input_get_drvdata(%p) returned NULL\n",
|
|
__func__, visorinput_dev);
|
|
return -EINVAL;
|
|
}
|
|
dev_dbg(&visorinput_dev->dev, "%s opened\n", __func__);
|
|
|
|
/*
|
|
* If we're not paused, really enable interrupts.
|
|
* Regardless of whether we are paused, set a flag indicating
|
|
* interrupts should be enabled so when we resume, interrupts
|
|
* will really be enabled.
|
|
*/
|
|
mutex_lock(&devdata->lock_visor_dev);
|
|
devdata->interrupts_enabled = true;
|
|
if (devdata->paused)
|
|
goto out_unlock;
|
|
visorbus_enable_channel_interrupts(devdata->dev);
|
|
|
|
out_unlock:
|
|
mutex_unlock(&devdata->lock_visor_dev);
|
|
return 0;
|
|
}
|
|
|
|
static void visorinput_close(struct input_dev *visorinput_dev)
|
|
{
|
|
struct visorinput_devdata *devdata = input_get_drvdata(visorinput_dev);
|
|
|
|
if (!devdata) {
|
|
dev_err(&visorinput_dev->dev,
|
|
"%s input_get_drvdata(%p) returned NULL\n",
|
|
__func__, visorinput_dev);
|
|
return;
|
|
}
|
|
dev_dbg(&visorinput_dev->dev, "%s closed\n", __func__);
|
|
|
|
/*
|
|
* If we're not paused, really disable interrupts.
|
|
* Regardless of whether we are paused, set a flag indicating
|
|
* interrupts should be disabled so when we resume we will
|
|
* not re-enable them.
|
|
*/
|
|
|
|
mutex_lock(&devdata->lock_visor_dev);
|
|
devdata->interrupts_enabled = false;
|
|
if (devdata->paused)
|
|
goto out_unlock;
|
|
visorbus_disable_channel_interrupts(devdata->dev);
|
|
|
|
out_unlock:
|
|
mutex_unlock(&devdata->lock_visor_dev);
|
|
}
|
|
|
|
/*
|
|
* setup_client_keyboard() initializes and returns a Linux input node that
|
|
* we can use to deliver keyboard inputs to Linux. We of course do this when
|
|
* we see keyboard inputs coming in on a keyboard channel.
|
|
*/
|
|
static struct input_dev *
|
|
setup_client_keyboard(void *devdata, /* opaque on purpose */
|
|
unsigned char *keycode_table)
|
|
|
|
{
|
|
int i;
|
|
struct input_dev *visorinput_dev;
|
|
|
|
visorinput_dev = input_allocate_device();
|
|
if (!visorinput_dev)
|
|
return NULL;
|
|
|
|
visorinput_dev->name = "visor Keyboard";
|
|
visorinput_dev->phys = "visorkbd:input0";
|
|
visorinput_dev->id.bustype = BUS_VIRTUAL;
|
|
visorinput_dev->id.vendor = 0x0001;
|
|
visorinput_dev->id.product = 0x0001;
|
|
visorinput_dev->id.version = 0x0100;
|
|
|
|
visorinput_dev->evbit[0] = BIT_MASK(EV_KEY) |
|
|
BIT_MASK(EV_REP) |
|
|
BIT_MASK(EV_LED);
|
|
visorinput_dev->ledbit[0] = BIT_MASK(LED_CAPSL) |
|
|
BIT_MASK(LED_SCROLLL) |
|
|
BIT_MASK(LED_NUML);
|
|
visorinput_dev->keycode = keycode_table;
|
|
visorinput_dev->keycodesize = 1; /* sizeof(unsigned char) */
|
|
visorinput_dev->keycodemax = KEYCODE_TABLE_BYTES;
|
|
|
|
for (i = 1; i < visorinput_dev->keycodemax; i++)
|
|
set_bit(keycode_table[i], visorinput_dev->keybit);
|
|
for (i = 1; i < visorinput_dev->keycodemax; i++)
|
|
set_bit(keycode_table[i + KEYCODE_TABLE_BYTES],
|
|
visorinput_dev->keybit);
|
|
|
|
visorinput_dev->open = visorinput_open;
|
|
visorinput_dev->close = visorinput_close;
|
|
input_set_drvdata(visorinput_dev, devdata); /* pre input_register! */
|
|
|
|
return visorinput_dev;
|
|
}
|
|
|
|
static struct input_dev *
|
|
setup_client_mouse(void *devdata /* opaque on purpose */)
|
|
{
|
|
struct input_dev *visorinput_dev = NULL;
|
|
int xres, yres;
|
|
struct fb_info *fb0;
|
|
|
|
visorinput_dev = input_allocate_device();
|
|
if (!visorinput_dev)
|
|
return NULL;
|
|
|
|
visorinput_dev->name = "visor Mouse";
|
|
visorinput_dev->phys = "visormou:input0";
|
|
visorinput_dev->id.bustype = BUS_VIRTUAL;
|
|
visorinput_dev->id.vendor = 0x0001;
|
|
visorinput_dev->id.product = 0x0002;
|
|
visorinput_dev->id.version = 0x0100;
|
|
|
|
visorinput_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
|
|
set_bit(BTN_LEFT, visorinput_dev->keybit);
|
|
set_bit(BTN_RIGHT, visorinput_dev->keybit);
|
|
set_bit(BTN_MIDDLE, visorinput_dev->keybit);
|
|
|
|
if (registered_fb[0]) {
|
|
fb0 = registered_fb[0];
|
|
xres = fb0->var.xres_virtual;
|
|
yres = fb0->var.yres_virtual;
|
|
} else {
|
|
xres = PIXELS_ACROSS_DEFAULT;
|
|
yres = PIXELS_DOWN_DEFAULT;
|
|
}
|
|
input_set_abs_params(visorinput_dev, ABS_X, 0, xres, 0, 0);
|
|
input_set_abs_params(visorinput_dev, ABS_Y, 0, yres, 0, 0);
|
|
|
|
visorinput_dev->open = visorinput_open;
|
|
visorinput_dev->close = visorinput_close;
|
|
input_set_drvdata(visorinput_dev, devdata); /* pre input_register! */
|
|
input_set_capability(visorinput_dev, EV_REL, REL_WHEEL);
|
|
|
|
return visorinput_dev;
|
|
}
|
|
|
|
static struct visorinput_devdata *
|
|
devdata_create(struct visor_device *dev, enum visorinput_device_type devtype)
|
|
{
|
|
struct visorinput_devdata *devdata = NULL;
|
|
unsigned int extra_bytes = 0;
|
|
|
|
if (devtype == visorinput_keyboard)
|
|
/* allocate room for devdata->keycode_table, filled in below */
|
|
extra_bytes = KEYCODE_TABLE_BYTES * 2;
|
|
devdata = kzalloc(sizeof(*devdata) + extra_bytes, GFP_KERNEL);
|
|
if (!devdata)
|
|
return NULL;
|
|
mutex_init(&devdata->lock_visor_dev);
|
|
mutex_lock(&devdata->lock_visor_dev);
|
|
devdata->dev = dev;
|
|
|
|
/*
|
|
* visorinput_open() can be called as soon as input_register_device()
|
|
* happens, and that will enable channel interrupts. Setting paused
|
|
* prevents us from getting into visorinput_channel_interrupt() prior
|
|
* to the device structure being totally initialized.
|
|
*/
|
|
devdata->paused = true;
|
|
|
|
/*
|
|
* This is an input device in a client guest partition,
|
|
* so we need to create whatever input nodes are necessary to
|
|
* deliver our inputs to the guest OS.
|
|
*/
|
|
switch (devtype) {
|
|
case visorinput_keyboard:
|
|
devdata->keycode_table_bytes = extra_bytes;
|
|
memcpy(devdata->keycode_table, visorkbd_keycode,
|
|
KEYCODE_TABLE_BYTES);
|
|
memcpy(devdata->keycode_table + KEYCODE_TABLE_BYTES,
|
|
visorkbd_ext_keycode, KEYCODE_TABLE_BYTES);
|
|
devdata->visorinput_dev = setup_client_keyboard
|
|
(devdata, devdata->keycode_table);
|
|
if (!devdata->visorinput_dev)
|
|
goto cleanups_register;
|
|
break;
|
|
case visorinput_mouse:
|
|
devdata->visorinput_dev = setup_client_mouse(devdata);
|
|
if (!devdata->visorinput_dev)
|
|
goto cleanups_register;
|
|
break;
|
|
default:
|
|
/* No other input devices supported */
|
|
break;
|
|
}
|
|
|
|
dev_set_drvdata(&dev->device, devdata);
|
|
mutex_unlock(&devdata->lock_visor_dev);
|
|
|
|
/*
|
|
* Device struct is completely set up now, with the exception of
|
|
* visorinput_dev being registered.
|
|
* We need to unlock before we register the device, because this
|
|
* can cause an on-stack call of visorinput_open(), which would
|
|
* deadlock if we had the lock.
|
|
*/
|
|
if (input_register_device(devdata->visorinput_dev)) {
|
|
input_free_device(devdata->visorinput_dev);
|
|
goto err_kfree_devdata;
|
|
}
|
|
|
|
mutex_lock(&devdata->lock_visor_dev);
|
|
/*
|
|
* Establish calls to visorinput_channel_interrupt() if that is
|
|
* the desired state that we've kept track of in interrupts_enabled
|
|
* while the device was being created.
|
|
*/
|
|
devdata->paused = false;
|
|
if (devdata->interrupts_enabled)
|
|
visorbus_enable_channel_interrupts(dev);
|
|
mutex_unlock(&devdata->lock_visor_dev);
|
|
|
|
return devdata;
|
|
|
|
cleanups_register:
|
|
mutex_unlock(&devdata->lock_visor_dev);
|
|
err_kfree_devdata:
|
|
kfree(devdata);
|
|
return NULL;
|
|
}
|
|
|
|
static int
|
|
visorinput_probe(struct visor_device *dev)
|
|
{
|
|
uuid_le guid;
|
|
enum visorinput_device_type devtype;
|
|
|
|
guid = visorchannel_get_uuid(dev->visorchannel);
|
|
if (uuid_le_cmp(guid, spar_mouse_channel_protocol_uuid) == 0)
|
|
devtype = visorinput_mouse;
|
|
else if (uuid_le_cmp(guid, spar_keyboard_channel_protocol_uuid) == 0)
|
|
devtype = visorinput_keyboard;
|
|
else
|
|
return -ENODEV;
|
|
visorbus_disable_channel_interrupts(dev);
|
|
if (!devdata_create(dev, devtype))
|
|
return -ENOMEM;
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
unregister_client_input(struct input_dev *visorinput_dev)
|
|
{
|
|
if (visorinput_dev)
|
|
input_unregister_device(visorinput_dev);
|
|
}
|
|
|
|
static void
|
|
visorinput_remove(struct visor_device *dev)
|
|
{
|
|
struct visorinput_devdata *devdata = dev_get_drvdata(&dev->device);
|
|
|
|
if (!devdata)
|
|
return;
|
|
|
|
mutex_lock(&devdata->lock_visor_dev);
|
|
visorbus_disable_channel_interrupts(dev);
|
|
|
|
/*
|
|
* due to above, at this time no thread of execution will be
|
|
* in visorinput_channel_interrupt()
|
|
*/
|
|
|
|
dev_set_drvdata(&dev->device, NULL);
|
|
mutex_unlock(&devdata->lock_visor_dev);
|
|
|
|
unregister_client_input(devdata->visorinput_dev);
|
|
kfree(devdata);
|
|
}
|
|
|
|
/*
|
|
* Make it so the current locking state of the locking key indicated by
|
|
* <keycode> is as indicated by <desired_state> (1=locked, 0=unlocked).
|
|
*/
|
|
static void
|
|
handle_locking_key(struct input_dev *visorinput_dev,
|
|
int keycode, int desired_state)
|
|
{
|
|
int led;
|
|
|
|
switch (keycode) {
|
|
case KEY_CAPSLOCK:
|
|
led = LED_CAPSL;
|
|
break;
|
|
case KEY_SCROLLLOCK:
|
|
led = LED_SCROLLL;
|
|
break;
|
|
case KEY_NUMLOCK:
|
|
led = LED_NUML;
|
|
break;
|
|
default:
|
|
led = -1;
|
|
return;
|
|
}
|
|
if (test_bit(led, visorinput_dev->led) != desired_state) {
|
|
input_report_key(visorinput_dev, keycode, 1);
|
|
input_sync(visorinput_dev);
|
|
input_report_key(visorinput_dev, keycode, 0);
|
|
input_sync(visorinput_dev);
|
|
__change_bit(led, visorinput_dev->led);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* <scancode> is either a 1-byte scancode, or an extended 16-bit scancode
|
|
* with 0xE0 in the low byte and the extended scancode value in the next
|
|
* higher byte.
|
|
*/
|
|
static int
|
|
scancode_to_keycode(int scancode)
|
|
{
|
|
if (scancode > 0xff)
|
|
return visorkbd_ext_keycode[(scancode >> 8) & 0xff];
|
|
|
|
return visorkbd_keycode[scancode];
|
|
}
|
|
|
|
static int
|
|
calc_button(int x)
|
|
{
|
|
switch (x) {
|
|
case 1:
|
|
return BTN_LEFT;
|
|
case 2:
|
|
return BTN_MIDDLE;
|
|
case 3:
|
|
return BTN_RIGHT;
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This is used only when this driver is active as an input driver in the
|
|
* client guest partition. It is called periodically so we can obtain inputs
|
|
* from the channel, and deliver them to the guest OS.
|
|
*/
|
|
static void
|
|
visorinput_channel_interrupt(struct visor_device *dev)
|
|
{
|
|
struct ultra_inputreport r;
|
|
int scancode, keycode;
|
|
struct input_dev *visorinput_dev;
|
|
int xmotion, ymotion, button;
|
|
int i;
|
|
|
|
struct visorinput_devdata *devdata = dev_get_drvdata(&dev->device);
|
|
|
|
if (!devdata)
|
|
return;
|
|
|
|
visorinput_dev = devdata->visorinput_dev;
|
|
|
|
while (!visorchannel_signalremove(dev->visorchannel, 0, &r)) {
|
|
scancode = r.activity.arg1;
|
|
keycode = scancode_to_keycode(scancode);
|
|
switch (r.activity.action) {
|
|
case inputaction_key_down:
|
|
input_report_key(visorinput_dev, keycode, 1);
|
|
input_sync(visorinput_dev);
|
|
break;
|
|
case inputaction_key_up:
|
|
input_report_key(visorinput_dev, keycode, 0);
|
|
input_sync(visorinput_dev);
|
|
break;
|
|
case inputaction_key_down_up:
|
|
input_report_key(visorinput_dev, keycode, 1);
|
|
input_sync(visorinput_dev);
|
|
input_report_key(visorinput_dev, keycode, 0);
|
|
input_sync(visorinput_dev);
|
|
break;
|
|
case inputaction_set_locking_key_state:
|
|
handle_locking_key(visorinput_dev, keycode,
|
|
r.activity.arg2);
|
|
break;
|
|
case inputaction_xy_motion:
|
|
xmotion = r.activity.arg1;
|
|
ymotion = r.activity.arg2;
|
|
input_report_abs(visorinput_dev, ABS_X, xmotion);
|
|
input_report_abs(visorinput_dev, ABS_Y, ymotion);
|
|
input_sync(visorinput_dev);
|
|
break;
|
|
case inputaction_mouse_button_down:
|
|
button = calc_button(r.activity.arg1);
|
|
if (button < 0)
|
|
break;
|
|
input_report_key(visorinput_dev, button, 1);
|
|
input_sync(visorinput_dev);
|
|
break;
|
|
case inputaction_mouse_button_up:
|
|
button = calc_button(r.activity.arg1);
|
|
if (button < 0)
|
|
break;
|
|
input_report_key(visorinput_dev, button, 0);
|
|
input_sync(visorinput_dev);
|
|
break;
|
|
case inputaction_mouse_button_click:
|
|
button = calc_button(r.activity.arg1);
|
|
if (button < 0)
|
|
break;
|
|
input_report_key(visorinput_dev, button, 1);
|
|
|
|
input_sync(visorinput_dev);
|
|
input_report_key(visorinput_dev, button, 0);
|
|
input_sync(visorinput_dev);
|
|
break;
|
|
case inputaction_mouse_button_dclick:
|
|
button = calc_button(r.activity.arg1);
|
|
if (button < 0)
|
|
break;
|
|
for (i = 0; i < 2; i++) {
|
|
input_report_key(visorinput_dev, button, 1);
|
|
input_sync(visorinput_dev);
|
|
input_report_key(visorinput_dev, button, 0);
|
|
input_sync(visorinput_dev);
|
|
}
|
|
break;
|
|
case inputaction_wheel_rotate_away:
|
|
input_report_rel(visorinput_dev, REL_WHEEL, 1);
|
|
input_sync(visorinput_dev);
|
|
break;
|
|
case inputaction_wheel_rotate_toward:
|
|
input_report_rel(visorinput_dev, REL_WHEEL, -1);
|
|
input_sync(visorinput_dev);
|
|
break;
|
|
default:
|
|
/* Unsupported input action */
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static int
|
|
visorinput_pause(struct visor_device *dev,
|
|
visorbus_state_complete_func complete_func)
|
|
{
|
|
int rc;
|
|
struct visorinput_devdata *devdata = dev_get_drvdata(&dev->device);
|
|
|
|
if (!devdata) {
|
|
rc = -ENODEV;
|
|
goto out;
|
|
}
|
|
|
|
mutex_lock(&devdata->lock_visor_dev);
|
|
if (devdata->paused) {
|
|
rc = -EBUSY;
|
|
goto out_locked;
|
|
}
|
|
if (devdata->interrupts_enabled)
|
|
visorbus_disable_channel_interrupts(dev);
|
|
|
|
/*
|
|
* due to above, at this time no thread of execution will be
|
|
* in visorinput_channel_interrupt()
|
|
*/
|
|
|
|
devdata->paused = true;
|
|
complete_func(dev, 0);
|
|
rc = 0;
|
|
out_locked:
|
|
mutex_unlock(&devdata->lock_visor_dev);
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
static int
|
|
visorinput_resume(struct visor_device *dev,
|
|
visorbus_state_complete_func complete_func)
|
|
{
|
|
int rc;
|
|
struct visorinput_devdata *devdata = dev_get_drvdata(&dev->device);
|
|
|
|
if (!devdata) {
|
|
rc = -ENODEV;
|
|
goto out;
|
|
}
|
|
mutex_lock(&devdata->lock_visor_dev);
|
|
if (!devdata->paused) {
|
|
rc = -EBUSY;
|
|
goto out_locked;
|
|
}
|
|
devdata->paused = false;
|
|
complete_func(dev, 0);
|
|
|
|
/*
|
|
* Re-establish calls to visorinput_channel_interrupt() if that is
|
|
* the desired state that we've kept track of in interrupts_enabled
|
|
* while the device was paused.
|
|
*/
|
|
if (devdata->interrupts_enabled)
|
|
visorbus_enable_channel_interrupts(dev);
|
|
|
|
rc = 0;
|
|
out_locked:
|
|
mutex_unlock(&devdata->lock_visor_dev);
|
|
out:
|
|
return rc;
|
|
}
|
|
|
|
/* GUIDS for all channel types supported by this driver. */
|
|
static struct visor_channeltype_descriptor visorinput_channel_types[] = {
|
|
{ SPAR_KEYBOARD_CHANNEL_PROTOCOL_UUID, "keyboard"},
|
|
{ SPAR_MOUSE_CHANNEL_PROTOCOL_UUID, "mouse"},
|
|
{ NULL_UUID_LE, NULL }
|
|
};
|
|
|
|
static struct visor_driver visorinput_driver = {
|
|
.name = "visorinput",
|
|
.owner = THIS_MODULE,
|
|
.channel_types = visorinput_channel_types,
|
|
.probe = visorinput_probe,
|
|
.remove = visorinput_remove,
|
|
.channel_interrupt = visorinput_channel_interrupt,
|
|
.pause = visorinput_pause,
|
|
.resume = visorinput_resume,
|
|
};
|
|
|
|
static int
|
|
visorinput_init(void)
|
|
{
|
|
return visorbus_register_visor_driver(&visorinput_driver);
|
|
}
|
|
|
|
static void
|
|
visorinput_cleanup(void)
|
|
{
|
|
visorbus_unregister_visor_driver(&visorinput_driver);
|
|
}
|
|
|
|
module_init(visorinput_init);
|
|
module_exit(visorinput_cleanup);
|
|
|
|
MODULE_DEVICE_TABLE(visorbus, visorinput_channel_types);
|
|
|
|
MODULE_AUTHOR("Unisys");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_DESCRIPTION("s-Par human input driver for virtual keyboard/mouse");
|
|
|
|
MODULE_ALIAS("visorbus:" SPAR_MOUSE_CHANNEL_PROTOCOL_UUID_STR);
|
|
MODULE_ALIAS("visorbus:" SPAR_KEYBOARD_CHANNEL_PROTOCOL_UUID_STR);
|