Merge tag 'icc-6.7-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/djakov/icc...
[linux-2.6-microblaze.git] / drivers / hid / hid-apple.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  USB HID quirks support for Linux
4  *
5  *  Copyright (c) 1999 Andreas Gal
6  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
7  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
8  *  Copyright (c) 2006-2007 Jiri Kosina
9  *  Copyright (c) 2008 Jiri Slaby <jirislaby@gmail.com>
10  *  Copyright (c) 2019 Paul Pawlowski <paul@mrarm.io>
11  */
12
13 /*
14  */
15
16 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
17
18 #include <linux/device.h>
19 #include <linux/hid.h>
20 #include <linux/jiffies.h>
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/timer.h>
24 #include <linux/string.h>
25 #include <linux/leds.h>
26
27 #include "hid-ids.h"
28
29 #define APPLE_RDESC_JIS         BIT(0)
30 #define APPLE_IGNORE_MOUSE      BIT(1)
31 #define APPLE_HAS_FN            BIT(2)
32 /* BIT(3) reserved, was: APPLE_HIDDEV */
33 #define APPLE_ISO_TILDE_QUIRK   BIT(4)
34 #define APPLE_MIGHTYMOUSE       BIT(5)
35 #define APPLE_INVERT_HWHEEL     BIT(6)
36 /* BIT(7) reserved, was: APPLE_IGNORE_HIDINPUT */
37 #define APPLE_NUMLOCK_EMULATION BIT(8)
38 #define APPLE_RDESC_BATTERY     BIT(9)
39 #define APPLE_BACKLIGHT_CTL     BIT(10)
40 #define APPLE_IS_NON_APPLE      BIT(11)
41
42 #define APPLE_FLAG_FKEY         0x01
43
44 #define HID_COUNTRY_INTERNATIONAL_ISO   13
45 #define APPLE_BATTERY_TIMEOUT_MS        60000
46
47 static unsigned int fnmode = 3;
48 module_param(fnmode, uint, 0644);
49 MODULE_PARM_DESC(fnmode, "Mode of fn key on Apple keyboards (0 = disabled, "
50                 "1 = fkeyslast, 2 = fkeysfirst, [3] = auto)");
51
52 static int iso_layout = -1;
53 module_param(iso_layout, int, 0644);
54 MODULE_PARM_DESC(iso_layout, "Swap the backtick/tilde and greater-than/less-than keys. "
55                 "([-1] = auto, 0 = disabled, 1 = enabled)");
56
57 static unsigned int swap_opt_cmd;
58 module_param(swap_opt_cmd, uint, 0644);
59 MODULE_PARM_DESC(swap_opt_cmd, "Swap the Option (\"Alt\") and Command (\"Flag\") keys. "
60                 "(For people who want to keep Windows PC keyboard muscle memory. "
61                 "[0] = as-is, Mac layout. 1 = swapped, Windows layout., 2 = swapped, Swap only left side)");
62
63 static unsigned int swap_ctrl_cmd;
64 module_param(swap_ctrl_cmd, uint, 0644);
65 MODULE_PARM_DESC(swap_ctrl_cmd, "Swap the Control (\"Ctrl\") and Command (\"Flag\") keys. "
66                 "(For people who are used to Mac shortcuts involving Command instead of Control. "
67                 "[0] = No change. 1 = Swapped.)");
68
69 static unsigned int swap_fn_leftctrl;
70 module_param(swap_fn_leftctrl, uint, 0644);
71 MODULE_PARM_DESC(swap_fn_leftctrl, "Swap the Fn and left Control keys. "
72                 "(For people who want to keep PC keyboard muscle memory. "
73                 "[0] = as-is, Mac layout, 1 = swapped, PC layout)");
74
75 struct apple_non_apple_keyboard {
76         char *name;
77 };
78
79 struct apple_sc_backlight {
80         struct led_classdev cdev;
81         struct hid_device *hdev;
82         unsigned short backlight_off, backlight_on_min, backlight_on_max;
83 };
84
85 struct apple_sc {
86         struct hid_device *hdev;
87         unsigned long quirks;
88         unsigned int fn_on;
89         unsigned int fn_found;
90         DECLARE_BITMAP(pressed_numlock, KEY_CNT);
91         struct timer_list battery_timer;
92         struct apple_sc_backlight *backlight;
93 };
94
95 struct apple_key_translation {
96         u16 from;
97         u16 to;
98         u8 flags;
99 };
100
101 static const struct apple_key_translation magic_keyboard_alu_fn_keys[] = {
102         { KEY_BACKSPACE, KEY_DELETE },
103         { KEY_ENTER,    KEY_INSERT },
104         { KEY_F1,       KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
105         { KEY_F2,       KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
106         { KEY_F3,       KEY_SCALE,          APPLE_FLAG_FKEY },
107         { KEY_F4,       KEY_DASHBOARD,      APPLE_FLAG_FKEY },
108         { KEY_F6,       KEY_NUMLOCK,        APPLE_FLAG_FKEY },
109         { KEY_F7,       KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
110         { KEY_F8,       KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
111         { KEY_F9,       KEY_NEXTSONG,       APPLE_FLAG_FKEY },
112         { KEY_F10,      KEY_MUTE,           APPLE_FLAG_FKEY },
113         { KEY_F11,      KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
114         { KEY_F12,      KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
115         { KEY_UP,       KEY_PAGEUP },
116         { KEY_DOWN,     KEY_PAGEDOWN },
117         { KEY_LEFT,     KEY_HOME },
118         { KEY_RIGHT,    KEY_END },
119         { }
120 };
121
122 static const struct apple_key_translation magic_keyboard_2015_fn_keys[] = {
123         { KEY_BACKSPACE, KEY_DELETE },
124         { KEY_ENTER,    KEY_INSERT },
125         { KEY_F1,       KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
126         { KEY_F2,       KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
127         { KEY_F3,       KEY_SCALE,          APPLE_FLAG_FKEY },
128         { KEY_F4,       KEY_DASHBOARD,      APPLE_FLAG_FKEY },
129         { KEY_F7,       KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
130         { KEY_F8,       KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
131         { KEY_F9,       KEY_NEXTSONG,       APPLE_FLAG_FKEY },
132         { KEY_F10,      KEY_MUTE,           APPLE_FLAG_FKEY },
133         { KEY_F11,      KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
134         { KEY_F12,      KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
135         { KEY_UP,       KEY_PAGEUP },
136         { KEY_DOWN,     KEY_PAGEDOWN },
137         { KEY_LEFT,     KEY_HOME },
138         { KEY_RIGHT,    KEY_END },
139         { }
140 };
141
142 struct apple_backlight_config_report {
143         u8 report_id;
144         u8 version;
145         u16 backlight_off, backlight_on_min, backlight_on_max;
146 };
147
148 struct apple_backlight_set_report {
149         u8 report_id;
150         u8 version;
151         u16 backlight;
152         u16 rate;
153 };
154
155
156 static const struct apple_key_translation apple2021_fn_keys[] = {
157         { KEY_BACKSPACE, KEY_DELETE },
158         { KEY_ENTER,    KEY_INSERT },
159         { KEY_F1,       KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
160         { KEY_F2,       KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
161         { KEY_F3,       KEY_SCALE,          APPLE_FLAG_FKEY },
162         { KEY_F4,       KEY_SEARCH,         APPLE_FLAG_FKEY },
163         { KEY_F5,       KEY_MICMUTE,        APPLE_FLAG_FKEY },
164         { KEY_F6,       KEY_SLEEP,          APPLE_FLAG_FKEY },
165         { KEY_F7,       KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
166         { KEY_F8,       KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
167         { KEY_F9,       KEY_NEXTSONG,       APPLE_FLAG_FKEY },
168         { KEY_F10,      KEY_MUTE,           APPLE_FLAG_FKEY },
169         { KEY_F11,      KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
170         { KEY_F12,      KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
171         { KEY_UP,       KEY_PAGEUP },
172         { KEY_DOWN,     KEY_PAGEDOWN },
173         { KEY_LEFT,     KEY_HOME },
174         { KEY_RIGHT,    KEY_END },
175         { }
176 };
177
178 static const struct apple_key_translation macbookair_fn_keys[] = {
179         { KEY_BACKSPACE, KEY_DELETE },
180         { KEY_ENTER,    KEY_INSERT },
181         { KEY_F1,       KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
182         { KEY_F2,       KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
183         { KEY_F3,       KEY_SCALE,          APPLE_FLAG_FKEY },
184         { KEY_F4,       KEY_DASHBOARD,      APPLE_FLAG_FKEY },
185         { KEY_F6,       KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
186         { KEY_F7,       KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
187         { KEY_F8,       KEY_NEXTSONG,       APPLE_FLAG_FKEY },
188         { KEY_F9,       KEY_MUTE,           APPLE_FLAG_FKEY },
189         { KEY_F10,      KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
190         { KEY_F11,      KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
191         { KEY_F12,      KEY_EJECTCD,        APPLE_FLAG_FKEY },
192         { KEY_UP,       KEY_PAGEUP },
193         { KEY_DOWN,     KEY_PAGEDOWN },
194         { KEY_LEFT,     KEY_HOME },
195         { KEY_RIGHT,    KEY_END },
196         { }
197 };
198
199 static const struct apple_key_translation macbookpro_no_esc_fn_keys[] = {
200         { KEY_BACKSPACE, KEY_DELETE },
201         { KEY_ENTER,    KEY_INSERT },
202         { KEY_GRAVE,    KEY_ESC },
203         { KEY_1,        KEY_F1 },
204         { KEY_2,        KEY_F2 },
205         { KEY_3,        KEY_F3 },
206         { KEY_4,        KEY_F4 },
207         { KEY_5,        KEY_F5 },
208         { KEY_6,        KEY_F6 },
209         { KEY_7,        KEY_F7 },
210         { KEY_8,        KEY_F8 },
211         { KEY_9,        KEY_F9 },
212         { KEY_0,        KEY_F10 },
213         { KEY_MINUS,    KEY_F11 },
214         { KEY_EQUAL,    KEY_F12 },
215         { KEY_UP,       KEY_PAGEUP },
216         { KEY_DOWN,     KEY_PAGEDOWN },
217         { KEY_LEFT,     KEY_HOME },
218         { KEY_RIGHT,    KEY_END },
219         { }
220 };
221
222 static const struct apple_key_translation macbookpro_dedicated_esc_fn_keys[] = {
223         { KEY_BACKSPACE, KEY_DELETE },
224         { KEY_ENTER,    KEY_INSERT },
225         { KEY_1,        KEY_F1 },
226         { KEY_2,        KEY_F2 },
227         { KEY_3,        KEY_F3 },
228         { KEY_4,        KEY_F4 },
229         { KEY_5,        KEY_F5 },
230         { KEY_6,        KEY_F6 },
231         { KEY_7,        KEY_F7 },
232         { KEY_8,        KEY_F8 },
233         { KEY_9,        KEY_F9 },
234         { KEY_0,        KEY_F10 },
235         { KEY_MINUS,    KEY_F11 },
236         { KEY_EQUAL,    KEY_F12 },
237         { KEY_UP,       KEY_PAGEUP },
238         { KEY_DOWN,     KEY_PAGEDOWN },
239         { KEY_LEFT,     KEY_HOME },
240         { KEY_RIGHT,    KEY_END },
241         { }
242 };
243
244 static const struct apple_key_translation apple_fn_keys[] = {
245         { KEY_BACKSPACE, KEY_DELETE },
246         { KEY_ENTER,    KEY_INSERT },
247         { KEY_F1,       KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
248         { KEY_F2,       KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
249         { KEY_F3,       KEY_SCALE,          APPLE_FLAG_FKEY },
250         { KEY_F4,       KEY_DASHBOARD,      APPLE_FLAG_FKEY },
251         { KEY_F5,       KEY_KBDILLUMDOWN,   APPLE_FLAG_FKEY },
252         { KEY_F6,       KEY_KBDILLUMUP,     APPLE_FLAG_FKEY },
253         { KEY_F7,       KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
254         { KEY_F8,       KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
255         { KEY_F9,       KEY_NEXTSONG,       APPLE_FLAG_FKEY },
256         { KEY_F10,      KEY_MUTE,           APPLE_FLAG_FKEY },
257         { KEY_F11,      KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
258         { KEY_F12,      KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
259         { KEY_UP,       KEY_PAGEUP },
260         { KEY_DOWN,     KEY_PAGEDOWN },
261         { KEY_LEFT,     KEY_HOME },
262         { KEY_RIGHT,    KEY_END },
263         { }
264 };
265
266 static const struct apple_key_translation powerbook_fn_keys[] = {
267         { KEY_BACKSPACE, KEY_DELETE },
268         { KEY_F1,       KEY_BRIGHTNESSDOWN,     APPLE_FLAG_FKEY },
269         { KEY_F2,       KEY_BRIGHTNESSUP,       APPLE_FLAG_FKEY },
270         { KEY_F3,       KEY_MUTE,               APPLE_FLAG_FKEY },
271         { KEY_F4,       KEY_VOLUMEDOWN,         APPLE_FLAG_FKEY },
272         { KEY_F5,       KEY_VOLUMEUP,           APPLE_FLAG_FKEY },
273         { KEY_F6,       KEY_NUMLOCK,            APPLE_FLAG_FKEY },
274         { KEY_F7,       KEY_SWITCHVIDEOMODE,    APPLE_FLAG_FKEY },
275         { KEY_F8,       KEY_KBDILLUMTOGGLE,     APPLE_FLAG_FKEY },
276         { KEY_F9,       KEY_KBDILLUMDOWN,       APPLE_FLAG_FKEY },
277         { KEY_F10,      KEY_KBDILLUMUP,         APPLE_FLAG_FKEY },
278         { KEY_UP,       KEY_PAGEUP },
279         { KEY_DOWN,     KEY_PAGEDOWN },
280         { KEY_LEFT,     KEY_HOME },
281         { KEY_RIGHT,    KEY_END },
282         { }
283 };
284
285 static const struct apple_key_translation powerbook_numlock_keys[] = {
286         { KEY_J,        KEY_KP1 },
287         { KEY_K,        KEY_KP2 },
288         { KEY_L,        KEY_KP3 },
289         { KEY_U,        KEY_KP4 },
290         { KEY_I,        KEY_KP5 },
291         { KEY_O,        KEY_KP6 },
292         { KEY_7,        KEY_KP7 },
293         { KEY_8,        KEY_KP8 },
294         { KEY_9,        KEY_KP9 },
295         { KEY_M,        KEY_KP0 },
296         { KEY_DOT,      KEY_KPDOT },
297         { KEY_SLASH,    KEY_KPPLUS },
298         { KEY_SEMICOLON, KEY_KPMINUS },
299         { KEY_P,        KEY_KPASTERISK },
300         { KEY_MINUS,    KEY_KPEQUAL },
301         { KEY_0,        KEY_KPSLASH },
302         { KEY_F6,       KEY_NUMLOCK },
303         { KEY_KPENTER,  KEY_KPENTER },
304         { KEY_BACKSPACE, KEY_BACKSPACE },
305         { }
306 };
307
308 static const struct apple_key_translation apple_iso_keyboard[] = {
309         { KEY_GRAVE,    KEY_102ND },
310         { KEY_102ND,    KEY_GRAVE },
311         { }
312 };
313
314 static const struct apple_key_translation swapped_option_cmd_keys[] = {
315         { KEY_LEFTALT,  KEY_LEFTMETA },
316         { KEY_LEFTMETA, KEY_LEFTALT },
317         { KEY_RIGHTALT, KEY_RIGHTMETA },
318         { KEY_RIGHTMETA, KEY_RIGHTALT },
319         { }
320 };
321
322 static const struct apple_key_translation swapped_option_cmd_left_keys[] = {
323         { KEY_LEFTALT,  KEY_LEFTMETA },
324         { KEY_LEFTMETA, KEY_LEFTALT },
325         { }
326 };
327
328 static const struct apple_key_translation swapped_ctrl_cmd_keys[] = {
329         { KEY_LEFTCTRL, KEY_LEFTMETA },
330         { KEY_LEFTMETA, KEY_LEFTCTRL },
331         { KEY_RIGHTCTRL, KEY_RIGHTMETA },
332         { KEY_RIGHTMETA, KEY_RIGHTCTRL },
333         { }
334 };
335
336 static const struct apple_key_translation swapped_fn_leftctrl_keys[] = {
337         { KEY_FN, KEY_LEFTCTRL },
338         { KEY_LEFTCTRL, KEY_FN },
339         { }
340 };
341
342 static const struct apple_non_apple_keyboard non_apple_keyboards[] = {
343         { "SONiX USB DEVICE" },
344         { "Keychron" },
345         { "AONE" },
346         { "GANSS" },
347         { "Hailuck" },
348         { "Jamesdonkey" },
349         { "A3R" },
350 };
351
352 static bool apple_is_non_apple_keyboard(struct hid_device *hdev)
353 {
354         int i;
355
356         for (i = 0; i < ARRAY_SIZE(non_apple_keyboards); i++) {
357                 char *non_apple = non_apple_keyboards[i].name;
358
359                 if (strncmp(hdev->name, non_apple, strlen(non_apple)) == 0)
360                         return true;
361         }
362
363         return false;
364 }
365
366 static inline void apple_setup_key_translation(struct input_dev *input,
367                 const struct apple_key_translation *table)
368 {
369         const struct apple_key_translation *trans;
370
371         for (trans = table; trans->from; trans++)
372                 set_bit(trans->to, input->keybit);
373 }
374
375 static const struct apple_key_translation *apple_find_translation(
376                 const struct apple_key_translation *table, u16 from)
377 {
378         const struct apple_key_translation *trans;
379
380         /* Look for the translation */
381         for (trans = table; trans->from; trans++)
382                 if (trans->from == from)
383                         return trans;
384
385         return NULL;
386 }
387
388 static void input_event_with_scancode(struct input_dev *input,
389                 __u8 type, __u16 code, unsigned int hid, __s32 value)
390 {
391         if (type == EV_KEY &&
392             (!test_bit(code, input->key)) == value)
393                 input_event(input, EV_MSC, MSC_SCAN, hid);
394         input_event(input, type, code, value);
395 }
396
397 static int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
398                 struct hid_usage *usage, __s32 value)
399 {
400         struct apple_sc *asc = hid_get_drvdata(hid);
401         const struct apple_key_translation *trans, *table;
402         bool do_translate;
403         u16 code = usage->code;
404         unsigned int real_fnmode;
405
406         if (fnmode == 3) {
407                 real_fnmode = (asc->quirks & APPLE_IS_NON_APPLE) ? 2 : 1;
408         } else {
409                 real_fnmode = fnmode;
410         }
411
412         if (swap_fn_leftctrl) {
413                 trans = apple_find_translation(swapped_fn_leftctrl_keys, code);
414
415                 if (trans)
416                         code = trans->to;
417         }
418
419         if (iso_layout > 0 || (iso_layout < 0 && (asc->quirks & APPLE_ISO_TILDE_QUIRK) &&
420                         hid->country == HID_COUNTRY_INTERNATIONAL_ISO)) {
421                 trans = apple_find_translation(apple_iso_keyboard, code);
422
423                 if (trans)
424                         code = trans->to;
425         }
426
427         if (swap_opt_cmd) {
428                 if (swap_opt_cmd == 2)
429                         trans = apple_find_translation(swapped_option_cmd_left_keys, code);
430                 else
431                         trans = apple_find_translation(swapped_option_cmd_keys, code);
432
433                 if (trans)
434                         code = trans->to;
435         }
436
437         if (swap_ctrl_cmd) {
438                 trans = apple_find_translation(swapped_ctrl_cmd_keys, code);
439
440                 if (trans)
441                         code = trans->to;
442         }
443
444         if (code == KEY_FN)
445                 asc->fn_on = !!value;
446
447         if (real_fnmode) {
448                 if (hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI ||
449                     hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO ||
450                     hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS ||
451                     hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI ||
452                     hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO ||
453                     hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS ||
454                     hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI ||
455                     hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO ||
456                     hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_JIS)
457                         table = magic_keyboard_alu_fn_keys;
458                 else if (hid->product == USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2015 ||
459                          hid->product == USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2015)
460                         table = magic_keyboard_2015_fn_keys;
461                 else if (hid->product == USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2021 ||
462                          hid->product == USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_FINGERPRINT_2021 ||
463                          hid->product == USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2021)
464                         table = apple2021_fn_keys;
465                 else if (hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J132 ||
466                          hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J680 ||
467                          hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J213)
468                                 table = macbookpro_no_esc_fn_keys;
469                 else if (hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J214K ||
470                          hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J223 ||
471                          hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J152F)
472                                 table = macbookpro_dedicated_esc_fn_keys;
473                 else if (hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J140K ||
474                          hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J230K)
475                                 table = apple_fn_keys;
476                 else if (hid->product >= USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI &&
477                                 hid->product <= USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS)
478                         table = macbookair_fn_keys;
479                 else if (hid->product < 0x21d || hid->product >= 0x300)
480                         table = powerbook_fn_keys;
481                 else
482                         table = apple_fn_keys;
483
484                 trans = apple_find_translation(table, code);
485
486                 if (trans) {
487                         bool from_is_set = test_bit(trans->from, input->key);
488                         bool to_is_set = test_bit(trans->to, input->key);
489
490                         if (from_is_set)
491                                 code = trans->from;
492                         else if (to_is_set)
493                                 code = trans->to;
494
495                         if (!(from_is_set || to_is_set)) {
496                                 if (trans->flags & APPLE_FLAG_FKEY) {
497                                         switch (real_fnmode) {
498                                         case 1:
499                                                 do_translate = !asc->fn_on;
500                                                 break;
501                                         case 2:
502                                                 do_translate = asc->fn_on;
503                                                 break;
504                                         default:
505                                                 /* should never happen */
506                                                 do_translate = false;
507                                         }
508                                 } else {
509                                         do_translate = asc->fn_on;
510                                 }
511
512                                 if (do_translate)
513                                         code = trans->to;
514                         }
515                 }
516
517                 if (asc->quirks & APPLE_NUMLOCK_EMULATION &&
518                                 (test_bit(code, asc->pressed_numlock) ||
519                                 test_bit(LED_NUML, input->led))) {
520                         trans = apple_find_translation(powerbook_numlock_keys, code);
521
522                         if (trans) {
523                                 if (value)
524                                         set_bit(code, asc->pressed_numlock);
525                                 else
526                                         clear_bit(code, asc->pressed_numlock);
527
528                                 code = trans->to;
529                         }
530                 }
531         }
532
533         if (usage->code != code) {
534                 input_event_with_scancode(input, usage->type, code, usage->hid, value);
535
536                 return 1;
537         }
538
539         return 0;
540 }
541
542 static int apple_event(struct hid_device *hdev, struct hid_field *field,
543                 struct hid_usage *usage, __s32 value)
544 {
545         struct apple_sc *asc = hid_get_drvdata(hdev);
546
547         if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
548                         !usage->type)
549                 return 0;
550
551         if ((asc->quirks & APPLE_INVERT_HWHEEL) &&
552                         usage->code == REL_HWHEEL) {
553                 input_event_with_scancode(field->hidinput->input, usage->type,
554                                 usage->code, usage->hid, -value);
555                 return 1;
556         }
557
558         if ((asc->quirks & APPLE_HAS_FN) &&
559                         hidinput_apple_event(hdev, field->hidinput->input,
560                                 usage, value))
561                 return 1;
562
563
564         return 0;
565 }
566
567 static int apple_fetch_battery(struct hid_device *hdev)
568 {
569 #ifdef CONFIG_HID_BATTERY_STRENGTH
570         struct apple_sc *asc = hid_get_drvdata(hdev);
571         struct hid_report_enum *report_enum;
572         struct hid_report *report;
573
574         if (!(asc->quirks & APPLE_RDESC_BATTERY) || !hdev->battery)
575                 return -1;
576
577         report_enum = &hdev->report_enum[hdev->battery_report_type];
578         report = report_enum->report_id_hash[hdev->battery_report_id];
579
580         if (!report || report->maxfield < 1)
581                 return -1;
582
583         if (hdev->battery_capacity == hdev->battery_max)
584                 return -1;
585
586         hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
587         return 0;
588 #else
589         return -1;
590 #endif
591 }
592
593 static void apple_battery_timer_tick(struct timer_list *t)
594 {
595         struct apple_sc *asc = from_timer(asc, t, battery_timer);
596         struct hid_device *hdev = asc->hdev;
597
598         if (apple_fetch_battery(hdev) == 0) {
599                 mod_timer(&asc->battery_timer,
600                           jiffies + msecs_to_jiffies(APPLE_BATTERY_TIMEOUT_MS));
601         }
602 }
603
604 /*
605  * MacBook JIS keyboard has wrong logical maximum
606  * Magic Keyboard JIS has wrong logical maximum
607  */
608 static __u8 *apple_report_fixup(struct hid_device *hdev, __u8 *rdesc,
609                 unsigned int *rsize)
610 {
611         struct apple_sc *asc = hid_get_drvdata(hdev);
612
613         if(*rsize >=71 && rdesc[70] == 0x65 && rdesc[64] == 0x65) {
614                 hid_info(hdev,
615                          "fixing up Magic Keyboard JIS report descriptor\n");
616                 rdesc[64] = rdesc[70] = 0xe7;
617         }
618
619         if ((asc->quirks & APPLE_RDESC_JIS) && *rsize >= 60 &&
620                         rdesc[53] == 0x65 && rdesc[59] == 0x65) {
621                 hid_info(hdev,
622                          "fixing up MacBook JIS keyboard report descriptor\n");
623                 rdesc[53] = rdesc[59] = 0xe7;
624         }
625
626         /*
627          * Change the usage from:
628          *   0x06, 0x00, 0xff, // Usage Page (Vendor Defined Page 1)  0
629          *   0x09, 0x0b,       // Usage (Vendor Usage 0x0b)           3
630          * To:
631          *   0x05, 0x01,       // Usage Page (Generic Desktop)        0
632          *   0x09, 0x06,       // Usage (Keyboard)                    2
633          */
634         if ((asc->quirks & APPLE_RDESC_BATTERY) && *rsize == 83 &&
635             rdesc[46] == 0x84 && rdesc[58] == 0x85) {
636                 hid_info(hdev,
637                          "fixing up Magic Keyboard battery report descriptor\n");
638                 *rsize = *rsize - 1;
639                 rdesc = kmemdup(rdesc + 1, *rsize, GFP_KERNEL);
640                 if (!rdesc)
641                         return NULL;
642
643                 rdesc[0] = 0x05;
644                 rdesc[1] = 0x01;
645                 rdesc[2] = 0x09;
646                 rdesc[3] = 0x06;
647         }
648
649         return rdesc;
650 }
651
652 static void apple_setup_input(struct input_dev *input)
653 {
654         set_bit(KEY_NUMLOCK, input->keybit);
655
656         /* Enable all needed keys */
657         apple_setup_key_translation(input, apple_fn_keys);
658         apple_setup_key_translation(input, powerbook_fn_keys);
659         apple_setup_key_translation(input, powerbook_numlock_keys);
660         apple_setup_key_translation(input, apple_iso_keyboard);
661         apple_setup_key_translation(input, magic_keyboard_alu_fn_keys);
662         apple_setup_key_translation(input, magic_keyboard_2015_fn_keys);
663         apple_setup_key_translation(input, apple2021_fn_keys);
664         apple_setup_key_translation(input, macbookpro_no_esc_fn_keys);
665         apple_setup_key_translation(input, macbookpro_dedicated_esc_fn_keys);
666 }
667
668 static int apple_input_mapping(struct hid_device *hdev, struct hid_input *hi,
669                 struct hid_field *field, struct hid_usage *usage,
670                 unsigned long **bit, int *max)
671 {
672         struct apple_sc *asc = hid_get_drvdata(hdev);
673
674         if (usage->hid == (HID_UP_CUSTOM | 0x0003) ||
675                         usage->hid == (HID_UP_MSVENDOR | 0x0003) ||
676                         usage->hid == (HID_UP_HPVENDOR2 | 0x0003)) {
677                 /* The fn key on Apple USB keyboards */
678                 set_bit(EV_REP, hi->input->evbit);
679                 hid_map_usage_clear(hi, usage, bit, max, EV_KEY, KEY_FN);
680                 asc->fn_found = true;
681                 apple_setup_input(hi->input);
682                 return 1;
683         }
684
685         /* we want the hid layer to go through standard path (set and ignore) */
686         return 0;
687 }
688
689 static int apple_input_mapped(struct hid_device *hdev, struct hid_input *hi,
690                 struct hid_field *field, struct hid_usage *usage,
691                 unsigned long **bit, int *max)
692 {
693         struct apple_sc *asc = hid_get_drvdata(hdev);
694
695         if (asc->quirks & APPLE_MIGHTYMOUSE) {
696                 if (usage->hid == HID_GD_Z)
697                         hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
698                 else if (usage->code == BTN_1)
699                         hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_2);
700                 else if (usage->code == BTN_2)
701                         hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_1);
702         }
703
704         return 0;
705 }
706
707 static int apple_input_configured(struct hid_device *hdev,
708                 struct hid_input *hidinput)
709 {
710         struct apple_sc *asc = hid_get_drvdata(hdev);
711
712         if ((asc->quirks & APPLE_HAS_FN) && !asc->fn_found) {
713                 hid_info(hdev, "Fn key not found (Apple Wireless Keyboard clone?), disabling Fn key handling\n");
714                 asc->quirks &= ~APPLE_HAS_FN;
715         }
716
717         if (apple_is_non_apple_keyboard(hdev)) {
718                 hid_info(hdev, "Non-apple keyboard detected; function keys will default to fnmode=2 behavior\n");
719                 asc->quirks |= APPLE_IS_NON_APPLE;
720         }
721
722         return 0;
723 }
724
725 static bool apple_backlight_check_support(struct hid_device *hdev)
726 {
727         int i;
728         unsigned int hid;
729         struct hid_report *report;
730
731         list_for_each_entry(report, &hdev->report_enum[HID_INPUT_REPORT].report_list, list) {
732                 for (i = 0; i < report->maxfield; i++) {
733                         hid = report->field[i]->usage->hid;
734                         if ((hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR && (hid & HID_USAGE) == 0xf)
735                                 return true;
736                 }
737         }
738
739         return false;
740 }
741
742 static int apple_backlight_set(struct hid_device *hdev, u16 value, u16 rate)
743 {
744         int ret = 0;
745         struct apple_backlight_set_report *rep;
746
747         rep = kmalloc(sizeof(*rep), GFP_KERNEL);
748         if (rep == NULL)
749                 return -ENOMEM;
750
751         rep->report_id = 0xB0;
752         rep->version = 1;
753         rep->backlight = value;
754         rep->rate = rate;
755
756         ret = hid_hw_raw_request(hdev, 0xB0u, (u8 *) rep, sizeof(*rep),
757                                  HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
758
759         kfree(rep);
760         return ret;
761 }
762
763 static int apple_backlight_led_set(struct led_classdev *led_cdev,
764         enum led_brightness brightness)
765 {
766         struct apple_sc_backlight *backlight = container_of(led_cdev,
767                                                             struct apple_sc_backlight, cdev);
768
769         return apple_backlight_set(backlight->hdev, brightness, 0);
770 }
771
772 static int apple_backlight_init(struct hid_device *hdev)
773 {
774         int ret;
775         struct apple_sc *asc = hid_get_drvdata(hdev);
776         struct apple_backlight_config_report *rep;
777
778         if (!apple_backlight_check_support(hdev))
779                 return -EINVAL;
780
781         rep = kmalloc(0x200, GFP_KERNEL);
782         if (rep == NULL)
783                 return -ENOMEM;
784
785         ret = hid_hw_raw_request(hdev, 0xBFu, (u8 *) rep, sizeof(*rep),
786                                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
787         if (ret < 0) {
788                 hid_err(hdev, "backlight request failed: %d\n", ret);
789                 goto cleanup_and_exit;
790         }
791         if (ret < 8 || rep->version != 1) {
792                 hid_err(hdev, "backlight config struct: bad version %i\n", rep->version);
793                 ret = -EINVAL;
794                 goto cleanup_and_exit;
795         }
796
797         hid_dbg(hdev, "backlight config: off=%u, on_min=%u, on_max=%u\n",
798                 rep->backlight_off, rep->backlight_on_min, rep->backlight_on_max);
799
800         asc->backlight = devm_kzalloc(&hdev->dev, sizeof(*asc->backlight), GFP_KERNEL);
801         if (!asc->backlight) {
802                 ret = -ENOMEM;
803                 goto cleanup_and_exit;
804         }
805
806         asc->backlight->hdev = hdev;
807         asc->backlight->cdev.name = "apple::kbd_backlight";
808         asc->backlight->cdev.max_brightness = rep->backlight_on_max;
809         asc->backlight->cdev.brightness_set_blocking = apple_backlight_led_set;
810
811         ret = apple_backlight_set(hdev, 0, 0);
812         if (ret < 0) {
813                 hid_err(hdev, "backlight set request failed: %d\n", ret);
814                 goto cleanup_and_exit;
815         }
816
817         ret = devm_led_classdev_register(&hdev->dev, &asc->backlight->cdev);
818
819 cleanup_and_exit:
820         kfree(rep);
821         return ret;
822 }
823
824 static int apple_probe(struct hid_device *hdev,
825                 const struct hid_device_id *id)
826 {
827         unsigned long quirks = id->driver_data;
828         struct apple_sc *asc;
829         int ret;
830
831         asc = devm_kzalloc(&hdev->dev, sizeof(*asc), GFP_KERNEL);
832         if (asc == NULL) {
833                 hid_err(hdev, "can't alloc apple descriptor\n");
834                 return -ENOMEM;
835         }
836
837         asc->hdev = hdev;
838         asc->quirks = quirks;
839
840         hid_set_drvdata(hdev, asc);
841
842         ret = hid_parse(hdev);
843         if (ret) {
844                 hid_err(hdev, "parse failed\n");
845                 return ret;
846         }
847
848         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
849         if (ret) {
850                 hid_err(hdev, "hw start failed\n");
851                 return ret;
852         }
853
854         timer_setup(&asc->battery_timer, apple_battery_timer_tick, 0);
855         mod_timer(&asc->battery_timer,
856                   jiffies + msecs_to_jiffies(APPLE_BATTERY_TIMEOUT_MS));
857         apple_fetch_battery(hdev);
858
859         if (quirks & APPLE_BACKLIGHT_CTL)
860                 apple_backlight_init(hdev);
861
862         return 0;
863 }
864
865 static void apple_remove(struct hid_device *hdev)
866 {
867         struct apple_sc *asc = hid_get_drvdata(hdev);
868
869         del_timer_sync(&asc->battery_timer);
870
871         hid_hw_stop(hdev);
872 }
873
874 static const struct hid_device_id apple_devices[] = {
875         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE),
876                 .driver_data = APPLE_MIGHTYMOUSE | APPLE_INVERT_HWHEEL },
877
878         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI),
879                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
880         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO),
881                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
882         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI),
883                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
884         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO),
885                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
886         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS),
887                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
888         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI),
889                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
890         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO),
891                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
892                         APPLE_ISO_TILDE_QUIRK },
893         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS),
894                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
895                         APPLE_RDESC_JIS },
896         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI),
897                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
898         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO),
899                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
900                         APPLE_ISO_TILDE_QUIRK },
901         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS),
902                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
903                         APPLE_RDESC_JIS },
904         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ANSI),
905                 .driver_data = APPLE_HAS_FN },
906         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ISO),
907                 .driver_data = APPLE_HAS_FN },
908         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_JIS),
909                 .driver_data = APPLE_HAS_FN },
910         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI),
911                 .driver_data = APPLE_HAS_FN },
912         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO),
913                 .driver_data = APPLE_HAS_FN },
914         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS),
915                 .driver_data = APPLE_HAS_FN },
916         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI),
917                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
918         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO),
919                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
920                         APPLE_ISO_TILDE_QUIRK },
921         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS),
922                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
923                         APPLE_RDESC_JIS },
924         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI),
925                 .driver_data = APPLE_HAS_FN },
926         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI),
927                 .driver_data = APPLE_HAS_FN },
928         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO),
929                 .driver_data = APPLE_HAS_FN },
930         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO),
931                 .driver_data = APPLE_HAS_FN },
932         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS),
933                 .driver_data = APPLE_HAS_FN },
934         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
935                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
936         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
937                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
938                         APPLE_ISO_TILDE_QUIRK },
939         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO),
940                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
941                         APPLE_ISO_TILDE_QUIRK },
942         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
943                                 USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI),
944                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
945         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
946                                 USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_JIS),
947                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
948         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS),
949                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
950         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2015),
951                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK | APPLE_RDESC_BATTERY },
952         { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2015),
953                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
954         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2015),
955                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK | APPLE_RDESC_BATTERY },
956         { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2015),
957                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
958         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI),
959                 .driver_data = APPLE_HAS_FN },
960         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO),
961                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
962         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS),
963                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
964         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI),
965                 .driver_data = APPLE_HAS_FN },
966         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO),
967                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
968         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS),
969                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
970         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI),
971                 .driver_data = APPLE_HAS_FN },
972         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO),
973                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
974         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS),
975                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
976         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI),
977                 .driver_data = APPLE_HAS_FN },
978         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO),
979                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
980         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS),
981                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
982         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI),
983                 .driver_data = APPLE_HAS_FN },
984         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO),
985                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
986         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS),
987                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
988         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI),
989                 .driver_data = APPLE_HAS_FN },
990         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO),
991                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
992         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS),
993                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
994         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI),
995                 .driver_data = APPLE_HAS_FN },
996         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO),
997                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
998         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS),
999                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
1000         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI),
1001                 .driver_data = APPLE_HAS_FN },
1002         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO),
1003                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1004         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS),
1005                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
1006         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI),
1007                 .driver_data = APPLE_HAS_FN },
1008         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO),
1009                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1010         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS),
1011                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
1012         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI),
1013                 .driver_data = APPLE_HAS_FN },
1014         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO),
1015                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1016         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS),
1017                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
1018         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI),
1019                 .driver_data = APPLE_HAS_FN },
1020         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO),
1021                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1022         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS),
1023                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
1024         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI),
1025                 .driver_data = APPLE_HAS_FN },
1026         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ISO),
1027                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1028         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_JIS),
1029                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
1030         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ANSI),
1031                 .driver_data = APPLE_HAS_FN },
1032         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ISO),
1033                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1034         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_JIS),
1035                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
1036         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J140K),
1037                 .driver_data = APPLE_HAS_FN | APPLE_BACKLIGHT_CTL | APPLE_ISO_TILDE_QUIRK },
1038         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J132),
1039                 .driver_data = APPLE_HAS_FN | APPLE_BACKLIGHT_CTL | APPLE_ISO_TILDE_QUIRK },
1040         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J680),
1041                 .driver_data = APPLE_HAS_FN | APPLE_BACKLIGHT_CTL | APPLE_ISO_TILDE_QUIRK },
1042         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J213),
1043                 .driver_data = APPLE_HAS_FN | APPLE_BACKLIGHT_CTL | APPLE_ISO_TILDE_QUIRK },
1044         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J214K),
1045                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1046         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J223),
1047                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1048         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J230K),
1049                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1050         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J152F),
1051                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1052         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI),
1053                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
1054         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
1055                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
1056                         APPLE_ISO_TILDE_QUIRK },
1057         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS),
1058                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
1059         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY),
1060                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
1061         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY),
1062                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
1063         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2021),
1064                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK | APPLE_RDESC_BATTERY },
1065         { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2021),
1066                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1067         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_FINGERPRINT_2021),
1068                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK | APPLE_RDESC_BATTERY },
1069         { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_FINGERPRINT_2021),
1070                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1071         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2021),
1072                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK | APPLE_RDESC_BATTERY },
1073         { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2021),
1074                 .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1075
1076         { }
1077 };
1078 MODULE_DEVICE_TABLE(hid, apple_devices);
1079
1080 static struct hid_driver apple_driver = {
1081         .name = "apple",
1082         .id_table = apple_devices,
1083         .report_fixup = apple_report_fixup,
1084         .probe = apple_probe,
1085         .remove = apple_remove,
1086         .event = apple_event,
1087         .input_mapping = apple_input_mapping,
1088         .input_mapped = apple_input_mapped,
1089         .input_configured = apple_input_configured,
1090 };
1091 module_hid_driver(apple_driver);
1092
1093 MODULE_LICENSE("GPL");