[linux.git] / drivers / hid / hid-icade.c

/*
 *  ION iCade input driver
 *
 *  Copyright (c) 2012 Bastien Nocera <[email protected]>
 *  Copyright (c) 2012 Benjamin Tissoires <[email protected]>
 */

/*
 * 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 > 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,
};
module_hid_driver(icade_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Bastien Nocera <[email protected]>");
MODULE_DESCRIPTION("ION iCade input driver");
Commit	Line	Data
4ddfe028 BN	1	/*
	2	* ION iCade input driver
	3	*
	4	* Copyright (c) 2012 Bastien Nocera <[email protected]>
	5	* Copyright (c) 2012 Benjamin Tissoires <[email protected]>
	6	*/
	7
	8	/*
	9	* This program is free software; you can redistribute it and/or modify it
	10	* under the terms of the GNU General Public License as published by the Free
	11	* Software Foundation; either version 2 of the License, or (at your option)
	12	* any later version.
	13	*/
	14
	15	#include <linux/device.h>
	16	#include <linux/hid.h>
	17	#include <linux/module.h>
	18
	19	#include "hid-ids.h"
	20
	21	/*
	22	* ↑ A C Y L
	23	* ← →
	24	* ↓ B X Z R
	25	*
	26	*
	27	* UP ON,OFF = w,e
	28	* RT ON,OFF = d,c
	29	* DN ON,OFF = x,z
	30	* LT ON,OFF = a,q
	31	* A ON,OFF = y,t
	32	* B ON,OFF = h,r
	33	* C ON,OFF = u,f
	34	* X ON,OFF = j,n
	35	* Y ON,OFF = i,m
	36	* Z ON,OFF = k,p
	37	* L ON,OFF = o,g
	38	* R ON,OFF = l,v
	39	*/
	40
	41	/* The translation code uses HID usage instead of input layer
	42	* keys. This code generates a lookup table that makes
	43	* translation quick.
	44	*
	45	* #include <linux/input.h>
	46	* #include <stdio.h>
	47	* #include <assert.h>
	48	*
	49	* #define unk KEY_UNKNOWN
	50	*
	51	* < copy of hid_keyboard[] from hid-input.c >
	52	*
	53	* struct icade_key_translation {
	54	* int from;
	55	* const char *to;
	56	* int press;
	57	* };
	58	*
	59	* static const struct icade_key_translation icade_keys[] = {
	60	* { KEY_W, "KEY_UP", 1 },
	61	* { KEY_E, "KEY_UP", 0 },
	62	* { KEY_D, "KEY_RIGHT", 1 },
	63	* { KEY_C, "KEY_RIGHT", 0 },
	64	* { KEY_X, "KEY_DOWN", 1 },
65	* { KEY_Z, "KEY_DOWN", 0 },
66	* { KEY_A, "KEY_LEFT", 1 },
67	* { KEY_Q, "KEY_LEFT", 0 },
68	* { KEY_Y, "BTN_A", 1 },
69	* { KEY_T, "BTN_A", 0 },
70	* { KEY_H, "BTN_B", 1 },
71	* { KEY_R, "BTN_B", 0 },
72	* { KEY_U, "BTN_C", 1 },
73	* { KEY_F, "BTN_C", 0 },
74	* { KEY_J, "BTN_X", 1 },
75	* { KEY_N, "BTN_X", 0 },
76	* { KEY_I, "BTN_Y", 1 },
77	* { KEY_M, "BTN_Y", 0 },
78	* { KEY_K, "BTN_Z", 1 },
79	* { KEY_P, "BTN_Z", 0 },
80	* { KEY_O, "BTN_THUMBL", 1 },
81	* { KEY_G, "BTN_THUMBL", 0 },
82	* { KEY_L, "BTN_THUMBR", 1 },
83	* { KEY_V, "BTN_THUMBR", 0 },
84	*
85	* { }
86	* };
87	*
88	* static int
89	* usage_for_key (int key)
90	* {
91	* int i;
92	* for (i = 0; i < 256; i++) {
93	* if (hid_keyboard[i] == key)
94	* return i;
95	* }
96	* assert(0);
97	* }
98	*
99	* int main (int argc, char **argv)
100	* {
101	* const struct icade_key_translation *trans;
102	* int max_usage = 0;
103	*
104	* for (trans = icade_keys; trans->from; trans++) {
105	* int usage = usage_for_key (trans->from);
106	* max_usage = usage > max_usage ? usage : max_usage;
107	* }
108	*
109	* printf ("#define ICADE_MAX_USAGE %d\n\n", max_usage);
110	* printf ("struct icade_key {\n");
111	* printf ("\tu16 to;\n");
112	* printf ("\tu8 press:1;\n");
113	* printf ("};\n\n");
114	* printf ("static const struct icade_key "
115	* "icade_usage_table[%d] = {\n", max_usage + 1);
116	* for (trans = icade_keys; trans->from; trans++) {
117	* printf ("\t[%d] = { %s, %d },\n",
118	* usage_for_key (trans->from), trans->to, trans->press);
119	* }
120	* printf ("};\n");
121	*
122	* return 0;
123	* }
124	*/
125
126	#define ICADE_MAX_USAGE 29
127
128	struct icade_key {
129	u16 to;
130	u8 press:1;
131	};
132
133	static const struct icade_key icade_usage_table[30] = {
134	[26] = { KEY_UP, 1 },
135	[8] = { KEY_UP, 0 },
136	[7] = { KEY_RIGHT, 1 },
137	[6] = { KEY_RIGHT, 0 },
138	[27] = { KEY_DOWN, 1 },
139	[29] = { KEY_DOWN, 0 },
140	[4] = { KEY_LEFT, 1 },
141	[20] = { KEY_LEFT, 0 },
142	[28] = { BTN_A, 1 },
143	[23] = { BTN_A, 0 },
144	[11] = { BTN_B, 1 },
145	[21] = { BTN_B, 0 },
146	[24] = { BTN_C, 1 },
147	[9] = { BTN_C, 0 },
148	[13] = { BTN_X, 1 },
149	[17] = { BTN_X, 0 },
150	[12] = { BTN_Y, 1 },
151	[16] = { BTN_Y, 0 },
152	[14] = { BTN_Z, 1 },
153	[19] = { BTN_Z, 0 },
154	[18] = { BTN_THUMBL, 1 },
155	[10] = { BTN_THUMBL, 0 },
156	[15] = { BTN_THUMBR, 1 },
157	[25] = { BTN_THUMBR, 0 },
158	};
159
160	static const struct icade_key *icade_find_translation(u16 from)
161	{
d8565014	162	if (from > ICADE_MAX_USAGE)
4ddfe028 BN	163	return NULL;
	164	return &icade_usage_table[from];
	165	}
	166
	167	static int icade_event(struct hid_device hdev, struct hid_field field,
	168	struct hid_usage *usage, __s32 value)
	169	{
	170	const struct icade_key *trans;
	171
	172	if (!(hdev->claimed & HID_CLAIMED_INPUT) \|\| !field->hidinput \|\|
	173	!usage->type)
	174	return 0;
	175
	176	/* We ignore the fake key up, and act only on key down */
	177	if (!value)
	178	return 1;
	179
	180	trans = icade_find_translation(usage->hid & HID_USAGE);
	181
	182	if (!trans)
	183	return 1;
	184
	185	input_event(field->hidinput->input, usage->type,
	186	trans->to, trans->press);
	187
	188	return 1;
	189	}
	190
	191	static int icade_input_mapping(struct hid_device hdev, struct hid_input hi,
	192	struct hid_field field, struct hid_usage usage,
	193	unsigned long *bit, int max)
	194	{
	195	const struct icade_key *trans;
	196
	197	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_KEYBOARD) {
	198	trans = icade_find_translation(usage->hid & HID_USAGE);
	199
	200	if (!trans)
	201	return -1;
	202
	203	hid_map_usage(hi, usage, bit, max, EV_KEY, trans->to);
	204	set_bit(trans->to, hi->input->keybit);
	205
	206	return 1;
	207	}
	208
	209	/* ignore others */
	210	return -1;
	211
	212	}
	213
	214	static int icade_input_mapped(struct hid_device hdev, struct hid_input hi,
	215	struct hid_field field, struct hid_usage usage,
	216	unsigned long *bit, int max)
	217	{
	218	if (usage->type == EV_KEY)
	219	set_bit(usage->type, hi->input->evbit);
	220
	221	return -1;
	222	}
	223
	224	static const struct hid_device_id icade_devices[] = {
	225	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ION, USB_DEVICE_ID_ICADE) },
	226
227	{ }
228	};
229	MODULE_DEVICE_TABLE(hid, icade_devices);
230
231	static struct hid_driver icade_driver = {
232	.name = "icade",
233	.id_table = icade_devices,
234	.event = icade_event,
235	.input_mapped = icade_input_mapped,
236	.input_mapping = icade_input_mapping,
237	};
f425458e	238	module_hid_driver(icade_driver);
4ddfe028	239
4ddfe028 BN	240	MODULE_LICENSE("GPL");
	241	MODULE_AUTHOR("Bastien Nocera <[email protected]>");
	242	MODULE_DESCRIPTION("ION iCade input driver");