hid-saitek.c 5.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * HID driver for Saitek devices.
  4. *
  5. * PS1000 (USB gamepad):
  6. * Fixes the HID report descriptor by removing a non-existent axis and
  7. * clearing the constant bit on the input reports for buttons and d-pad.
  8. * (This module is based on "hid-ortek".)
  9. * Copyright (c) 2012 Andreas Hübner
  10. *
  11. * R.A.T.7, R.A.T.9, M.M.O.7 (USB gaming mice):
  12. * Fixes the mode button which cycles through three constantly pressed
  13. * buttons. All three press events are mapped to one button and the
  14. * missing release event is generated immediately.
  15. */
  16. /*
  17. */
  18. #include <linux/device.h>
  19. #include <linux/hid.h>
  20. #include <linux/module.h>
  21. #include <linux/kernel.h>
  22. #include "hid-ids.h"
  23. #define SAITEK_FIX_PS1000 0x0001
  24. #define SAITEK_RELEASE_MODE_RAT7 0x0002
  25. #define SAITEK_RELEASE_MODE_MMO7 0x0004
  26. struct saitek_sc {
  27. unsigned long quirks;
  28. int mode;
  29. };
  30. static int saitek_probe(struct hid_device *hdev,
  31. const struct hid_device_id *id)
  32. {
  33. unsigned long quirks = id->driver_data;
  34. struct saitek_sc *ssc;
  35. int ret;
  36. ssc = devm_kzalloc(&hdev->dev, sizeof(*ssc), GFP_KERNEL);
  37. if (ssc == NULL) {
  38. hid_err(hdev, "can't alloc saitek descriptor\n");
  39. return -ENOMEM;
  40. }
  41. ssc->quirks = quirks;
  42. ssc->mode = -1;
  43. hid_set_drvdata(hdev, ssc);
  44. ret = hid_parse(hdev);
  45. if (ret) {
  46. hid_err(hdev, "parse failed\n");
  47. return ret;
  48. }
  49. ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
  50. if (ret) {
  51. hid_err(hdev, "hw start failed\n");
  52. return ret;
  53. }
  54. return 0;
  55. }
  56. static __u8 *saitek_report_fixup(struct hid_device *hdev, __u8 *rdesc,
  57. unsigned int *rsize)
  58. {
  59. struct saitek_sc *ssc = hid_get_drvdata(hdev);
  60. if ((ssc->quirks & SAITEK_FIX_PS1000) && *rsize == 137 &&
  61. rdesc[20] == 0x09 && rdesc[21] == 0x33 &&
  62. rdesc[94] == 0x81 && rdesc[95] == 0x03 &&
  63. rdesc[110] == 0x81 && rdesc[111] == 0x03) {
  64. hid_info(hdev, "Fixing up Saitek PS1000 report descriptor\n");
  65. /* convert spurious axis to a "noop" Logical Minimum (0) */
  66. rdesc[20] = 0x15;
  67. rdesc[21] = 0x00;
  68. /* clear constant bit on buttons and d-pad */
  69. rdesc[95] = 0x02;
  70. rdesc[111] = 0x02;
  71. }
  72. return rdesc;
  73. }
  74. static int saitek_raw_event(struct hid_device *hdev,
  75. struct hid_report *report, u8 *raw_data, int size)
  76. {
  77. struct saitek_sc *ssc = hid_get_drvdata(hdev);
  78. if (ssc->quirks & SAITEK_RELEASE_MODE_RAT7 && size == 7) {
  79. /* R.A.T.7 uses bits 13, 14, 15 for the mode */
  80. int mode = -1;
  81. if (raw_data[1] & 0x01)
  82. mode = 0;
  83. else if (raw_data[1] & 0x02)
  84. mode = 1;
  85. else if (raw_data[1] & 0x04)
  86. mode = 2;
  87. /* clear mode bits */
  88. raw_data[1] &= ~0x07;
  89. if (mode != ssc->mode) {
  90. hid_dbg(hdev, "entered mode %d\n", mode);
  91. if (ssc->mode != -1) {
  92. /* use bit 13 as the mode button */
  93. raw_data[1] |= 0x04;
  94. }
  95. ssc->mode = mode;
  96. }
  97. } else if (ssc->quirks & SAITEK_RELEASE_MODE_MMO7 && size == 8) {
  98. /* M.M.O.7 uses bits 8, 22, 23 for the mode */
  99. int mode = -1;
  100. if (raw_data[1] & 0x80)
  101. mode = 0;
  102. else if (raw_data[2] & 0x01)
  103. mode = 1;
  104. else if (raw_data[2] & 0x02)
  105. mode = 2;
  106. /* clear mode bits */
  107. raw_data[1] &= ~0x80;
  108. raw_data[2] &= ~0x03;
  109. if (mode != ssc->mode) {
  110. hid_dbg(hdev, "entered mode %d\n", mode);
  111. if (ssc->mode != -1) {
  112. /* use bit 8 as the mode button, bits 22
  113. * and 23 do not represent buttons
  114. * according to the HID report descriptor
  115. */
  116. raw_data[1] |= 0x80;
  117. }
  118. ssc->mode = mode;
  119. }
  120. }
  121. return 0;
  122. }
  123. static int saitek_event(struct hid_device *hdev, struct hid_field *field,
  124. struct hid_usage *usage, __s32 value)
  125. {
  126. struct saitek_sc *ssc = hid_get_drvdata(hdev);
  127. struct input_dev *input = field->hidinput->input;
  128. if (usage->type == EV_KEY && value &&
  129. (((ssc->quirks & SAITEK_RELEASE_MODE_RAT7) &&
  130. usage->code - BTN_MOUSE == 10) ||
  131. ((ssc->quirks & SAITEK_RELEASE_MODE_MMO7) &&
  132. usage->code - BTN_MOUSE == 15))) {
  133. input_report_key(input, usage->code, 1);
  134. /* report missing release event */
  135. input_report_key(input, usage->code, 0);
  136. return 1;
  137. }
  138. return 0;
  139. }
  140. static const struct hid_device_id saitek_devices[] = {
  141. { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_PS1000),
  142. .driver_data = SAITEK_FIX_PS1000 },
  143. { HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_RAT5),
  144. .driver_data = SAITEK_RELEASE_MODE_RAT7 },
  145. { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7_OLD),
  146. .driver_data = SAITEK_RELEASE_MODE_RAT7 },
  147. { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7),
  148. .driver_data = SAITEK_RELEASE_MODE_RAT7 },
  149. { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT7_CONTAGION),
  150. .driver_data = SAITEK_RELEASE_MODE_RAT7 },
  151. { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RAT9),
  152. .driver_data = SAITEK_RELEASE_MODE_RAT7 },
  153. { HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_RAT9),
  154. .driver_data = SAITEK_RELEASE_MODE_RAT7 },
  155. { HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_MMO7),
  156. .driver_data = SAITEK_RELEASE_MODE_MMO7 },
  157. { }
  158. };
  159. MODULE_DEVICE_TABLE(hid, saitek_devices);
  160. static struct hid_driver saitek_driver = {
  161. .name = "saitek",
  162. .id_table = saitek_devices,
  163. .probe = saitek_probe,
  164. .report_fixup = saitek_report_fixup,
  165. .raw_event = saitek_raw_event,
  166. .event = saitek_event,
  167. };
  168. module_hid_driver(saitek_driver);
  169. MODULE_LICENSE("GPL");