| // SPDX-License-Identifier: GPL-2.0 |
| /* |
| * Copyright (C) 2011 - 2015 UNISYS CORPORATION |
| * All rights reserved. |
| */ |
| |
| /* |
| * 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/fb.h> |
| #include <linux/input.h> |
| #include <linux/kernel.h> |
| #include <linux/module.h> |
| #include <linux/uuid.h> |
| #include <linux/visorbus.h> |
| |
| /* These defines identify mouse and keyboard activity which is specified by the |
| * firmware to the host using the cmsimpleinput protocol. @ingroup coretypes |
| */ |
| /* only motion; arg1=x, arg2=y */ |
| #define INPUTACTION_XY_MOTION 1 |
| |
| /* arg1: 1=left,2=center,3=right */ |
| #define INPUTACTION_MOUSE_BUTTON_DOWN 2 |
| #define INPUTACTION_MOUSE_BUTTON_UP 3 |
| #define INPUTACTION_MOUSE_BUTTON_CLICK 4 |
| #define INPUTACTION_MOUSE_BUTTON_DCLICK 5 |
| |
| /* arg1: wheel rotation away from/toward user */ |
| #define INPUTACTION_WHEEL_ROTATE_AWAY 6 |
| #define INPUTACTION_WHEEL_ROTATE_TOWARD 7 |
| |
| /* arg1: scancode, as follows: If arg1 <= 0xff, it's a 1-byte scancode and arg1 |
| * is that scancode. If arg1 > 0xff, it's a 2-byte scanecode, with the 1st |
| * byte in the low 8 bits, and the 2nd byte in the high 8 bits. |
| * E.g., the right ALT key would appear as x'38e0'. |
| */ |
| #define INPUTACTION_KEY_DOWN 64 |
| #define INPUTACTION_KEY_UP 65 |
| #define INPUTACTION_KEY_DOWN_UP 67 |
| |
| /* arg1: scancode (in same format as inputaction_keyDown); MUST refer to one of |
| * the locking keys, like capslock, numlock, or scrolllock. |
| * arg2: 1 iff locking key should be in the LOCKED position (e.g., light is ON) |
| */ |
| #define INPUTACTION_SET_LOCKING_KEY_STATE 66 |
| |
| /* Keyboard channel {c73416d0-b0b8-44af-b304-9d2ae99f1b3d} */ |
| #define VISOR_KEYBOARD_CHANNEL_GUID \ |
| GUID_INIT(0xc73416d0, 0xb0b8, 0x44af, \ |
| 0xb3, 0x4, 0x9d, 0x2a, 0xe9, 0x9f, 0x1b, 0x3d) |
| #define VISOR_KEYBOARD_CHANNEL_GUID_STR "c73416d0-b0b8-44af-b304-9d2ae99f1b3d" |
| |
| /* Mouse channel {addf07d4-94a9-46e2-81c3-61abcdbdbd87} */ |
| #define VISOR_MOUSE_CHANNEL_GUID \ |
| GUID_INIT(0xaddf07d4, 0x94a9, 0x46e2, \ |
| 0x81, 0xc3, 0x61, 0xab, 0xcd, 0xbd, 0xbd, 0x87) |
| #define VISOR_MOUSE_CHANNEL_GUID_STR "addf07d4-94a9-46e2-81c3-61abcdbdbd87" |
| |
| #define PIXELS_ACROSS_DEFAULT 1024 |
| #define PIXELS_DOWN_DEFAULT 768 |
| #define KEYCODE_TABLE_BYTES 256 |
| |
| struct visor_inputactivity { |
| u16 action; |
| u16 arg1; |
| u16 arg2; |
| u16 arg3; |
| } __packed; |
| |
| struct visor_inputreport { |
| u64 seq_no; |
| struct visor_inputactivity activity; |
| } __packed; |
| |
| /* header of keyboard/mouse channels */ |
| struct visor_input_channel_data { |
| u32 n_input_reports; |
| union { |
| struct { |
| u16 x_res; |
| u16 y_res; |
| } mouse; |
| struct { |
| u32 flags; |
| } keyboard; |
| }; |
| } __packed; |
| |
| enum visorinput_dev_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; |
| /* lock for dev */ |
| struct mutex lock_visor_dev; |
| struct input_dev *visorinput_dev; |
| bool paused; |
| bool interrupts_enabled; |
| /* size of following array */ |
| unsigned int keycode_table_bytes; |
| /* for keyboard devices: visorkbd_keycode[] + visorkbd_ext_keycode[] */ |
| unsigned char keycode_table[]; |
| }; |
| |
| static const guid_t visor_keyboard_channel_guid = VISOR_KEYBOARD_CHANNEL_GUID; |
| static const guid_t visor_mouse_channel_guid = VISOR_MOUSE_CHANNEL_GUID; |
| |
| /* |
| * 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, |
| /* enables UK backslash+pipe key and FR lessthan+greaterthan key */ |
| [86] = KEY_102ND, |
| [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, |
| unsigned char *keycode_table) |
| |
| { |
| int i; |
| struct input_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; |
| /* sizeof(unsigned char) */ |
| visorinput_dev->keycodesize = 1; |
| 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; |
| /* pre input_register! */ |
| input_set_drvdata(visorinput_dev, devdata); |
| |
| return visorinput_dev; |
| } |
| |
| static struct input_dev *setup_client_mouse(void *devdata, unsigned int xres, |
| unsigned int yres) |
| { |
| struct input_dev *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 (xres == 0) |
| xres = PIXELS_ACROSS_DEFAULT; |
| if (yres == 0) |
| 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; |
| /* pre input_register! */ |
| input_set_drvdata(visorinput_dev, devdata); |
| input_set_capability(visorinput_dev, EV_REL, REL_WHEEL); |
| |
| return visorinput_dev; |
| } |
| |
| static struct visorinput_devdata *devdata_create(struct visor_device *dev, |
| enum visorinput_dev_type dtype) |
| { |
| struct visorinput_devdata *devdata = NULL; |
| unsigned int extra_bytes = 0; |
| unsigned int size, xres, yres, err; |
| struct visor_input_channel_data data; |
| |
| if (dtype == 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 (dtype) { |
| 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: |
| size = sizeof(struct visor_input_channel_data); |
| err = visorbus_read_channel(dev, sizeof(struct channel_header), |
| &data, size); |
| if (err) |
| goto cleanups_register; |
| xres = data.mouse.x_res; |
| yres = data.mouse.y_res; |
| devdata->visorinput_dev = setup_client_mouse(devdata, xres, |
| yres); |
| 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) |
| { |
| const guid_t *guid; |
| enum visorinput_dev_type dtype; |
| |
| guid = visorchannel_get_guid(dev->visorchannel); |
| if (guid_equal(guid, &visor_mouse_channel_guid)) |
| dtype = visorinput_mouse; |
| else if (guid_equal(guid, &visor_keyboard_channel_guid)) |
| dtype = visorinput_keyboard; |
| else |
| return -ENODEV; |
| visorbus_disable_channel_interrupts(dev); |
| if (!devdata_create(dev, dtype)) |
| 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 visor_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[] = { |
| { VISOR_KEYBOARD_CHANNEL_GUID, "keyboard", |
| sizeof(struct channel_header), 0 }, |
| { VISOR_MOUSE_CHANNEL_GUID, "mouse", sizeof(struct channel_header), 0 }, |
| {} |
| }; |
| |
| 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, |
| }; |
| |
| module_driver(visorinput_driver, visorbus_register_visor_driver, |
| visorbus_unregister_visor_driver); |
| |
| 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:" VISOR_MOUSE_CHANNEL_GUID_STR); |
| MODULE_ALIAS("visorbus:" VISOR_KEYBOARD_CHANNEL_GUID_STR); |