forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
342 lines
8.2 KiB
342 lines
8.2 KiB
// SPDX-License-Identifier: GPL-2.0+ |
|
/* |
|
* HID driver for Cougar 500k Gaming Keyboard |
|
* |
|
* Copyright (c) 2018 Daniel M. Lambea <[email protected]> |
|
*/ |
|
|
|
#include <linux/hid.h> |
|
#include <linux/module.h> |
|
#include <linux/printk.h> |
|
|
|
#include "hid-ids.h" |
|
|
|
MODULE_AUTHOR("Daniel M. Lambea <[email protected]>"); |
|
MODULE_DESCRIPTION("Cougar 500k Gaming Keyboard"); |
|
MODULE_LICENSE("GPL"); |
|
MODULE_INFO(key_mappings, "G1-G6 are mapped to F13-F18"); |
|
|
|
static bool g6_is_space = true; |
|
MODULE_PARM_DESC(g6_is_space, |
|
"If true, G6 programmable key sends SPACE instead of F18 (default=true)"); |
|
|
|
#define COUGAR_VENDOR_USAGE 0xff00ff00 |
|
|
|
#define COUGAR_FIELD_CODE 1 |
|
#define COUGAR_FIELD_ACTION 2 |
|
|
|
#define COUGAR_KEY_G1 0x83 |
|
#define COUGAR_KEY_G2 0x84 |
|
#define COUGAR_KEY_G3 0x85 |
|
#define COUGAR_KEY_G4 0x86 |
|
#define COUGAR_KEY_G5 0x87 |
|
#define COUGAR_KEY_G6 0x78 |
|
#define COUGAR_KEY_FN 0x0d |
|
#define COUGAR_KEY_MR 0x6f |
|
#define COUGAR_KEY_M1 0x80 |
|
#define COUGAR_KEY_M2 0x81 |
|
#define COUGAR_KEY_M3 0x82 |
|
#define COUGAR_KEY_LEDS 0x67 |
|
#define COUGAR_KEY_LOCK 0x6e |
|
|
|
|
|
/* Default key mappings. The special key COUGAR_KEY_G6 is defined first |
|
* because it is more frequent to use the spacebar rather than any other |
|
* special keys. Depending on the value of the parameter 'g6_is_space', |
|
* the mapping will be updated in the probe function. |
|
*/ |
|
static unsigned char cougar_mapping[][2] = { |
|
{ COUGAR_KEY_G6, KEY_SPACE }, |
|
{ COUGAR_KEY_G1, KEY_F13 }, |
|
{ COUGAR_KEY_G2, KEY_F14 }, |
|
{ COUGAR_KEY_G3, KEY_F15 }, |
|
{ COUGAR_KEY_G4, KEY_F16 }, |
|
{ COUGAR_KEY_G5, KEY_F17 }, |
|
{ COUGAR_KEY_LOCK, KEY_SCREENLOCK }, |
|
/* The following keys are handled by the hardware itself, so no special |
|
* treatment is required: |
|
{ COUGAR_KEY_FN, KEY_RESERVED }, |
|
{ COUGAR_KEY_MR, KEY_RESERVED }, |
|
{ COUGAR_KEY_M1, KEY_RESERVED }, |
|
{ COUGAR_KEY_M2, KEY_RESERVED }, |
|
{ COUGAR_KEY_M3, KEY_RESERVED }, |
|
{ COUGAR_KEY_LEDS, KEY_RESERVED }, |
|
*/ |
|
{ 0, 0 }, |
|
}; |
|
|
|
struct cougar_shared { |
|
struct list_head list; |
|
struct kref kref; |
|
bool enabled; |
|
struct hid_device *dev; |
|
struct input_dev *input; |
|
}; |
|
|
|
struct cougar { |
|
bool special_intf; |
|
struct cougar_shared *shared; |
|
}; |
|
|
|
static LIST_HEAD(cougar_udev_list); |
|
static DEFINE_MUTEX(cougar_udev_list_lock); |
|
|
|
/** |
|
* cougar_fix_g6_mapping - configure the mapping for key G6/Spacebar |
|
*/ |
|
static void cougar_fix_g6_mapping(void) |
|
{ |
|
int i; |
|
|
|
for (i = 0; cougar_mapping[i][0]; i++) { |
|
if (cougar_mapping[i][0] == COUGAR_KEY_G6) { |
|
cougar_mapping[i][1] = |
|
g6_is_space ? KEY_SPACE : KEY_F18; |
|
pr_info("cougar: G6 mapped to %s\n", |
|
g6_is_space ? "space" : "F18"); |
|
return; |
|
} |
|
} |
|
pr_warn("cougar: no mappings defined for G6/spacebar"); |
|
} |
|
|
|
/* |
|
* Constant-friendly rdesc fixup for mouse interface |
|
*/ |
|
static __u8 *cougar_report_fixup(struct hid_device *hdev, __u8 *rdesc, |
|
unsigned int *rsize) |
|
{ |
|
if (rdesc[2] == 0x09 && rdesc[3] == 0x02 && |
|
(rdesc[115] | rdesc[116] << 8) >= HID_MAX_USAGES) { |
|
hid_info(hdev, |
|
"usage count exceeds max: fixing up report descriptor\n"); |
|
rdesc[115] = ((HID_MAX_USAGES-1) & 0xff); |
|
rdesc[116] = ((HID_MAX_USAGES-1) >> 8); |
|
} |
|
return rdesc; |
|
} |
|
|
|
static struct cougar_shared *cougar_get_shared_data(struct hid_device *hdev) |
|
{ |
|
struct cougar_shared *shared; |
|
|
|
/* Try to find an already-probed interface from the same device */ |
|
list_for_each_entry(shared, &cougar_udev_list, list) { |
|
if (hid_compare_device_paths(hdev, shared->dev, '/')) { |
|
kref_get(&shared->kref); |
|
return shared; |
|
} |
|
} |
|
return NULL; |
|
} |
|
|
|
static void cougar_release_shared_data(struct kref *kref) |
|
{ |
|
struct cougar_shared *shared = container_of(kref, |
|
struct cougar_shared, kref); |
|
|
|
mutex_lock(&cougar_udev_list_lock); |
|
list_del(&shared->list); |
|
mutex_unlock(&cougar_udev_list_lock); |
|
|
|
kfree(shared); |
|
} |
|
|
|
static void cougar_remove_shared_data(void *resource) |
|
{ |
|
struct cougar *cougar = resource; |
|
|
|
if (cougar->shared) { |
|
kref_put(&cougar->shared->kref, cougar_release_shared_data); |
|
cougar->shared = NULL; |
|
} |
|
} |
|
|
|
/* |
|
* Bind the device group's shared data to this cougar struct. |
|
* If no shared data exists for this group, create and initialize it. |
|
*/ |
|
static int cougar_bind_shared_data(struct hid_device *hdev, |
|
struct cougar *cougar) |
|
{ |
|
struct cougar_shared *shared; |
|
int error = 0; |
|
|
|
mutex_lock(&cougar_udev_list_lock); |
|
|
|
shared = cougar_get_shared_data(hdev); |
|
if (!shared) { |
|
shared = kzalloc(sizeof(*shared), GFP_KERNEL); |
|
if (!shared) { |
|
error = -ENOMEM; |
|
goto out; |
|
} |
|
|
|
kref_init(&shared->kref); |
|
shared->dev = hdev; |
|
list_add_tail(&shared->list, &cougar_udev_list); |
|
} |
|
|
|
cougar->shared = shared; |
|
|
|
error = devm_add_action(&hdev->dev, cougar_remove_shared_data, cougar); |
|
if (error) { |
|
mutex_unlock(&cougar_udev_list_lock); |
|
cougar_remove_shared_data(cougar); |
|
return error; |
|
} |
|
|
|
out: |
|
mutex_unlock(&cougar_udev_list_lock); |
|
return error; |
|
} |
|
|
|
static int cougar_probe(struct hid_device *hdev, |
|
const struct hid_device_id *id) |
|
{ |
|
struct cougar *cougar; |
|
struct hid_input *next, *hidinput = NULL; |
|
unsigned int connect_mask; |
|
int error; |
|
|
|
cougar = devm_kzalloc(&hdev->dev, sizeof(*cougar), GFP_KERNEL); |
|
if (!cougar) |
|
return -ENOMEM; |
|
hid_set_drvdata(hdev, cougar); |
|
|
|
error = hid_parse(hdev); |
|
if (error) { |
|
hid_err(hdev, "parse failed\n"); |
|
return error; |
|
} |
|
|
|
if (hdev->collection->usage == COUGAR_VENDOR_USAGE) { |
|
cougar->special_intf = true; |
|
connect_mask = HID_CONNECT_HIDRAW; |
|
} else |
|
connect_mask = HID_CONNECT_DEFAULT; |
|
|
|
error = hid_hw_start(hdev, connect_mask); |
|
if (error) { |
|
hid_err(hdev, "hw start failed\n"); |
|
return error; |
|
} |
|
|
|
error = cougar_bind_shared_data(hdev, cougar); |
|
if (error) |
|
goto fail_stop_and_cleanup; |
|
|
|
/* The custom vendor interface will use the hid_input registered |
|
* for the keyboard interface, in order to send translated key codes |
|
* to it. |
|
*/ |
|
if (hdev->collection->usage == HID_GD_KEYBOARD) { |
|
list_for_each_entry_safe(hidinput, next, &hdev->inputs, list) { |
|
if (hidinput->registered && hidinput->input != NULL) { |
|
cougar->shared->input = hidinput->input; |
|
cougar->shared->enabled = true; |
|
break; |
|
} |
|
} |
|
} else if (hdev->collection->usage == COUGAR_VENDOR_USAGE) { |
|
/* Preinit the mapping table */ |
|
cougar_fix_g6_mapping(); |
|
error = hid_hw_open(hdev); |
|
if (error) |
|
goto fail_stop_and_cleanup; |
|
} |
|
return 0; |
|
|
|
fail_stop_and_cleanup: |
|
hid_hw_stop(hdev); |
|
return error; |
|
} |
|
|
|
/* |
|
* Convert events from vendor intf to input key events |
|
*/ |
|
static int cougar_raw_event(struct hid_device *hdev, struct hid_report *report, |
|
u8 *data, int size) |
|
{ |
|
struct cougar *cougar; |
|
struct cougar_shared *shared; |
|
unsigned char code, action; |
|
int i; |
|
|
|
cougar = hid_get_drvdata(hdev); |
|
shared = cougar->shared; |
|
if (!cougar->special_intf || !shared) |
|
return 0; |
|
|
|
if (!shared->enabled || !shared->input) |
|
return -EPERM; |
|
|
|
code = data[COUGAR_FIELD_CODE]; |
|
action = data[COUGAR_FIELD_ACTION]; |
|
for (i = 0; cougar_mapping[i][0]; i++) { |
|
if (code == cougar_mapping[i][0]) { |
|
input_event(shared->input, EV_KEY, |
|
cougar_mapping[i][1], action); |
|
input_sync(shared->input); |
|
return -EPERM; |
|
} |
|
} |
|
/* Avoid warnings on the same unmapped key twice */ |
|
if (action != 0) |
|
hid_warn(hdev, "unmapped special key code %0x: ignoring\n", code); |
|
return -EPERM; |
|
} |
|
|
|
static void cougar_remove(struct hid_device *hdev) |
|
{ |
|
struct cougar *cougar = hid_get_drvdata(hdev); |
|
|
|
if (cougar) { |
|
/* Stop the vendor intf to process more events */ |
|
if (cougar->shared) |
|
cougar->shared->enabled = false; |
|
if (cougar->special_intf) |
|
hid_hw_close(hdev); |
|
} |
|
hid_hw_stop(hdev); |
|
} |
|
|
|
static int cougar_param_set_g6_is_space(const char *val, |
|
const struct kernel_param *kp) |
|
{ |
|
int ret; |
|
|
|
ret = param_set_bool(val, kp); |
|
if (ret) |
|
return ret; |
|
|
|
cougar_fix_g6_mapping(); |
|
|
|
return 0; |
|
} |
|
|
|
static const struct kernel_param_ops cougar_g6_is_space_ops = { |
|
.set = cougar_param_set_g6_is_space, |
|
.get = param_get_bool, |
|
}; |
|
module_param_cb(g6_is_space, &cougar_g6_is_space_ops, &g6_is_space, 0644); |
|
|
|
static const struct hid_device_id cougar_id_table[] = { |
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SOLID_YEAR, |
|
USB_DEVICE_ID_COUGAR_500K_GAMING_KEYBOARD) }, |
|
{ HID_USB_DEVICE(USB_VENDOR_ID_SOLID_YEAR, |
|
USB_DEVICE_ID_COUGAR_700K_GAMING_KEYBOARD) }, |
|
{} |
|
}; |
|
MODULE_DEVICE_TABLE(hid, cougar_id_table); |
|
|
|
static struct hid_driver cougar_driver = { |
|
.name = "cougar", |
|
.id_table = cougar_id_table, |
|
.report_fixup = cougar_report_fixup, |
|
.probe = cougar_probe, |
|
.remove = cougar_remove, |
|
.raw_event = cougar_raw_event, |
|
}; |
|
|
|
module_hid_driver(cougar_driver);
|
|
|