drivers/misc/ibmasm/remote.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * IBM ASM Service Processor Device Driver
   4  *
   5  * Copyright (C) IBM Corporation, 2004
   6  *
   7  * Authors: Max Asböck <amax@us.ibm.com>
   8  *          Vernon Mauery <vernux@us.ibm.com>
   9  */
  10
  11 /* Remote mouse and keyboard event handling functions */
  12
  13 #include <linux/pci.h>
  14 #include "ibmasm.h"
  15 #include "remote.h"
  16
  17 #define MOUSE_X_MAX     1600
  18 #define MOUSE_Y_MAX     1200
  19
  20 static const unsigned short xlate_high[XLATE_SIZE] = {
  21         [KEY_SYM_ENTER & 0xff] = KEY_ENTER,
  22         [KEY_SYM_KPSLASH & 0xff] = KEY_KPSLASH,
  23         [KEY_SYM_KPSTAR & 0xff] = KEY_KPASTERISK,
  24         [KEY_SYM_KPMINUS & 0xff] = KEY_KPMINUS,
  25         [KEY_SYM_KPDOT & 0xff] = KEY_KPDOT,
  26         [KEY_SYM_KPPLUS & 0xff] = KEY_KPPLUS,
  27         [KEY_SYM_KP0 & 0xff] = KEY_KP0,
  28         [KEY_SYM_KP1 & 0xff] = KEY_KP1,
  29         [KEY_SYM_KP2 & 0xff] = KEY_KP2, [KEY_SYM_KPDOWN & 0xff] = KEY_KP2,
  30         [KEY_SYM_KP3 & 0xff] = KEY_KP3,
  31         [KEY_SYM_KP4 & 0xff] = KEY_KP4, [KEY_SYM_KPLEFT & 0xff] = KEY_KP4,
  32         [KEY_SYM_KP5 & 0xff] = KEY_KP5,
  33         [KEY_SYM_KP6 & 0xff] = KEY_KP6, [KEY_SYM_KPRIGHT & 0xff] = KEY_KP6,
  34         [KEY_SYM_KP7 & 0xff] = KEY_KP7,
  35         [KEY_SYM_KP8 & 0xff] = KEY_KP8, [KEY_SYM_KPUP & 0xff] = KEY_KP8,
  36         [KEY_SYM_KP9 & 0xff] = KEY_KP9,
  37         [KEY_SYM_BK_SPC & 0xff] = KEY_BACKSPACE,
  38         [KEY_SYM_TAB & 0xff] = KEY_TAB,
  39         [KEY_SYM_CTRL & 0xff] = KEY_LEFTCTRL,
  40         [KEY_SYM_ALT & 0xff] = KEY_LEFTALT,
  41         [KEY_SYM_INSERT & 0xff] = KEY_INSERT,
  42         [KEY_SYM_DELETE & 0xff] = KEY_DELETE,
  43         [KEY_SYM_SHIFT & 0xff] = KEY_LEFTSHIFT,
  44         [KEY_SYM_UARROW & 0xff] = KEY_UP,
  45         [KEY_SYM_DARROW & 0xff] = KEY_DOWN,
  46         [KEY_SYM_LARROW & 0xff] = KEY_LEFT,
  47         [KEY_SYM_RARROW & 0xff] = KEY_RIGHT,
  48         [KEY_SYM_ESCAPE & 0xff] = KEY_ESC,
  49         [KEY_SYM_PAGEUP & 0xff] = KEY_PAGEUP,
  50         [KEY_SYM_PAGEDOWN & 0xff] = KEY_PAGEDOWN,
  51         [KEY_SYM_HOME & 0xff] = KEY_HOME,
  52         [KEY_SYM_END & 0xff] = KEY_END,
  53         [KEY_SYM_F1 & 0xff] = KEY_F1,
  54         [KEY_SYM_F2 & 0xff] = KEY_F2,
  55         [KEY_SYM_F3 & 0xff] = KEY_F3,
  56         [KEY_SYM_F4 & 0xff] = KEY_F4,
  57         [KEY_SYM_F5 & 0xff] = KEY_F5,
  58         [KEY_SYM_F6 & 0xff] = KEY_F6,
  59         [KEY_SYM_F7 & 0xff] = KEY_F7,
  60         [KEY_SYM_F8 & 0xff] = KEY_F8,
  61         [KEY_SYM_F9 & 0xff] = KEY_F9,
  62         [KEY_SYM_F10 & 0xff] = KEY_F10,
  63         [KEY_SYM_F11 & 0xff] = KEY_F11,
  64         [KEY_SYM_F12 & 0xff] = KEY_F12,
  65         [KEY_SYM_CAP_LOCK & 0xff] = KEY_CAPSLOCK,
  66         [KEY_SYM_NUM_LOCK & 0xff] = KEY_NUMLOCK,
  67         [KEY_SYM_SCR_LOCK & 0xff] = KEY_SCROLLLOCK,
  68 };
  69
  70 static const unsigned short xlate[XLATE_SIZE] = {
  71         [NO_KEYCODE] = KEY_RESERVED,
  72         [KEY_SYM_SPACE] = KEY_SPACE,
  73         [KEY_SYM_TILDE] = KEY_GRAVE,        [KEY_SYM_BKTIC] = KEY_GRAVE,
  74         [KEY_SYM_ONE] = KEY_1,              [KEY_SYM_BANG] = KEY_1,
  75         [KEY_SYM_TWO] = KEY_2,              [KEY_SYM_AT] = KEY_2,
  76         [KEY_SYM_THREE] = KEY_3,            [KEY_SYM_POUND] = KEY_3,
  77         [KEY_SYM_FOUR] = KEY_4,             [KEY_SYM_DOLLAR] = KEY_4,
  78         [KEY_SYM_FIVE] = KEY_5,             [KEY_SYM_PERCENT] = KEY_5,
  79         [KEY_SYM_SIX] = KEY_6,              [KEY_SYM_CARAT] = KEY_6,
  80         [KEY_SYM_SEVEN] = KEY_7,            [KEY_SYM_AMPER] = KEY_7,
  81         [KEY_SYM_EIGHT] = KEY_8,            [KEY_SYM_STAR] = KEY_8,
  82         [KEY_SYM_NINE] = KEY_9,             [KEY_SYM_LPAREN] = KEY_9,
  83         [KEY_SYM_ZERO] = KEY_0,             [KEY_SYM_RPAREN] = KEY_0,
  84         [KEY_SYM_MINUS] = KEY_MINUS,        [KEY_SYM_USCORE] = KEY_MINUS,
  85         [KEY_SYM_EQUAL] = KEY_EQUAL,        [KEY_SYM_PLUS] = KEY_EQUAL,
  86         [KEY_SYM_LBRKT] = KEY_LEFTBRACE,    [KEY_SYM_LCURLY] = KEY_LEFTBRACE,
  87         [KEY_SYM_RBRKT] = KEY_RIGHTBRACE,   [KEY_SYM_RCURLY] = KEY_RIGHTBRACE,
  88         [KEY_SYM_SLASH] = KEY_BACKSLASH,    [KEY_SYM_PIPE] = KEY_BACKSLASH,
  89         [KEY_SYM_TIC] = KEY_APOSTROPHE,     [KEY_SYM_QUOTE] = KEY_APOSTROPHE,
  90         [KEY_SYM_SEMIC] = KEY_SEMICOLON,    [KEY_SYM_COLON] = KEY_SEMICOLON,
  91         [KEY_SYM_COMMA] = KEY_COMMA,        [KEY_SYM_LT] = KEY_COMMA,
  92         [KEY_SYM_PERIOD] = KEY_DOT,         [KEY_SYM_GT] = KEY_DOT,
  93         [KEY_SYM_BSLASH] = KEY_SLASH,       [KEY_SYM_QMARK] = KEY_SLASH,
  94         [KEY_SYM_A] = KEY_A,                [KEY_SYM_a] = KEY_A,
  95         [KEY_SYM_B] = KEY_B,                [KEY_SYM_b] = KEY_B,
  96         [KEY_SYM_C] = KEY_C,                [KEY_SYM_c] = KEY_C,
  97         [KEY_SYM_D] = KEY_D,                [KEY_SYM_d] = KEY_D,
  98         [KEY_SYM_E] = KEY_E,                [KEY_SYM_e] = KEY_E,
  99         [KEY_SYM_F] = KEY_F,                [KEY_SYM_f] = KEY_F,
 100         [KEY_SYM_G] = KEY_G,                [KEY_SYM_g] = KEY_G,
 101         [KEY_SYM_H] = KEY_H,                [KEY_SYM_h] = KEY_H,
 102         [KEY_SYM_I] = KEY_I,                [KEY_SYM_i] = KEY_I,
 103         [KEY_SYM_J] = KEY_J,                [KEY_SYM_j] = KEY_J,
 104         [KEY_SYM_K] = KEY_K,                [KEY_SYM_k] = KEY_K,
 105         [KEY_SYM_L] = KEY_L,                [KEY_SYM_l] = KEY_L,
 106         [KEY_SYM_M] = KEY_M,                [KEY_SYM_m] = KEY_M,
 107         [KEY_SYM_N] = KEY_N,                [KEY_SYM_n] = KEY_N,
 108         [KEY_SYM_O] = KEY_O,                [KEY_SYM_o] = KEY_O,
 109         [KEY_SYM_P] = KEY_P,                [KEY_SYM_p] = KEY_P,
 110         [KEY_SYM_Q] = KEY_Q,                [KEY_SYM_q] = KEY_Q,
 111         [KEY_SYM_R] = KEY_R,                [KEY_SYM_r] = KEY_R,
 112         [KEY_SYM_S] = KEY_S,                [KEY_SYM_s] = KEY_S,
 113         [KEY_SYM_T] = KEY_T,                [KEY_SYM_t] = KEY_T,
 114         [KEY_SYM_U] = KEY_U,                [KEY_SYM_u] = KEY_U,
 115         [KEY_SYM_V] = KEY_V,                [KEY_SYM_v] = KEY_V,
 116         [KEY_SYM_W] = KEY_W,                [KEY_SYM_w] = KEY_W,
 117         [KEY_SYM_X] = KEY_X,                [KEY_SYM_x] = KEY_X,
 118         [KEY_SYM_Y] = KEY_Y,                [KEY_SYM_y] = KEY_Y,
 119         [KEY_SYM_Z] = KEY_Z,                [KEY_SYM_z] = KEY_Z,
 120 };
 121
 122 static void print_input(struct remote_input *input)
 123 {
 124         if (input->type == INPUT_TYPE_MOUSE) {
 125                 unsigned char buttons = input->mouse_buttons;
 126                 dbg("remote mouse movement: (x,y)=(%d,%d)%s%s%s%s\n",
 127                         input->data.mouse.x, input->data.mouse.y,
 128                         (buttons) ? " -- buttons:" : "",
 129                         (buttons & REMOTE_BUTTON_LEFT) ? "left " : "",
 130                         (buttons & REMOTE_BUTTON_MIDDLE) ? "middle " : "",
 131                         (buttons & REMOTE_BUTTON_RIGHT) ? "right" : ""
 132                       );
 133         } else {
 134                 dbg("remote keypress (code, flag, down):"
 135                            "%d (0x%x) [0x%x] [0x%x]\n",
 136                                 input->data.keyboard.key_code,
 137                                 input->data.keyboard.key_code,
 138                                 input->data.keyboard.key_flag,
 139                                 input->data.keyboard.key_down
 140                       );
 141         }
 142 }
 143
 144 static void send_mouse_event(struct input_dev *dev, struct remote_input *input)
 145 {
 146         unsigned char buttons = input->mouse_buttons;
 147
 148         input_report_abs(dev, ABS_X, input->data.mouse.x);
 149         input_report_abs(dev, ABS_Y, input->data.mouse.y);
 150         input_report_key(dev, BTN_LEFT, buttons & REMOTE_BUTTON_LEFT);
 151         input_report_key(dev, BTN_MIDDLE, buttons & REMOTE_BUTTON_MIDDLE);
 152         input_report_key(dev, BTN_RIGHT, buttons & REMOTE_BUTTON_RIGHT);
 153         input_sync(dev);
 154 }
 155
 156 static void send_keyboard_event(struct input_dev *dev,
 157                 struct remote_input *input)
 158 {
 159         unsigned int key;
 160         unsigned short code = input->data.keyboard.key_code;
 161
 162         if (code & 0xff00)
 163                 key = xlate_high[code & 0xff];
 164         else
 165                 key = xlate[code];
 166         input_report_key(dev, key, input->data.keyboard.key_down);
 167         input_sync(dev);
 168 }
 169
 170 void ibmasm_handle_mouse_interrupt(struct service_processor *sp)
 171 {
 172         unsigned long reader;
 173         unsigned long writer;
 174         struct remote_input input;
 175
 176         reader = get_queue_reader(sp);
 177         writer = get_queue_writer(sp);
 178
 179         while (reader != writer) {
 180                 memcpy_fromio(&input, get_queue_entry(sp, reader),
 181                                 sizeof(struct remote_input));
 182
 183                 print_input(&input);
 184                 if (input.type == INPUT_TYPE_MOUSE) {
 185                         send_mouse_event(sp->remote.mouse_dev, &input);
 186                 } else if (input.type == INPUT_TYPE_KEYBOARD) {
 187                         send_keyboard_event(sp->remote.keybd_dev, &input);
 188                 } else
 189                         break;
 190
 191                 reader = advance_queue_reader(sp, reader);
 192                 writer = get_queue_writer(sp);
 193         }
 194 }
 195
 196 int ibmasm_init_remote_input_dev(struct service_processor *sp)
 197 {
 198         /* set up the mouse input device */
 199         struct input_dev *mouse_dev, *keybd_dev;
 200         struct pci_dev *pdev = to_pci_dev(sp->dev);
 201         int error = -ENOMEM;
 202         int i;
 203
 204         sp->remote.mouse_dev = mouse_dev = input_allocate_device();
 205         sp->remote.keybd_dev = keybd_dev = input_allocate_device();
 206
 207         if (!mouse_dev || !keybd_dev)
 208                 goto err_free_devices;
 209
 210         mouse_dev->id.bustype = BUS_PCI;
 211         mouse_dev->id.vendor = pdev->vendor;
 212         mouse_dev->id.product = pdev->device;
 213         mouse_dev->id.version = 1;
 214         mouse_dev->dev.parent = sp->dev;
 215         mouse_dev->evbit[0]  = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 216         mouse_dev->keybit[BIT_WORD(BTN_MOUSE)] = BIT_MASK(BTN_LEFT) |
 217                 BIT_MASK(BTN_RIGHT) | BIT_MASK(BTN_MIDDLE);
 218         set_bit(BTN_TOUCH, mouse_dev->keybit);
 219         mouse_dev->name = "ibmasm RSA I remote mouse";
 220         input_set_abs_params(mouse_dev, ABS_X, 0, MOUSE_X_MAX, 0, 0);
 221         input_set_abs_params(mouse_dev, ABS_Y, 0, MOUSE_Y_MAX, 0, 0);
 222
 223         keybd_dev->id.bustype = BUS_PCI;
 224         keybd_dev->id.vendor = pdev->vendor;
 225         keybd_dev->id.product = pdev->device;
 226         keybd_dev->id.version = 2;
 227         keybd_dev->dev.parent = sp->dev;
 228         keybd_dev->evbit[0]  = BIT_MASK(EV_KEY);
 229         keybd_dev->name = "ibmasm RSA I remote keyboard";
 230
 231         for (i = 0; i < XLATE_SIZE; i++) {
 232                 if (xlate_high[i])
 233                         set_bit(xlate_high[i], keybd_dev->keybit);
 234                 if (xlate[i])
 235                         set_bit(xlate[i], keybd_dev->keybit);
 236         }
 237
 238         error = input_register_device(mouse_dev);
 239         if (error)
 240                 goto err_free_devices;
 241
 242         error = input_register_device(keybd_dev);
 243         if (error)
 244                 goto err_unregister_mouse_dev;
 245
 246         enable_mouse_interrupts(sp);
 247
 248         printk(KERN_INFO "ibmasm remote responding to events on RSA card %d\n", sp->number);
 249
 250         return 0;
 251
 252  err_unregister_mouse_dev:
 253         input_unregister_device(mouse_dev);
 254         mouse_dev = NULL; /* so we don't try to free it again below */
 255  err_free_devices:
 256         input_free_device(mouse_dev);
 257         input_free_device(keybd_dev);
 258
 259         return error;
 260 }
 261
 262 void ibmasm_free_remote_input_dev(struct service_processor *sp)
 263 {
 264         disable_mouse_interrupts(sp);
 265         input_unregister_device(sp->remote.mouse_dev);
 266         input_unregister_device(sp->remote.keybd_dev);
 267 }
 268