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