drivers/input/keyboard/applespi.c

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

DEFINITIONS
