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