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