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