drivers/input/keyboard/applespi.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * MacBook (Pro) SPI keyboard and touchpad driver
   4  *
   5  * Copyright (c) 2015-2018 Federico Lorenzi
   6  * Copyright (c) 2017-2018 Ronald Tschalär
   7  */
   8
   9 /*
  10  * The keyboard and touchpad controller on the MacBookAir6, MacBookPro12,
  11  * MacBook8 and newer can be driven either by USB or SPI. However the USB
  12  * pins are only connected on the MacBookAir6 and 7 and the MacBookPro12.
  13  * All others need this driver. The interface is selected using ACPI methods:
  14  *
  15  * * UIEN ("USB Interface Enable"): If invoked with argument 1, disables SPI
  16  *   and enables USB. If invoked with argument 0, disables USB.
  17  * * UIST ("USB Interface Status"): Returns 1 if USB is enabled, 0 otherwise.
  18  * * SIEN ("SPI Interface Enable"): If invoked with argument 1, disables USB
  19  *   and enables SPI. If invoked with argument 0, disables SPI.
  20  * * SIST ("SPI Interface Status"): Returns 1 if SPI is enabled, 0 otherwise.
  21  * * ISOL: Resets the four GPIO pins used for SPI. Intended to be invoked with
  22  *   argument 1, then once more with argument 0.
  23  *
  24  * UIEN and UIST are only provided on models where the USB pins are connected.
  25  *
  26  * SPI-based Protocol
  27  * ------------------
  28  *
  29  * The device and driver exchange messages (struct message); each message is
  30  * encapsulated in one or more packets (struct spi_packet). There are two types
  31  * of exchanges: reads, and writes. A read is signaled by a GPE, upon which one
  32  * message can be read from the device. A write exchange consists of writing a
  33  * command message, immediately reading a short status packet, and then, upon
  34  * receiving a GPE, reading the response message. Write exchanges cannot be
  35  * interleaved, i.e. a new write exchange must not be started till the previous
  36  * write exchange is complete. Whether a received message is part of a read or
  37  * write exchange is indicated in the encapsulating packet's flags field.
  38  *
  39  * A single message may be too large to fit in a single packet (which has a
  40  * fixed, 256-byte size). In that case it will be split over multiple,
  41  * consecutive packets.
  42  */
  43
  44 #include <linux/acpi.h>
  45 #include <linux/crc16.h>
  46 #include <linux/debugfs.h>
  47 #include <linux/delay.h>
  48 #include <linux/efi.h>
  49 #include <linux/input.h>
  50 #include <linux/input/mt.h>
  51 #include <linux/leds.h>
  52 #include <linux/module.h>
  53 #include <linux/spinlock.h>
  54 #include <linux/spi/spi.h>
  55 #include <linux/wait.h>
  56 #include <linux/workqueue.h>
  57
  58 #include <asm/barrier.h>
  59 #include <asm/unaligned.h>
  60
  61 #define CREATE_TRACE_POINTS
  62 #include "applespi.h"
  63 #include "applespi_trace.h"
  64
  65 #define APPLESPI_PACKET_SIZE    256
  66 #define APPLESPI_STATUS_SIZE    4
  67
  68 #define PACKET_TYPE_READ        0x20
  69 #define PACKET_TYPE_WRITE       0x40
  70 #define PACKET_DEV_KEYB         0x01
  71 #define PACKET_DEV_TPAD         0x02
  72 #define PACKET_DEV_INFO         0xd0
  73
  74 #define MAX_ROLLOVER            6
  75
  76 #define MAX_FINGERS             11
  77 #define MAX_FINGER_ORIENTATION  16384
  78 #define MAX_PKTS_PER_MSG        2
  79
  80 #define KBD_BL_LEVEL_MIN        32U
  81 #define KBD_BL_LEVEL_MAX        255U
  82 #define KBD_BL_LEVEL_SCALE      1000000U
  83 #define KBD_BL_LEVEL_ADJ        \
  84         ((KBD_BL_LEVEL_MAX - KBD_BL_LEVEL_MIN) * KBD_BL_LEVEL_SCALE / 255U)
  85
  86 #define EFI_BL_LEVEL_NAME       L"KeyboardBacklightLevel"
  87 #define EFI_BL_LEVEL_GUID       EFI_GUID(0xa076d2af, 0x9678, 0x4386, 0x8b, 0x58, 0x1f, 0xc8, 0xef, 0x04, 0x16, 0x19)
  88
  89 #define APPLE_FLAG_FKEY         0x01
  90
  91 #define SPI_RW_CHG_DELAY_US     100     /* from experimentation, in µs */
  92
  93 #define SYNAPTICS_VENDOR_ID     0x06cb
  94
  95 static unsigned int fnmode = 1;
  96 module_param(fnmode, uint, 0644);
  97 MODULE_PARM_DESC(fnmode, "Mode of Fn key on Apple keyboards (0 = disabled, [1] = fkeyslast, 2 = fkeysfirst)");
  98
  99 static unsigned int fnremap;
 100 module_param(fnremap, uint, 0644);
 101 MODULE_PARM_DESC(fnremap, "Remap Fn key ([0] = no-remap; 1 = left-ctrl, 2 = left-shift, 3 = left-alt, 4 = left-meta, 6 = right-shift, 7 = right-alt, 8 = right-meta)");
 102
 103 static bool iso_layout;
 104 module_param(iso_layout, bool, 0644);
 105 MODULE_PARM_DESC(iso_layout, "Enable/Disable hardcoded ISO-layout of the keyboard. ([0] = disabled, 1 = enabled)");
 106
 107 static char touchpad_dimensions[40];
 108 module_param_string(touchpad_dimensions, touchpad_dimensions,
 109                     sizeof(touchpad_dimensions), 0444);
 110 MODULE_PARM_DESC(touchpad_dimensions, "The pixel dimensions of the touchpad, as XxY+W+H .");
 111
 112 /**
 113  * struct keyboard_protocol - keyboard message.
 114  * message.type = 0x0110, message.length = 0x000a
 115  *
 116  * @unknown1:           unknown
 117  * @modifiers:          bit-set of modifier/control keys pressed
 118  * @unknown2:           unknown
 119  * @keys_pressed:       the (non-modifier) keys currently pressed
 120  * @fn_pressed:         whether the fn key is currently pressed
 121  * @crc16:              crc over the whole message struct (message header +
 122  *                      this struct) minus this @crc16 field
 123  */
 124 struct keyboard_protocol {
 125         u8                      unknown1;
 126         u8                      modifiers;
 127         u8                      unknown2;
 128         u8                      keys_pressed[MAX_ROLLOVER];
 129         u8                      fn_pressed;
 130         __le16                  crc16;
 131 };
 132
 133 /**
 134  * struct tp_finger - single trackpad finger structure, le16-aligned
 135  *
 136  * @origin:             zero when switching track finger
 137  * @abs_x:              absolute x coordinate
 138  * @abs_y:              absolute y coordinate
 139  * @rel_x:              relative x coordinate
 140  * @rel_y:              relative y coordinate
 141  * @tool_major:         tool area, major axis
 142  * @tool_minor:         tool area, minor axis
 143  * @orientation:        16384 when point, else 15 bit angle
 144  * @touch_major:        touch area, major axis
 145  * @touch_minor:        touch area, minor axis
 146  * @unused:             zeros
 147  * @pressure:           pressure on forcetouch touchpad
 148  * @multi:              one finger: varies, more fingers: constant
 149  * @crc16:              on last finger: crc over the whole message struct
 150  *                      (i.e. message header + this struct) minus the last
 151  *                      @crc16 field; unknown on all other fingers.
 152  */
 153 struct tp_finger {
 154         __le16 origin;
 155         __le16 abs_x;
 156         __le16 abs_y;
 157         __le16 rel_x;
 158         __le16 rel_y;
 159         __le16 tool_major;
 160         __le16 tool_minor;
 161         __le16 orientation;
 162         __le16 touch_major;
 163         __le16 touch_minor;
 164         __le16 unused[2];
 165         __le16 pressure;
 166         __le16 multi;
 167         __le16 crc16;
 168 };
 169
 170 /**
 171  * struct touchpad_protocol - touchpad message.
 172  * message.type = 0x0210
 173  *
 174  * @unknown1:           unknown
 175  * @clicked:            1 if a button-click was detected, 0 otherwise
 176  * @unknown2:           unknown
 177  * @number_of_fingers:  the number of fingers being reported in @fingers
 178  * @clicked2:           same as @clicked
 179  * @unknown3:           unknown
 180  * @fingers:            the data for each finger
 181  */
 182 struct touchpad_protocol {
 183         u8                      unknown1[1];
 184         u8                      clicked;
 185         u8                      unknown2[28];
 186         u8                      number_of_fingers;
 187         u8                      clicked2;
 188         u8                      unknown3[16];
 189         struct tp_finger        fingers[];
 190 };
 191
 192 /**
 193  * struct command_protocol_tp_info - get touchpad info.
 194  * message.type = 0x1020, message.length = 0x0000
 195  *
 196  * @crc16:              crc over the whole message struct (message header +
 197  *                      this struct) minus this @crc16 field
 198  */
 199 struct command_protocol_tp_info {
 200         __le16                  crc16;
 201 };
 202
 203 /**
 204  * struct touchpad_info - touchpad info response.
 205  * message.type = 0x1020, message.length = 0x006e
 206  *
 207  * @unknown1:           unknown
 208  * @model_flags:        flags (vary by model number, but significance otherwise
 209  *                      unknown)
 210  * @model_no:           the touchpad model number
 211  * @unknown2:           unknown
 212  * @crc16:              crc over the whole message struct (message header +
 213  *                      this struct) minus this @crc16 field
 214  */
 215 struct touchpad_info_protocol {
 216         u8                      unknown1[105];
 217         u8                      model_flags;
 218         u8                      model_no;
 219         u8                      unknown2[3];
 220         __le16                  crc16;
 221 };
 222
 223 /**
 224  * struct command_protocol_mt_init - initialize multitouch.
 225  * message.type = 0x0252, message.length = 0x0002
 226  *
 227  * @cmd:                value: 0x0102
 228  * @crc16:              crc over the whole message struct (message header +
 229  *                      this struct) minus this @crc16 field
 230  */
 231 struct command_protocol_mt_init {
 232         __le16                  cmd;
 233         __le16                  crc16;
 234 };
 235
 236 /**
 237  * struct command_protocol_capsl - toggle caps-lock led
 238  * message.type = 0x0151, message.length = 0x0002
 239  *
 240  * @unknown:            value: 0x01 (length?)
 241  * @led:                0 off, 2 on
 242  * @crc16:              crc over the whole message struct (message header +
 243  *                      this struct) minus this @crc16 field
 244  */
 245 struct command_protocol_capsl {
 246         u8                      unknown;
 247         u8                      led;
 248         __le16                  crc16;
 249 };
 250
 251 /**
 252  * struct command_protocol_bl - set keyboard backlight brightness
 253  * message.type = 0xB051, message.length = 0x0006
 254  *
 255  * @const1:             value: 0x01B0
 256  * @level:              the brightness level to set
 257  * @const2:             value: 0x0001 (backlight off), 0x01F4 (backlight on)
 258  * @crc16:              crc over the whole message struct (message header +
 259  *                      this struct) minus this @crc16 field
 260  */
 261 struct command_protocol_bl {
 262         __le16                  const1;
 263         __le16                  level;
 264         __le16                  const2;
 265         __le16                  crc16;
 266 };
 267
 268 /**
 269  * struct message - a complete spi message.
 270  *
 271  * Each message begins with fixed header, followed by a message-type specific
 272  * payload, and ends with a 16-bit crc. Because of the varying lengths of the
 273  * payload, the crc is defined at the end of each payload struct, rather than
 274  * in this struct.
 275  *
 276  * @type:       the message type
 277  * @zero:       always 0
 278  * @counter:    incremented on each message, rolls over after 255; there is a
 279  *              separate counter for each message type.
 280  * @rsp_buf_len:response buffer length (the exact nature of this field is quite
 281  *              speculative). On a request/write this is often the same as
 282  *              @length, though in some cases it has been seen to be much larger
 283  *              (e.g. 0x400); on a response/read this the same as on the
 284  *              request; for reads that are not responses it is 0.
 285  * @length:     length of the remainder of the data in the whole message
 286  *              structure (after re-assembly in case of being split over
 287  *              multiple spi-packets), minus the trailing crc. The total size
 288  *              of the message struct is therefore @length + 10.
 289  *
 290  * @keyboard:           Keyboard message
 291  * @touchpad:           Touchpad message
 292  * @tp_info:            Touchpad info (response)
 293  * @tp_info_command:    Touchpad info (CRC)
 294  * @init_mt_command:    Initialise Multitouch
 295  * @capsl_command:      Toggle caps-lock LED
 296  * @bl_command:         Keyboard brightness
 297  * @data:               Buffer data
 298  */
 299 struct message {
 300         __le16          type;
 301         u8              zero;
 302         u8              counter;
 303         __le16          rsp_buf_len;
 304         __le16          length;
 305         union {
 306                 struct keyboard_protocol        keyboard;
 307                 struct touchpad_protocol        touchpad;
 308                 struct touchpad_info_protocol   tp_info;
 309                 struct command_protocol_tp_info tp_info_command;
 310                 struct command_protocol_mt_init init_mt_command;
 311                 struct command_protocol_capsl   capsl_command;
 312                 struct command_protocol_bl      bl_command;
 313                 u8                              data[0];
 314         };
 315 };
 316
 317 /* type + zero + counter + rsp_buf_len + length */
 318 #define MSG_HEADER_SIZE         8
 319
 320 /**
 321  * struct spi_packet - a complete spi packet; always 256 bytes. This carries
 322  * the (parts of the) message in the data. But note that this does not
 323  * necessarily contain a complete message, as in some cases (e.g. many
 324  * fingers pressed) the message is split over multiple packets (see the
 325  * @offset, @remaining, and @length fields). In general the data parts in
 326  * spi_packet's are concatenated until @remaining is 0, and the result is an
 327  * message.
 328  *
 329  * @flags:      0x40 = write (to device), 0x20 = read (from device); note that
 330  *              the response to a write still has 0x40.
 331  * @device:     1 = keyboard, 2 = touchpad
 332  * @offset:     specifies the offset of this packet's data in the complete
 333  *              message; i.e. > 0 indicates this is a continuation packet (in
 334  *              the second packet for a message split over multiple packets
 335  *              this would then be the same as the @length in the first packet)
 336  * @remaining:  number of message bytes remaining in subsequents packets (in
 337  *              the first packet of a message split over two packets this would
 338  *              then be the same as the @length in the second packet)
 339  * @length:     length of the valid data in the @data in this packet
 340  * @data:       all or part of a message
 341  * @crc16:      crc over this whole structure minus this @crc16 field. This
 342  *              covers just this packet, even on multi-packet messages (in
 343  *              contrast to the crc in the message).
 344  */
 345 struct spi_packet {
 346         u8                      flags;
 347         u8                      device;
 348         __le16                  offset;
 349         __le16                  remaining;
 350         __le16                  length;
 351         u8                      data[246];
 352         __le16                  crc16;
 353 };
 354
 355 struct spi_settings {
 356         u64     spi_cs_delay;           /* cs-to-clk delay in us */
 357         u64     reset_a2r_usec;         /* active-to-receive delay? */
 358         u64     reset_rec_usec;         /* ? (cur val: 10) */
 359 };
 360
 361 /* this mimics struct drm_rect */
 362 struct applespi_tp_info {
 363         int     x_min;
 364         int     y_min;
 365         int     x_max;
 366         int     y_max;
 367 };
 368
 369 struct applespi_data {
 370         struct spi_device               *spi;
 371         struct spi_settings             spi_settings;
 372         struct input_dev                *keyboard_input_dev;
 373         struct input_dev                *touchpad_input_dev;
 374
 375         u8                              *tx_buffer;
 376         u8                              *tx_status;
 377         u8                              *rx_buffer;
 378
 379         u8                              *msg_buf;
 380         unsigned int                    saved_msg_len;
 381
 382         struct applespi_tp_info         tp_info;
 383
 384         u8                              last_keys_pressed[MAX_ROLLOVER];
 385         u8                              last_keys_fn_pressed[MAX_ROLLOVER];
 386         u8                              last_fn_pressed;
 387         struct input_mt_pos             pos[MAX_FINGERS];
 388         int                             slots[MAX_FINGERS];
 389         int                             gpe;
 390         acpi_handle                     sien;
 391         acpi_handle                     sist;
 392
 393         struct spi_transfer             dl_t;
 394         struct spi_transfer             rd_t;
 395         struct spi_message              rd_m;
 396
 397         struct spi_transfer             ww_t;
 398         struct spi_transfer             wd_t;
 399         struct spi_transfer             wr_t;
 400         struct spi_transfer             st_t;
 401         struct spi_message              wr_m;
 402
 403         bool                            want_tp_info_cmd;
 404         bool                            want_mt_init_cmd;
 405         bool                            want_cl_led_on;
 406         bool                            have_cl_led_on;
 407         unsigned int                    want_bl_level;
 408         unsigned int                    have_bl_level;
 409         unsigned int                    cmd_msg_cntr;
 410         /* lock to protect the above parameters and flags below */
 411         spinlock_t                      cmd_msg_lock;
 412         bool                            cmd_msg_queued;
 413         enum applespi_evt_type          cmd_evt_type;
 414
 415         struct led_classdev             backlight_info;
 416
 417         bool                            suspended;
 418         bool                            drain;
 419         wait_queue_head_t               drain_complete;
 420         bool                            read_active;
 421         bool                            write_active;
 422
 423         struct work_struct              work;
 424         struct touchpad_info_protocol   rcvd_tp_info;
 425
 426         struct dentry                   *debugfs_root;
 427         bool                            debug_tp_dim;
 428         char                            tp_dim_val[40];
 429         int                             tp_dim_min_x;
 430         int                             tp_dim_max_x;
 431         int                             tp_dim_min_y;
 432         int                             tp_dim_max_y;
 433 };
 434
 435 static const unsigned char applespi_scancodes[] = {
 436         0, 0, 0, 0,
 437         KEY_A, KEY_B, KEY_C, KEY_D, KEY_E, KEY_F, KEY_G, KEY_H, KEY_I, KEY_J,
 438         KEY_K, KEY_L, KEY_M, KEY_N, KEY_O, KEY_P, KEY_Q, KEY_R, KEY_S, KEY_T,
 439         KEY_U, KEY_V, KEY_W, KEY_X, KEY_Y, KEY_Z,
 440         KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0,
 441         KEY_ENTER, KEY_ESC, KEY_BACKSPACE, KEY_TAB, KEY_SPACE, KEY_MINUS,
 442         KEY_EQUAL, KEY_LEFTBRACE, KEY_RIGHTBRACE, KEY_BACKSLASH, 0,
 443         KEY_SEMICOLON, KEY_APOSTROPHE, KEY_GRAVE, KEY_COMMA, KEY_DOT, KEY_SLASH,
 444         KEY_CAPSLOCK,
 445         KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9,
 446         KEY_F10, KEY_F11, KEY_F12, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 447         KEY_RIGHT, KEY_LEFT, KEY_DOWN, KEY_UP,
 448         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_102ND,
 449         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 450         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_RO, 0, KEY_YEN, 0, 0, 0, 0, 0,
 451         0, KEY_KATAKANAHIRAGANA, KEY_MUHENKAN
 452 };
 453
 454 /*
 455  * This must have exactly as many entries as there are bits in
 456  * struct keyboard_protocol.modifiers .
 457  */
 458 static const unsigned char applespi_controlcodes[] = {
 459         KEY_LEFTCTRL,
 460         KEY_LEFTSHIFT,
 461         KEY_LEFTALT,
 462         KEY_LEFTMETA,
 463         0,
 464         KEY_RIGHTSHIFT,
 465         KEY_RIGHTALT,
 466         KEY_RIGHTMETA
 467 };
 468
 469 struct applespi_key_translation {
 470         u16 from;
 471         u16 to;
 472         u8 flags;
 473 };
 474
 475 static const struct applespi_key_translation applespi_fn_codes[] = {
 476         { KEY_BACKSPACE, KEY_DELETE },
 477         { KEY_ENTER,    KEY_INSERT },
 478         { KEY_F1,       KEY_BRIGHTNESSDOWN,     APPLE_FLAG_FKEY },
 479         { KEY_F2,       KEY_BRIGHTNESSUP,       APPLE_FLAG_FKEY },
 480         { KEY_F3,       KEY_SCALE,              APPLE_FLAG_FKEY },
 481         { KEY_F4,       KEY_DASHBOARD,          APPLE_FLAG_FKEY },
 482         { KEY_F5,       KEY_KBDILLUMDOWN,       APPLE_FLAG_FKEY },
 483         { KEY_F6,       KEY_KBDILLUMUP,         APPLE_FLAG_FKEY },
 484         { KEY_F7,       KEY_PREVIOUSSONG,       APPLE_FLAG_FKEY },
 485         { KEY_F8,       KEY_PLAYPAUSE,          APPLE_FLAG_FKEY },
 486         { KEY_F9,       KEY_NEXTSONG,           APPLE_FLAG_FKEY },
 487         { KEY_F10,      KEY_MUTE,               APPLE_FLAG_FKEY },
 488         { KEY_F11,      KEY_VOLUMEDOWN,         APPLE_FLAG_FKEY },
 489         { KEY_F12,      KEY_VOLUMEUP,           APPLE_FLAG_FKEY },
 490         { KEY_RIGHT,    KEY_END },
 491         { KEY_LEFT,     KEY_HOME },
 492         { KEY_DOWN,     KEY_PAGEDOWN },
 493         { KEY_UP,       KEY_PAGEUP },
 494         { }
 495 };
 496
 497 static const struct applespi_key_translation apple_iso_keyboard[] = {
 498         { KEY_GRAVE,    KEY_102ND },
 499         { KEY_102ND,    KEY_GRAVE },
 500         { }
 501 };
 502
 503 struct applespi_tp_model_info {
 504         u16                     model;
 505         struct applespi_tp_info tp_info;
 506 };
 507
 508 static const struct applespi_tp_model_info applespi_tp_models[] = {
 509         {
 510                 .model = 0x04,  /* MB8 MB9 MB10 */
 511                 .tp_info = { -5087, -182, 5579, 6089 },
 512         },
 513         {
 514                 .model = 0x05,  /* MBP13,1 MBP13,2 MBP14,1 MBP14,2 */
 515                 .tp_info = { -6243, -170, 6749, 7685 },
 516         },
 517         {
 518                 .model = 0x06,  /* MBP13,3 MBP14,3 */
 519                 .tp_info = { -7456, -163, 7976, 9283 },
 520         },
 521         {}
 522 };
 523
 524 typedef void (*applespi_trace_fun)(enum applespi_evt_type,
 525                                    enum applespi_pkt_type, u8 *, size_t);
 526
 527 static applespi_trace_fun applespi_get_trace_fun(enum applespi_evt_type type)
 528 {
 529         switch (type) {
 530         case ET_CMD_TP_INI:
 531                 return trace_applespi_tp_ini_cmd;
 532         case ET_CMD_BL:
 533                 return trace_applespi_backlight_cmd;
 534         case ET_CMD_CL:
 535                 return trace_applespi_caps_lock_cmd;
 536         case ET_RD_KEYB:
 537                 return trace_applespi_keyboard_data;
 538         case ET_RD_TPAD:
 539                 return trace_applespi_touchpad_data;
 540         case ET_RD_UNKN:
 541                 return trace_applespi_unknown_data;
 542         default:
 543                 WARN_ONCE(1, "Unknown msg type %d", type);
 544                 return trace_applespi_unknown_data;
 545         }
 546 }
 547
 548 static void applespi_setup_read_txfrs(struct applespi_data *applespi)
 549 {
 550         struct spi_message *msg = &applespi->rd_m;
 551         struct spi_transfer *dl_t = &applespi->dl_t;
 552         struct spi_transfer *rd_t = &applespi->rd_t;
 553
 554         memset(dl_t, 0, sizeof(*dl_t));
 555         memset(rd_t, 0, sizeof(*rd_t));
 556
 557         dl_t->delay.value = applespi->spi_settings.spi_cs_delay;
 558         dl_t->delay.unit = SPI_DELAY_UNIT_USECS;
 559
 560         rd_t->rx_buf = applespi->rx_buffer;
 561         rd_t->len = APPLESPI_PACKET_SIZE;
 562
 563         spi_message_init(msg);
 564         spi_message_add_tail(dl_t, msg);
 565         spi_message_add_tail(rd_t, msg);
 566 }
 567
 568 static void applespi_setup_write_txfrs(struct applespi_data *applespi)
 569 {
 570         struct spi_message *msg = &applespi->wr_m;
 571         struct spi_transfer *wt_t = &applespi->ww_t;
 572         struct spi_transfer *dl_t = &applespi->wd_t;
 573         struct spi_transfer *wr_t = &applespi->wr_t;
 574         struct spi_transfer *st_t = &applespi->st_t;
 575
 576         memset(wt_t, 0, sizeof(*wt_t));
 577         memset(dl_t, 0, sizeof(*dl_t));
 578         memset(wr_t, 0, sizeof(*wr_t));
 579         memset(st_t, 0, sizeof(*st_t));
 580
 581         /*
 582          * All we need here is a delay at the beginning of the message before
 583          * asserting cs. But the current spi API doesn't support this, so we
 584          * end up with an extra unnecessary (but harmless) cs assertion and
 585          * deassertion.
 586          */
 587         wt_t->delay.value = SPI_RW_CHG_DELAY_US;
 588         wt_t->delay.unit = SPI_DELAY_UNIT_USECS;
 589         wt_t->cs_change = 1;
 590
 591         dl_t->delay.value = applespi->spi_settings.spi_cs_delay;
 592         dl_t->delay.unit = SPI_DELAY_UNIT_USECS;
 593
 594         wr_t->tx_buf = applespi->tx_buffer;
 595         wr_t->len = APPLESPI_PACKET_SIZE;
 596         wr_t->delay.value = SPI_RW_CHG_DELAY_US;
 597         wr_t->delay.unit = SPI_DELAY_UNIT_USECS;
 598
 599         st_t->rx_buf = applespi->tx_status;
 600         st_t->len = APPLESPI_STATUS_SIZE;
 601
 602         spi_message_init(msg);
 603         spi_message_add_tail(wt_t, msg);
 604         spi_message_add_tail(dl_t, msg);
 605         spi_message_add_tail(wr_t, msg);
 606         spi_message_add_tail(st_t, msg);
 607 }
 608
 609 static int applespi_async(struct applespi_data *applespi,
 610                           struct spi_message *message, void (*complete)(void *))
 611 {
 612         message->complete = complete;
 613         message->context = applespi;
 614
 615         return spi_async(applespi->spi, message);
 616 }
 617
 618 static inline bool applespi_check_write_status(struct applespi_data *applespi,
 619                                                int sts)
 620 {
 621         static u8 status_ok[] = { 0xac, 0x27, 0x68, 0xd5 };
 622
 623         if (sts < 0) {
 624                 dev_warn(&applespi->spi->dev, "Error writing to device: %d\n",
 625                          sts);
 626                 return false;
 627         }
 628
 629         if (memcmp(applespi->tx_status, status_ok, APPLESPI_STATUS_SIZE)) {
 630                 dev_warn(&applespi->spi->dev, "Error writing to device: %*ph\n",
 631                          APPLESPI_STATUS_SIZE, applespi->tx_status);
 632                 return false;
 633         }
 634
 635         return true;
 636 }
 637
 638 static int applespi_get_spi_settings(struct applespi_data *applespi)
 639 {
 640         struct acpi_device *adev = ACPI_COMPANION(&applespi->spi->dev);
 641         const union acpi_object *o;
 642         struct spi_settings *settings = &applespi->spi_settings;
 643
 644         if (!acpi_dev_get_property(adev, "spiCSDelay", ACPI_TYPE_BUFFER, &o))
 645                 settings->spi_cs_delay = *(u64 *)o->buffer.pointer;
 646         else
 647                 dev_warn(&applespi->spi->dev,
 648                          "Property spiCSDelay not found\n");
 649
 650         if (!acpi_dev_get_property(adev, "resetA2RUsec", ACPI_TYPE_BUFFER, &o))
 651                 settings->reset_a2r_usec = *(u64 *)o->buffer.pointer;
 652         else
 653                 dev_warn(&applespi->spi->dev,
 654                          "Property resetA2RUsec not found\n");
 655
 656         if (!acpi_dev_get_property(adev, "resetRecUsec", ACPI_TYPE_BUFFER, &o))
 657                 settings->reset_rec_usec = *(u64 *)o->buffer.pointer;
 658         else
 659                 dev_warn(&applespi->spi->dev,
 660                          "Property resetRecUsec not found\n");
 661
 662         dev_dbg(&applespi->spi->dev,
 663                 "SPI settings: spi_cs_delay=%llu reset_a2r_usec=%llu reset_rec_usec=%llu\n",
 664                 settings->spi_cs_delay, settings->reset_a2r_usec,
 665                 settings->reset_rec_usec);
 666
 667         return 0;
 668 }
 669
 670 static int applespi_setup_spi(struct applespi_data *applespi)
 671 {
 672         int sts;
 673
 674         sts = applespi_get_spi_settings(applespi);
 675         if (sts)
 676                 return sts;
 677
 678         spin_lock_init(&applespi->cmd_msg_lock);
 679         init_waitqueue_head(&applespi->drain_complete);
 680
 681         return 0;
 682 }
 683
 684 static int applespi_enable_spi(struct applespi_data *applespi)
 685 {
 686         acpi_status acpi_sts;
 687         unsigned long long spi_status;
 688
 689         /* check if SPI is already enabled, so we can skip the delay below */
 690         acpi_sts = acpi_evaluate_integer(applespi->sist, NULL, NULL,
 691                                          &spi_status);
 692         if (ACPI_SUCCESS(acpi_sts) && spi_status)
 693                 return 0;
 694
 695         /* SIEN(1) will enable SPI communication */
 696         acpi_sts = acpi_execute_simple_method(applespi->sien, NULL, 1);
 697         if (ACPI_FAILURE(acpi_sts)) {
 698                 dev_err(&applespi->spi->dev, "SIEN failed: %s\n",
 699                         acpi_format_exception(acpi_sts));
 700                 return -ENODEV;
 701         }
 702
 703         /*
 704          * Allow the SPI interface to come up before returning. Without this
 705          * delay, the SPI commands to enable multitouch mode may not reach
 706          * the trackpad controller, causing pointer movement to break upon
 707          * resume from sleep.
 708          */
 709         msleep(50);
 710
 711         return 0;
 712 }
 713
 714 static int applespi_send_cmd_msg(struct applespi_data *applespi);
 715
 716 static void applespi_msg_complete(struct applespi_data *applespi,
 717                                   bool is_write_msg, bool is_read_compl)
 718 {
 719         unsigned long flags;
 720
 721         spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
 722
 723         if (is_read_compl)
 724                 applespi->read_active = false;
 725         if (is_write_msg)
 726                 applespi->write_active = false;
 727
 728         if (applespi->drain && !applespi->write_active)
 729                 wake_up_all(&applespi->drain_complete);
 730
 731         if (is_write_msg) {
 732                 applespi->cmd_msg_queued = false;
 733                 applespi_send_cmd_msg(applespi);
 734         }
 735
 736         spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
 737 }
 738
 739 static void applespi_async_write_complete(void *context)
 740 {
 741         struct applespi_data *applespi = context;
 742         enum applespi_evt_type evt_type = applespi->cmd_evt_type;
 743
 744         applespi_get_trace_fun(evt_type)(evt_type, PT_WRITE,
 745                                          applespi->tx_buffer,
 746                                          APPLESPI_PACKET_SIZE);
 747         applespi_get_trace_fun(evt_type)(evt_type, PT_STATUS,
 748                                          applespi->tx_status,
 749                                          APPLESPI_STATUS_SIZE);
 750
 751         if (!applespi_check_write_status(applespi, applespi->wr_m.status)) {
 752                 /*
 753                  * If we got an error, we presumably won't get the expected
 754                  * response message either.
 755                  */
 756                 applespi_msg_complete(applespi, true, false);
 757         }
 758 }
 759
 760 static int applespi_send_cmd_msg(struct applespi_data *applespi)
 761 {
 762         u16 crc;
 763         int sts;
 764         struct spi_packet *packet = (struct spi_packet *)applespi->tx_buffer;
 765         struct message *message = (struct message *)packet->data;
 766         u16 msg_len;
 767         u8 device;
 768
 769         /* check if draining */
 770         if (applespi->drain)
 771                 return 0;
 772
 773         /* check whether send is in progress */
 774         if (applespi->cmd_msg_queued)
 775                 return 0;
 776
 777         /* set up packet */
 778         memset(packet, 0, APPLESPI_PACKET_SIZE);
 779
 780         /* are we processing init commands? */
 781         if (applespi->want_tp_info_cmd) {
 782                 applespi->want_tp_info_cmd = false;
 783                 applespi->want_mt_init_cmd = true;
 784                 applespi->cmd_evt_type = ET_CMD_TP_INI;
 785
 786                 /* build init command */
 787                 device = PACKET_DEV_INFO;
 788
 789                 message->type = cpu_to_le16(0x1020);
 790                 msg_len = sizeof(message->tp_info_command);
 791
 792                 message->zero = 0x02;
 793                 message->rsp_buf_len = cpu_to_le16(0x0200);
 794
 795         } else if (applespi->want_mt_init_cmd) {
 796                 applespi->want_mt_init_cmd = false;
 797                 applespi->cmd_evt_type = ET_CMD_TP_INI;
 798
 799                 /* build init command */
 800                 device = PACKET_DEV_TPAD;
 801
 802                 message->type = cpu_to_le16(0x0252);
 803                 msg_len = sizeof(message->init_mt_command);
 804
 805                 message->init_mt_command.cmd = cpu_to_le16(0x0102);
 806
 807         /* do we need caps-lock command? */
 808         } else if (applespi->want_cl_led_on != applespi->have_cl_led_on) {
 809                 applespi->have_cl_led_on = applespi->want_cl_led_on;
 810                 applespi->cmd_evt_type = ET_CMD_CL;
 811
 812                 /* build led command */
 813                 device = PACKET_DEV_KEYB;
 814
 815                 message->type = cpu_to_le16(0x0151);
 816                 msg_len = sizeof(message->capsl_command);
 817
 818                 message->capsl_command.unknown = 0x01;
 819                 message->capsl_command.led = applespi->have_cl_led_on ? 2 : 0;
 820
 821         /* do we need backlight command? */
 822         } else if (applespi->want_bl_level != applespi->have_bl_level) {
 823                 applespi->have_bl_level = applespi->want_bl_level;
 824                 applespi->cmd_evt_type = ET_CMD_BL;
 825
 826                 /* build command buffer */
 827                 device = PACKET_DEV_KEYB;
 828
 829                 message->type = cpu_to_le16(0xB051);
 830                 msg_len = sizeof(message->bl_command);
 831
 832                 message->bl_command.const1 = cpu_to_le16(0x01B0);
 833                 message->bl_command.level =
 834                                 cpu_to_le16(applespi->have_bl_level);
 835
 836                 if (applespi->have_bl_level > 0)
 837                         message->bl_command.const2 = cpu_to_le16(0x01F4);
 838                 else
 839                         message->bl_command.const2 = cpu_to_le16(0x0001);
 840
 841         /* everything's up-to-date */
 842         } else {
 843                 return 0;
 844         }
 845
 846         /* finalize packet */
 847         packet->flags = PACKET_TYPE_WRITE;
 848         packet->device = device;
 849         packet->length = cpu_to_le16(MSG_HEADER_SIZE + msg_len);
 850
 851         message->counter = applespi->cmd_msg_cntr++ % (U8_MAX + 1);
 852
 853         message->length = cpu_to_le16(msg_len - 2);
 854         if (!message->rsp_buf_len)
 855                 message->rsp_buf_len = message->length;
 856
 857         crc = crc16(0, (u8 *)message, le16_to_cpu(packet->length) - 2);
 858         put_unaligned_le16(crc, &message->data[msg_len - 2]);
 859
 860         crc = crc16(0, (u8 *)packet, sizeof(*packet) - 2);
 861         packet->crc16 = cpu_to_le16(crc);
 862
 863         /* send command */
 864         sts = applespi_async(applespi, &applespi->wr_m,
 865                              applespi_async_write_complete);
 866         if (sts) {
 867                 dev_warn(&applespi->spi->dev,
 868                          "Error queueing async write to device: %d\n", sts);
 869                 return sts;
 870         }
 871
 872         applespi->cmd_msg_queued = true;
 873         applespi->write_active = true;
 874
 875         return 0;
 876 }
 877
 878 static void applespi_init(struct applespi_data *applespi, bool is_resume)
 879 {
 880         unsigned long flags;
 881
 882         spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
 883
 884         if (is_resume)
 885                 applespi->want_mt_init_cmd = true;
 886         else
 887                 applespi->want_tp_info_cmd = true;
 888         applespi_send_cmd_msg(applespi);
 889
 890         spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
 891 }
 892
 893 static int applespi_set_capsl_led(struct applespi_data *applespi,
 894                                   bool capslock_on)
 895 {
 896         unsigned long flags;
 897         int sts;
 898
 899         spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
 900
 901         applespi->want_cl_led_on = capslock_on;
 902         sts = applespi_send_cmd_msg(applespi);
 903
 904         spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
 905
 906         return sts;
 907 }
 908
 909 static void applespi_set_bl_level(struct led_classdev *led_cdev,
 910                                   enum led_brightness value)
 911 {
 912         struct applespi_data *applespi =
 913                 container_of(led_cdev, struct applespi_data, backlight_info);
 914         unsigned long flags;
 915
 916         spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
 917
 918         if (value == 0) {
 919                 applespi->want_bl_level = value;
 920         } else {
 921                 /*
 922                  * The backlight does not turn on till level 32, so we scale
 923                  * the range here so that from a user's perspective it turns
 924                  * on at 1.
 925                  */
 926                 applespi->want_bl_level =
 927                         ((value * KBD_BL_LEVEL_ADJ) / KBD_BL_LEVEL_SCALE +
 928                          KBD_BL_LEVEL_MIN);
 929         }
 930
 931         applespi_send_cmd_msg(applespi);
 932
 933         spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
 934 }
 935
 936 static int applespi_event(struct input_dev *dev, unsigned int type,
 937                           unsigned int code, int value)
 938 {
 939         struct applespi_data *applespi = input_get_drvdata(dev);
 940
 941         switch (type) {
 942         case EV_LED:
 943                 applespi_set_capsl_led(applespi, !!test_bit(LED_CAPSL, dev->led));
 944                 return 0;
 945         }
 946
 947         return -EINVAL;
 948 }
 949
 950 /* lifted from the BCM5974 driver and renamed from raw2int */
 951 /* convert 16-bit little endian to signed integer */
 952 static inline int le16_to_int(__le16 x)
 953 {
 954         return (signed short)le16_to_cpu(x);
 955 }
 956
 957 static void applespi_debug_update_dimensions(struct applespi_data *applespi,
 958                                              const struct tp_finger *f)
 959 {
 960         applespi->tp_dim_min_x = min(applespi->tp_dim_min_x,
 961                                      le16_to_int(f->abs_x));
 962         applespi->tp_dim_max_x = max(applespi->tp_dim_max_x,
 963                                      le16_to_int(f->abs_x));
 964         applespi->tp_dim_min_y = min(applespi->tp_dim_min_y,
 965                                      le16_to_int(f->abs_y));
 966         applespi->tp_dim_max_y = max(applespi->tp_dim_max_y,
 967                                      le16_to_int(f->abs_y));
 968 }
 969
 970 static int applespi_tp_dim_open(struct inode *inode, struct file *file)
 971 {
 972         struct applespi_data *applespi = inode->i_private;
 973
 974         file->private_data = applespi;
 975
 976         snprintf(applespi->tp_dim_val, sizeof(applespi->tp_dim_val),
 977                  "0x%.4x %dx%d+%u+%u\n",
 978                  applespi->touchpad_input_dev->id.product,
 979                  applespi->tp_dim_min_x, applespi->tp_dim_min_y,
 980                  applespi->tp_dim_max_x - applespi->tp_dim_min_x,
 981                  applespi->tp_dim_max_y - applespi->tp_dim_min_y);
 982
 983         return nonseekable_open(inode, file);
 984 }
 985
 986 static ssize_t applespi_tp_dim_read(struct file *file, char __user *buf,
 987                                     size_t len, loff_t *off)
 988 {
 989         struct applespi_data *applespi = file->private_data;
 990
 991         return simple_read_from_buffer(buf, len, off, applespi->tp_dim_val,
 992                                        strlen(applespi->tp_dim_val));
 993 }
 994
 995 static const struct file_operations applespi_tp_dim_fops = {
 996         .owner = THIS_MODULE,
 997         .open = applespi_tp_dim_open,
 998         .read = applespi_tp_dim_read,
 999         .llseek = no_llseek,
1000 };
1001
1002 static void report_finger_data(struct input_dev *input, int slot,
1003                                const struct input_mt_pos *pos,
1004                                const struct tp_finger *f)
1005 {
1006         input_mt_slot(input, slot);
1007         input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
1008
1009         input_report_abs(input, ABS_MT_TOUCH_MAJOR,
1010                          le16_to_int(f->touch_major) << 1);
1011         input_report_abs(input, ABS_MT_TOUCH_MINOR,
1012                          le16_to_int(f->touch_minor) << 1);
1013         input_report_abs(input, ABS_MT_WIDTH_MAJOR,
1014                          le16_to_int(f->tool_major) << 1);
1015         input_report_abs(input, ABS_MT_WIDTH_MINOR,
1016                          le16_to_int(f->tool_minor) << 1);
1017         input_report_abs(input, ABS_MT_ORIENTATION,
1018                          MAX_FINGER_ORIENTATION - le16_to_int(f->orientation));
1019         input_report_abs(input, ABS_MT_POSITION_X, pos->x);
1020         input_report_abs(input, ABS_MT_POSITION_Y, pos->y);
1021 }
1022
1023 static void report_tp_state(struct applespi_data *applespi,
1024                             struct touchpad_protocol *t)
1025 {
1026         const struct tp_finger *f;
1027         struct input_dev *input;
1028         const struct applespi_tp_info *tp_info = &applespi->tp_info;
1029         int i, n;
1030
1031         /* touchpad_input_dev is set async in worker */
1032         input = smp_load_acquire(&applespi->touchpad_input_dev);
1033         if (!input)
1034                 return; /* touchpad isn't initialized yet */
1035
1036         n = 0;
1037
1038         for (i = 0; i < t->number_of_fingers; i++) {
1039                 f = &t->fingers[i];
1040                 if (le16_to_int(f->touch_major) == 0)
1041                         continue;
1042                 applespi->pos[n].x = le16_to_int(f->abs_x);
1043                 applespi->pos[n].y = tp_info->y_min + tp_info->y_max -
1044                                      le16_to_int(f->abs_y);
1045                 n++;
1046
1047                 if (applespi->debug_tp_dim)
1048                         applespi_debug_update_dimensions(applespi, f);
1049         }
1050
1051         input_mt_assign_slots(input, applespi->slots, applespi->pos, n, 0);
1052
1053         for (i = 0; i < n; i++)
1054                 report_finger_data(input, applespi->slots[i],
1055                                    &applespi->pos[i], &t->fingers[i]);
1056
1057         input_mt_sync_frame(input);
1058         input_report_key(input, BTN_LEFT, t->clicked);
1059
1060         input_sync(input);
1061 }
1062
1063 static const struct applespi_key_translation *
1064 applespi_find_translation(const struct applespi_key_translation *table, u16 key)
1065 {
1066         const struct applespi_key_translation *trans;
1067
1068         for (trans = table; trans->from; trans++)
1069                 if (trans->from == key)
1070                         return trans;
1071
1072         return NULL;
1073 }
1074
1075 static unsigned int applespi_translate_fn_key(unsigned int key, int fn_pressed)
1076 {
1077         const struct applespi_key_translation *trans;
1078         int do_translate;
1079
1080         trans = applespi_find_translation(applespi_fn_codes, key);
1081         if (trans) {
1082                 if (trans->flags & APPLE_FLAG_FKEY)
1083                         do_translate = (fnmode == 2 && fn_pressed) ||
1084                                        (fnmode == 1 && !fn_pressed);
1085                 else
1086                         do_translate = fn_pressed;
1087
1088                 if (do_translate)
1089                         key = trans->to;
1090         }
1091
1092         return key;
1093 }
1094
1095 static unsigned int applespi_translate_iso_layout(unsigned int key)
1096 {
1097         const struct applespi_key_translation *trans;
1098
1099         trans = applespi_find_translation(apple_iso_keyboard, key);
1100         if (trans)
1101                 key = trans->to;
1102
1103         return key;
1104 }
1105
1106 static unsigned int applespi_code_to_key(u8 code, int fn_pressed)
1107 {
1108         unsigned int key = applespi_scancodes[code];
1109
1110         if (fnmode)
1111                 key = applespi_translate_fn_key(key, fn_pressed);
1112         if (iso_layout)
1113                 key = applespi_translate_iso_layout(key);
1114         return key;
1115 }
1116
1117 static void
1118 applespi_remap_fn_key(struct keyboard_protocol *keyboard_protocol)
1119 {
1120         unsigned char tmp;
1121         u8 bit = BIT((fnremap - 1) & 0x07);
1122
1123         if (!fnremap || fnremap > ARRAY_SIZE(applespi_controlcodes) ||
1124             !applespi_controlcodes[fnremap - 1])
1125                 return;
1126
1127         tmp = keyboard_protocol->fn_pressed;
1128         keyboard_protocol->fn_pressed = !!(keyboard_protocol->modifiers & bit);
1129         if (tmp)
1130                 keyboard_protocol->modifiers |= bit;
1131         else
1132                 keyboard_protocol->modifiers &= ~bit;
1133 }
1134
1135 static void
1136 applespi_handle_keyboard_event(struct applespi_data *applespi,
1137                                struct keyboard_protocol *keyboard_protocol)
1138 {
1139         unsigned int key;
1140         int i;
1141
1142         compiletime_assert(ARRAY_SIZE(applespi_controlcodes) ==
1143                            sizeof_field(struct keyboard_protocol, modifiers) * 8,
1144                            "applespi_controlcodes has wrong number of entries");
1145
1146         /* check for rollover overflow, which is signalled by all keys == 1 */
1147         if (!memchr_inv(keyboard_protocol->keys_pressed, 1, MAX_ROLLOVER))
1148                 return;
1149
1150         /* remap fn key if desired */
1151         applespi_remap_fn_key(keyboard_protocol);
1152
1153         /* check released keys */
1154         for (i = 0; i < MAX_ROLLOVER; i++) {
1155                 if (memchr(keyboard_protocol->keys_pressed,
1156                            applespi->last_keys_pressed[i], MAX_ROLLOVER))
1157                         continue;       /* key is still pressed */
1158
1159                 key = applespi_code_to_key(applespi->last_keys_pressed[i],
1160                                            applespi->last_keys_fn_pressed[i]);
1161                 input_report_key(applespi->keyboard_input_dev, key, 0);
1162                 applespi->last_keys_fn_pressed[i] = 0;
1163         }
1164
1165         /* check pressed keys */
1166         for (i = 0; i < MAX_ROLLOVER; i++) {
1167                 if (keyboard_protocol->keys_pressed[i] <
1168                                 ARRAY_SIZE(applespi_scancodes) &&
1169                     keyboard_protocol->keys_pressed[i] > 0) {
1170                         key = applespi_code_to_key(
1171                                         keyboard_protocol->keys_pressed[i],
1172                                         keyboard_protocol->fn_pressed);
1173                         input_report_key(applespi->keyboard_input_dev, key, 1);
1174                         applespi->last_keys_fn_pressed[i] =
1175                                         keyboard_protocol->fn_pressed;
1176                 }
1177         }
1178
1179         /* check control keys */
1180         for (i = 0; i < ARRAY_SIZE(applespi_controlcodes); i++) {
1181                 if (keyboard_protocol->modifiers & BIT(i))
1182                         input_report_key(applespi->keyboard_input_dev,
1183                                          applespi_controlcodes[i], 1);
1184                 else
1185                         input_report_key(applespi->keyboard_input_dev,
1186                                          applespi_controlcodes[i], 0);
1187         }
1188
1189         /* check function key */
1190         if (keyboard_protocol->fn_pressed && !applespi->last_fn_pressed)
1191                 input_report_key(applespi->keyboard_input_dev, KEY_FN, 1);
1192         else if (!keyboard_protocol->fn_pressed && applespi->last_fn_pressed)
1193                 input_report_key(applespi->keyboard_input_dev, KEY_FN, 0);
1194         applespi->last_fn_pressed = keyboard_protocol->fn_pressed;
1195
1196         /* done */
1197         input_sync(applespi->keyboard_input_dev);
1198         memcpy(&applespi->last_keys_pressed, keyboard_protocol->keys_pressed,
1199                sizeof(applespi->last_keys_pressed));
1200 }
1201
1202 static const struct applespi_tp_info *applespi_find_touchpad_info(u8 model)
1203 {
1204         const struct applespi_tp_model_info *info;
1205
1206         for (info = applespi_tp_models; info->model; info++) {
1207                 if (info->model == model)
1208                         return &info->tp_info;
1209         }
1210
1211         return NULL;
1212 }
1213
1214 static int
1215 applespi_register_touchpad_device(struct applespi_data *applespi,
1216                                   struct touchpad_info_protocol *rcvd_tp_info)
1217 {
1218         const struct applespi_tp_info *tp_info;
1219         struct input_dev *touchpad_input_dev;
1220         int sts;
1221
1222         /* set up touchpad dimensions */
1223         tp_info = applespi_find_touchpad_info(rcvd_tp_info->model_no);
1224         if (!tp_info) {
1225                 dev_warn(&applespi->spi->dev,
1226                          "Unknown touchpad model %x - falling back to MB8 touchpad\n",
1227                          rcvd_tp_info->model_no);
1228                 tp_info = &applespi_tp_models[0].tp_info;
1229         }
1230
1231         applespi->tp_info = *tp_info;
1232
1233         if (touchpad_dimensions[0]) {
1234                 int x, y, w, h;
1235
1236                 sts = sscanf(touchpad_dimensions, "%dx%d+%u+%u", &x, &y, &w, &h);
1237                 if (sts == 4) {
1238                         dev_info(&applespi->spi->dev,
1239                                  "Overriding touchpad dimensions from module param\n");
1240                         applespi->tp_info.x_min = x;
1241                         applespi->tp_info.y_min = y;
1242                         applespi->tp_info.x_max = x + w;
1243                         applespi->tp_info.y_max = y + h;
1244                 } else {
1245                         dev_warn(&applespi->spi->dev,
1246                                  "Invalid touchpad dimensions '%s': must be in the form XxY+W+H\n",
1247                                  touchpad_dimensions);
1248                         touchpad_dimensions[0] = '\0';
1249                 }
1250         }
1251         if (!touchpad_dimensions[0]) {
1252                 snprintf(touchpad_dimensions, sizeof(touchpad_dimensions),
1253                          "%dx%d+%u+%u",
1254                          applespi->tp_info.x_min,
1255                          applespi->tp_info.y_min,
1256                          applespi->tp_info.x_max - applespi->tp_info.x_min,
1257                          applespi->tp_info.y_max - applespi->tp_info.y_min);
1258         }
1259
1260         /* create touchpad input device */
1261         touchpad_input_dev = devm_input_allocate_device(&applespi->spi->dev);
1262         if (!touchpad_input_dev) {
1263                 dev_err(&applespi->spi->dev,
1264                         "Failed to allocate touchpad input device\n");
1265                 return -ENOMEM;
1266         }
1267
1268         touchpad_input_dev->name = "Apple SPI Touchpad";
1269         touchpad_input_dev->phys = "applespi/input1";
1270         touchpad_input_dev->dev.parent = &applespi->spi->dev;
1271         touchpad_input_dev->id.bustype = BUS_SPI;
1272         touchpad_input_dev->id.vendor = SYNAPTICS_VENDOR_ID;
1273         touchpad_input_dev->id.product =
1274                         rcvd_tp_info->model_no << 8 | rcvd_tp_info->model_flags;
1275
1276         /* basic properties */
1277         input_set_capability(touchpad_input_dev, EV_REL, REL_X);
1278         input_set_capability(touchpad_input_dev, EV_REL, REL_Y);
1279
1280         __set_bit(INPUT_PROP_POINTER, touchpad_input_dev->propbit);
1281         __set_bit(INPUT_PROP_BUTTONPAD, touchpad_input_dev->propbit);
1282
1283         /* finger touch area */
1284         input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MAJOR,
1285                              0, 5000, 0, 0);
1286         input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MINOR,
1287                              0, 5000, 0, 0);
1288
1289         /* finger approach area */
1290         input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MAJOR,
1291                              0, 5000, 0, 0);
1292         input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MINOR,
1293                              0, 5000, 0, 0);
1294
1295         /* finger orientation */
1296         input_set_abs_params(touchpad_input_dev, ABS_MT_ORIENTATION,
1297                              -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION,
1298                              0, 0);
1299
1300         /* finger position */
1301         input_set_abs_params(touchpad_input_dev, ABS_MT_POSITION_X,
1302                              applespi->tp_info.x_min, applespi->tp_info.x_max,
1303                              0, 0);
1304         input_set_abs_params(touchpad_input_dev, ABS_MT_POSITION_Y,
1305                              applespi->tp_info.y_min, applespi->tp_info.y_max,
1306                              0, 0);
1307
1308         /* touchpad button */
1309         input_set_capability(touchpad_input_dev, EV_KEY, BTN_LEFT);
1310
1311         /* multitouch */
1312         sts = input_mt_init_slots(touchpad_input_dev, MAX_FINGERS,
1313                                   INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
1314                                         INPUT_MT_TRACK);
1315         if (sts) {
1316                 dev_err(&applespi->spi->dev,
1317                         "failed to initialize slots: %d", sts);
1318                 return sts;
1319         }
1320
1321         /* register input device */
1322         sts = input_register_device(touchpad_input_dev);
1323         if (sts) {
1324                 dev_err(&applespi->spi->dev,
1325                         "Unable to register touchpad input device (%d)\n", sts);
1326                 return sts;
1327         }
1328
1329         /* touchpad_input_dev is read async in spi callback */
1330         smp_store_release(&applespi->touchpad_input_dev, touchpad_input_dev);
1331
1332         return 0;
1333 }
1334
1335 static void applespi_worker(struct work_struct *work)
1336 {
1337         struct applespi_data *applespi =
1338                 container_of(work, struct applespi_data, work);
1339
1340         applespi_register_touchpad_device(applespi, &applespi->rcvd_tp_info);
1341 }
1342
1343 static void applespi_handle_cmd_response(struct applespi_data *applespi,
1344                                          struct spi_packet *packet,
1345                                          struct message *message)
1346 {
1347         if (packet->device == PACKET_DEV_INFO &&
1348             le16_to_cpu(message->type) == 0x1020) {
1349                 /*
1350                  * We're not allowed to sleep here, but registering an input
1351                  * device can sleep.
1352                  */
1353                 applespi->rcvd_tp_info = message->tp_info;
1354                 schedule_work(&applespi->work);
1355                 return;
1356         }
1357
1358         if (le16_to_cpu(message->length) != 0x0000) {
1359                 dev_warn_ratelimited(&applespi->spi->dev,
1360                                      "Received unexpected write response: length=%x\n",
1361                                      le16_to_cpu(message->length));
1362                 return;
1363         }
1364
1365         if (packet->device == PACKET_DEV_TPAD &&
1366             le16_to_cpu(message->type) == 0x0252 &&
1367             le16_to_cpu(message->rsp_buf_len) == 0x0002)
1368                 dev_info(&applespi->spi->dev, "modeswitch done.\n");
1369 }
1370
1371 static bool applespi_verify_crc(struct applespi_data *applespi, u8 *buffer,
1372                                 size_t buflen)
1373 {
1374         u16 crc;
1375
1376         crc = crc16(0, buffer, buflen);
1377         if (crc) {
1378                 dev_warn_ratelimited(&applespi->spi->dev,
1379                                      "Received corrupted packet (crc mismatch)\n");
1380                 trace_applespi_bad_crc(ET_RD_CRC, READ, buffer, buflen);
1381
1382                 return false;
1383         }
1384
1385         return true;
1386 }
1387
1388 static void applespi_debug_print_read_packet(struct applespi_data *applespi,
1389                                              struct spi_packet *packet)
1390 {
1391         unsigned int evt_type;
1392
1393         if (packet->flags == PACKET_TYPE_READ &&
1394             packet->device == PACKET_DEV_KEYB)
1395                 evt_type = ET_RD_KEYB;
1396         else if (packet->flags == PACKET_TYPE_READ &&
1397                  packet->device == PACKET_DEV_TPAD)
1398                 evt_type = ET_RD_TPAD;
1399         else if (packet->flags == PACKET_TYPE_WRITE)
1400                 evt_type = applespi->cmd_evt_type;
1401         else
1402                 evt_type = ET_RD_UNKN;
1403
1404         applespi_get_trace_fun(evt_type)(evt_type, PT_READ, applespi->rx_buffer,
1405                                          APPLESPI_PACKET_SIZE);
1406 }
1407
1408 static void applespi_got_data(struct applespi_data *applespi)
1409 {
1410         struct spi_packet *packet;
1411         struct message *message;
1412         unsigned int msg_len;
1413         unsigned int off;
1414         unsigned int rem;
1415         unsigned int len;
1416
1417         /* process packet header */
1418         if (!applespi_verify_crc(applespi, applespi->rx_buffer,
1419                                  APPLESPI_PACKET_SIZE)) {
1420                 unsigned long flags;
1421
1422                 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1423
1424                 if (applespi->drain) {
1425                         applespi->read_active = false;
1426                         applespi->write_active = false;
1427
1428                         wake_up_all(&applespi->drain_complete);
1429                 }
1430
1431                 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1432
1433                 return;
1434         }
1435
1436         packet = (struct spi_packet *)applespi->rx_buffer;
1437
1438         applespi_debug_print_read_packet(applespi, packet);
1439
1440         off = le16_to_cpu(packet->offset);
1441         rem = le16_to_cpu(packet->remaining);
1442         len = le16_to_cpu(packet->length);
1443
1444         if (len > sizeof(packet->data)) {
1445                 dev_warn_ratelimited(&applespi->spi->dev,
1446                                      "Received corrupted packet (invalid packet length %u)\n",
1447                                      len);
1448                 goto msg_complete;
1449         }
1450
1451         /* handle multi-packet messages */
1452         if (rem > 0 || off > 0) {
1453                 if (off != applespi->saved_msg_len) {
1454                         dev_warn_ratelimited(&applespi->spi->dev,
1455                                              "Received unexpected offset (got %u, expected %u)\n",
1456                                              off, applespi->saved_msg_len);
1457                         goto msg_complete;
1458                 }
1459
1460                 if (off + rem > MAX_PKTS_PER_MSG * APPLESPI_PACKET_SIZE) {
1461                         dev_warn_ratelimited(&applespi->spi->dev,
1462                                              "Received message too large (size %u)\n",
1463                                              off + rem);
1464                         goto msg_complete;
1465                 }
1466
1467                 if (off + len > MAX_PKTS_PER_MSG * APPLESPI_PACKET_SIZE) {
1468                         dev_warn_ratelimited(&applespi->spi->dev,
1469                                              "Received message too large (size %u)\n",
1470                                              off + len);
1471                         goto msg_complete;
1472                 }
1473
1474                 memcpy(applespi->msg_buf + off, &packet->data, len);
1475                 applespi->saved_msg_len += len;
1476
1477                 if (rem > 0)
1478                         return;
1479
1480                 message = (struct message *)applespi->msg_buf;
1481                 msg_len = applespi->saved_msg_len;
1482         } else {
1483                 message = (struct message *)&packet->data;
1484                 msg_len = len;
1485         }
1486
1487         /* got complete message - verify */
1488         if (!applespi_verify_crc(applespi, (u8 *)message, msg_len))
1489                 goto msg_complete;
1490
1491         if (le16_to_cpu(message->length) != msg_len - MSG_HEADER_SIZE - 2) {
1492                 dev_warn_ratelimited(&applespi->spi->dev,
1493                                      "Received corrupted packet (invalid message length %u - expected %u)\n",
1494                                      le16_to_cpu(message->length),
1495                                      msg_len - MSG_HEADER_SIZE - 2);
1496                 goto msg_complete;
1497         }
1498
1499         /* handle message */
1500         if (packet->flags == PACKET_TYPE_READ &&
1501             packet->device == PACKET_DEV_KEYB) {
1502                 applespi_handle_keyboard_event(applespi, &message->keyboard);
1503
1504         } else if (packet->flags == PACKET_TYPE_READ &&
1505                    packet->device == PACKET_DEV_TPAD) {
1506                 struct touchpad_protocol *tp;
1507                 size_t tp_len;
1508
1509                 tp = &message->touchpad;
1510                 tp_len = struct_size(tp, fingers, tp->number_of_fingers);
1511
1512                 if (le16_to_cpu(message->length) + 2 != tp_len) {
1513                         dev_warn_ratelimited(&applespi->spi->dev,
1514                                              "Received corrupted packet (invalid message length %u - num-fingers %u, tp-len %zu)\n",
1515                                              le16_to_cpu(message->length),
1516                                              tp->number_of_fingers, tp_len);
1517                         goto msg_complete;
1518                 }
1519
1520                 if (tp->number_of_fingers > MAX_FINGERS) {
1521                         dev_warn_ratelimited(&applespi->spi->dev,
1522                                              "Number of reported fingers (%u) exceeds max (%u))\n",
1523                                              tp->number_of_fingers,
1524                                              MAX_FINGERS);
1525                         tp->number_of_fingers = MAX_FINGERS;
1526                 }
1527
1528                 report_tp_state(applespi, tp);
1529
1530         } else if (packet->flags == PACKET_TYPE_WRITE) {
1531                 applespi_handle_cmd_response(applespi, packet, message);
1532         }
1533
1534 msg_complete:
1535         applespi->saved_msg_len = 0;
1536
1537         applespi_msg_complete(applespi, packet->flags == PACKET_TYPE_WRITE,
1538                               true);
1539 }
1540
1541 static void applespi_async_read_complete(void *context)
1542 {
1543         struct applespi_data *applespi = context;
1544
1545         if (applespi->rd_m.status < 0) {
1546                 dev_warn(&applespi->spi->dev, "Error reading from device: %d\n",
1547                          applespi->rd_m.status);
1548                 /*
1549                  * We don't actually know if this was a pure read, or a response
1550                  * to a write. But this is a rare error condition that should
1551                  * never occur, so clearing both flags to avoid deadlock.
1552                  */
1553                 applespi_msg_complete(applespi, true, true);
1554         } else {
1555                 applespi_got_data(applespi);
1556         }
1557
1558         acpi_finish_gpe(NULL, applespi->gpe);
1559 }
1560
1561 static u32 applespi_notify(acpi_handle gpe_device, u32 gpe, void *context)
1562 {
1563         struct applespi_data *applespi = context;
1564         int sts;
1565         unsigned long flags;
1566
1567         trace_applespi_irq_received(ET_RD_IRQ, PT_READ);
1568
1569         spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1570
1571         if (!applespi->suspended) {
1572                 sts = applespi_async(applespi, &applespi->rd_m,
1573                                      applespi_async_read_complete);
1574                 if (sts)
1575                         dev_warn(&applespi->spi->dev,
1576                                  "Error queueing async read to device: %d\n",
1577                                  sts);
1578                 else
1579                         applespi->read_active = true;
1580         }
1581
1582         spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1583
1584         return ACPI_INTERRUPT_HANDLED;
1585 }
1586
1587 static int applespi_get_saved_bl_level(struct applespi_data *applespi)
1588 {
1589         struct efivar_entry *efivar_entry;
1590         u16 efi_data = 0;
1591         unsigned long efi_data_len;
1592         int sts;
1593
1594         efivar_entry = kmalloc(sizeof(*efivar_entry), GFP_KERNEL);
1595         if (!efivar_entry)
1596                 return -ENOMEM;
1597
1598         memcpy(efivar_entry->var.VariableName, EFI_BL_LEVEL_NAME,
1599                sizeof(EFI_BL_LEVEL_NAME));
1600         efivar_entry->var.VendorGuid = EFI_BL_LEVEL_GUID;
1601         efi_data_len = sizeof(efi_data);
1602
1603         sts = efivar_entry_get(efivar_entry, NULL, &efi_data_len, &efi_data);
1604         if (sts && sts != -ENOENT)
1605                 dev_warn(&applespi->spi->dev,
1606                          "Error getting backlight level from EFI vars: %d\n",
1607                          sts);
1608
1609         kfree(efivar_entry);
1610
1611         return sts ? sts : efi_data;
1612 }
1613
1614 static void applespi_save_bl_level(struct applespi_data *applespi,
1615                                    unsigned int level)
1616 {
1617         efi_guid_t efi_guid;
1618         u32 efi_attr;
1619         unsigned long efi_data_len;
1620         u16 efi_data;
1621         int sts;
1622
1623         /* Save keyboard backlight level */
1624         efi_guid = EFI_BL_LEVEL_GUID;
1625         efi_data = (u16)level;
1626         efi_data_len = sizeof(efi_data);
1627         efi_attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS |
1628                    EFI_VARIABLE_RUNTIME_ACCESS;
1629
1630         sts = efivar_entry_set_safe((efi_char16_t *)EFI_BL_LEVEL_NAME, efi_guid,
1631                                     efi_attr, true, efi_data_len, &efi_data);
1632         if (sts)
1633                 dev_warn(&applespi->spi->dev,
1634                          "Error saving backlight level to EFI vars: %d\n", sts);
1635 }
1636
1637 static int applespi_probe(struct spi_device *spi)
1638 {
1639         struct applespi_data *applespi;
1640         acpi_handle spi_handle = ACPI_HANDLE(&spi->dev);
1641         acpi_status acpi_sts;
1642         int sts, i;
1643         unsigned long long gpe, usb_status;
1644
1645         /* check if the USB interface is present and enabled already */
1646         acpi_sts = acpi_evaluate_integer(spi_handle, "UIST", NULL, &usb_status);
1647         if (ACPI_SUCCESS(acpi_sts) && usb_status) {
1648                 /* let the USB driver take over instead */
1649                 dev_info(&spi->dev, "USB interface already enabled\n");
1650                 return -ENODEV;
1651         }
1652
1653         /* allocate driver data */
1654         applespi = devm_kzalloc(&spi->dev, sizeof(*applespi), GFP_KERNEL);
1655         if (!applespi)
1656                 return -ENOMEM;
1657
1658         applespi->spi = spi;
1659
1660         INIT_WORK(&applespi->work, applespi_worker);
1661
1662         /* store the driver data */
1663         spi_set_drvdata(spi, applespi);
1664
1665         /* create our buffers */
1666         applespi->tx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1667                                            GFP_KERNEL);
1668         applespi->tx_status = devm_kmalloc(&spi->dev, APPLESPI_STATUS_SIZE,
1669                                            GFP_KERNEL);
1670         applespi->rx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1671                                            GFP_KERNEL);
1672         applespi->msg_buf = devm_kmalloc_array(&spi->dev, MAX_PKTS_PER_MSG,
1673                                                APPLESPI_PACKET_SIZE,
1674                                                GFP_KERNEL);
1675
1676         if (!applespi->tx_buffer || !applespi->tx_status ||
1677             !applespi->rx_buffer || !applespi->msg_buf)
1678                 return -ENOMEM;
1679
1680         /* set up our spi messages */
1681         applespi_setup_read_txfrs(applespi);
1682         applespi_setup_write_txfrs(applespi);
1683
1684         /* cache ACPI method handles */
1685         acpi_sts = acpi_get_handle(spi_handle, "SIEN", &applespi->sien);
1686         if (ACPI_FAILURE(acpi_sts)) {
1687                 dev_err(&applespi->spi->dev,
1688                         "Failed to get SIEN ACPI method handle: %s\n",
1689                         acpi_format_exception(acpi_sts));
1690                 return -ENODEV;
1691         }
1692
1693         acpi_sts = acpi_get_handle(spi_handle, "SIST", &applespi->sist);
1694         if (ACPI_FAILURE(acpi_sts)) {
1695                 dev_err(&applespi->spi->dev,
1696                         "Failed to get SIST ACPI method handle: %s\n",
1697                         acpi_format_exception(acpi_sts));
1698                 return -ENODEV;
1699         }
1700
1701         /* switch on the SPI interface */
1702         sts = applespi_setup_spi(applespi);
1703         if (sts)
1704                 return sts;
1705
1706         sts = applespi_enable_spi(applespi);
1707         if (sts)
1708                 return sts;
1709
1710         /* setup the keyboard input dev */
1711         applespi->keyboard_input_dev = devm_input_allocate_device(&spi->dev);
1712
1713         if (!applespi->keyboard_input_dev)
1714                 return -ENOMEM;
1715
1716         applespi->keyboard_input_dev->name = "Apple SPI Keyboard";
1717         applespi->keyboard_input_dev->phys = "applespi/input0";
1718         applespi->keyboard_input_dev->dev.parent = &spi->dev;
1719         applespi->keyboard_input_dev->id.bustype = BUS_SPI;
1720
1721         applespi->keyboard_input_dev->evbit[0] =
1722                         BIT_MASK(EV_KEY) | BIT_MASK(EV_LED) | BIT_MASK(EV_REP);
1723         applespi->keyboard_input_dev->ledbit[0] = BIT_MASK(LED_CAPSL);
1724
1725         input_set_drvdata(applespi->keyboard_input_dev, applespi);
1726         applespi->keyboard_input_dev->event = applespi_event;
1727
1728         for (i = 0; i < ARRAY_SIZE(applespi_scancodes); i++)
1729                 if (applespi_scancodes[i])
1730                         input_set_capability(applespi->keyboard_input_dev,
1731                                              EV_KEY, applespi_scancodes[i]);
1732
1733         for (i = 0; i < ARRAY_SIZE(applespi_controlcodes); i++)
1734                 if (applespi_controlcodes[i])
1735                         input_set_capability(applespi->keyboard_input_dev,
1736                                              EV_KEY, applespi_controlcodes[i]);
1737
1738         for (i = 0; i < ARRAY_SIZE(applespi_fn_codes); i++)
1739                 if (applespi_fn_codes[i].to)
1740                         input_set_capability(applespi->keyboard_input_dev,
1741                                              EV_KEY, applespi_fn_codes[i].to);
1742
1743         input_set_capability(applespi->keyboard_input_dev, EV_KEY, KEY_FN);
1744
1745         sts = input_register_device(applespi->keyboard_input_dev);
1746         if (sts) {
1747                 dev_err(&applespi->spi->dev,
1748                         "Unable to register keyboard input device (%d)\n", sts);
1749                 return -ENODEV;
1750         }
1751
1752         /*
1753          * The applespi device doesn't send interrupts normally (as is described
1754          * in its DSDT), but rather seems to use ACPI GPEs.
1755          */
1756         acpi_sts = acpi_evaluate_integer(spi_handle, "_GPE", NULL, &gpe);
1757         if (ACPI_FAILURE(acpi_sts)) {
1758                 dev_err(&applespi->spi->dev,
1759                         "Failed to obtain GPE for SPI slave device: %s\n",
1760                         acpi_format_exception(acpi_sts));
1761                 return -ENODEV;
1762         }
1763         applespi->gpe = (int)gpe;
1764
1765         acpi_sts = acpi_install_gpe_handler(NULL, applespi->gpe,
1766                                             ACPI_GPE_LEVEL_TRIGGERED,
1767                                             applespi_notify, applespi);
1768         if (ACPI_FAILURE(acpi_sts)) {
1769                 dev_err(&applespi->spi->dev,
1770                         "Failed to install GPE handler for GPE %d: %s\n",
1771                         applespi->gpe, acpi_format_exception(acpi_sts));
1772                 return -ENODEV;
1773         }
1774
1775         applespi->suspended = false;
1776
1777         acpi_sts = acpi_enable_gpe(NULL, applespi->gpe);
1778         if (ACPI_FAILURE(acpi_sts)) {
1779                 dev_err(&applespi->spi->dev,
1780                         "Failed to enable GPE handler for GPE %d: %s\n",
1781                         applespi->gpe, acpi_format_exception(acpi_sts));
1782                 acpi_remove_gpe_handler(NULL, applespi->gpe, applespi_notify);
1783                 return -ENODEV;
1784         }
1785
1786         /* trigger touchpad setup */
1787         applespi_init(applespi, false);
1788
1789         /*
1790          * By default this device is not enabled for wakeup; but USB keyboards
1791          * generally are, so the expectation is that by default the keyboard
1792          * will wake the system.
1793          */
1794         device_wakeup_enable(&spi->dev);
1795
1796         /* set up keyboard-backlight */
1797         sts = applespi_get_saved_bl_level(applespi);
1798         if (sts >= 0)
1799                 applespi_set_bl_level(&applespi->backlight_info, sts);
1800
1801         applespi->backlight_info.name            = "spi::kbd_backlight";
1802         applespi->backlight_info.default_trigger = "kbd-backlight";
1803         applespi->backlight_info.brightness_set  = applespi_set_bl_level;
1804
1805         sts = devm_led_classdev_register(&spi->dev, &applespi->backlight_info);
1806         if (sts)
1807                 dev_warn(&applespi->spi->dev,
1808                          "Unable to register keyboard backlight class dev (%d)\n",
1809                          sts);
1810
1811         /* set up debugfs entries for touchpad dimensions logging */
1812         applespi->debugfs_root = debugfs_create_dir("applespi", NULL);
1813
1814         debugfs_create_bool("enable_tp_dim", 0600, applespi->debugfs_root,
1815                             &applespi->debug_tp_dim);
1816
1817         debugfs_create_file("tp_dim", 0400, applespi->debugfs_root, applespi,
1818                             &applespi_tp_dim_fops);
1819
1820         return 0;
1821 }
1822
1823 static void applespi_drain_writes(struct applespi_data *applespi)
1824 {
1825         unsigned long flags;
1826
1827         spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1828
1829         applespi->drain = true;
1830         wait_event_lock_irq(applespi->drain_complete, !applespi->write_active,
1831                             applespi->cmd_msg_lock);
1832
1833         spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1834 }
1835
1836 static void applespi_drain_reads(struct applespi_data *applespi)
1837 {
1838         unsigned long flags;
1839
1840         spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1841
1842         wait_event_lock_irq(applespi->drain_complete, !applespi->read_active,
1843                             applespi->cmd_msg_lock);
1844
1845         applespi->suspended = true;
1846
1847         spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1848 }
1849
1850 static int applespi_remove(struct spi_device *spi)
1851 {
1852         struct applespi_data *applespi = spi_get_drvdata(spi);
1853
1854         applespi_drain_writes(applespi);
1855
1856         acpi_disable_gpe(NULL, applespi->gpe);
1857         acpi_remove_gpe_handler(NULL, applespi->gpe, applespi_notify);
1858         device_wakeup_disable(&spi->dev);
1859
1860         applespi_drain_reads(applespi);
1861
1862         debugfs_remove_recursive(applespi->debugfs_root);
1863
1864         return 0;
1865 }
1866
1867 static void applespi_shutdown(struct spi_device *spi)
1868 {
1869         struct applespi_data *applespi = spi_get_drvdata(spi);
1870
1871         applespi_save_bl_level(applespi, applespi->have_bl_level);
1872 }
1873
1874 static int applespi_poweroff_late(struct device *dev)
1875 {
1876         struct spi_device *spi = to_spi_device(dev);
1877         struct applespi_data *applespi = spi_get_drvdata(spi);
1878
1879         applespi_save_bl_level(applespi, applespi->have_bl_level);
1880
1881         return 0;
1882 }
1883
1884 static int __maybe_unused applespi_suspend(struct device *dev)
1885 {
1886         struct spi_device *spi = to_spi_device(dev);
1887         struct applespi_data *applespi = spi_get_drvdata(spi);
1888         acpi_status acpi_sts;
1889         int sts;
1890
1891         /* turn off caps-lock - it'll stay on otherwise */
1892         sts = applespi_set_capsl_led(applespi, false);
1893         if (sts)
1894                 dev_warn(&applespi->spi->dev,
1895                          "Failed to turn off caps-lock led (%d)\n", sts);
1896
1897         applespi_drain_writes(applespi);
1898
1899         /* disable the interrupt */
1900         acpi_sts = acpi_disable_gpe(NULL, applespi->gpe);
1901         if (ACPI_FAILURE(acpi_sts))
1902                 dev_err(&applespi->spi->dev,
1903                         "Failed to disable GPE handler for GPE %d: %s\n",
1904                         applespi->gpe, acpi_format_exception(acpi_sts));
1905
1906         applespi_drain_reads(applespi);
1907
1908         return 0;
1909 }
1910
1911 static int __maybe_unused applespi_resume(struct device *dev)
1912 {
1913         struct spi_device *spi = to_spi_device(dev);
1914         struct applespi_data *applespi = spi_get_drvdata(spi);
1915         acpi_status acpi_sts;
1916         unsigned long flags;
1917
1918         /* ensure our flags and state reflect a newly resumed device */
1919         spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1920
1921         applespi->drain = false;
1922         applespi->have_cl_led_on = false;
1923         applespi->have_bl_level = 0;
1924         applespi->cmd_msg_queued = false;
1925         applespi->read_active = false;
1926         applespi->write_active = false;
1927
1928         applespi->suspended = false;
1929
1930         spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1931
1932         /* switch on the SPI interface */
1933         applespi_enable_spi(applespi);
1934
1935         /* re-enable the interrupt */
1936         acpi_sts = acpi_enable_gpe(NULL, applespi->gpe);
1937         if (ACPI_FAILURE(acpi_sts))
1938                 dev_err(&applespi->spi->dev,
1939                         "Failed to re-enable GPE handler for GPE %d: %s\n",
1940                         applespi->gpe, acpi_format_exception(acpi_sts));
1941
1942         /* switch the touchpad into multitouch mode */
1943         applespi_init(applespi, true);
1944
1945         return 0;
1946 }
1947
1948 static const struct acpi_device_id applespi_acpi_match[] = {
1949         { "APP000D", 0 },
1950         { }
1951 };
1952 MODULE_DEVICE_TABLE(acpi, applespi_acpi_match);
1953
1954 static const struct dev_pm_ops applespi_pm_ops = {
1955         SET_SYSTEM_SLEEP_PM_OPS(applespi_suspend, applespi_resume)
1956         .poweroff_late  = applespi_poweroff_late,
1957 };
1958
1959 static struct spi_driver applespi_driver = {
1960         .driver         = {
1961                 .name                   = "applespi",
1962                 .acpi_match_table       = applespi_acpi_match,
1963                 .pm                     = &applespi_pm_ops,
1964         },
1965         .probe          = applespi_probe,
1966         .remove         = applespi_remove,
1967         .shutdown       = applespi_shutdown,
1968 };
1969
1970 module_spi_driver(applespi_driver)
1971
1972 MODULE_LICENSE("GPL v2");
1973 MODULE_DESCRIPTION("MacBook(Pro) SPI Keyboard/Touchpad driver");
1974 MODULE_AUTHOR("Federico Lorenzi");
1975 MODULE_AUTHOR("Ronald Tschalär");