linux/drivers/input/keyboard/applespi.c
<<
>>
Prefs
   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
  96static unsigned int fnmode = 1;
  97module_param(fnmode, uint, 0644);
  98MODULE_PARM_DESC(fnmode, "Mode of Fn key on Apple keyboards (0 = disabled, [1] = fkeyslast, 2 = fkeysfirst)");
  99
 100static unsigned int fnremap;
 101module_param(fnremap, uint, 0644);
 102MODULE_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
 104static bool iso_layout;
 105module_param(iso_layout, bool, 0644);
 106MODULE_PARM_DESC(iso_layout, "Enable/Disable hardcoded ISO-layout of the keyboard. ([0] = disabled, 1 = enabled)");
 107
 108static char touchpad_dimensions[40];
 109module_param_string(touchpad_dimensions, touchpad_dimensions,
 110                    sizeof(touchpad_dimensions), 0444);
 111MODULE_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 */
 125struct 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 */
 154struct 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 */
 183struct 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 */
 200struct 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 */
 216struct 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 */
 232struct 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 */
 246struct 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 */
 262struct 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 */
 300struct 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 */
 346struct 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
 356struct 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 */
 363struct applespi_tp_info {
 364        int     x_min;
 365        int     y_min;
 366        int     x_max;
 367        int     y_max;
 368};
 369
 370struct 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
 436static 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 */
 459static 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
 470struct applespi_key_translation {
 471        u16 from;
 472        u16 to;
 473        u8 flags;
 474};
 475
 476static 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
 498static const struct applespi_key_translation apple_iso_keyboard[] = {
 499        { KEY_GRAVE,    KEY_102ND },
 500        { KEY_102ND,    KEY_GRAVE },
 501        { }
 502};
 503
 504struct applespi_tp_model_info {
 505        u16                     model;
 506        struct applespi_tp_info tp_info;
 507};
 508
 509static 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
 525typedef void (*applespi_trace_fun)(enum applespi_evt_type,
 526                                   enum applespi_pkt_type, u8 *, size_t);
 527
 528static 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
 549static 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
 569static 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
 610static 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
 619static 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
 639static 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
 671static 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
 685static 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
 715static int applespi_send_cmd_msg(struct applespi_data *applespi);
 716
 717static 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
 740static 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
 763static 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
 889static 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
 904static 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
 920static 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
 947static 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 */
 963static inline int le16_to_int(__le16 x)
 964{
 965        return (signed short)le16_to_cpu(x);
 966}
 967
 968static 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
 981static 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
 997static 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
1006static 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
1013static 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
1034static 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
1074static const struct applespi_key_translation *
1075applespi_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
1086static 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
1106static 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
1117static 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
1128static void
1129applespi_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
1146static void
1147applespi_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
1213static 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
1225static int
1226applespi_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
1346static 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
1354static 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
1382static 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
1399static 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
1419static 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
1545msg_complete:
1546        applespi->saved_msg_len = 0;
1547
1548        applespi_msg_complete(applespi, packet->flags == PACKET_TYPE_WRITE,
1549                              true);
1550}
1551
1552static 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
1572static 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
1598static 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
1625static 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
1648static 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
1834static 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
1847static 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
1861static void 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
1876static void applespi_shutdown(struct spi_device *spi)
1877{
1878        struct applespi_data *applespi = spi_get_drvdata(spi);
1879
1880        applespi_save_bl_level(applespi, applespi->have_bl_level);
1881}
1882
1883static int applespi_poweroff_late(struct device *dev)
1884{
1885        struct spi_device *spi = to_spi_device(dev);
1886        struct applespi_data *applespi = spi_get_drvdata(spi);
1887
1888        applespi_save_bl_level(applespi, applespi->have_bl_level);
1889
1890        return 0;
1891}
1892
1893static int __maybe_unused applespi_suspend(struct device *dev)
1894{
1895        struct spi_device *spi = to_spi_device(dev);
1896        struct applespi_data *applespi = spi_get_drvdata(spi);
1897        acpi_status acpi_sts;
1898        int sts;
1899
1900        /* turn off caps-lock - it'll stay on otherwise */
1901        sts = applespi_set_capsl_led(applespi, false);
1902        if (sts)
1903                dev_warn(&applespi->spi->dev,
1904                         "Failed to turn off caps-lock led (%d)\n", sts);
1905
1906        applespi_drain_writes(applespi);
1907
1908        /* disable the interrupt */
1909        acpi_sts = acpi_disable_gpe(NULL, applespi->gpe);
1910        if (ACPI_FAILURE(acpi_sts))
1911                dev_err(&applespi->spi->dev,
1912                        "Failed to disable GPE handler for GPE %d: %s\n",
1913                        applespi->gpe, acpi_format_exception(acpi_sts));
1914
1915        applespi_drain_reads(applespi);
1916
1917        return 0;
1918}
1919
1920static int __maybe_unused applespi_resume(struct device *dev)
1921{
1922        struct spi_device *spi = to_spi_device(dev);
1923        struct applespi_data *applespi = spi_get_drvdata(spi);
1924        acpi_status acpi_sts;
1925        unsigned long flags;
1926
1927        /* ensure our flags and state reflect a newly resumed device */
1928        spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1929
1930        applespi->drain = false;
1931        applespi->have_cl_led_on = false;
1932        applespi->have_bl_level = 0;
1933        applespi->cmd_msg_queued = 0;
1934        applespi->read_active = false;
1935        applespi->write_active = false;
1936
1937        applespi->suspended = false;
1938
1939        spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1940
1941        /* switch on the SPI interface */
1942        applespi_enable_spi(applespi);
1943
1944        /* re-enable the interrupt */
1945        acpi_sts = acpi_enable_gpe(NULL, applespi->gpe);
1946        if (ACPI_FAILURE(acpi_sts))
1947                dev_err(&applespi->spi->dev,
1948                        "Failed to re-enable GPE handler for GPE %d: %s\n",
1949                        applespi->gpe, acpi_format_exception(acpi_sts));
1950
1951        /* switch the touchpad into multitouch mode */
1952        applespi_init(applespi, true);
1953
1954        return 0;
1955}
1956
1957static const struct acpi_device_id applespi_acpi_match[] = {
1958        { "APP000D", 0 },
1959        { }
1960};
1961MODULE_DEVICE_TABLE(acpi, applespi_acpi_match);
1962
1963static const struct dev_pm_ops applespi_pm_ops = {
1964        SET_SYSTEM_SLEEP_PM_OPS(applespi_suspend, applespi_resume)
1965        .poweroff_late  = applespi_poweroff_late,
1966};
1967
1968static struct spi_driver applespi_driver = {
1969        .driver         = {
1970                .name                   = "applespi",
1971                .acpi_match_table       = applespi_acpi_match,
1972                .pm                     = &applespi_pm_ops,
1973        },
1974        .probe          = applespi_probe,
1975        .remove         = applespi_remove,
1976        .shutdown       = applespi_shutdown,
1977};
1978
1979module_spi_driver(applespi_driver)
1980
1981MODULE_LICENSE("GPL v2");
1982MODULE_DESCRIPTION("MacBook(Pro) SPI Keyboard/Touchpad driver");
1983MODULE_AUTHOR("Federico Lorenzi");
1984MODULE_AUTHOR("Ronald Tschalär");
1985