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