mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-04 16:46:49 +07:00
4ddfe0289b
Add a driver for the ION iCade mini arcade cabinet [1]. The device generates a key press and release for each joystick movement or button press or release. For example, moving the stick to the left will generate the "A" key being pressed and then released. A list of all the combinations is available in the iCade developer guide [2]. This driver hides all this and makes the device work as a generic joystick. [1]: http://www.ionaudio.com/products/details/icade [2]: http://www.ionaudio.com/downloads/iCade_Dev_Resource_v1.3.pdf Signed-off-by: Bastien Nocera <hadess@hadess.net> Reviewed-by: Benjamin Tissoires <benjamin.tissoires@gmail.com> Signed-off-by: Jiri Kosina <jkosina@suse.cz>
260 lines
6.2 KiB
C
260 lines
6.2 KiB
C
/*
|
|
* ION iCade input driver
|
|
*
|
|
* Copyright (c) 2012 Bastien Nocera <hadess@hadess.net>
|
|
* Copyright (c) 2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
|
|
*/
|
|
|
|
/*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License as published by the Free
|
|
* Software Foundation; either version 2 of the License, or (at your option)
|
|
* any later version.
|
|
*/
|
|
|
|
#include <linux/device.h>
|
|
#include <linux/hid.h>
|
|
#include <linux/module.h>
|
|
|
|
#include "hid-ids.h"
|
|
|
|
/*
|
|
* ↑ A C Y L
|
|
* ← →
|
|
* ↓ B X Z R
|
|
*
|
|
*
|
|
* UP ON,OFF = w,e
|
|
* RT ON,OFF = d,c
|
|
* DN ON,OFF = x,z
|
|
* LT ON,OFF = a,q
|
|
* A ON,OFF = y,t
|
|
* B ON,OFF = h,r
|
|
* C ON,OFF = u,f
|
|
* X ON,OFF = j,n
|
|
* Y ON,OFF = i,m
|
|
* Z ON,OFF = k,p
|
|
* L ON,OFF = o,g
|
|
* R ON,OFF = l,v
|
|
*/
|
|
|
|
/* The translation code uses HID usage instead of input layer
|
|
* keys. This code generates a lookup table that makes
|
|
* translation quick.
|
|
*
|
|
* #include <linux/input.h>
|
|
* #include <stdio.h>
|
|
* #include <assert.h>
|
|
*
|
|
* #define unk KEY_UNKNOWN
|
|
*
|
|
* < copy of hid_keyboard[] from hid-input.c >
|
|
*
|
|
* struct icade_key_translation {
|
|
* int from;
|
|
* const char *to;
|
|
* int press;
|
|
* };
|
|
*
|
|
* static const struct icade_key_translation icade_keys[] = {
|
|
* { KEY_W, "KEY_UP", 1 },
|
|
* { KEY_E, "KEY_UP", 0 },
|
|
* { KEY_D, "KEY_RIGHT", 1 },
|
|
* { KEY_C, "KEY_RIGHT", 0 },
|
|
* { KEY_X, "KEY_DOWN", 1 },
|
|
* { KEY_Z, "KEY_DOWN", 0 },
|
|
* { KEY_A, "KEY_LEFT", 1 },
|
|
* { KEY_Q, "KEY_LEFT", 0 },
|
|
* { KEY_Y, "BTN_A", 1 },
|
|
* { KEY_T, "BTN_A", 0 },
|
|
* { KEY_H, "BTN_B", 1 },
|
|
* { KEY_R, "BTN_B", 0 },
|
|
* { KEY_U, "BTN_C", 1 },
|
|
* { KEY_F, "BTN_C", 0 },
|
|
* { KEY_J, "BTN_X", 1 },
|
|
* { KEY_N, "BTN_X", 0 },
|
|
* { KEY_I, "BTN_Y", 1 },
|
|
* { KEY_M, "BTN_Y", 0 },
|
|
* { KEY_K, "BTN_Z", 1 },
|
|
* { KEY_P, "BTN_Z", 0 },
|
|
* { KEY_O, "BTN_THUMBL", 1 },
|
|
* { KEY_G, "BTN_THUMBL", 0 },
|
|
* { KEY_L, "BTN_THUMBR", 1 },
|
|
* { KEY_V, "BTN_THUMBR", 0 },
|
|
*
|
|
* { }
|
|
* };
|
|
*
|
|
* static int
|
|
* usage_for_key (int key)
|
|
* {
|
|
* int i;
|
|
* for (i = 0; i < 256; i++) {
|
|
* if (hid_keyboard[i] == key)
|
|
* return i;
|
|
* }
|
|
* assert(0);
|
|
* }
|
|
*
|
|
* int main (int argc, char **argv)
|
|
* {
|
|
* const struct icade_key_translation *trans;
|
|
* int max_usage = 0;
|
|
*
|
|
* for (trans = icade_keys; trans->from; trans++) {
|
|
* int usage = usage_for_key (trans->from);
|
|
* max_usage = usage > max_usage ? usage : max_usage;
|
|
* }
|
|
*
|
|
* printf ("#define ICADE_MAX_USAGE %d\n\n", max_usage);
|
|
* printf ("struct icade_key {\n");
|
|
* printf ("\tu16 to;\n");
|
|
* printf ("\tu8 press:1;\n");
|
|
* printf ("};\n\n");
|
|
* printf ("static const struct icade_key "
|
|
* "icade_usage_table[%d] = {\n", max_usage + 1);
|
|
* for (trans = icade_keys; trans->from; trans++) {
|
|
* printf ("\t[%d] = { %s, %d },\n",
|
|
* usage_for_key (trans->from), trans->to, trans->press);
|
|
* }
|
|
* printf ("};\n");
|
|
*
|
|
* return 0;
|
|
* }
|
|
*/
|
|
|
|
#define ICADE_MAX_USAGE 29
|
|
|
|
struct icade_key {
|
|
u16 to;
|
|
u8 press:1;
|
|
};
|
|
|
|
static const struct icade_key icade_usage_table[30] = {
|
|
[26] = { KEY_UP, 1 },
|
|
[8] = { KEY_UP, 0 },
|
|
[7] = { KEY_RIGHT, 1 },
|
|
[6] = { KEY_RIGHT, 0 },
|
|
[27] = { KEY_DOWN, 1 },
|
|
[29] = { KEY_DOWN, 0 },
|
|
[4] = { KEY_LEFT, 1 },
|
|
[20] = { KEY_LEFT, 0 },
|
|
[28] = { BTN_A, 1 },
|
|
[23] = { BTN_A, 0 },
|
|
[11] = { BTN_B, 1 },
|
|
[21] = { BTN_B, 0 },
|
|
[24] = { BTN_C, 1 },
|
|
[9] = { BTN_C, 0 },
|
|
[13] = { BTN_X, 1 },
|
|
[17] = { BTN_X, 0 },
|
|
[12] = { BTN_Y, 1 },
|
|
[16] = { BTN_Y, 0 },
|
|
[14] = { BTN_Z, 1 },
|
|
[19] = { BTN_Z, 0 },
|
|
[18] = { BTN_THUMBL, 1 },
|
|
[10] = { BTN_THUMBL, 0 },
|
|
[15] = { BTN_THUMBR, 1 },
|
|
[25] = { BTN_THUMBR, 0 },
|
|
};
|
|
|
|
static const struct icade_key *icade_find_translation(u16 from)
|
|
{
|
|
if (from < 0 || from > ICADE_MAX_USAGE)
|
|
return NULL;
|
|
return &icade_usage_table[from];
|
|
}
|
|
|
|
static int icade_event(struct hid_device *hdev, struct hid_field *field,
|
|
struct hid_usage *usage, __s32 value)
|
|
{
|
|
const struct icade_key *trans;
|
|
|
|
if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
|
|
!usage->type)
|
|
return 0;
|
|
|
|
/* We ignore the fake key up, and act only on key down */
|
|
if (!value)
|
|
return 1;
|
|
|
|
trans = icade_find_translation(usage->hid & HID_USAGE);
|
|
|
|
if (!trans)
|
|
return 1;
|
|
|
|
input_event(field->hidinput->input, usage->type,
|
|
trans->to, trans->press);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int icade_input_mapping(struct hid_device *hdev, struct hid_input *hi,
|
|
struct hid_field *field, struct hid_usage *usage,
|
|
unsigned long **bit, int *max)
|
|
{
|
|
const struct icade_key *trans;
|
|
|
|
if ((usage->hid & HID_USAGE_PAGE) == HID_UP_KEYBOARD) {
|
|
trans = icade_find_translation(usage->hid & HID_USAGE);
|
|
|
|
if (!trans)
|
|
return -1;
|
|
|
|
hid_map_usage(hi, usage, bit, max, EV_KEY, trans->to);
|
|
set_bit(trans->to, hi->input->keybit);
|
|
|
|
return 1;
|
|
}
|
|
|
|
/* ignore others */
|
|
return -1;
|
|
|
|
}
|
|
|
|
static int icade_input_mapped(struct hid_device *hdev, struct hid_input *hi,
|
|
struct hid_field *field, struct hid_usage *usage,
|
|
unsigned long **bit, int *max)
|
|
{
|
|
if (usage->type == EV_KEY)
|
|
set_bit(usage->type, hi->input->evbit);
|
|
|
|
return -1;
|
|
}
|
|
|
|
static const struct hid_device_id icade_devices[] = {
|
|
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ION, USB_DEVICE_ID_ICADE) },
|
|
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(hid, icade_devices);
|
|
|
|
static struct hid_driver icade_driver = {
|
|
.name = "icade",
|
|
.id_table = icade_devices,
|
|
.event = icade_event,
|
|
.input_mapped = icade_input_mapped,
|
|
.input_mapping = icade_input_mapping,
|
|
};
|
|
|
|
static int __init icade_init(void)
|
|
{
|
|
int ret;
|
|
|
|
ret = hid_register_driver(&icade_driver);
|
|
if (ret)
|
|
pr_err("can't register icade driver\n");
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void __exit icade_exit(void)
|
|
{
|
|
hid_unregister_driver(&icade_driver);
|
|
}
|
|
|
|
module_init(icade_init);
|
|
module_exit(icade_exit);
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
|
|
MODULE_DESCRIPTION("ION iCade input driver");
|