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 <linux/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
applespi_get_trace_fun(enum applespi_evt_type type)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
applespi_setup_read_txfrs(struct applespi_data * applespi)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
applespi_setup_write_txfrs(struct applespi_data * applespi)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
applespi_async(struct applespi_data * applespi,struct spi_message * message,void (* complete)(void *))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
applespi_check_write_status(struct applespi_data * applespi,int sts)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
applespi_get_spi_settings(struct applespi_data * applespi)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
applespi_setup_spi(struct applespi_data * applespi)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
applespi_enable_spi(struct applespi_data * applespi)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
applespi_msg_complete(struct applespi_data * applespi,bool is_write_msg,bool is_read_compl)717 static void applespi_msg_complete(struct applespi_data *applespi,
718 bool is_write_msg, bool is_read_compl)
719 {
720 unsigned long flags;
721
722 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
723
724 if (is_read_compl)
725 applespi->read_active = false;
726 if (is_write_msg)
727 applespi->write_active = false;
728
729 if (applespi->drain && !applespi->write_active)
730 wake_up_all(&applespi->drain_complete);
731
732 if (is_write_msg) {
733 applespi->cmd_msg_queued = 0;
734 applespi_send_cmd_msg(applespi);
735 }
736
737 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
738 }
739
applespi_async_write_complete(void * context)740 static void applespi_async_write_complete(void *context)
741 {
742 struct applespi_data *applespi = context;
743 enum applespi_evt_type evt_type = applespi->cmd_evt_type;
744
745 applespi_get_trace_fun(evt_type)(evt_type, PT_WRITE,
746 applespi->tx_buffer,
747 APPLESPI_PACKET_SIZE);
748 applespi_get_trace_fun(evt_type)(evt_type, PT_STATUS,
749 applespi->tx_status,
750 APPLESPI_STATUS_SIZE);
751
752 udelay(SPI_RW_CHG_DELAY_US);
753
754 if (!applespi_check_write_status(applespi, applespi->wr_m.status)) {
755 /*
756 * If we got an error, we presumably won't get the expected
757 * response message either.
758 */
759 applespi_msg_complete(applespi, true, false);
760 }
761 }
762
applespi_send_cmd_msg(struct applespi_data * applespi)763 static int applespi_send_cmd_msg(struct applespi_data *applespi)
764 {
765 u16 crc;
766 int sts;
767 struct spi_packet *packet = (struct spi_packet *)applespi->tx_buffer;
768 struct message *message = (struct message *)packet->data;
769 u16 msg_len;
770 u8 device;
771
772 /* check if draining */
773 if (applespi->drain)
774 return 0;
775
776 /* check whether send is in progress */
777 if (applespi->cmd_msg_queued) {
778 if (ktime_ms_delta(ktime_get(), applespi->cmd_msg_queued) < 1000)
779 return 0;
780
781 dev_warn(&applespi->spi->dev, "Command %d timed out\n",
782 applespi->cmd_evt_type);
783
784 applespi->cmd_msg_queued = 0;
785 applespi->write_active = false;
786 }
787
788 /* set up packet */
789 memset(packet, 0, APPLESPI_PACKET_SIZE);
790
791 /* are we processing init commands? */
792 if (applespi->want_tp_info_cmd) {
793 applespi->want_tp_info_cmd = false;
794 applespi->want_mt_init_cmd = true;
795 applespi->cmd_evt_type = ET_CMD_TP_INI;
796
797 /* build init command */
798 device = PACKET_DEV_INFO;
799
800 message->type = cpu_to_le16(0x1020);
801 msg_len = sizeof(message->tp_info_command);
802
803 message->zero = 0x02;
804 message->rsp_buf_len = cpu_to_le16(0x0200);
805
806 } else if (applespi->want_mt_init_cmd) {
807 applespi->want_mt_init_cmd = false;
808 applespi->cmd_evt_type = ET_CMD_TP_INI;
809
810 /* build init command */
811 device = PACKET_DEV_TPAD;
812
813 message->type = cpu_to_le16(0x0252);
814 msg_len = sizeof(message->init_mt_command);
815
816 message->init_mt_command.cmd = cpu_to_le16(0x0102);
817
818 /* do we need caps-lock command? */
819 } else if (applespi->want_cl_led_on != applespi->have_cl_led_on) {
820 applespi->have_cl_led_on = applespi->want_cl_led_on;
821 applespi->cmd_evt_type = ET_CMD_CL;
822
823 /* build led command */
824 device = PACKET_DEV_KEYB;
825
826 message->type = cpu_to_le16(0x0151);
827 msg_len = sizeof(message->capsl_command);
828
829 message->capsl_command.unknown = 0x01;
830 message->capsl_command.led = applespi->have_cl_led_on ? 2 : 0;
831
832 /* do we need backlight command? */
833 } else if (applespi->want_bl_level != applespi->have_bl_level) {
834 applespi->have_bl_level = applespi->want_bl_level;
835 applespi->cmd_evt_type = ET_CMD_BL;
836
837 /* build command buffer */
838 device = PACKET_DEV_KEYB;
839
840 message->type = cpu_to_le16(0xB051);
841 msg_len = sizeof(message->bl_command);
842
843 message->bl_command.const1 = cpu_to_le16(0x01B0);
844 message->bl_command.level =
845 cpu_to_le16(applespi->have_bl_level);
846
847 if (applespi->have_bl_level > 0)
848 message->bl_command.const2 = cpu_to_le16(0x01F4);
849 else
850 message->bl_command.const2 = cpu_to_le16(0x0001);
851
852 /* everything's up-to-date */
853 } else {
854 return 0;
855 }
856
857 /* finalize packet */
858 packet->flags = PACKET_TYPE_WRITE;
859 packet->device = device;
860 packet->length = cpu_to_le16(MSG_HEADER_SIZE + msg_len);
861
862 message->counter = applespi->cmd_msg_cntr++ % (U8_MAX + 1);
863
864 message->length = cpu_to_le16(msg_len - 2);
865 if (!message->rsp_buf_len)
866 message->rsp_buf_len = message->length;
867
868 crc = crc16(0, (u8 *)message, le16_to_cpu(packet->length) - 2);
869 put_unaligned_le16(crc, &message->data[msg_len - 2]);
870
871 crc = crc16(0, (u8 *)packet, sizeof(*packet) - 2);
872 packet->crc16 = cpu_to_le16(crc);
873
874 /* send command */
875 sts = applespi_async(applespi, &applespi->wr_m,
876 applespi_async_write_complete);
877 if (sts) {
878 dev_warn(&applespi->spi->dev,
879 "Error queueing async write to device: %d\n", sts);
880 return sts;
881 }
882
883 applespi->cmd_msg_queued = ktime_get_coarse();
884 applespi->write_active = true;
885
886 return 0;
887 }
888
applespi_init(struct applespi_data * applespi,bool is_resume)889 static void applespi_init(struct applespi_data *applespi, bool is_resume)
890 {
891 unsigned long flags;
892
893 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
894
895 if (is_resume)
896 applespi->want_mt_init_cmd = true;
897 else
898 applespi->want_tp_info_cmd = true;
899 applespi_send_cmd_msg(applespi);
900
901 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
902 }
903
applespi_set_capsl_led(struct applespi_data * applespi,bool capslock_on)904 static int applespi_set_capsl_led(struct applespi_data *applespi,
905 bool capslock_on)
906 {
907 unsigned long flags;
908 int sts;
909
910 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
911
912 applespi->want_cl_led_on = capslock_on;
913 sts = applespi_send_cmd_msg(applespi);
914
915 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
916
917 return sts;
918 }
919
applespi_set_bl_level(struct led_classdev * led_cdev,enum led_brightness value)920 static void applespi_set_bl_level(struct led_classdev *led_cdev,
921 enum led_brightness value)
922 {
923 struct applespi_data *applespi =
924 container_of(led_cdev, struct applespi_data, backlight_info);
925 unsigned long flags;
926
927 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
928
929 if (value == 0) {
930 applespi->want_bl_level = value;
931 } else {
932 /*
933 * The backlight does not turn on till level 32, so we scale
934 * the range here so that from a user's perspective it turns
935 * on at 1.
936 */
937 applespi->want_bl_level =
938 ((value * KBD_BL_LEVEL_ADJ) / KBD_BL_LEVEL_SCALE +
939 KBD_BL_LEVEL_MIN);
940 }
941
942 applespi_send_cmd_msg(applespi);
943
944 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
945 }
946
applespi_event(struct input_dev * dev,unsigned int type,unsigned int code,int value)947 static int applespi_event(struct input_dev *dev, unsigned int type,
948 unsigned int code, int value)
949 {
950 struct applespi_data *applespi = input_get_drvdata(dev);
951
952 switch (type) {
953 case EV_LED:
954 applespi_set_capsl_led(applespi, !!test_bit(LED_CAPSL, dev->led));
955 return 0;
956 }
957
958 return -EINVAL;
959 }
960
961 /* lifted from the BCM5974 driver and renamed from raw2int */
962 /* convert 16-bit little endian to signed integer */
le16_to_int(__le16 x)963 static inline int le16_to_int(__le16 x)
964 {
965 return (signed short)le16_to_cpu(x);
966 }
967
applespi_debug_update_dimensions(struct applespi_data * applespi,const struct tp_finger * f)968 static void applespi_debug_update_dimensions(struct applespi_data *applespi,
969 const struct tp_finger *f)
970 {
971 applespi->tp_dim_min_x = min(applespi->tp_dim_min_x,
972 le16_to_int(f->abs_x));
973 applespi->tp_dim_max_x = max(applespi->tp_dim_max_x,
974 le16_to_int(f->abs_x));
975 applespi->tp_dim_min_y = min(applespi->tp_dim_min_y,
976 le16_to_int(f->abs_y));
977 applespi->tp_dim_max_y = max(applespi->tp_dim_max_y,
978 le16_to_int(f->abs_y));
979 }
980
applespi_tp_dim_open(struct inode * inode,struct file * file)981 static int applespi_tp_dim_open(struct inode *inode, struct file *file)
982 {
983 struct applespi_data *applespi = inode->i_private;
984
985 file->private_data = applespi;
986
987 snprintf(applespi->tp_dim_val, sizeof(applespi->tp_dim_val),
988 "0x%.4x %dx%d+%u+%u\n",
989 applespi->touchpad_input_dev->id.product,
990 applespi->tp_dim_min_x, applespi->tp_dim_min_y,
991 applespi->tp_dim_max_x - applespi->tp_dim_min_x,
992 applespi->tp_dim_max_y - applespi->tp_dim_min_y);
993
994 return nonseekable_open(inode, file);
995 }
996
applespi_tp_dim_read(struct file * file,char __user * buf,size_t len,loff_t * off)997 static ssize_t applespi_tp_dim_read(struct file *file, char __user *buf,
998 size_t len, loff_t *off)
999 {
1000 struct applespi_data *applespi = file->private_data;
1001
1002 return simple_read_from_buffer(buf, len, off, applespi->tp_dim_val,
1003 strlen(applespi->tp_dim_val));
1004 }
1005
1006 static const struct file_operations applespi_tp_dim_fops = {
1007 .owner = THIS_MODULE,
1008 .open = applespi_tp_dim_open,
1009 .read = applespi_tp_dim_read,
1010 };
1011
report_finger_data(struct input_dev * input,int slot,const struct input_mt_pos * pos,const struct tp_finger * f)1012 static void report_finger_data(struct input_dev *input, int slot,
1013 const struct input_mt_pos *pos,
1014 const struct tp_finger *f)
1015 {
1016 input_mt_slot(input, slot);
1017 input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
1018
1019 input_report_abs(input, ABS_MT_TOUCH_MAJOR,
1020 le16_to_int(f->touch_major) << 1);
1021 input_report_abs(input, ABS_MT_TOUCH_MINOR,
1022 le16_to_int(f->touch_minor) << 1);
1023 input_report_abs(input, ABS_MT_WIDTH_MAJOR,
1024 le16_to_int(f->tool_major) << 1);
1025 input_report_abs(input, ABS_MT_WIDTH_MINOR,
1026 le16_to_int(f->tool_minor) << 1);
1027 input_report_abs(input, ABS_MT_ORIENTATION,
1028 MAX_FINGER_ORIENTATION - le16_to_int(f->orientation));
1029 input_report_abs(input, ABS_MT_POSITION_X, pos->x);
1030 input_report_abs(input, ABS_MT_POSITION_Y, pos->y);
1031 }
1032
report_tp_state(struct applespi_data * applespi,struct touchpad_protocol * t)1033 static void report_tp_state(struct applespi_data *applespi,
1034 struct touchpad_protocol *t)
1035 {
1036 const struct tp_finger *f;
1037 struct input_dev *input;
1038 const struct applespi_tp_info *tp_info = &applespi->tp_info;
1039 int i, n;
1040
1041 /* touchpad_input_dev is set async in worker */
1042 input = smp_load_acquire(&applespi->touchpad_input_dev);
1043 if (!input)
1044 return; /* touchpad isn't initialized yet */
1045
1046 n = 0;
1047
1048 for (i = 0; i < t->number_of_fingers; i++) {
1049 f = &t->fingers[i];
1050 if (le16_to_int(f->touch_major) == 0)
1051 continue;
1052 applespi->pos[n].x = le16_to_int(f->abs_x);
1053 applespi->pos[n].y = tp_info->y_min + tp_info->y_max -
1054 le16_to_int(f->abs_y);
1055 n++;
1056
1057 if (applespi->debug_tp_dim)
1058 applespi_debug_update_dimensions(applespi, f);
1059 }
1060
1061 input_mt_assign_slots(input, applespi->slots, applespi->pos, n, 0);
1062
1063 for (i = 0; i < n; i++)
1064 report_finger_data(input, applespi->slots[i],
1065 &applespi->pos[i], &t->fingers[i]);
1066
1067 input_mt_sync_frame(input);
1068 input_report_key(input, BTN_LEFT, t->clicked);
1069
1070 input_sync(input);
1071 }
1072
1073 static const struct applespi_key_translation *
applespi_find_translation(const struct applespi_key_translation * table,u16 key)1074 applespi_find_translation(const struct applespi_key_translation *table, u16 key)
1075 {
1076 const struct applespi_key_translation *trans;
1077
1078 for (trans = table; trans->from; trans++)
1079 if (trans->from == key)
1080 return trans;
1081
1082 return NULL;
1083 }
1084
applespi_translate_fn_key(unsigned int key,int fn_pressed)1085 static unsigned int applespi_translate_fn_key(unsigned int key, int fn_pressed)
1086 {
1087 const struct applespi_key_translation *trans;
1088 int do_translate;
1089
1090 trans = applespi_find_translation(applespi_fn_codes, key);
1091 if (trans) {
1092 if (trans->flags & APPLE_FLAG_FKEY)
1093 do_translate = (fnmode == 2 && fn_pressed) ||
1094 (fnmode == 1 && !fn_pressed);
1095 else
1096 do_translate = fn_pressed;
1097
1098 if (do_translate)
1099 key = trans->to;
1100 }
1101
1102 return key;
1103 }
1104
applespi_translate_iso_layout(unsigned int key)1105 static unsigned int applespi_translate_iso_layout(unsigned int key)
1106 {
1107 const struct applespi_key_translation *trans;
1108
1109 trans = applespi_find_translation(apple_iso_keyboard, key);
1110 if (trans)
1111 key = trans->to;
1112
1113 return key;
1114 }
1115
applespi_code_to_key(u8 code,int fn_pressed)1116 static unsigned int applespi_code_to_key(u8 code, int fn_pressed)
1117 {
1118 unsigned int key = applespi_scancodes[code];
1119
1120 if (fnmode)
1121 key = applespi_translate_fn_key(key, fn_pressed);
1122 if (iso_layout)
1123 key = applespi_translate_iso_layout(key);
1124 return key;
1125 }
1126
1127 static void
applespi_remap_fn_key(struct keyboard_protocol * keyboard_protocol)1128 applespi_remap_fn_key(struct keyboard_protocol *keyboard_protocol)
1129 {
1130 unsigned char tmp;
1131 u8 bit = BIT((fnremap - 1) & 0x07);
1132
1133 if (!fnremap || fnremap > ARRAY_SIZE(applespi_controlcodes) ||
1134 !applespi_controlcodes[fnremap - 1])
1135 return;
1136
1137 tmp = keyboard_protocol->fn_pressed;
1138 keyboard_protocol->fn_pressed = !!(keyboard_protocol->modifiers & bit);
1139 if (tmp)
1140 keyboard_protocol->modifiers |= bit;
1141 else
1142 keyboard_protocol->modifiers &= ~bit;
1143 }
1144
1145 static void
applespi_handle_keyboard_event(struct applespi_data * applespi,struct keyboard_protocol * keyboard_protocol)1146 applespi_handle_keyboard_event(struct applespi_data *applespi,
1147 struct keyboard_protocol *keyboard_protocol)
1148 {
1149 unsigned int key;
1150 int i;
1151
1152 compiletime_assert(ARRAY_SIZE(applespi_controlcodes) ==
1153 sizeof_field(struct keyboard_protocol, modifiers) * 8,
1154 "applespi_controlcodes has wrong number of entries");
1155
1156 /* check for rollover overflow, which is signalled by all keys == 1 */
1157 if (!memchr_inv(keyboard_protocol->keys_pressed, 1, MAX_ROLLOVER))
1158 return;
1159
1160 /* remap fn key if desired */
1161 applespi_remap_fn_key(keyboard_protocol);
1162
1163 /* check released keys */
1164 for (i = 0; i < MAX_ROLLOVER; i++) {
1165 if (memchr(keyboard_protocol->keys_pressed,
1166 applespi->last_keys_pressed[i], MAX_ROLLOVER))
1167 continue; /* key is still pressed */
1168
1169 key = applespi_code_to_key(applespi->last_keys_pressed[i],
1170 applespi->last_keys_fn_pressed[i]);
1171 input_report_key(applespi->keyboard_input_dev, key, 0);
1172 applespi->last_keys_fn_pressed[i] = 0;
1173 }
1174
1175 /* check pressed keys */
1176 for (i = 0; i < MAX_ROLLOVER; i++) {
1177 if (keyboard_protocol->keys_pressed[i] <
1178 ARRAY_SIZE(applespi_scancodes) &&
1179 keyboard_protocol->keys_pressed[i] > 0) {
1180 key = applespi_code_to_key(
1181 keyboard_protocol->keys_pressed[i],
1182 keyboard_protocol->fn_pressed);
1183 input_report_key(applespi->keyboard_input_dev, key, 1);
1184 applespi->last_keys_fn_pressed[i] =
1185 keyboard_protocol->fn_pressed;
1186 }
1187 }
1188
1189 /* check control keys */
1190 for (i = 0; i < ARRAY_SIZE(applespi_controlcodes); i++) {
1191 if (keyboard_protocol->modifiers & BIT(i))
1192 input_report_key(applespi->keyboard_input_dev,
1193 applespi_controlcodes[i], 1);
1194 else
1195 input_report_key(applespi->keyboard_input_dev,
1196 applespi_controlcodes[i], 0);
1197 }
1198
1199 /* check function key */
1200 if (keyboard_protocol->fn_pressed && !applespi->last_fn_pressed)
1201 input_report_key(applespi->keyboard_input_dev, KEY_FN, 1);
1202 else if (!keyboard_protocol->fn_pressed && applespi->last_fn_pressed)
1203 input_report_key(applespi->keyboard_input_dev, KEY_FN, 0);
1204 applespi->last_fn_pressed = keyboard_protocol->fn_pressed;
1205
1206 /* done */
1207 input_sync(applespi->keyboard_input_dev);
1208 memcpy(&applespi->last_keys_pressed, keyboard_protocol->keys_pressed,
1209 sizeof(applespi->last_keys_pressed));
1210 }
1211
applespi_find_touchpad_info(u8 model)1212 static const struct applespi_tp_info *applespi_find_touchpad_info(u8 model)
1213 {
1214 const struct applespi_tp_model_info *info;
1215
1216 for (info = applespi_tp_models; info->model; info++) {
1217 if (info->model == model)
1218 return &info->tp_info;
1219 }
1220
1221 return NULL;
1222 }
1223
1224 static int
applespi_register_touchpad_device(struct applespi_data * applespi,struct touchpad_info_protocol * rcvd_tp_info)1225 applespi_register_touchpad_device(struct applespi_data *applespi,
1226 struct touchpad_info_protocol *rcvd_tp_info)
1227 {
1228 const struct applespi_tp_info *tp_info;
1229 struct input_dev *touchpad_input_dev;
1230 int sts;
1231
1232 /* set up touchpad dimensions */
1233 tp_info = applespi_find_touchpad_info(rcvd_tp_info->model_no);
1234 if (!tp_info) {
1235 dev_warn(&applespi->spi->dev,
1236 "Unknown touchpad model %x - falling back to MB8 touchpad\n",
1237 rcvd_tp_info->model_no);
1238 tp_info = &applespi_tp_models[0].tp_info;
1239 }
1240
1241 applespi->tp_info = *tp_info;
1242
1243 if (touchpad_dimensions[0]) {
1244 int x, y, w, h;
1245
1246 sts = sscanf(touchpad_dimensions, "%dx%d+%u+%u", &x, &y, &w, &h);
1247 if (sts == 4) {
1248 dev_info(&applespi->spi->dev,
1249 "Overriding touchpad dimensions from module param\n");
1250 applespi->tp_info.x_min = x;
1251 applespi->tp_info.y_min = y;
1252 applespi->tp_info.x_max = x + w;
1253 applespi->tp_info.y_max = y + h;
1254 } else {
1255 dev_warn(&applespi->spi->dev,
1256 "Invalid touchpad dimensions '%s': must be in the form XxY+W+H\n",
1257 touchpad_dimensions);
1258 touchpad_dimensions[0] = '\0';
1259 }
1260 }
1261 if (!touchpad_dimensions[0]) {
1262 snprintf(touchpad_dimensions, sizeof(touchpad_dimensions),
1263 "%dx%d+%u+%u",
1264 applespi->tp_info.x_min,
1265 applespi->tp_info.y_min,
1266 applespi->tp_info.x_max - applespi->tp_info.x_min,
1267 applespi->tp_info.y_max - applespi->tp_info.y_min);
1268 }
1269
1270 /* create touchpad input device */
1271 touchpad_input_dev = devm_input_allocate_device(&applespi->spi->dev);
1272 if (!touchpad_input_dev) {
1273 dev_err(&applespi->spi->dev,
1274 "Failed to allocate touchpad input device\n");
1275 return -ENOMEM;
1276 }
1277
1278 touchpad_input_dev->name = "Apple SPI Touchpad";
1279 touchpad_input_dev->phys = "applespi/input1";
1280 touchpad_input_dev->dev.parent = &applespi->spi->dev;
1281 touchpad_input_dev->id.bustype = BUS_SPI;
1282 touchpad_input_dev->id.vendor = SYNAPTICS_VENDOR_ID;
1283 touchpad_input_dev->id.product =
1284 rcvd_tp_info->model_no << 8 | rcvd_tp_info->model_flags;
1285
1286 /* basic properties */
1287 input_set_capability(touchpad_input_dev, EV_REL, REL_X);
1288 input_set_capability(touchpad_input_dev, EV_REL, REL_Y);
1289
1290 __set_bit(INPUT_PROP_POINTER, touchpad_input_dev->propbit);
1291 __set_bit(INPUT_PROP_BUTTONPAD, touchpad_input_dev->propbit);
1292
1293 /* finger touch area */
1294 input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MAJOR,
1295 0, 5000, 0, 0);
1296 input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MINOR,
1297 0, 5000, 0, 0);
1298
1299 /* finger approach area */
1300 input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MAJOR,
1301 0, 5000, 0, 0);
1302 input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MINOR,
1303 0, 5000, 0, 0);
1304
1305 /* finger orientation */
1306 input_set_abs_params(touchpad_input_dev, ABS_MT_ORIENTATION,
1307 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION,
1308 0, 0);
1309
1310 /* finger position */
1311 input_set_abs_params(touchpad_input_dev, ABS_MT_POSITION_X,
1312 applespi->tp_info.x_min, applespi->tp_info.x_max,
1313 0, 0);
1314 input_set_abs_params(touchpad_input_dev, ABS_MT_POSITION_Y,
1315 applespi->tp_info.y_min, applespi->tp_info.y_max,
1316 0, 0);
1317
1318 /* touchpad button */
1319 input_set_capability(touchpad_input_dev, EV_KEY, BTN_LEFT);
1320
1321 /* multitouch */
1322 sts = input_mt_init_slots(touchpad_input_dev, MAX_FINGERS,
1323 INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
1324 INPUT_MT_TRACK);
1325 if (sts) {
1326 dev_err(&applespi->spi->dev,
1327 "failed to initialize slots: %d", sts);
1328 return sts;
1329 }
1330
1331 /* register input device */
1332 sts = input_register_device(touchpad_input_dev);
1333 if (sts) {
1334 dev_err(&applespi->spi->dev,
1335 "Unable to register touchpad input device (%d)\n", sts);
1336 return sts;
1337 }
1338
1339 /* touchpad_input_dev is read async in spi callback */
1340 smp_store_release(&applespi->touchpad_input_dev, touchpad_input_dev);
1341
1342 return 0;
1343 }
1344
applespi_worker(struct work_struct * work)1345 static void applespi_worker(struct work_struct *work)
1346 {
1347 struct applespi_data *applespi =
1348 container_of(work, struct applespi_data, work);
1349
1350 applespi_register_touchpad_device(applespi, &applespi->rcvd_tp_info);
1351 }
1352
applespi_handle_cmd_response(struct applespi_data * applespi,struct spi_packet * packet,struct message * message)1353 static void applespi_handle_cmd_response(struct applespi_data *applespi,
1354 struct spi_packet *packet,
1355 struct message *message)
1356 {
1357 if (packet->device == PACKET_DEV_INFO &&
1358 le16_to_cpu(message->type) == 0x1020) {
1359 /*
1360 * We're not allowed to sleep here, but registering an input
1361 * device can sleep.
1362 */
1363 applespi->rcvd_tp_info = message->tp_info;
1364 schedule_work(&applespi->work);
1365 return;
1366 }
1367
1368 if (le16_to_cpu(message->length) != 0x0000) {
1369 dev_warn_ratelimited(&applespi->spi->dev,
1370 "Received unexpected write response: length=%x\n",
1371 le16_to_cpu(message->length));
1372 return;
1373 }
1374
1375 if (packet->device == PACKET_DEV_TPAD &&
1376 le16_to_cpu(message->type) == 0x0252 &&
1377 le16_to_cpu(message->rsp_buf_len) == 0x0002)
1378 dev_info(&applespi->spi->dev, "modeswitch done.\n");
1379 }
1380
applespi_verify_crc(struct applespi_data * applespi,u8 * buffer,size_t buflen)1381 static bool applespi_verify_crc(struct applespi_data *applespi, u8 *buffer,
1382 size_t buflen)
1383 {
1384 u16 crc;
1385
1386 crc = crc16(0, buffer, buflen);
1387 if (crc) {
1388 dev_warn_ratelimited(&applespi->spi->dev,
1389 "Received corrupted packet (crc mismatch)\n");
1390 trace_applespi_bad_crc(ET_RD_CRC, READ, buffer, buflen);
1391
1392 return false;
1393 }
1394
1395 return true;
1396 }
1397
applespi_debug_print_read_packet(struct applespi_data * applespi,struct spi_packet * packet)1398 static void applespi_debug_print_read_packet(struct applespi_data *applespi,
1399 struct spi_packet *packet)
1400 {
1401 unsigned int evt_type;
1402
1403 if (packet->flags == PACKET_TYPE_READ &&
1404 packet->device == PACKET_DEV_KEYB)
1405 evt_type = ET_RD_KEYB;
1406 else if (packet->flags == PACKET_TYPE_READ &&
1407 packet->device == PACKET_DEV_TPAD)
1408 evt_type = ET_RD_TPAD;
1409 else if (packet->flags == PACKET_TYPE_WRITE)
1410 evt_type = applespi->cmd_evt_type;
1411 else
1412 evt_type = ET_RD_UNKN;
1413
1414 applespi_get_trace_fun(evt_type)(evt_type, PT_READ, applespi->rx_buffer,
1415 APPLESPI_PACKET_SIZE);
1416 }
1417
applespi_got_data(struct applespi_data * applespi)1418 static void applespi_got_data(struct applespi_data *applespi)
1419 {
1420 struct spi_packet *packet;
1421 struct message *message;
1422 unsigned int msg_len;
1423 unsigned int off;
1424 unsigned int rem;
1425 unsigned int len;
1426
1427 /* process packet header */
1428 if (!applespi_verify_crc(applespi, applespi->rx_buffer,
1429 APPLESPI_PACKET_SIZE)) {
1430 unsigned long flags;
1431
1432 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1433
1434 if (applespi->drain) {
1435 applespi->read_active = false;
1436 applespi->write_active = false;
1437
1438 wake_up_all(&applespi->drain_complete);
1439 }
1440
1441 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1442
1443 return;
1444 }
1445
1446 packet = (struct spi_packet *)applespi->rx_buffer;
1447
1448 applespi_debug_print_read_packet(applespi, packet);
1449
1450 off = le16_to_cpu(packet->offset);
1451 rem = le16_to_cpu(packet->remaining);
1452 len = le16_to_cpu(packet->length);
1453
1454 if (len > sizeof(packet->data)) {
1455 dev_warn_ratelimited(&applespi->spi->dev,
1456 "Received corrupted packet (invalid packet length %u)\n",
1457 len);
1458 goto msg_complete;
1459 }
1460
1461 /* handle multi-packet messages */
1462 if (rem > 0 || off > 0) {
1463 if (off != applespi->saved_msg_len) {
1464 dev_warn_ratelimited(&applespi->spi->dev,
1465 "Received unexpected offset (got %u, expected %u)\n",
1466 off, applespi->saved_msg_len);
1467 goto msg_complete;
1468 }
1469
1470 if (off + rem > MAX_PKTS_PER_MSG * APPLESPI_PACKET_SIZE) {
1471 dev_warn_ratelimited(&applespi->spi->dev,
1472 "Received message too large (size %u)\n",
1473 off + rem);
1474 goto msg_complete;
1475 }
1476
1477 if (off + len > MAX_PKTS_PER_MSG * APPLESPI_PACKET_SIZE) {
1478 dev_warn_ratelimited(&applespi->spi->dev,
1479 "Received message too large (size %u)\n",
1480 off + len);
1481 goto msg_complete;
1482 }
1483
1484 memcpy(applespi->msg_buf + off, &packet->data, len);
1485 applespi->saved_msg_len += len;
1486
1487 if (rem > 0)
1488 return;
1489
1490 message = (struct message *)applespi->msg_buf;
1491 msg_len = applespi->saved_msg_len;
1492 } else {
1493 message = (struct message *)&packet->data;
1494 msg_len = len;
1495 }
1496
1497 /* got complete message - verify */
1498 if (!applespi_verify_crc(applespi, (u8 *)message, msg_len))
1499 goto msg_complete;
1500
1501 if (le16_to_cpu(message->length) != msg_len - MSG_HEADER_SIZE - 2) {
1502 dev_warn_ratelimited(&applespi->spi->dev,
1503 "Received corrupted packet (invalid message length %u - expected %u)\n",
1504 le16_to_cpu(message->length),
1505 msg_len - MSG_HEADER_SIZE - 2);
1506 goto msg_complete;
1507 }
1508
1509 /* handle message */
1510 if (packet->flags == PACKET_TYPE_READ &&
1511 packet->device == PACKET_DEV_KEYB) {
1512 applespi_handle_keyboard_event(applespi, &message->keyboard);
1513
1514 } else if (packet->flags == PACKET_TYPE_READ &&
1515 packet->device == PACKET_DEV_TPAD) {
1516 struct touchpad_protocol *tp;
1517 size_t tp_len;
1518
1519 tp = &message->touchpad;
1520 tp_len = struct_size(tp, fingers, tp->number_of_fingers);
1521
1522 if (le16_to_cpu(message->length) + 2 != tp_len) {
1523 dev_warn_ratelimited(&applespi->spi->dev,
1524 "Received corrupted packet (invalid message length %u - num-fingers %u, tp-len %zu)\n",
1525 le16_to_cpu(message->length),
1526 tp->number_of_fingers, tp_len);
1527 goto msg_complete;
1528 }
1529
1530 if (tp->number_of_fingers > MAX_FINGERS) {
1531 dev_warn_ratelimited(&applespi->spi->dev,
1532 "Number of reported fingers (%u) exceeds max (%u))\n",
1533 tp->number_of_fingers,
1534 MAX_FINGERS);
1535 tp->number_of_fingers = MAX_FINGERS;
1536 }
1537
1538 report_tp_state(applespi, tp);
1539
1540 } else if (packet->flags == PACKET_TYPE_WRITE) {
1541 applespi_handle_cmd_response(applespi, packet, message);
1542 }
1543
1544 msg_complete:
1545 applespi->saved_msg_len = 0;
1546
1547 applespi_msg_complete(applespi, packet->flags == PACKET_TYPE_WRITE,
1548 true);
1549 }
1550
applespi_async_read_complete(void * context)1551 static void applespi_async_read_complete(void *context)
1552 {
1553 struct applespi_data *applespi = context;
1554
1555 if (applespi->rd_m.status < 0) {
1556 dev_warn(&applespi->spi->dev, "Error reading from device: %d\n",
1557 applespi->rd_m.status);
1558 /*
1559 * We don't actually know if this was a pure read, or a response
1560 * to a write. But this is a rare error condition that should
1561 * never occur, so clearing both flags to avoid deadlock.
1562 */
1563 applespi_msg_complete(applespi, true, true);
1564 } else {
1565 applespi_got_data(applespi);
1566 }
1567
1568 acpi_finish_gpe(NULL, applespi->gpe);
1569 }
1570
applespi_notify(acpi_handle gpe_device,u32 gpe,void * context)1571 static u32 applespi_notify(acpi_handle gpe_device, u32 gpe, void *context)
1572 {
1573 struct applespi_data *applespi = context;
1574 int sts;
1575 unsigned long flags;
1576
1577 trace_applespi_irq_received(ET_RD_IRQ, PT_READ);
1578
1579 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1580
1581 if (!applespi->suspended) {
1582 sts = applespi_async(applespi, &applespi->rd_m,
1583 applespi_async_read_complete);
1584 if (sts)
1585 dev_warn(&applespi->spi->dev,
1586 "Error queueing async read to device: %d\n",
1587 sts);
1588 else
1589 applespi->read_active = true;
1590 }
1591
1592 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1593
1594 return ACPI_INTERRUPT_HANDLED;
1595 }
1596
applespi_get_saved_bl_level(struct applespi_data * applespi)1597 static int applespi_get_saved_bl_level(struct applespi_data *applespi)
1598 {
1599 efi_status_t sts = EFI_NOT_FOUND;
1600 u16 efi_data = 0;
1601 unsigned long efi_data_len = sizeof(efi_data);
1602
1603 if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE))
1604 sts = efi.get_variable(EFI_BL_LEVEL_NAME, &EFI_BL_LEVEL_GUID,
1605 NULL, &efi_data_len, &efi_data);
1606 if (sts != EFI_SUCCESS && sts != EFI_NOT_FOUND)
1607 dev_warn(&applespi->spi->dev,
1608 "Error getting backlight level from EFI vars: 0x%lx\n",
1609 sts);
1610
1611 return sts != EFI_SUCCESS ? -ENODEV : efi_data;
1612 }
1613
applespi_save_bl_level(struct applespi_data * applespi,unsigned int level)1614 static void applespi_save_bl_level(struct applespi_data *applespi,
1615 unsigned int level)
1616 {
1617 efi_status_t sts = EFI_UNSUPPORTED;
1618 u32 efi_attr;
1619 u16 efi_data;
1620
1621 efi_data = (u16)level;
1622 efi_attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS |
1623 EFI_VARIABLE_RUNTIME_ACCESS;
1624
1625 if (efi_rt_services_supported(EFI_RT_SUPPORTED_SET_VARIABLE))
1626 sts = efi.set_variable(EFI_BL_LEVEL_NAME, &EFI_BL_LEVEL_GUID,
1627 efi_attr, sizeof(efi_data), &efi_data);
1628 if (sts != EFI_SUCCESS)
1629 dev_warn(&applespi->spi->dev,
1630 "Error saving backlight level to EFI vars: 0x%lx\n", sts);
1631 }
1632
applespi_probe(struct spi_device * spi)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
applespi_drain_writes(struct applespi_data * applespi)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
applespi_drain_reads(struct applespi_data * applespi)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
applespi_remove(struct spi_device * spi)1846 static void 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
applespi_shutdown(struct spi_device * spi)1861 static void applespi_shutdown(struct spi_device *spi)
1862 {
1863 struct applespi_data *applespi = spi_get_drvdata(spi);
1864
1865 applespi_save_bl_level(applespi, applespi->have_bl_level);
1866 }
1867
applespi_poweroff_late(struct device * dev)1868 static int applespi_poweroff_late(struct device *dev)
1869 {
1870 struct spi_device *spi = to_spi_device(dev);
1871 struct applespi_data *applespi = spi_get_drvdata(spi);
1872
1873 applespi_save_bl_level(applespi, applespi->have_bl_level);
1874
1875 return 0;
1876 }
1877
applespi_suspend(struct device * dev)1878 static int applespi_suspend(struct device *dev)
1879 {
1880 struct spi_device *spi = to_spi_device(dev);
1881 struct applespi_data *applespi = spi_get_drvdata(spi);
1882 acpi_status acpi_sts;
1883 int sts;
1884
1885 /* turn off caps-lock - it'll stay on otherwise */
1886 sts = applespi_set_capsl_led(applespi, false);
1887 if (sts)
1888 dev_warn(&applespi->spi->dev,
1889 "Failed to turn off caps-lock led (%d)\n", sts);
1890
1891 applespi_drain_writes(applespi);
1892
1893 /* disable the interrupt */
1894 acpi_sts = acpi_disable_gpe(NULL, applespi->gpe);
1895 if (ACPI_FAILURE(acpi_sts))
1896 dev_err(&applespi->spi->dev,
1897 "Failed to disable GPE handler for GPE %d: %s\n",
1898 applespi->gpe, acpi_format_exception(acpi_sts));
1899
1900 applespi_drain_reads(applespi);
1901
1902 return 0;
1903 }
1904
applespi_resume(struct device * dev)1905 static int applespi_resume(struct device *dev)
1906 {
1907 struct spi_device *spi = to_spi_device(dev);
1908 struct applespi_data *applespi = spi_get_drvdata(spi);
1909 acpi_status acpi_sts;
1910 unsigned long flags;
1911
1912 /* ensure our flags and state reflect a newly resumed device */
1913 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1914
1915 applespi->drain = false;
1916 applespi->have_cl_led_on = false;
1917 applespi->have_bl_level = 0;
1918 applespi->cmd_msg_queued = 0;
1919 applespi->read_active = false;
1920 applespi->write_active = false;
1921
1922 applespi->suspended = false;
1923
1924 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1925
1926 /* switch on the SPI interface */
1927 applespi_enable_spi(applespi);
1928
1929 /* re-enable the interrupt */
1930 acpi_sts = acpi_enable_gpe(NULL, applespi->gpe);
1931 if (ACPI_FAILURE(acpi_sts))
1932 dev_err(&applespi->spi->dev,
1933 "Failed to re-enable GPE handler for GPE %d: %s\n",
1934 applespi->gpe, acpi_format_exception(acpi_sts));
1935
1936 /* switch the touchpad into multitouch mode */
1937 applespi_init(applespi, true);
1938
1939 return 0;
1940 }
1941
1942 static const struct acpi_device_id applespi_acpi_match[] = {
1943 { "APP000D", 0 },
1944 { }
1945 };
1946 MODULE_DEVICE_TABLE(acpi, applespi_acpi_match);
1947
1948 static const struct dev_pm_ops applespi_pm_ops = {
1949 SYSTEM_SLEEP_PM_OPS(applespi_suspend, applespi_resume)
1950 .poweroff_late = pm_sleep_ptr(applespi_poweroff_late),
1951 };
1952
1953 static struct spi_driver applespi_driver = {
1954 .driver = {
1955 .name = "applespi",
1956 .acpi_match_table = applespi_acpi_match,
1957 .pm = pm_sleep_ptr(&applespi_pm_ops),
1958 },
1959 .probe = applespi_probe,
1960 .remove = applespi_remove,
1961 .shutdown = applespi_shutdown,
1962 };
1963
1964 module_spi_driver(applespi_driver)
1965
1966 MODULE_LICENSE("GPL v2");
1967 MODULE_DESCRIPTION("MacBook(Pro) SPI Keyboard/Touchpad driver");
1968 MODULE_AUTHOR("Federico Lorenzi");
1969 MODULE_AUTHOR("Ronald Tschalär");
1970