PageRenderTime 50ms CodeModel.GetById 17ms app.highlight 28ms RepoModel.GetById 2ms app.codeStats 0ms

/drivers/hid/hid-apple.c

https://gitlab.com/TeamTators/hp-kernel-tenderloin
C | 487 lines | 398 code | 66 blank | 23 comment | 54 complexity | 6e22c1d73c1a668c02ee73d98239df7b MD5 | raw file
  1/*
  2 *  USB HID quirks support for Linux
  3 *
  4 *  Copyright (c) 1999 Andreas Gal
  5 *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
  6 *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
  7 *  Copyright (c) 2006-2007 Jiri Kosina
  8 *  Copyright (c) 2007 Paul Walmsley
  9 *  Copyright (c) 2008 Jiri Slaby <jirislaby@gmail.com>
 10 */
 11
 12/*
 13 * This program is free software; you can redistribute it and/or modify it
 14 * under the terms of the GNU General Public License as published by the Free
 15 * Software Foundation; either version 2 of the License, or (at your option)
 16 * any later version.
 17 */
 18
 19#include <linux/device.h>
 20#include <linux/hid.h>
 21#include <linux/module.h>
 22#include <linux/slab.h>
 23#include <linux/usb.h>
 24
 25#include "hid-ids.h"
 26
 27#define APPLE_RDESC_JIS		0x0001
 28#define APPLE_IGNORE_MOUSE	0x0002
 29#define APPLE_HAS_FN		0x0004
 30#define APPLE_HIDDEV		0x0008
 31#define APPLE_ISO_KEYBOARD	0x0010
 32#define APPLE_MIGHTYMOUSE	0x0020
 33#define APPLE_INVERT_HWHEEL	0x0040
 34#define APPLE_IGNORE_HIDINPUT	0x0080
 35#define APPLE_NUMLOCK_EMULATION	0x0100
 36
 37#define APPLE_FLAG_FKEY		0x01
 38
 39static unsigned int fnmode = 1;
 40module_param(fnmode, uint, 0644);
 41MODULE_PARM_DESC(fnmode, "Mode of fn key on Apple keyboards (0 = disabled, "
 42		"[1] = fkeyslast, 2 = fkeysfirst)");
 43
 44static unsigned int iso_layout = 1;
 45module_param(iso_layout, uint, 0644);
 46MODULE_PARM_DESC(iso_layout, "Enable/Disable hardcoded ISO-layout of the keyboard. "
 47		"(0 = disabled, [1] = enabled)");
 48
 49struct apple_sc {
 50	unsigned long quirks;
 51	unsigned int fn_on;
 52	DECLARE_BITMAP(pressed_fn, KEY_CNT);
 53	DECLARE_BITMAP(pressed_numlock, KEY_CNT);
 54};
 55
 56struct apple_key_translation {
 57	u16 from;
 58	u16 to;
 59	u8 flags;
 60};
 61
 62static const struct apple_key_translation apple_fn_keys[] = {
 63	{ KEY_BACKSPACE, KEY_DELETE },
 64	{ KEY_ENTER,	KEY_INSERT },
 65	{ KEY_F1,	KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
 66	{ KEY_F2,	KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
 67	{ KEY_F3,	KEY_SCALE,          APPLE_FLAG_FKEY },
 68	{ KEY_F4,	KEY_DASHBOARD,      APPLE_FLAG_FKEY },
 69	{ KEY_F5,	KEY_KBDILLUMDOWN,   APPLE_FLAG_FKEY },
 70	{ KEY_F6,	KEY_KBDILLUMUP,     APPLE_FLAG_FKEY },
 71	{ KEY_F7,	KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
 72	{ KEY_F8,	KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
 73	{ KEY_F9,	KEY_NEXTSONG,       APPLE_FLAG_FKEY },
 74	{ KEY_F10,	KEY_MUTE,           APPLE_FLAG_FKEY },
 75	{ KEY_F11,	KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
 76	{ KEY_F12,	KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
 77	{ KEY_UP,	KEY_PAGEUP },
 78	{ KEY_DOWN,	KEY_PAGEDOWN },
 79	{ KEY_LEFT,	KEY_HOME },
 80	{ KEY_RIGHT,	KEY_END },
 81	{ }
 82};
 83
 84static const struct apple_key_translation powerbook_fn_keys[] = {
 85	{ KEY_BACKSPACE, KEY_DELETE },
 86	{ KEY_F1,	KEY_BRIGHTNESSDOWN,     APPLE_FLAG_FKEY },
 87	{ KEY_F2,	KEY_BRIGHTNESSUP,       APPLE_FLAG_FKEY },
 88	{ KEY_F3,	KEY_MUTE,               APPLE_FLAG_FKEY },
 89	{ KEY_F4,	KEY_VOLUMEDOWN,         APPLE_FLAG_FKEY },
 90	{ KEY_F5,	KEY_VOLUMEUP,           APPLE_FLAG_FKEY },
 91	{ KEY_F6,	KEY_NUMLOCK,            APPLE_FLAG_FKEY },
 92	{ KEY_F7,	KEY_SWITCHVIDEOMODE,    APPLE_FLAG_FKEY },
 93	{ KEY_F8,	KEY_KBDILLUMTOGGLE,     APPLE_FLAG_FKEY },
 94	{ KEY_F9,	KEY_KBDILLUMDOWN,       APPLE_FLAG_FKEY },
 95	{ KEY_F10,	KEY_KBDILLUMUP,         APPLE_FLAG_FKEY },
 96	{ KEY_UP,	KEY_PAGEUP },
 97	{ KEY_DOWN,	KEY_PAGEDOWN },
 98	{ KEY_LEFT,	KEY_HOME },
 99	{ KEY_RIGHT,	KEY_END },
100	{ }
101};
102
103static const struct apple_key_translation powerbook_numlock_keys[] = {
104	{ KEY_J,	KEY_KP1 },
105	{ KEY_K,	KEY_KP2 },
106	{ KEY_L,	KEY_KP3 },
107	{ KEY_U,	KEY_KP4 },
108	{ KEY_I,	KEY_KP5 },
109	{ KEY_O,	KEY_KP6 },
110	{ KEY_7,	KEY_KP7 },
111	{ KEY_8,	KEY_KP8 },
112	{ KEY_9,	KEY_KP9 },
113	{ KEY_M,	KEY_KP0 },
114	{ KEY_DOT,	KEY_KPDOT },
115	{ KEY_SLASH,	KEY_KPPLUS },
116	{ KEY_SEMICOLON, KEY_KPMINUS },
117	{ KEY_P,	KEY_KPASTERISK },
118	{ KEY_MINUS,	KEY_KPEQUAL },
119	{ KEY_0,	KEY_KPSLASH },
120	{ KEY_F6,	KEY_NUMLOCK },
121	{ KEY_KPENTER,	KEY_KPENTER },
122	{ KEY_BACKSPACE, KEY_BACKSPACE },
123	{ }
124};
125
126static const struct apple_key_translation apple_iso_keyboard[] = {
127	{ KEY_GRAVE,	KEY_102ND },
128	{ KEY_102ND,	KEY_GRAVE },
129	{ }
130};
131
132static const struct apple_key_translation *apple_find_translation(
133		const struct apple_key_translation *table, u16 from)
134{
135	const struct apple_key_translation *trans;
136
137	/* Look for the translation */
138	for (trans = table; trans->from; trans++)
139		if (trans->from == from)
140			return trans;
141
142	return NULL;
143}
144
145static int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
146		struct hid_usage *usage, __s32 value)
147{
148	struct apple_sc *asc = hid_get_drvdata(hid);
149	const struct apple_key_translation *trans;
150
151	if (usage->code == KEY_FN) {
152		asc->fn_on = !!value;
153		input_event(input, usage->type, usage->code, value);
154		return 1;
155	}
156
157	if (fnmode) {
158		int do_translate;
159
160		trans = apple_find_translation((hid->product < 0x21d ||
161					hid->product >= 0x300) ?
162					powerbook_fn_keys : apple_fn_keys,
163					usage->code);
164		if (trans) {
165			if (test_bit(usage->code, asc->pressed_fn))
166				do_translate = 1;
167			else if (trans->flags & APPLE_FLAG_FKEY)
168				do_translate = (fnmode == 2 && asc->fn_on) ||
169					(fnmode == 1 && !asc->fn_on);
170			else
171				do_translate = asc->fn_on;
172
173			if (do_translate) {
174				if (value)
175					set_bit(usage->code, asc->pressed_fn);
176				else
177					clear_bit(usage->code, asc->pressed_fn);
178
179				input_event(input, usage->type, trans->to,
180						value);
181
182				return 1;
183			}
184		}
185
186		if (asc->quirks & APPLE_NUMLOCK_EMULATION &&
187				(test_bit(usage->code, asc->pressed_numlock) ||
188				test_bit(LED_NUML, input->led))) {
189			trans = apple_find_translation(powerbook_numlock_keys,
190					usage->code);
191
192			if (trans) {
193				if (value)
194					set_bit(usage->code,
195							asc->pressed_numlock);
196				else
197					clear_bit(usage->code,
198							asc->pressed_numlock);
199
200				input_event(input, usage->type, trans->to,
201						value);
202			}
203
204			return 1;
205		}
206	}
207
208        if (iso_layout) {
209		if (asc->quirks & APPLE_ISO_KEYBOARD) {
210			trans = apple_find_translation(apple_iso_keyboard, usage->code);
211			if (trans) {
212				input_event(input, usage->type, trans->to, value);
213				return 1;
214			}
215		}
216	}
217
218	return 0;
219}
220
221static int apple_event(struct hid_device *hdev, struct hid_field *field,
222		struct hid_usage *usage, __s32 value)
223{
224	struct apple_sc *asc = hid_get_drvdata(hdev);
225
226	if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
227			!usage->type)
228		return 0;
229
230	if ((asc->quirks & APPLE_INVERT_HWHEEL) &&
231			usage->code == REL_HWHEEL) {
232		input_event(field->hidinput->input, usage->type, usage->code,
233				-value);
234		return 1;
235	}
236
237	if ((asc->quirks & APPLE_HAS_FN) &&
238			hidinput_apple_event(hdev, field->hidinput->input,
239				usage, value))
240		return 1;
241
242
243	return 0;
244}
245
246/*
247 * MacBook JIS keyboard has wrong logical maximum
248 */
249static void apple_report_fixup(struct hid_device *hdev, __u8 *rdesc,
250		unsigned int rsize)
251{
252	struct apple_sc *asc = hid_get_drvdata(hdev);
253
254	if ((asc->quirks & APPLE_RDESC_JIS) && rsize >= 60 &&
255			rdesc[53] == 0x65 && rdesc[59] == 0x65) {
256		dev_info(&hdev->dev, "fixing up MacBook JIS keyboard report "
257				"descriptor\n");
258		rdesc[53] = rdesc[59] = 0xe7;
259	}
260}
261
262static void apple_setup_input(struct input_dev *input)
263{
264	const struct apple_key_translation *trans;
265
266	set_bit(KEY_NUMLOCK, input->keybit);
267
268	/* Enable all needed keys */
269	for (trans = apple_fn_keys; trans->from; trans++)
270		set_bit(trans->to, input->keybit);
271
272	for (trans = powerbook_fn_keys; trans->from; trans++)
273		set_bit(trans->to, input->keybit);
274
275	for (trans = powerbook_numlock_keys; trans->from; trans++)
276		set_bit(trans->to, input->keybit);
277
278	for (trans = apple_iso_keyboard; trans->from; trans++)
279		set_bit(trans->to, input->keybit);
280}
281
282static int apple_input_mapping(struct hid_device *hdev, struct hid_input *hi,
283		struct hid_field *field, struct hid_usage *usage,
284		unsigned long **bit, int *max)
285{
286	if (usage->hid == (HID_UP_CUSTOM | 0x0003)) {
287		/* The fn key on Apple USB keyboards */
288		set_bit(EV_REP, hi->input->evbit);
289		hid_map_usage_clear(hi, usage, bit, max, EV_KEY, KEY_FN);
290		apple_setup_input(hi->input);
291		return 1;
292	}
293
294	/* we want the hid layer to go through standard path (set and ignore) */
295	return 0;
296}
297
298static int apple_input_mapped(struct hid_device *hdev, struct hid_input *hi,
299		struct hid_field *field, struct hid_usage *usage,
300		unsigned long **bit, int *max)
301{
302	struct apple_sc *asc = hid_get_drvdata(hdev);
303
304	if (asc->quirks & APPLE_MIGHTYMOUSE) {
305		if (usage->hid == HID_GD_Z)
306			hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
307		else if (usage->code == BTN_1)
308			hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_2);
309		else if (usage->code == BTN_2)
310			hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_1);
311	}
312
313	return 0;
314}
315
316static int apple_probe(struct hid_device *hdev,
317		const struct hid_device_id *id)
318{
319	unsigned long quirks = id->driver_data;
320	struct apple_sc *asc;
321	unsigned int connect_mask = HID_CONNECT_DEFAULT;
322	int ret;
323
324	asc = kzalloc(sizeof(*asc), GFP_KERNEL);
325	if (asc == NULL) {
326		dev_err(&hdev->dev, "can't alloc apple descriptor\n");
327		return -ENOMEM;
328	}
329
330	asc->quirks = quirks;
331
332	hid_set_drvdata(hdev, asc);
333
334	ret = hid_parse(hdev);
335	if (ret) {
336		dev_err(&hdev->dev, "parse failed\n");
337		goto err_free;
338	}
339
340	if (quirks & APPLE_HIDDEV)
341		connect_mask |= HID_CONNECT_HIDDEV_FORCE;
342	if (quirks & APPLE_IGNORE_HIDINPUT)
343		connect_mask &= ~HID_CONNECT_HIDINPUT;
344
345	ret = hid_hw_start(hdev, connect_mask);
346	if (ret) {
347		dev_err(&hdev->dev, "hw start failed\n");
348		goto err_free;
349	}
350
351	return 0;
352err_free:
353	kfree(asc);
354	return ret;
355}
356
357static void apple_remove(struct hid_device *hdev)
358{
359	hid_hw_stop(hdev);
360	kfree(hid_get_drvdata(hdev));
361}
362
363static const struct hid_device_id apple_devices[] = {
364	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ATV_IRCONTROL),
365		.driver_data = APPLE_HIDDEV | APPLE_IGNORE_HIDINPUT },
366	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4),
367		.driver_data = APPLE_HIDDEV | APPLE_IGNORE_HIDINPUT },
368	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE),
369		.driver_data = APPLE_MIGHTYMOUSE | APPLE_INVERT_HWHEEL },
370
371	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI),
372		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
373	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO),
374		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
375	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI),
376		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
377	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO),
378		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
379			APPLE_ISO_KEYBOARD },
380	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS),
381		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
382	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI),
383		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
384	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO),
385		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
386			APPLE_ISO_KEYBOARD },
387	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS),
388		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
389			APPLE_RDESC_JIS },
390	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI),
391		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
392	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO),
393		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
394			APPLE_ISO_KEYBOARD },
395	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS),
396		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
397			APPLE_RDESC_JIS },
398	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ANSI),
399		.driver_data = APPLE_HAS_FN },
400	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ISO),
401		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
402	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_JIS),
403		.driver_data = APPLE_HAS_FN },
404	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI),
405		.driver_data = APPLE_HAS_FN },
406	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO),
407		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
408	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS),
409		.driver_data = APPLE_HAS_FN },
410	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI),
411		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
412	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO),
413		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
414	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS),
415		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
416			APPLE_RDESC_JIS },
417	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
418		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
419	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
420		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
421			APPLE_ISO_KEYBOARD },
422	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS),
423		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
424	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI),
425		.driver_data = APPLE_HAS_FN },
426	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO),
427		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
428	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS),
429		.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
430	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI),
431		.driver_data = APPLE_HAS_FN },
432	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO),
433		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
434	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS),
435		.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
436	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI),
437		.driver_data = APPLE_HAS_FN },
438	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO),
439		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
440	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS),
441		.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
442	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI),
443		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
444	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
445		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
446			APPLE_ISO_KEYBOARD },
447	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS),
448		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
449	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY),
450		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
451	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY),
452		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
453
454	{ }
455};
456MODULE_DEVICE_TABLE(hid, apple_devices);
457
458static struct hid_driver apple_driver = {
459	.name = "apple",
460	.id_table = apple_devices,
461	.report_fixup = apple_report_fixup,
462	.probe = apple_probe,
463	.remove = apple_remove,
464	.event = apple_event,
465	.input_mapping = apple_input_mapping,
466	.input_mapped = apple_input_mapped,
467};
468
469static int __init apple_init(void)
470{
471	int ret;
472
473	ret = hid_register_driver(&apple_driver);
474	if (ret)
475		printk(KERN_ERR "can't register apple driver\n");
476
477	return ret;
478}
479
480static void __exit apple_exit(void)
481{
482	hid_unregister_driver(&apple_driver);
483}
484
485module_init(apple_init);
486module_exit(apple_exit);
487MODULE_LICENSE("GPL");