guillemot.c 6.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * Copyright (c) 2001 Vojtech Pavlik
  4. */
  5. /*
  6. * Guillemot Digital Interface Protocol driver for Linux
  7. */
  8. /*
  9. */
  10. #include <linux/kernel.h>
  11. #include <linux/slab.h>
  12. #include <linux/module.h>
  13. #include <linux/delay.h>
  14. #include <linux/gameport.h>
  15. #include <linux/input.h>
  16. #include <linux/jiffies.h>
  17. #define DRIVER_DESC "Guillemot Digital joystick driver"
  18. MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>");
  19. MODULE_DESCRIPTION(DRIVER_DESC);
  20. MODULE_LICENSE("GPL");
  21. #define GUILLEMOT_MAX_START 600 /* 600 us */
  22. #define GUILLEMOT_MAX_STROBE 60 /* 60 us */
  23. #define GUILLEMOT_MAX_LENGTH 17 /* 17 bytes */
  24. static short guillemot_abs_pad[] =
  25. { ABS_X, ABS_Y, ABS_THROTTLE, ABS_RUDDER, -1 };
  26. static short guillemot_btn_pad[] =
  27. { BTN_A, BTN_B, BTN_C, BTN_X, BTN_Y, BTN_Z, BTN_TL, BTN_TR, BTN_MODE, BTN_SELECT, -1 };
  28. static struct {
  29. int x;
  30. int y;
  31. } guillemot_hat_to_axis[16] = {{ 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
  32. struct guillemot_type {
  33. unsigned char id;
  34. short *abs;
  35. short *btn;
  36. int hat;
  37. char *name;
  38. };
  39. struct guillemot {
  40. struct gameport *gameport;
  41. struct input_dev *dev;
  42. int bads;
  43. int reads;
  44. struct guillemot_type *type;
  45. unsigned char length;
  46. char phys[32];
  47. };
  48. static struct guillemot_type guillemot_type[] = {
  49. { 0x00, guillemot_abs_pad, guillemot_btn_pad, 1, "Guillemot Pad" },
  50. { 0 }};
  51. /*
  52. * guillemot_read_packet() reads Guillemot joystick data.
  53. */
  54. static int guillemot_read_packet(struct gameport *gameport, u8 *data)
  55. {
  56. unsigned long flags;
  57. unsigned char u, v;
  58. unsigned int t, s;
  59. int i;
  60. for (i = 0; i < GUILLEMOT_MAX_LENGTH; i++)
  61. data[i] = 0;
  62. i = 0;
  63. t = gameport_time(gameport, GUILLEMOT_MAX_START);
  64. s = gameport_time(gameport, GUILLEMOT_MAX_STROBE);
  65. local_irq_save(flags);
  66. gameport_trigger(gameport);
  67. v = gameport_read(gameport);
  68. while (t > 0 && i < GUILLEMOT_MAX_LENGTH * 8) {
  69. t--;
  70. u = v; v = gameport_read(gameport);
  71. if (v & ~u & 0x10) {
  72. data[i >> 3] |= ((v >> 5) & 1) << (i & 7);
  73. i++;
  74. t = s;
  75. }
  76. }
  77. local_irq_restore(flags);
  78. return i;
  79. }
  80. /*
  81. * guillemot_poll() reads and analyzes Guillemot joystick data.
  82. */
  83. static void guillemot_poll(struct gameport *gameport)
  84. {
  85. struct guillemot *guillemot = gameport_get_drvdata(gameport);
  86. struct input_dev *dev = guillemot->dev;
  87. u8 data[GUILLEMOT_MAX_LENGTH];
  88. int i;
  89. guillemot->reads++;
  90. if (guillemot_read_packet(guillemot->gameport, data) != GUILLEMOT_MAX_LENGTH * 8 ||
  91. data[0] != 0x55 || data[16] != 0xaa) {
  92. guillemot->bads++;
  93. } else {
  94. for (i = 0; i < 6 && guillemot->type->abs[i] >= 0; i++)
  95. input_report_abs(dev, guillemot->type->abs[i], data[i + 5]);
  96. if (guillemot->type->hat) {
  97. input_report_abs(dev, ABS_HAT0X, guillemot_hat_to_axis[data[4] >> 4].x);
  98. input_report_abs(dev, ABS_HAT0Y, guillemot_hat_to_axis[data[4] >> 4].y);
  99. }
  100. for (i = 0; i < 16 && guillemot->type->btn[i] >= 0; i++)
  101. input_report_key(dev, guillemot->type->btn[i], (data[2 + (i >> 3)] >> (i & 7)) & 1);
  102. }
  103. input_sync(dev);
  104. }
  105. /*
  106. * guillemot_open() is a callback from the input open routine.
  107. */
  108. static int guillemot_open(struct input_dev *dev)
  109. {
  110. struct guillemot *guillemot = input_get_drvdata(dev);
  111. gameport_start_polling(guillemot->gameport);
  112. return 0;
  113. }
  114. /*
  115. * guillemot_close() is a callback from the input close routine.
  116. */
  117. static void guillemot_close(struct input_dev *dev)
  118. {
  119. struct guillemot *guillemot = input_get_drvdata(dev);
  120. gameport_stop_polling(guillemot->gameport);
  121. }
  122. /*
  123. * guillemot_connect() probes for Guillemot joysticks.
  124. */
  125. static int guillemot_connect(struct gameport *gameport, struct gameport_driver *drv)
  126. {
  127. struct guillemot *guillemot;
  128. struct input_dev *input_dev;
  129. u8 data[GUILLEMOT_MAX_LENGTH];
  130. int i, t;
  131. int err;
  132. guillemot = kzalloc(sizeof(struct guillemot), GFP_KERNEL);
  133. input_dev = input_allocate_device();
  134. if (!guillemot || !input_dev) {
  135. err = -ENOMEM;
  136. goto fail1;
  137. }
  138. guillemot->gameport = gameport;
  139. guillemot->dev = input_dev;
  140. gameport_set_drvdata(gameport, guillemot);
  141. err = gameport_open(gameport, drv, GAMEPORT_MODE_RAW);
  142. if (err)
  143. goto fail1;
  144. i = guillemot_read_packet(gameport, data);
  145. if (i != GUILLEMOT_MAX_LENGTH * 8 || data[0] != 0x55 || data[16] != 0xaa) {
  146. err = -ENODEV;
  147. goto fail2;
  148. }
  149. for (i = 0; guillemot_type[i].name; i++)
  150. if (guillemot_type[i].id == data[11])
  151. break;
  152. if (!guillemot_type[i].name) {
  153. printk(KERN_WARNING "guillemot.c: Unknown joystick on %s. [ %02x%02x:%04x, ver %d.%02d ]\n",
  154. gameport->phys, data[12], data[13], data[11], data[14], data[15]);
  155. err = -ENODEV;
  156. goto fail2;
  157. }
  158. gameport_set_poll_handler(gameport, guillemot_poll);
  159. gameport_set_poll_interval(gameport, 20);
  160. snprintf(guillemot->phys, sizeof(guillemot->phys), "%s/input0", gameport->phys);
  161. guillemot->type = guillemot_type + i;
  162. input_dev->name = guillemot_type[i].name;
  163. input_dev->phys = guillemot->phys;
  164. input_dev->id.bustype = BUS_GAMEPORT;
  165. input_dev->id.vendor = GAMEPORT_ID_VENDOR_GUILLEMOT;
  166. input_dev->id.product = guillemot_type[i].id;
  167. input_dev->id.version = (int)data[14] << 8 | data[15];
  168. input_dev->dev.parent = &gameport->dev;
  169. input_set_drvdata(input_dev, guillemot);
  170. input_dev->open = guillemot_open;
  171. input_dev->close = guillemot_close;
  172. input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
  173. for (i = 0; (t = guillemot->type->abs[i]) >= 0; i++)
  174. input_set_abs_params(input_dev, t, 0, 255, 0, 0);
  175. if (guillemot->type->hat) {
  176. input_set_abs_params(input_dev, ABS_HAT0X, -1, 1, 0, 0);
  177. input_set_abs_params(input_dev, ABS_HAT0Y, -1, 1, 0, 0);
  178. }
  179. for (i = 0; (t = guillemot->type->btn[i]) >= 0; i++)
  180. set_bit(t, input_dev->keybit);
  181. err = input_register_device(guillemot->dev);
  182. if (err)
  183. goto fail2;
  184. return 0;
  185. fail2: gameport_close(gameport);
  186. fail1: gameport_set_drvdata(gameport, NULL);
  187. input_free_device(input_dev);
  188. kfree(guillemot);
  189. return err;
  190. }
  191. static void guillemot_disconnect(struct gameport *gameport)
  192. {
  193. struct guillemot *guillemot = gameport_get_drvdata(gameport);
  194. printk(KERN_INFO "guillemot.c: Failed %d reads out of %d on %s\n", guillemot->reads, guillemot->bads, guillemot->phys);
  195. input_unregister_device(guillemot->dev);
  196. gameport_close(gameport);
  197. kfree(guillemot);
  198. }
  199. static struct gameport_driver guillemot_drv = {
  200. .driver = {
  201. .name = "guillemot",
  202. },
  203. .description = DRIVER_DESC,
  204. .connect = guillemot_connect,
  205. .disconnect = guillemot_disconnect,
  206. };
  207. module_gameport_driver(guillemot_drv);