remote.c 9.3 KB

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