Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *  USB HID quirks support for Linux
0004  *
0005  *  Copyright (c) 1999 Andreas Gal
0006  *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
0007  *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
0008  *  Copyright (c) 2006-2007 Jiri Kosina
0009  *  Copyright (c) 2008 Jiri Slaby <jirislaby@gmail.com>
0010  *  Copyright (c) 2019 Paul Pawlowski <paul@mrarm.io>
0011  */
0012 
0013 /*
0014  */
0015 
0016 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0017 
0018 #include <linux/device.h>
0019 #include <linux/hid.h>
0020 #include <linux/jiffies.h>
0021 #include <linux/module.h>
0022 #include <linux/slab.h>
0023 #include <linux/timer.h>
0024 #include <linux/string.h>
0025 
0026 #include "hid-ids.h"
0027 
0028 #define APPLE_RDESC_JIS     BIT(0)
0029 #define APPLE_IGNORE_MOUSE  BIT(1)
0030 #define APPLE_HAS_FN        BIT(2)
0031 /* BIT(3) reserved, was: APPLE_HIDDEV */
0032 #define APPLE_ISO_TILDE_QUIRK   BIT(4)
0033 #define APPLE_MIGHTYMOUSE   BIT(5)
0034 #define APPLE_INVERT_HWHEEL BIT(6)
0035 /* BIT(7) reserved, was: APPLE_IGNORE_HIDINPUT */
0036 #define APPLE_NUMLOCK_EMULATION BIT(8)
0037 #define APPLE_RDESC_BATTERY BIT(9)
0038 #define APPLE_BACKLIGHT_CTL BIT(10)
0039 #define APPLE_IS_NON_APPLE  BIT(11)
0040 
0041 #define APPLE_FLAG_FKEY     0x01
0042 
0043 #define HID_COUNTRY_INTERNATIONAL_ISO   13
0044 #define APPLE_BATTERY_TIMEOUT_MS    60000
0045 
0046 static unsigned int fnmode = 3;
0047 module_param(fnmode, uint, 0644);
0048 MODULE_PARM_DESC(fnmode, "Mode of fn key on Apple keyboards (0 = disabled, "
0049         "1 = fkeyslast, 2 = fkeysfirst, [3] = auto)");
0050 
0051 static int iso_layout = -1;
0052 module_param(iso_layout, int, 0644);
0053 MODULE_PARM_DESC(iso_layout, "Swap the backtick/tilde and greater-than/less-than keys. "
0054         "([-1] = auto, 0 = disabled, 1 = enabled)");
0055 
0056 static unsigned int swap_opt_cmd;
0057 module_param(swap_opt_cmd, uint, 0644);
0058 MODULE_PARM_DESC(swap_opt_cmd, "Swap the Option (\"Alt\") and Command (\"Flag\") keys. "
0059         "(For people who want to keep Windows PC keyboard muscle memory. "
0060         "[0] = as-is, Mac layout. 1 = swapped, Windows layout.)");
0061 
0062 static unsigned int swap_fn_leftctrl;
0063 module_param(swap_fn_leftctrl, uint, 0644);
0064 MODULE_PARM_DESC(swap_fn_leftctrl, "Swap the Fn and left Control keys. "
0065         "(For people who want to keep PC keyboard muscle memory. "
0066         "[0] = as-is, Mac layout, 1 = swapped, PC layout)");
0067 
0068 struct apple_non_apple_keyboard {
0069     char *name;
0070 };
0071 
0072 struct apple_sc_backlight {
0073     struct led_classdev cdev;
0074     struct hid_device *hdev;
0075     unsigned short backlight_off, backlight_on_min, backlight_on_max;
0076 };
0077 
0078 struct apple_sc {
0079     struct hid_device *hdev;
0080     unsigned long quirks;
0081     unsigned int fn_on;
0082     unsigned int fn_found;
0083     DECLARE_BITMAP(pressed_numlock, KEY_CNT);
0084     struct timer_list battery_timer;
0085     struct apple_sc_backlight *backlight;
0086 };
0087 
0088 struct apple_key_translation {
0089     u16 from;
0090     u16 to;
0091     u8 flags;
0092 };
0093 
0094 static const struct apple_key_translation magic_keyboard_alu_fn_keys[] = {
0095     { KEY_BACKSPACE, KEY_DELETE },
0096     { KEY_ENTER,    KEY_INSERT },
0097     { KEY_F1,   KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
0098     { KEY_F2,   KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
0099     { KEY_F3,   KEY_SCALE,          APPLE_FLAG_FKEY },
0100     { KEY_F4,   KEY_DASHBOARD,      APPLE_FLAG_FKEY },
0101     { KEY_F6,   KEY_NUMLOCK,        APPLE_FLAG_FKEY },
0102     { KEY_F7,   KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
0103     { KEY_F8,   KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
0104     { KEY_F9,   KEY_NEXTSONG,       APPLE_FLAG_FKEY },
0105     { KEY_F10,  KEY_MUTE,           APPLE_FLAG_FKEY },
0106     { KEY_F11,  KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
0107     { KEY_F12,  KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
0108     { KEY_UP,   KEY_PAGEUP },
0109     { KEY_DOWN, KEY_PAGEDOWN },
0110     { KEY_LEFT, KEY_HOME },
0111     { KEY_RIGHT,    KEY_END },
0112     { }
0113 };
0114 
0115 static const struct apple_key_translation magic_keyboard_2015_fn_keys[] = {
0116     { KEY_BACKSPACE, KEY_DELETE },
0117     { KEY_ENTER,    KEY_INSERT },
0118     { KEY_F1,   KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
0119     { KEY_F2,   KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
0120     { KEY_F3,   KEY_SCALE,          APPLE_FLAG_FKEY },
0121     { KEY_F4,   KEY_DASHBOARD,      APPLE_FLAG_FKEY },
0122     { KEY_F7,   KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
0123     { KEY_F8,   KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
0124     { KEY_F9,   KEY_NEXTSONG,       APPLE_FLAG_FKEY },
0125     { KEY_F10,  KEY_MUTE,           APPLE_FLAG_FKEY },
0126     { KEY_F11,  KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
0127     { KEY_F12,  KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
0128     { KEY_UP,   KEY_PAGEUP },
0129     { KEY_DOWN, KEY_PAGEDOWN },
0130     { KEY_LEFT, KEY_HOME },
0131     { KEY_RIGHT,    KEY_END },
0132     { }
0133 };
0134 
0135 struct apple_backlight_config_report {
0136     u8 report_id;
0137     u8 version;
0138     u16 backlight_off, backlight_on_min, backlight_on_max;
0139 };
0140 
0141 struct apple_backlight_set_report {
0142     u8 report_id;
0143     u8 version;
0144     u16 backlight;
0145     u16 rate;
0146 };
0147 
0148 
0149 static const struct apple_key_translation apple2021_fn_keys[] = {
0150     { KEY_BACKSPACE, KEY_DELETE },
0151     { KEY_ENTER,    KEY_INSERT },
0152     { KEY_F1,   KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
0153     { KEY_F2,   KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
0154     { KEY_F3,   KEY_SCALE,          APPLE_FLAG_FKEY },
0155     { KEY_F4,   KEY_SEARCH,         APPLE_FLAG_FKEY },
0156     { KEY_F5,   KEY_MICMUTE,        APPLE_FLAG_FKEY },
0157     { KEY_F6,   KEY_SLEEP,          APPLE_FLAG_FKEY },
0158     { KEY_F7,   KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
0159     { KEY_F8,   KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
0160     { KEY_F9,   KEY_NEXTSONG,       APPLE_FLAG_FKEY },
0161     { KEY_F10,  KEY_MUTE,           APPLE_FLAG_FKEY },
0162     { KEY_F11,  KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
0163     { KEY_F12,  KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
0164     { KEY_UP,   KEY_PAGEUP },
0165     { KEY_DOWN, KEY_PAGEDOWN },
0166     { KEY_LEFT, KEY_HOME },
0167     { KEY_RIGHT,    KEY_END },
0168     { }
0169 };
0170 
0171 static const struct apple_key_translation macbookair_fn_keys[] = {
0172     { KEY_BACKSPACE, KEY_DELETE },
0173     { KEY_ENTER,    KEY_INSERT },
0174     { KEY_F1,   KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
0175     { KEY_F2,   KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
0176     { KEY_F3,   KEY_SCALE,          APPLE_FLAG_FKEY },
0177     { KEY_F4,   KEY_DASHBOARD,      APPLE_FLAG_FKEY },
0178     { KEY_F6,   KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
0179     { KEY_F7,   KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
0180     { KEY_F8,   KEY_NEXTSONG,       APPLE_FLAG_FKEY },
0181     { KEY_F9,   KEY_MUTE,           APPLE_FLAG_FKEY },
0182     { KEY_F10,  KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
0183     { KEY_F11,  KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
0184     { KEY_F12,  KEY_EJECTCD,        APPLE_FLAG_FKEY },
0185     { KEY_UP,   KEY_PAGEUP },
0186     { KEY_DOWN, KEY_PAGEDOWN },
0187     { KEY_LEFT, KEY_HOME },
0188     { KEY_RIGHT,    KEY_END },
0189     { }
0190 };
0191 
0192 static const struct apple_key_translation macbookpro_no_esc_fn_keys[] = {
0193     { KEY_BACKSPACE, KEY_DELETE },
0194     { KEY_ENTER,    KEY_INSERT },
0195     { KEY_GRAVE,    KEY_ESC },
0196     { KEY_1,    KEY_F1 },
0197     { KEY_2,    KEY_F2 },
0198     { KEY_3,    KEY_F3 },
0199     { KEY_4,    KEY_F4 },
0200     { KEY_5,    KEY_F5 },
0201     { KEY_6,    KEY_F6 },
0202     { KEY_7,    KEY_F7 },
0203     { KEY_8,    KEY_F8 },
0204     { KEY_9,    KEY_F9 },
0205     { KEY_0,    KEY_F10 },
0206     { KEY_MINUS,    KEY_F11 },
0207     { KEY_EQUAL,    KEY_F12 },
0208     { KEY_UP,   KEY_PAGEUP },
0209     { KEY_DOWN, KEY_PAGEDOWN },
0210     { KEY_LEFT, KEY_HOME },
0211     { KEY_RIGHT,    KEY_END },
0212     { }
0213 };
0214 
0215 static const struct apple_key_translation macbookpro_dedicated_esc_fn_keys[] = {
0216     { KEY_BACKSPACE, KEY_DELETE },
0217     { KEY_ENTER,    KEY_INSERT },
0218     { KEY_1,    KEY_F1 },
0219     { KEY_2,    KEY_F2 },
0220     { KEY_3,    KEY_F3 },
0221     { KEY_4,    KEY_F4 },
0222     { KEY_5,    KEY_F5 },
0223     { KEY_6,    KEY_F6 },
0224     { KEY_7,    KEY_F7 },
0225     { KEY_8,    KEY_F8 },
0226     { KEY_9,    KEY_F9 },
0227     { KEY_0,    KEY_F10 },
0228     { KEY_MINUS,    KEY_F11 },
0229     { KEY_EQUAL,    KEY_F12 },
0230     { KEY_UP,   KEY_PAGEUP },
0231     { KEY_DOWN, KEY_PAGEDOWN },
0232     { KEY_LEFT, KEY_HOME },
0233     { KEY_RIGHT,    KEY_END },
0234     { }
0235 };
0236 
0237 static const struct apple_key_translation apple_fn_keys[] = {
0238     { KEY_BACKSPACE, KEY_DELETE },
0239     { KEY_ENTER,    KEY_INSERT },
0240     { KEY_F1,   KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
0241     { KEY_F2,   KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
0242     { KEY_F3,   KEY_SCALE,          APPLE_FLAG_FKEY },
0243     { KEY_F4,   KEY_DASHBOARD,      APPLE_FLAG_FKEY },
0244     { KEY_F5,   KEY_KBDILLUMDOWN,   APPLE_FLAG_FKEY },
0245     { KEY_F6,   KEY_KBDILLUMUP,     APPLE_FLAG_FKEY },
0246     { KEY_F7,   KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
0247     { KEY_F8,   KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
0248     { KEY_F9,   KEY_NEXTSONG,       APPLE_FLAG_FKEY },
0249     { KEY_F10,  KEY_MUTE,           APPLE_FLAG_FKEY },
0250     { KEY_F11,  KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
0251     { KEY_F12,  KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
0252     { KEY_UP,   KEY_PAGEUP },
0253     { KEY_DOWN, KEY_PAGEDOWN },
0254     { KEY_LEFT, KEY_HOME },
0255     { KEY_RIGHT,    KEY_END },
0256     { }
0257 };
0258 
0259 static const struct apple_key_translation powerbook_fn_keys[] = {
0260     { KEY_BACKSPACE, KEY_DELETE },
0261     { KEY_F1,   KEY_BRIGHTNESSDOWN,     APPLE_FLAG_FKEY },
0262     { KEY_F2,   KEY_BRIGHTNESSUP,       APPLE_FLAG_FKEY },
0263     { KEY_F3,   KEY_MUTE,               APPLE_FLAG_FKEY },
0264     { KEY_F4,   KEY_VOLUMEDOWN,         APPLE_FLAG_FKEY },
0265     { KEY_F5,   KEY_VOLUMEUP,           APPLE_FLAG_FKEY },
0266     { KEY_F6,   KEY_NUMLOCK,            APPLE_FLAG_FKEY },
0267     { KEY_F7,   KEY_SWITCHVIDEOMODE,    APPLE_FLAG_FKEY },
0268     { KEY_F8,   KEY_KBDILLUMTOGGLE,     APPLE_FLAG_FKEY },
0269     { KEY_F9,   KEY_KBDILLUMDOWN,       APPLE_FLAG_FKEY },
0270     { KEY_F10,  KEY_KBDILLUMUP,         APPLE_FLAG_FKEY },
0271     { KEY_UP,   KEY_PAGEUP },
0272     { KEY_DOWN, KEY_PAGEDOWN },
0273     { KEY_LEFT, KEY_HOME },
0274     { KEY_RIGHT,    KEY_END },
0275     { }
0276 };
0277 
0278 static const struct apple_key_translation powerbook_numlock_keys[] = {
0279     { KEY_J,    KEY_KP1 },
0280     { KEY_K,    KEY_KP2 },
0281     { KEY_L,    KEY_KP3 },
0282     { KEY_U,    KEY_KP4 },
0283     { KEY_I,    KEY_KP5 },
0284     { KEY_O,    KEY_KP6 },
0285     { KEY_7,    KEY_KP7 },
0286     { KEY_8,    KEY_KP8 },
0287     { KEY_9,    KEY_KP9 },
0288     { KEY_M,    KEY_KP0 },
0289     { KEY_DOT,  KEY_KPDOT },
0290     { KEY_SLASH,    KEY_KPPLUS },
0291     { KEY_SEMICOLON, KEY_KPMINUS },
0292     { KEY_P,    KEY_KPASTERISK },
0293     { KEY_MINUS,    KEY_KPEQUAL },
0294     { KEY_0,    KEY_KPSLASH },
0295     { KEY_F6,   KEY_NUMLOCK },
0296     { KEY_KPENTER,  KEY_KPENTER },
0297     { KEY_BACKSPACE, KEY_BACKSPACE },
0298     { }
0299 };
0300 
0301 static const struct apple_key_translation apple_iso_keyboard[] = {
0302     { KEY_GRAVE,    KEY_102ND },
0303     { KEY_102ND,    KEY_GRAVE },
0304     { }
0305 };
0306 
0307 static const struct apple_key_translation swapped_option_cmd_keys[] = {
0308     { KEY_LEFTALT,  KEY_LEFTMETA },
0309     { KEY_LEFTMETA, KEY_LEFTALT },
0310     { KEY_RIGHTALT, KEY_RIGHTMETA },
0311     { KEY_RIGHTMETA,KEY_RIGHTALT },
0312     { }
0313 };
0314 
0315 static const struct apple_key_translation swapped_fn_leftctrl_keys[] = {
0316     { KEY_FN, KEY_LEFTCTRL },
0317     { }
0318 };
0319 
0320 static const struct apple_non_apple_keyboard non_apple_keyboards[] = {
0321     { "SONiX USB DEVICE" },
0322     { "Keychron" },
0323     { "AONE" },
0324     { "GANSS" }
0325 };
0326 
0327 static bool apple_is_non_apple_keyboard(struct hid_device *hdev)
0328 {
0329     int i;
0330 
0331     for (i = 0; i < ARRAY_SIZE(non_apple_keyboards); i++) {
0332         char *non_apple = non_apple_keyboards[i].name;
0333 
0334         if (strncmp(hdev->name, non_apple, strlen(non_apple)) == 0)
0335             return true;
0336     }
0337 
0338     return false;
0339 }
0340 
0341 static inline void apple_setup_key_translation(struct input_dev *input,
0342         const struct apple_key_translation *table)
0343 {
0344     const struct apple_key_translation *trans;
0345 
0346     for (trans = table; trans->from; trans++)
0347         set_bit(trans->to, input->keybit);
0348 }
0349 
0350 static const struct apple_key_translation *apple_find_translation(
0351         const struct apple_key_translation *table, u16 from)
0352 {
0353     const struct apple_key_translation *trans;
0354 
0355     /* Look for the translation */
0356     for (trans = table; trans->from; trans++)
0357         if (trans->from == from)
0358             return trans;
0359 
0360     return NULL;
0361 }
0362 
0363 static void input_event_with_scancode(struct input_dev *input,
0364         __u8 type, __u16 code, unsigned int hid, __s32 value)
0365 {
0366     if (type == EV_KEY &&
0367         (!test_bit(code, input->key)) == value)
0368         input_event(input, EV_MSC, MSC_SCAN, hid);
0369     input_event(input, type, code, value);
0370 }
0371 
0372 static int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
0373         struct hid_usage *usage, __s32 value)
0374 {
0375     struct apple_sc *asc = hid_get_drvdata(hid);
0376     const struct apple_key_translation *trans, *table;
0377     bool do_translate;
0378     u16 code = 0;
0379     unsigned int real_fnmode;
0380 
0381     u16 fn_keycode = (swap_fn_leftctrl) ? (KEY_LEFTCTRL) : (KEY_FN);
0382 
0383     if (usage->code == fn_keycode) {
0384         asc->fn_on = !!value;
0385         input_event_with_scancode(input, usage->type, KEY_FN,
0386                 usage->hid, value);
0387         return 1;
0388     }
0389 
0390     if (fnmode == 3) {
0391         real_fnmode = (asc->quirks & APPLE_IS_NON_APPLE) ? 2 : 1;
0392     } else {
0393         real_fnmode = fnmode;
0394     }
0395 
0396     if (real_fnmode) {
0397         if (hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI ||
0398             hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO ||
0399             hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS ||
0400             hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI ||
0401             hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO ||
0402             hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS ||
0403             hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI ||
0404             hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO ||
0405             hid->product == USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_JIS)
0406             table = magic_keyboard_alu_fn_keys;
0407         else if (hid->product == USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2015 ||
0408              hid->product == USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2015)
0409             table = magic_keyboard_2015_fn_keys;
0410         else if (hid->product == USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2021 ||
0411              hid->product == USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_FINGERPRINT_2021 ||
0412              hid->product == USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2021)
0413             table = apple2021_fn_keys;
0414         else if (hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J132 ||
0415              hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J680 ||
0416              hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J213)
0417                 table = macbookpro_no_esc_fn_keys;
0418         else if (hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J214K ||
0419              hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J223 ||
0420              hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J152F)
0421                 table = macbookpro_dedicated_esc_fn_keys;
0422         else if (hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J140K ||
0423              hid->product == USB_DEVICE_ID_APPLE_WELLSPRINGT2_J230K)
0424                 table = apple_fn_keys;
0425         else if (hid->product >= USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI &&
0426                 hid->product <= USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS)
0427             table = macbookair_fn_keys;
0428         else if (hid->product < 0x21d || hid->product >= 0x300)
0429             table = powerbook_fn_keys;
0430         else
0431             table = apple_fn_keys;
0432 
0433         trans = apple_find_translation (table, usage->code);
0434 
0435         if (trans) {
0436             if (test_bit(trans->from, input->key))
0437                 code = trans->from;
0438             else if (test_bit(trans->to, input->key))
0439                 code = trans->to;
0440 
0441             if (!code) {
0442                 if (trans->flags & APPLE_FLAG_FKEY) {
0443                     switch (real_fnmode) {
0444                     case 1:
0445                         do_translate = !asc->fn_on;
0446                         break;
0447                     case 2:
0448                         do_translate = asc->fn_on;
0449                         break;
0450                     default:
0451                         /* should never happen */
0452                         do_translate = false;
0453                     }
0454                 } else {
0455                     do_translate = asc->fn_on;
0456                 }
0457 
0458                 code = do_translate ? trans->to : trans->from;
0459             }
0460 
0461             input_event_with_scancode(input, usage->type, code,
0462                     usage->hid, value);
0463             return 1;
0464         }
0465 
0466         if (asc->quirks & APPLE_NUMLOCK_EMULATION &&
0467                 (test_bit(usage->code, asc->pressed_numlock) ||
0468                 test_bit(LED_NUML, input->led))) {
0469             trans = apple_find_translation(powerbook_numlock_keys,
0470                     usage->code);
0471 
0472             if (trans) {
0473                 if (value)
0474                     set_bit(usage->code,
0475                             asc->pressed_numlock);
0476                 else
0477                     clear_bit(usage->code,
0478                             asc->pressed_numlock);
0479 
0480                 input_event_with_scancode(input, usage->type,
0481                         trans->to, usage->hid, value);
0482             }
0483 
0484             return 1;
0485         }
0486     }
0487 
0488     if (iso_layout > 0 || (iso_layout < 0 && (asc->quirks & APPLE_ISO_TILDE_QUIRK) &&
0489             hid->country == HID_COUNTRY_INTERNATIONAL_ISO)) {
0490         trans = apple_find_translation(apple_iso_keyboard, usage->code);
0491         if (trans) {
0492             input_event_with_scancode(input, usage->type,
0493                     trans->to, usage->hid, value);
0494             return 1;
0495         }
0496     }
0497 
0498     if (swap_opt_cmd) {
0499         trans = apple_find_translation(swapped_option_cmd_keys, usage->code);
0500         if (trans) {
0501             input_event_with_scancode(input, usage->type,
0502                     trans->to, usage->hid, value);
0503             return 1;
0504         }
0505     }
0506 
0507     if (swap_fn_leftctrl) {
0508         trans = apple_find_translation(swapped_fn_leftctrl_keys, usage->code);
0509         if (trans) {
0510             input_event_with_scancode(input, usage->type,
0511                     trans->to, usage->hid, value);
0512             return 1;
0513         }
0514     }
0515 
0516     return 0;
0517 }
0518 
0519 static int apple_event(struct hid_device *hdev, struct hid_field *field,
0520         struct hid_usage *usage, __s32 value)
0521 {
0522     struct apple_sc *asc = hid_get_drvdata(hdev);
0523 
0524     if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
0525             !usage->type)
0526         return 0;
0527 
0528     if ((asc->quirks & APPLE_INVERT_HWHEEL) &&
0529             usage->code == REL_HWHEEL) {
0530         input_event_with_scancode(field->hidinput->input, usage->type,
0531                 usage->code, usage->hid, -value);
0532         return 1;
0533     }
0534 
0535     if ((asc->quirks & APPLE_HAS_FN) &&
0536             hidinput_apple_event(hdev, field->hidinput->input,
0537                 usage, value))
0538         return 1;
0539 
0540 
0541     return 0;
0542 }
0543 
0544 static int apple_fetch_battery(struct hid_device *hdev)
0545 {
0546 #ifdef CONFIG_HID_BATTERY_STRENGTH
0547     struct apple_sc *asc = hid_get_drvdata(hdev);
0548     struct hid_report_enum *report_enum;
0549     struct hid_report *report;
0550 
0551     if (!(asc->quirks & APPLE_RDESC_BATTERY) || !hdev->battery)
0552         return -1;
0553 
0554     report_enum = &hdev->report_enum[hdev->battery_report_type];
0555     report = report_enum->report_id_hash[hdev->battery_report_id];
0556 
0557     if (!report || report->maxfield < 1)
0558         return -1;
0559 
0560     if (hdev->battery_capacity == hdev->battery_max)
0561         return -1;
0562 
0563     hid_hw_request(hdev, report, HID_REQ_GET_REPORT);
0564     return 0;
0565 #else
0566     return -1;
0567 #endif
0568 }
0569 
0570 static void apple_battery_timer_tick(struct timer_list *t)
0571 {
0572     struct apple_sc *asc = from_timer(asc, t, battery_timer);
0573     struct hid_device *hdev = asc->hdev;
0574 
0575     if (apple_fetch_battery(hdev) == 0) {
0576         mod_timer(&asc->battery_timer,
0577               jiffies + msecs_to_jiffies(APPLE_BATTERY_TIMEOUT_MS));
0578     }
0579 }
0580 
0581 /*
0582  * MacBook JIS keyboard has wrong logical maximum
0583  * Magic Keyboard JIS has wrong logical maximum
0584  */
0585 static __u8 *apple_report_fixup(struct hid_device *hdev, __u8 *rdesc,
0586         unsigned int *rsize)
0587 {
0588     struct apple_sc *asc = hid_get_drvdata(hdev);
0589 
0590     if(*rsize >=71 && rdesc[70] == 0x65 && rdesc[64] == 0x65) {
0591         hid_info(hdev,
0592              "fixing up Magic Keyboard JIS report descriptor\n");
0593         rdesc[64] = rdesc[70] = 0xe7;
0594     }
0595 
0596     if ((asc->quirks & APPLE_RDESC_JIS) && *rsize >= 60 &&
0597             rdesc[53] == 0x65 && rdesc[59] == 0x65) {
0598         hid_info(hdev,
0599              "fixing up MacBook JIS keyboard report descriptor\n");
0600         rdesc[53] = rdesc[59] = 0xe7;
0601     }
0602 
0603     /*
0604      * Change the usage from:
0605      *   0x06, 0x00, 0xff, // Usage Page (Vendor Defined Page 1)  0
0606      *   0x09, 0x0b,       // Usage (Vendor Usage 0x0b)           3
0607      * To:
0608      *   0x05, 0x01,       // Usage Page (Generic Desktop)        0
0609      *   0x09, 0x06,       // Usage (Keyboard)                    2
0610      */
0611     if ((asc->quirks & APPLE_RDESC_BATTERY) && *rsize == 83 &&
0612         rdesc[46] == 0x84 && rdesc[58] == 0x85) {
0613         hid_info(hdev,
0614              "fixing up Magic Keyboard battery report descriptor\n");
0615         *rsize = *rsize - 1;
0616         rdesc = kmemdup(rdesc + 1, *rsize, GFP_KERNEL);
0617         if (!rdesc)
0618             return NULL;
0619 
0620         rdesc[0] = 0x05;
0621         rdesc[1] = 0x01;
0622         rdesc[2] = 0x09;
0623         rdesc[3] = 0x06;
0624     }
0625 
0626     return rdesc;
0627 }
0628 
0629 static void apple_setup_input(struct input_dev *input)
0630 {
0631     set_bit(KEY_NUMLOCK, input->keybit);
0632 
0633     /* Enable all needed keys */
0634     apple_setup_key_translation(input, apple_fn_keys);
0635     apple_setup_key_translation(input, powerbook_fn_keys);
0636     apple_setup_key_translation(input, powerbook_numlock_keys);
0637     apple_setup_key_translation(input, apple_iso_keyboard);
0638     apple_setup_key_translation(input, magic_keyboard_alu_fn_keys);
0639     apple_setup_key_translation(input, magic_keyboard_2015_fn_keys);
0640     apple_setup_key_translation(input, apple2021_fn_keys);
0641     apple_setup_key_translation(input, macbookpro_no_esc_fn_keys);
0642     apple_setup_key_translation(input, macbookpro_dedicated_esc_fn_keys);
0643 
0644     if (swap_fn_leftctrl)
0645         apple_setup_key_translation(input, swapped_fn_leftctrl_keys);
0646 }
0647 
0648 static int apple_input_mapping(struct hid_device *hdev, struct hid_input *hi,
0649         struct hid_field *field, struct hid_usage *usage,
0650         unsigned long **bit, int *max)
0651 {
0652     struct apple_sc *asc = hid_get_drvdata(hdev);
0653 
0654     if (usage->hid == (HID_UP_CUSTOM | 0x0003) ||
0655             usage->hid == (HID_UP_MSVENDOR | 0x0003) ||
0656             usage->hid == (HID_UP_HPVENDOR2 | 0x0003)) {
0657         /* The fn key on Apple USB keyboards */
0658         set_bit(EV_REP, hi->input->evbit);
0659         hid_map_usage_clear(hi, usage, bit, max, EV_KEY, KEY_FN);
0660         asc->fn_found = true;
0661         apple_setup_input(hi->input);
0662         return 1;
0663     }
0664 
0665     /* we want the hid layer to go through standard path (set and ignore) */
0666     return 0;
0667 }
0668 
0669 static int apple_input_mapped(struct hid_device *hdev, struct hid_input *hi,
0670         struct hid_field *field, struct hid_usage *usage,
0671         unsigned long **bit, int *max)
0672 {
0673     struct apple_sc *asc = hid_get_drvdata(hdev);
0674 
0675     if (asc->quirks & APPLE_MIGHTYMOUSE) {
0676         if (usage->hid == HID_GD_Z)
0677             hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
0678         else if (usage->code == BTN_1)
0679             hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_2);
0680         else if (usage->code == BTN_2)
0681             hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_1);
0682     }
0683 
0684     return 0;
0685 }
0686 
0687 static int apple_input_configured(struct hid_device *hdev,
0688         struct hid_input *hidinput)
0689 {
0690     struct apple_sc *asc = hid_get_drvdata(hdev);
0691 
0692     if ((asc->quirks & APPLE_HAS_FN) && !asc->fn_found) {
0693         hid_info(hdev, "Fn key not found (Apple Wireless Keyboard clone?), disabling Fn key handling\n");
0694         asc->quirks &= ~APPLE_HAS_FN;
0695     }
0696 
0697     if (apple_is_non_apple_keyboard(hdev)) {
0698         hid_info(hdev, "Non-apple keyboard detected; function keys will default to fnmode=2 behavior\n");
0699         asc->quirks |= APPLE_IS_NON_APPLE;
0700     }
0701 
0702     return 0;
0703 }
0704 
0705 static bool apple_backlight_check_support(struct hid_device *hdev)
0706 {
0707     int i;
0708     unsigned int hid;
0709     struct hid_report *report;
0710 
0711     list_for_each_entry(report, &hdev->report_enum[HID_INPUT_REPORT].report_list, list) {
0712         for (i = 0; i < report->maxfield; i++) {
0713             hid = report->field[i]->usage->hid;
0714             if ((hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR && (hid & HID_USAGE) == 0xf)
0715                 return true;
0716         }
0717     }
0718 
0719     return false;
0720 }
0721 
0722 static int apple_backlight_set(struct hid_device *hdev, u16 value, u16 rate)
0723 {
0724     int ret = 0;
0725     struct apple_backlight_set_report *rep;
0726 
0727     rep = kmalloc(sizeof(*rep), GFP_KERNEL);
0728     if (rep == NULL)
0729         return -ENOMEM;
0730 
0731     rep->report_id = 0xB0;
0732     rep->version = 1;
0733     rep->backlight = value;
0734     rep->rate = rate;
0735 
0736     ret = hid_hw_raw_request(hdev, 0xB0u, (u8 *) rep, sizeof(*rep),
0737                  HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
0738 
0739     kfree(rep);
0740     return ret;
0741 }
0742 
0743 static int apple_backlight_led_set(struct led_classdev *led_cdev,
0744     enum led_brightness brightness)
0745 {
0746     struct apple_sc_backlight *backlight = container_of(led_cdev,
0747                                 struct apple_sc_backlight, cdev);
0748 
0749     return apple_backlight_set(backlight->hdev, brightness, 0);
0750 }
0751 
0752 static int apple_backlight_init(struct hid_device *hdev)
0753 {
0754     int ret;
0755     struct apple_sc *asc = hid_get_drvdata(hdev);
0756     struct apple_backlight_config_report *rep;
0757 
0758     if (!apple_backlight_check_support(hdev))
0759         return -EINVAL;
0760 
0761     rep = kmalloc(0x200, GFP_KERNEL);
0762     if (rep == NULL)
0763         return -ENOMEM;
0764 
0765     ret = hid_hw_raw_request(hdev, 0xBFu, (u8 *) rep, sizeof(*rep),
0766                  HID_FEATURE_REPORT, HID_REQ_GET_REPORT);
0767     if (ret < 0) {
0768         hid_err(hdev, "backlight request failed: %d\n", ret);
0769         goto cleanup_and_exit;
0770     }
0771     if (ret < 8 || rep->version != 1) {
0772         hid_err(hdev, "backlight config struct: bad version %i\n", rep->version);
0773         ret = -EINVAL;
0774         goto cleanup_and_exit;
0775     }
0776 
0777     hid_dbg(hdev, "backlight config: off=%u, on_min=%u, on_max=%u\n",
0778         rep->backlight_off, rep->backlight_on_min, rep->backlight_on_max);
0779 
0780     asc->backlight = devm_kzalloc(&hdev->dev, sizeof(*asc->backlight), GFP_KERNEL);
0781     if (!asc->backlight) {
0782         ret = -ENOMEM;
0783         goto cleanup_and_exit;
0784     }
0785 
0786     asc->backlight->hdev = hdev;
0787     asc->backlight->cdev.name = "apple::kbd_backlight";
0788     asc->backlight->cdev.max_brightness = rep->backlight_on_max;
0789     asc->backlight->cdev.brightness_set_blocking = apple_backlight_led_set;
0790 
0791     ret = apple_backlight_set(hdev, 0, 0);
0792     if (ret < 0) {
0793         hid_err(hdev, "backlight set request failed: %d\n", ret);
0794         goto cleanup_and_exit;
0795     }
0796 
0797     ret = devm_led_classdev_register(&hdev->dev, &asc->backlight->cdev);
0798 
0799 cleanup_and_exit:
0800     kfree(rep);
0801     return ret;
0802 }
0803 
0804 static int apple_probe(struct hid_device *hdev,
0805         const struct hid_device_id *id)
0806 {
0807     unsigned long quirks = id->driver_data;
0808     struct apple_sc *asc;
0809     int ret;
0810 
0811     asc = devm_kzalloc(&hdev->dev, sizeof(*asc), GFP_KERNEL);
0812     if (asc == NULL) {
0813         hid_err(hdev, "can't alloc apple descriptor\n");
0814         return -ENOMEM;
0815     }
0816 
0817     asc->hdev = hdev;
0818     asc->quirks = quirks;
0819 
0820     hid_set_drvdata(hdev, asc);
0821 
0822     ret = hid_parse(hdev);
0823     if (ret) {
0824         hid_err(hdev, "parse failed\n");
0825         return ret;
0826     }
0827 
0828     ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
0829     if (ret) {
0830         hid_err(hdev, "hw start failed\n");
0831         return ret;
0832     }
0833 
0834     timer_setup(&asc->battery_timer, apple_battery_timer_tick, 0);
0835     mod_timer(&asc->battery_timer,
0836           jiffies + msecs_to_jiffies(APPLE_BATTERY_TIMEOUT_MS));
0837     apple_fetch_battery(hdev);
0838 
0839     if (quirks & APPLE_BACKLIGHT_CTL)
0840         apple_backlight_init(hdev);
0841 
0842     return 0;
0843 }
0844 
0845 static void apple_remove(struct hid_device *hdev)
0846 {
0847     struct apple_sc *asc = hid_get_drvdata(hdev);
0848 
0849     del_timer_sync(&asc->battery_timer);
0850 
0851     hid_hw_stop(hdev);
0852 }
0853 
0854 static const struct hid_device_id apple_devices[] = {
0855     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE),
0856         .driver_data = APPLE_MIGHTYMOUSE | APPLE_INVERT_HWHEEL },
0857 
0858     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI),
0859         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0860     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO),
0861         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0862     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI),
0863         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0864     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO),
0865         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0866     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS),
0867         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0868     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI),
0869         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0870     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO),
0871         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0872     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS),
0873         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
0874             APPLE_RDESC_JIS },
0875     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI),
0876         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0877     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO),
0878         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0879     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS),
0880         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
0881             APPLE_RDESC_JIS },
0882     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ANSI),
0883         .driver_data = APPLE_HAS_FN },
0884     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ISO),
0885         .driver_data = APPLE_HAS_FN },
0886     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_JIS),
0887         .driver_data = APPLE_HAS_FN },
0888     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI),
0889         .driver_data = APPLE_HAS_FN },
0890     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO),
0891         .driver_data = APPLE_HAS_FN },
0892     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS),
0893         .driver_data = APPLE_HAS_FN },
0894     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI),
0895         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0896     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO),
0897         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0898     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS),
0899         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
0900             APPLE_RDESC_JIS },
0901     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI),
0902         .driver_data = APPLE_HAS_FN },
0903     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ANSI),
0904         .driver_data = APPLE_HAS_FN },
0905     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO),
0906         .driver_data = APPLE_HAS_FN },
0907     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_ISO),
0908         .driver_data = APPLE_HAS_FN },
0909     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_REVB_JIS),
0910         .driver_data = APPLE_HAS_FN },
0911     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
0912         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0913     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
0914         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
0915             APPLE_ISO_TILDE_QUIRK },
0916     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ISO),
0917         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
0918             APPLE_ISO_TILDE_QUIRK },
0919     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
0920                 USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_ANSI),
0921         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0922     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE,
0923                 USB_DEVICE_ID_APPLE_ALU_WIRELESS_2011_JIS),
0924         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0925     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS),
0926         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
0927     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2015),
0928         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK | APPLE_RDESC_BATTERY },
0929     { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2015),
0930         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
0931     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2015),
0932         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK | APPLE_RDESC_BATTERY },
0933     { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2015),
0934         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
0935     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI),
0936         .driver_data = APPLE_HAS_FN },
0937     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO),
0938         .driver_data = APPLE_HAS_FN },
0939     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS),
0940         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
0941     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI),
0942         .driver_data = APPLE_HAS_FN },
0943     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO),
0944         .driver_data = APPLE_HAS_FN },
0945     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS),
0946         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
0947     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI),
0948         .driver_data = APPLE_HAS_FN },
0949     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO),
0950         .driver_data = APPLE_HAS_FN },
0951     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS),
0952         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
0953     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI),
0954         .driver_data = APPLE_HAS_FN },
0955     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO),
0956         .driver_data = APPLE_HAS_FN },
0957     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS),
0958         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
0959     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI),
0960         .driver_data = APPLE_HAS_FN },
0961     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO),
0962         .driver_data = APPLE_HAS_FN },
0963     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS),
0964         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
0965     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ANSI),
0966         .driver_data = APPLE_HAS_FN },
0967     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_ISO),
0968         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
0969     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5_JIS),
0970         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
0971     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI),
0972         .driver_data = APPLE_HAS_FN },
0973     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_ISO),
0974         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
0975     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6_JIS),
0976         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
0977     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI),
0978         .driver_data = APPLE_HAS_FN },
0979     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO),
0980         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
0981     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS),
0982         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
0983     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI),
0984         .driver_data = APPLE_HAS_FN },
0985     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO),
0986         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
0987     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS),
0988         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
0989     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI),
0990         .driver_data = APPLE_HAS_FN },
0991     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO),
0992         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
0993     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS),
0994         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
0995     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ANSI),
0996         .driver_data = APPLE_HAS_FN },
0997     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_ISO),
0998         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
0999     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7A_JIS),
1000         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
1001     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ANSI),
1002         .driver_data = APPLE_HAS_FN },
1003     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_ISO),
1004         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1005     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING8_JIS),
1006         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
1007     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ANSI),
1008         .driver_data = APPLE_HAS_FN },
1009     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_ISO),
1010         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1011     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING9_JIS),
1012         .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
1013     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J140K),
1014         .driver_data = APPLE_HAS_FN | APPLE_BACKLIGHT_CTL },
1015     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J132),
1016         .driver_data = APPLE_HAS_FN | APPLE_BACKLIGHT_CTL },
1017     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J680),
1018         .driver_data = APPLE_HAS_FN | APPLE_BACKLIGHT_CTL },
1019     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J213),
1020         .driver_data = APPLE_HAS_FN | APPLE_BACKLIGHT_CTL },
1021     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J214K),
1022         .driver_data = APPLE_HAS_FN },
1023     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J223),
1024         .driver_data = APPLE_HAS_FN },
1025     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J230K),
1026         .driver_data = APPLE_HAS_FN },
1027     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRINGT2_J152F),
1028         .driver_data = APPLE_HAS_FN },
1029     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI),
1030         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
1031     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
1032         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
1033             APPLE_ISO_TILDE_QUIRK },
1034     { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS),
1035         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
1036     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY),
1037         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
1038     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY),
1039         .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
1040     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2021),
1041         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK | APPLE_RDESC_BATTERY },
1042     { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_2021),
1043         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1044     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_FINGERPRINT_2021),
1045         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK | APPLE_RDESC_BATTERY },
1046     { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_FINGERPRINT_2021),
1047         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1048     { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2021),
1049         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK | APPLE_RDESC_BATTERY },
1050     { HID_BLUETOOTH_DEVICE(BT_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MAGIC_KEYBOARD_NUMPAD_2021),
1051         .driver_data = APPLE_HAS_FN | APPLE_ISO_TILDE_QUIRK },
1052 
1053     { }
1054 };
1055 MODULE_DEVICE_TABLE(hid, apple_devices);
1056 
1057 static struct hid_driver apple_driver = {
1058     .name = "apple",
1059     .id_table = apple_devices,
1060     .report_fixup = apple_report_fixup,
1061     .probe = apple_probe,
1062     .remove = apple_remove,
1063     .event = apple_event,
1064     .input_mapping = apple_input_mapping,
1065     .input_mapped = apple_input_mapped,
1066     .input_configured = apple_input_configured,
1067 };
1068 module_hid_driver(apple_driver);
1069 
1070 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!