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