1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* MacBook (Pro) SPI keyboard and touchpad driver
4	*
5	* Copyright (c) 2015-2018 Federico Lorenzi
6	* Copyright (c) 2017-2018 Ronald Tschalär
7	*/
8
9	/*
10	* The keyboard and touchpad controller on the MacBookAir6, MacBookPro12,
11	* MacBook8 and newer can be driven either by USB or SPI. However the USB
12	* pins are only connected on the MacBookAir6 and 7 and the MacBookPro12.
13	* All others need this driver. The interface is selected using ACPI methods:
14	*
15	* * UIEN ("USB Interface Enable"): If invoked with argument 1, disables SPI
16	* and enables USB. If invoked with argument 0, disables USB.
17	* * UIST ("USB Interface Status"): Returns 1 if USB is enabled, 0 otherwise.
18	* * SIEN ("SPI Interface Enable"): If invoked with argument 1, disables USB
19	* and enables SPI. If invoked with argument 0, disables SPI.
20	* * SIST ("SPI Interface Status"): Returns 1 if SPI is enabled, 0 otherwise.
21	* * ISOL: Resets the four GPIO pins used for SPI. Intended to be invoked with
22	* argument 1, then once more with argument 0.
23	*
24	* UIEN and UIST are only provided on models where the USB pins are connected.
25	*
26	* SPI-based Protocol
27	* ------------------
28	*
29	* The device and driver exchange messages (struct message); each message is
30	* encapsulated in one or more packets (struct spi_packet). There are two types
31	* of exchanges: reads, and writes. A read is signaled by a GPE, upon which one
32	* message can be read from the device. A write exchange consists of writing a
33	* command message, immediately reading a short status packet, and then, upon
34	* receiving a GPE, reading the response message. Write exchanges cannot be
35	* interleaved, i.e. a new write exchange must not be started till the previous
36	* write exchange is complete. Whether a received message is part of a read or
37	* write exchange is indicated in the encapsulating packet's flags field.
38	*
39	* A single message may be too large to fit in a single packet (which has a
40	* fixed, 256-byte size). In that case it will be split over multiple,
41	* consecutive packets.
42	*/
43
44	#include <linux/acpi.h>
45	#include <linux/crc16.h>
46	#include <linux/debugfs.h>
47	#include <linux/delay.h>
48	#include <linux/efi.h>
49	#include <linux/input.h>
50	#include <linux/input/mt.h>
51	#include <linux/ktime.h>
52	#include <linux/leds.h>
53	#include <linux/module.h>
54	#include <linux/spinlock.h>
55	#include <linux/spi/spi.h>
56	#include <linux/wait.h>
57	#include <linux/workqueue.h>
58
59	#include <asm/barrier.h>
60	#include <asm/unaligned.h>
61
62	#define CREATE_TRACE_POINTS
63	#include "applespi.h"
64	#include "applespi_trace.h"
65
66	#define APPLESPI_PACKET_SIZE 256
67	#define APPLESPI_STATUS_SIZE 4
68
69	#define PACKET_TYPE_READ 0x20
70	#define PACKET_TYPE_WRITE 0x40
71	#define PACKET_DEV_KEYB 0x01
72	#define PACKET_DEV_TPAD 0x02
73	#define PACKET_DEV_INFO 0xd0
74
75	#define MAX_ROLLOVER 6
76
77	#define MAX_FINGERS 11
78	#define MAX_FINGER_ORIENTATION 16384
79	#define MAX_PKTS_PER_MSG 2
80
81	#define KBD_BL_LEVEL_MIN 32U
82	#define KBD_BL_LEVEL_MAX 255U
83	#define KBD_BL_LEVEL_SCALE 1000000U
84	#define KBD_BL_LEVEL_ADJ \
85	((KBD_BL_LEVEL_MAX - KBD_BL_LEVEL_MIN) * KBD_BL_LEVEL_SCALE / 255U)
86
87	#define EFI_BL_LEVEL_NAME L"KeyboardBacklightLevel"
88	#define EFI_BL_LEVEL_GUID EFI_GUID(0xa076d2af, 0x9678, 0x4386, 0x8b, 0x58, 0x1f, 0xc8, 0xef, 0x04, 0x16, 0x19)
89
90	#define APPLE_FLAG_FKEY 0x01
91
92	#define SPI_RW_CHG_DELAY_US 100 /* from experimentation, in µs */
93
94	#define SYNAPTICS_VENDOR_ID 0x06cb
95
96	static unsigned int fnmode = 1;
97	module_param(fnmode, uint, 0644);
98	MODULE_PARM_DESC(fnmode, "Mode of Fn key on Apple keyboards (0 = disabled, [1] = fkeyslast, 2 = fkeysfirst)");
99
100	static unsigned int fnremap;
101	module_param(fnremap, uint, 0644);
102	MODULE_PARM_DESC(fnremap, "Remap Fn key ([0] = no-remap; 1 = left-ctrl, 2 = left-shift, 3 = left-alt, 4 = left-meta, 6 = right-shift, 7 = right-alt, 8 = right-meta)");
103
104	static bool iso_layout;
105	module_param(iso_layout, bool, 0644);
106	MODULE_PARM_DESC(iso_layout, "Enable/Disable hardcoded ISO-layout of the keyboard. ([0] = disabled, 1 = enabled)");
107
108	static char touchpad_dimensions[40];
109	module_param_string(touchpad_dimensions, touchpad_dimensions,
110	sizeof(touchpad_dimensions), 0444);
111	MODULE_PARM_DESC(touchpad_dimensions, "The pixel dimensions of the touchpad, as XxY+W+H .");
112
113	/**
114	* struct keyboard_protocol - keyboard message.
115	* message.type = 0x0110, message.length = 0x000a
116	*
117	* @unknown1: unknown
118	* @modifiers: bit-set of modifier/control keys pressed
119	* @unknown2: unknown
120	* @keys_pressed: the (non-modifier) keys currently pressed
121	* @fn_pressed: whether the fn key is currently pressed
122	* @crc16: crc over the whole message struct (message header +
123	* this struct) minus this @crc16 field
124	*/
125	struct keyboard_protocol {
126	u8 unknown1;
127	u8 modifiers;
128	u8 unknown2;
129	u8 keys_pressed[MAX_ROLLOVER];
130	u8 fn_pressed;
131	__le16 crc16;
132	};
133
134	/**
135	* struct tp_finger - single trackpad finger structure, le16-aligned
136	*
137	* @origin: zero when switching track finger
138	* @abs_x: absolute x coordinate
139	* @abs_y: absolute y coordinate
140	* @rel_x: relative x coordinate
141	* @rel_y: relative y coordinate
142	* @tool_major: tool area, major axis
143	* @tool_minor: tool area, minor axis
144	* @orientation: 16384 when point, else 15 bit angle
145	* @touch_major: touch area, major axis
146	* @touch_minor: touch area, minor axis
147	* @unused: zeros
148	* @pressure: pressure on forcetouch touchpad
149	* @multi: one finger: varies, more fingers: constant
150	* @crc16: on last finger: crc over the whole message struct
151	* (i.e. message header + this struct) minus the last
152	* @crc16 field; unknown on all other fingers.
153	*/
154	struct tp_finger {
155	__le16 origin;
156	__le16 abs_x;
157	__le16 abs_y;
158	__le16 rel_x;
159	__le16 rel_y;
160	__le16 tool_major;
161	__le16 tool_minor;
162	__le16 orientation;
163	__le16 touch_major;
164	__le16 touch_minor;
165	__le16 unused[2];
166	__le16 pressure;
167	__le16 multi;
168	__le16 crc16;
169	};
170
171	/**
172	* struct touchpad_protocol - touchpad message.
173	* message.type = 0x0210
174	*
175	* @unknown1: unknown
176	* @clicked: 1 if a button-click was detected, 0 otherwise
177	* @unknown2: unknown
178	* @number_of_fingers: the number of fingers being reported in @fingers
179	* @clicked2: same as @clicked
180	* @unknown3: unknown
181	* @fingers: the data for each finger
182	*/
183	struct touchpad_protocol {
184	u8 unknown1[1];
185	u8 clicked;
186	u8 unknown2[28];
187	u8 number_of_fingers;
188	u8 clicked2;
189	u8 unknown3[16];
190	struct tp_finger fingers[];
191	};
192
193	/**
194	* struct command_protocol_tp_info - get touchpad info.
195	* message.type = 0x1020, message.length = 0x0000
196	*
197	* @crc16: crc over the whole message struct (message header +
198	* this struct) minus this @crc16 field
199	*/
200	struct command_protocol_tp_info {
201	__le16 crc16;
202	};
203
204	/**
205	* struct touchpad_info_protocol - touchpad info response.
206	* message.type = 0x1020, message.length = 0x006e
207	*
208	* @unknown1: unknown
209	* @model_flags: flags (vary by model number, but significance otherwise
210	* unknown)
211	* @model_no: the touchpad model number
212	* @unknown2: unknown
213	* @crc16: crc over the whole message struct (message header +
214	* this struct) minus this @crc16 field
215	*/
216	struct touchpad_info_protocol {
217	u8 unknown1[105];
218	u8 model_flags;
219	u8 model_no;
220	u8 unknown2[3];
221	__le16 crc16;
222	};
223
224	/**
225	* struct command_protocol_mt_init - initialize multitouch.
226	* message.type = 0x0252, message.length = 0x0002
227	*
228	* @cmd: value: 0x0102
229	* @crc16: crc over the whole message struct (message header +
230	* this struct) minus this @crc16 field
231	*/
232	struct command_protocol_mt_init {
233	__le16 cmd;
234	__le16 crc16;
235	};
236
237	/**
238	* struct command_protocol_capsl - toggle caps-lock led
239	* message.type = 0x0151, message.length = 0x0002
240	*
241	* @unknown: value: 0x01 (length?)
242	* @led: 0 off, 2 on
243	* @crc16: crc over the whole message struct (message header +
244	* this struct) minus this @crc16 field
245	*/
246	struct command_protocol_capsl {
247	u8 unknown;
248	u8 led;
249	__le16 crc16;
250	};
251
252	/**
253	* struct command_protocol_bl - set keyboard backlight brightness
254	* message.type = 0xB051, message.length = 0x0006
255	*
256	* @const1: value: 0x01B0
257	* @level: the brightness level to set
258	* @const2: value: 0x0001 (backlight off), 0x01F4 (backlight on)
259	* @crc16: crc over the whole message struct (message header +
260	* this struct) minus this @crc16 field
261	*/
262	struct command_protocol_bl {
263	__le16 const1;
264	__le16 level;
265	__le16 const2;
266	__le16 crc16;
267	};
268
269	/**
270	* struct message - a complete spi message.
271	*
272	* Each message begins with fixed header, followed by a message-type specific
273	* payload, and ends with a 16-bit crc. Because of the varying lengths of the
274	* payload, the crc is defined at the end of each payload struct, rather than
275	* in this struct.
276	*
277	* @type: the message type
278	* @zero: always 0
279	* @counter: incremented on each message, rolls over after 255; there is a
280	* separate counter for each message type.
281	* @rsp_buf_len:response buffer length (the exact nature of this field is quite
282	* speculative). On a request/write this is often the same as
283	* @length, though in some cases it has been seen to be much larger
284	* (e.g. 0x400); on a response/read this the same as on the
285	* request; for reads that are not responses it is 0.
286	* @length: length of the remainder of the data in the whole message
287	* structure (after re-assembly in case of being split over
288	* multiple spi-packets), minus the trailing crc. The total size
289	* of the message struct is therefore @length + 10.
290	*
291	* @keyboard: Keyboard message
292	* @touchpad: Touchpad message
293	* @tp_info: Touchpad info (response)
294	* @tp_info_command: Touchpad info (CRC)
295	* @init_mt_command: Initialise Multitouch
296	* @capsl_command: Toggle caps-lock LED
297	* @bl_command: Keyboard brightness
298	* @data: Buffer data
299	*/
300	struct message {
301	__le16 type;
302	u8 zero;
303	u8 counter;
304	__le16 rsp_buf_len;
305	__le16 length;
306	union {
307	struct keyboard_protocol keyboard;
308	struct touchpad_protocol touchpad;
309	struct touchpad_info_protocol tp_info;
310	struct command_protocol_tp_info tp_info_command;
311	struct command_protocol_mt_init init_mt_command;
312	struct command_protocol_capsl capsl_command;
313	struct command_protocol_bl bl_command;
314	DECLARE_FLEX_ARRAY(u8, data);
315	};
316	};
317
318	/* type + zero + counter + rsp_buf_len + length */
319	#define MSG_HEADER_SIZE 8
320
321	/**
322	* struct spi_packet - a complete spi packet; always 256 bytes. This carries
323	* the (parts of the) message in the data. But note that this does not
324	* necessarily contain a complete message, as in some cases (e.g. many
325	* fingers pressed) the message is split over multiple packets (see the
326	* @offset, @remaining, and @length fields). In general the data parts in
327	* spi_packet's are concatenated until @remaining is 0, and the result is an
328	* message.
329	*
330	* @flags: 0x40 = write (to device), 0x20 = read (from device); note that
331	* the response to a write still has 0x40.
332	* @device: 1 = keyboard, 2 = touchpad
333	* @offset: specifies the offset of this packet's data in the complete
334	* message; i.e. > 0 indicates this is a continuation packet (in
335	* the second packet for a message split over multiple packets
336	* this would then be the same as the @length in the first packet)
337	* @remaining: number of message bytes remaining in subsequents packets (in
338	* the first packet of a message split over two packets this would
339	* then be the same as the @length in the second packet)
340	* @length: length of the valid data in the @data in this packet
341	* @data: all or part of a message
342	* @crc16: crc over this whole structure minus this @crc16 field. This
343	* covers just this packet, even on multi-packet messages (in
344	* contrast to the crc in the message).
345	*/
346	struct spi_packet {
347	u8 flags;
348	u8 device;
349	__le16 offset;
350	__le16 remaining;
351	__le16 length;
352	u8 data[246];
353	__le16 crc16;
354	};
355
356	struct spi_settings {
357	u64 spi_cs_delay; /* cs-to-clk delay in us */
358	u64 reset_a2r_usec; /* active-to-receive delay? */
359	u64 reset_rec_usec; /* ? (cur val: 10) */
360	};
361
362	/* this mimics struct drm_rect */
363	struct applespi_tp_info {
364	int x_min;
365	int y_min;
366	int x_max;
367	int y_max;
368	};
369
370	struct applespi_data {
371	struct spi_device *spi;
372	struct spi_settings spi_settings;
373	struct input_dev *keyboard_input_dev;
374	struct input_dev *touchpad_input_dev;
375
376	u8 *tx_buffer;
377	u8 *tx_status;
378	u8 *rx_buffer;
379
380	u8 *msg_buf;
381	unsigned int saved_msg_len;
382
383	struct applespi_tp_info tp_info;
384
385	u8 last_keys_pressed[MAX_ROLLOVER];
386	u8 last_keys_fn_pressed[MAX_ROLLOVER];
387	u8 last_fn_pressed;
388	struct input_mt_pos pos[MAX_FINGERS];
389	int slots[MAX_FINGERS];
390	int gpe;
391	acpi_handle sien;
392	acpi_handle sist;
393
394	struct spi_transfer dl_t;
395	struct spi_transfer rd_t;
396	struct spi_message rd_m;
397
398	struct spi_transfer ww_t;
399	struct spi_transfer wd_t;
400	struct spi_transfer wr_t;
401	struct spi_transfer st_t;
402	struct spi_message wr_m;
403
404	bool want_tp_info_cmd;
405	bool want_mt_init_cmd;
406	bool want_cl_led_on;
407	bool have_cl_led_on;
408	unsigned int want_bl_level;
409	unsigned int have_bl_level;
410	unsigned int cmd_msg_cntr;
411	/* lock to protect the above parameters and flags below */
412	spinlock_t cmd_msg_lock;
413	ktime_t cmd_msg_queued;
414	enum applespi_evt_type cmd_evt_type;
415
416	struct led_classdev backlight_info;
417
418	bool suspended;
419	bool drain;
420	wait_queue_head_t drain_complete;
421	bool read_active;
422	bool write_active;
423
424	struct work_struct work;
425	struct touchpad_info_protocol rcvd_tp_info;
426
427	struct dentry *debugfs_root;
428	bool debug_tp_dim;
429	char tp_dim_val[40];
430	int tp_dim_min_x;
431	int tp_dim_max_x;
432	int tp_dim_min_y;
433	int tp_dim_max_y;
434	};
435
436	static const unsigned char applespi_scancodes[] = {
437	0, 0, 0, 0,
438	KEY_A, KEY_B, KEY_C, KEY_D, KEY_E, KEY_F, KEY_G, KEY_H, KEY_I, KEY_J,
439	KEY_K, KEY_L, KEY_M, KEY_N, KEY_O, KEY_P, KEY_Q, KEY_R, KEY_S, KEY_T,
440	KEY_U, KEY_V, KEY_W, KEY_X, KEY_Y, KEY_Z,
441	KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0,
442	KEY_ENTER, KEY_ESC, KEY_BACKSPACE, KEY_TAB, KEY_SPACE, KEY_MINUS,
443	KEY_EQUAL, KEY_LEFTBRACE, KEY_RIGHTBRACE, KEY_BACKSLASH, 0,
444	KEY_SEMICOLON, KEY_APOSTROPHE, KEY_GRAVE, KEY_COMMA, KEY_DOT, KEY_SLASH,
445	KEY_CAPSLOCK,
446	KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9,
447	KEY_F10, KEY_F11, KEY_F12, 0, 0, 0, 0, 0, 0, 0, 0, 0,
448	KEY_RIGHT, KEY_LEFT, KEY_DOWN, KEY_UP,
449	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_102ND,
450	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
451	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_RO, 0, KEY_YEN, 0, 0, 0, 0, 0,
452	0, KEY_KATAKANAHIRAGANA, KEY_MUHENKAN
453	};
454
455	/*
456	* This must have exactly as many entries as there are bits in
457	* struct keyboard_protocol.modifiers .
458	*/
459	static const unsigned char applespi_controlcodes[] = {
460	KEY_LEFTCTRL,
461	KEY_LEFTSHIFT,
462	KEY_LEFTALT,
463	KEY_LEFTMETA,
464	0,
465	KEY_RIGHTSHIFT,
466	KEY_RIGHTALT,
467	KEY_RIGHTMETA
468	};
469
470	struct applespi_key_translation {
471	u16 from;
472	u16 to;
473	u8 flags;
474	};
475
476	static const struct applespi_key_translation applespi_fn_codes[] = {
477	{ KEY_BACKSPACE, KEY_DELETE },
478	{ KEY_ENTER, KEY_INSERT },
479	{ KEY_F1, KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
480	{ KEY_F2, KEY_BRIGHTNESSUP, APPLE_FLAG_FKEY },
481	{ KEY_F3, KEY_SCALE, APPLE_FLAG_FKEY },
482	{ KEY_F4, KEY_DASHBOARD, APPLE_FLAG_FKEY },
483	{ KEY_F5, KEY_KBDILLUMDOWN, APPLE_FLAG_FKEY },
484	{ KEY_F6, KEY_KBDILLUMUP, APPLE_FLAG_FKEY },
485	{ KEY_F7, KEY_PREVIOUSSONG, APPLE_FLAG_FKEY },
486	{ KEY_F8, KEY_PLAYPAUSE, APPLE_FLAG_FKEY },
487	{ KEY_F9, KEY_NEXTSONG, APPLE_FLAG_FKEY },
488	{ KEY_F10, KEY_MUTE, APPLE_FLAG_FKEY },
489	{ KEY_F11, KEY_VOLUMEDOWN, APPLE_FLAG_FKEY },
490	{ KEY_F12, KEY_VOLUMEUP, APPLE_FLAG_FKEY },
491	{ KEY_RIGHT, KEY_END },
492	{ KEY_LEFT, KEY_HOME },
493	{ KEY_DOWN, KEY_PAGEDOWN },
494	{ KEY_UP, KEY_PAGEUP },
495	{ }
496	};
497
498	static const struct applespi_key_translation apple_iso_keyboard[] = {
499	{ KEY_GRAVE, KEY_102ND },
500	{ KEY_102ND, KEY_GRAVE },
501	{ }
502	};
503
504	struct applespi_tp_model_info {
505	u16 model;
506	struct applespi_tp_info tp_info;
507	};
508
509	static const struct applespi_tp_model_info applespi_tp_models[] = {
510	{
511	.model = 0x04, /* MB8 MB9 MB10 */
512	.tp_info = { -5087, -182, 5579, 6089 },
513	},
514	{
515	.model = 0x05, /* MBP13,1 MBP13,2 MBP14,1 MBP14,2 */
516	.tp_info = { -6243, -170, 6749, 7685 },
517	},
518	{
519	.model = 0x06, /* MBP13,3 MBP14,3 */
520	.tp_info = { -7456, -163, 7976, 9283 },
521	},
522	{}
523	};
524
525	typedef void (*applespi_trace_fun)(enum applespi_evt_type,
526	enum applespi_pkt_type, u8 *, size_t);
527
528	static applespi_trace_fun applespi_get_trace_fun(enum applespi_evt_type type)
529	{
530	switch (type) {
531	case ET_CMD_TP_INI:
532	return trace_applespi_tp_ini_cmd;
533	case ET_CMD_BL:
534	return trace_applespi_backlight_cmd;
535	case ET_CMD_CL:
536	return trace_applespi_caps_lock_cmd;
537	case ET_RD_KEYB:
538	return trace_applespi_keyboard_data;
539	case ET_RD_TPAD:
540	return trace_applespi_touchpad_data;
541	case ET_RD_UNKN:
542	return trace_applespi_unknown_data;
543	default:
544	WARN_ONCE(1, "Unknown msg type %d", type);
545	return trace_applespi_unknown_data;
546	}
547	}
548
549	static void applespi_setup_read_txfrs(struct applespi_data *applespi)
550	{
551	struct spi_message *msg = &applespi->rd_m;
552	struct spi_transfer *dl_t = &applespi->dl_t;
553	struct spi_transfer *rd_t = &applespi->rd_t;
554
555	memset(dl_t, 0, sizeof(*dl_t));
556	memset(rd_t, 0, sizeof(*rd_t));
557
558	dl_t->delay.value = applespi->spi_settings.spi_cs_delay;
559	dl_t->delay.unit = SPI_DELAY_UNIT_USECS;
560
561	rd_t->rx_buf = applespi->rx_buffer;
562	rd_t->len = APPLESPI_PACKET_SIZE;
563
564	spi_message_init(m: msg);
565	spi_message_add_tail(t: dl_t, m: msg);
566	spi_message_add_tail(t: rd_t, m: 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(m: msg);
604	spi_message_add_tail(t: wt_t, m: msg);
605	spi_message_add_tail(t: dl_t, m: msg);
606	spi_message_add_tail(t: wr_t, m: msg);
607	spi_message_add_tail(t: st_t, m: 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(spi: 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(p: applespi->tx_status, q: 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, name: "spiCSDelay", ACPI_TYPE_BUFFER, obj: &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, name: "resetA2RUsec", ACPI_TYPE_BUFFER, obj: &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, name: "resetRecUsec", ACPI_TYPE_BUFFER, obj: &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(handle: applespi->sist, NULL, NULL,
692	data: &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(handle: applespi->sien, NULL, arg: 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(msecs: 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(lock: &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(type: evt_type)(evt_type, PT_WRITE,
746	applespi->tx_buffer,
747	APPLESPI_PACKET_SIZE);
748	applespi_get_trace_fun(type: 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, sts: 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, is_write_msg: true, is_read_compl: 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(later: ktime_get(), earlier: 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(crc: 0, buffer: (u8 *)message, le16_to_cpu(packet->length) - 2);
869	put_unaligned_le16(val: crc, p: &message->data[msg_len - 2]);
870
871	crc = crc16(crc: 0, buffer: (u8 *)packet, len: sizeof(*packet) - 2);
872	packet->crc16 = cpu_to_le16(crc);
873
874	/* send command */
875	sts = applespi_async(applespi, message: &applespi->wr_m,
876	complete: 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(lock: &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(lock: &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(lock: &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, capslock_on: !!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(buf: applespi->tp_dim_val, size: sizeof(applespi->tp_dim_val),
988	fmt: "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, filp: 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(to: buf, count: len, ppos: off, from: 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(dev: input, slot);
1018	input_mt_report_slot_state(dev: input, MT_TOOL_FINGER, active: true);
1019
1020	input_report_abs(dev: input, ABS_MT_TOUCH_MAJOR,
1021	value: le16_to_int(x: f->touch_major) << 1);
1022	input_report_abs(dev: input, ABS_MT_TOUCH_MINOR,
1023	value: le16_to_int(x: f->touch_minor) << 1);
1024	input_report_abs(dev: input, ABS_MT_WIDTH_MAJOR,
1025	value: le16_to_int(x: f->tool_major) << 1);
1026	input_report_abs(dev: input, ABS_MT_WIDTH_MINOR,
1027	value: le16_to_int(x: f->tool_minor) << 1);
1028	input_report_abs(dev: input, ABS_MT_ORIENTATION,
1029	MAX_FINGER_ORIENTATION - le16_to_int(x: f->orientation));
1030	input_report_abs(dev: input, ABS_MT_POSITION_X, value: pos->x);
1031	input_report_abs(dev: input, ABS_MT_POSITION_Y, value: 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(x: f->touch_major) == 0)
1052	continue;
1053	applespi->pos[n].x = le16_to_int(x: f->abs_x);
1054	applespi->pos[n].y = tp_info->y_min + tp_info->y_max -
1055	le16_to_int(x: 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(dev: input, slots: applespi->slots, pos: applespi->pos, num_pos: n, dmax: 0);
1063
1064	for (i = 0; i < n; i++)
1065	report_finger_data(input, slot: applespi->slots[i],
1066	pos: &applespi->pos[i], f: &t->fingers[i]);
1067
1068	input_mt_sync_frame(dev: input);
1069	input_report_key(dev: input, BTN_LEFT, value: t->clicked);
1070
1071	input_sync(dev: 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(table: 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(table: 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(p: keyboard_protocol->keys_pressed, c: 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(p: keyboard_protocol->keys_pressed,
1167	c: applespi->last_keys_pressed[i], MAX_ROLLOVER))
1168	continue; /* key is still pressed */
1169
1170	key = applespi_code_to_key(code: applespi->last_keys_pressed[i],
1171	fn_pressed: applespi->last_keys_fn_pressed[i]);
1172	input_report_key(dev: applespi->keyboard_input_dev, code: key, value: 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	code: keyboard_protocol->keys_pressed[i],
1183	fn_pressed: keyboard_protocol->fn_pressed);
1184	input_report_key(dev: applespi->keyboard_input_dev, code: key, value: 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(dev: applespi->keyboard_input_dev,
1194	code: applespi_controlcodes[i], value: 1);
1195	else
1196	input_report_key(dev: applespi->keyboard_input_dev,
1197	code: applespi_controlcodes[i], value: 0);
1198	}
1199
1200	/* check function key */
1201	if (keyboard_protocol->fn_pressed && !applespi->last_fn_pressed)
1202	input_report_key(dev: applespi->keyboard_input_dev, KEY_FN, value: 1);
1203	else if (!keyboard_protocol->fn_pressed && applespi->last_fn_pressed)
1204	input_report_key(dev: applespi->keyboard_input_dev, KEY_FN, value: 0);
1205	applespi->last_fn_pressed = keyboard_protocol->fn_pressed;
1206
1207	/* done */
1208	input_sync(dev: 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(model: 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(buf: touchpad_dimensions, size: sizeof(touchpad_dimensions),
1264	fmt: "%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(dev: touchpad_input_dev, EV_REL, REL_X);
1289	input_set_capability(dev: 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(dev: touchpad_input_dev, ABS_MT_TOUCH_MAJOR,
1296	min: 0, max: 5000, fuzz: 0, flat: 0);
1297	input_set_abs_params(dev: touchpad_input_dev, ABS_MT_TOUCH_MINOR,
1298	min: 0, max: 5000, fuzz: 0, flat: 0);
1299
1300	/* finger approach area */
1301	input_set_abs_params(dev: touchpad_input_dev, ABS_MT_WIDTH_MAJOR,
1302	min: 0, max: 5000, fuzz: 0, flat: 0);
1303	input_set_abs_params(dev: touchpad_input_dev, ABS_MT_WIDTH_MINOR,
1304	min: 0, max: 5000, fuzz: 0, flat: 0);
1305
1306	/* finger orientation */
1307	input_set_abs_params(dev: touchpad_input_dev, ABS_MT_ORIENTATION,
1308	min: -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION,
1309	fuzz: 0, flat: 0);
1310
1311	/* finger position */
1312	input_set_abs_params(dev: touchpad_input_dev, ABS_MT_POSITION_X,
1313	min: applespi->tp_info.x_min, max: applespi->tp_info.x_max,
1314	fuzz: 0, flat: 0);
1315	input_set_abs_params(dev: touchpad_input_dev, ABS_MT_POSITION_Y,
1316	min: applespi->tp_info.y_min, max: applespi->tp_info.y_max,
1317	fuzz: 0, flat: 0);
1318
1319	/* touchpad button */
1320	input_set_capability(dev: touchpad_input_dev, EV_KEY, BTN_LEFT);
1321
1322	/* multitouch */
1323	sts = input_mt_init_slots(dev: 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, rcvd_tp_info: &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(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(crc: 0, buffer, len: buflen);
1388	if (crc) {
1389	dev_warn_ratelimited(&applespi->spi->dev,
1390	"Received corrupted packet (crc mismatch)\n");
1391	trace_applespi_bad_crc(evt_type: ET_RD_CRC, READ, buf: buffer, len: 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(type: 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, buffer: 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(lock: &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, buffer: (u8 *)message, buflen: 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, keyboard_protocol: &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, t: 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, is_write_msg: packet->flags == PACKET_TYPE_WRITE,
1549	is_read_compl: 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, is_write_msg: true, is_read_compl: true);
1565	} else {
1566	applespi_got_data(applespi);
1567	}
1568
1569	acpi_finish_gpe(NULL, gpe_number: 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(evt_type: ET_RD_IRQ, pkt_type: PT_READ);
1579
1580	spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1581
1582	if (!applespi->suspended) {
1583	sts = applespi_async(applespi, message: &applespi->rd_m,
1584	complete: 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(lock: &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	efi_status_t sts = EFI_NOT_FOUND;
1601	u16 efi_data = 0;
1602	unsigned long efi_data_len = sizeof(efi_data);
1603
1604	if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE))
1605	sts = efi.get_variable(EFI_BL_LEVEL_NAME, &EFI_BL_LEVEL_GUID,
1606	NULL, &efi_data_len, &efi_data);
1607	if (sts != EFI_SUCCESS && sts != EFI_NOT_FOUND)
1608	dev_warn(&applespi->spi->dev,
1609	"Error getting backlight level from EFI vars: 0x%lx\n",
1610	sts);
1611
1612	return sts != EFI_SUCCESS ? -ENODEV : efi_data;
1613	}
1614
1615	static void applespi_save_bl_level(struct applespi_data *applespi,
1616	unsigned int level)
1617	{
1618	efi_status_t sts = EFI_UNSUPPORTED;
1619	u32 efi_attr;
1620	u16 efi_data;
1621
1622	efi_data = (u16)level;
1623	efi_attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS |
1624	EFI_VARIABLE_RUNTIME_ACCESS;
1625
1626	if (efi_rt_services_supported(EFI_RT_SUPPORTED_SET_VARIABLE))
1627	sts = efi.set_variable(EFI_BL_LEVEL_NAME, &EFI_BL_LEVEL_GUID,
1628	efi_attr, sizeof(efi_data), &efi_data);
1629	if (sts != EFI_SUCCESS)
1630	dev_warn(&applespi->spi->dev,
1631	"Error saving backlight level to EFI vars: 0x%lx\n", sts);
1632	}
1633
1634	static int applespi_probe(struct spi_device *spi)
1635	{
1636	struct applespi_data *applespi;
1637	acpi_handle spi_handle = ACPI_HANDLE(&spi->dev);
1638	acpi_status acpi_sts;
1639	int sts, i;
1640	unsigned long long gpe, usb_status;
1641
1642	/* check if the USB interface is present and enabled already */
1643	acpi_sts = acpi_evaluate_integer(handle: spi_handle, pathname: "UIST", NULL, data: &usb_status);
1644	if (ACPI_SUCCESS(acpi_sts) && usb_status) {
1645	/* let the USB driver take over instead */
1646	dev_info(&spi->dev, "USB interface already enabled\n");
1647	return -ENODEV;
1648	}
1649
1650	/* allocate driver data */
1651	applespi = devm_kzalloc(dev: &spi->dev, size: sizeof(*applespi), GFP_KERNEL);
1652	if (!applespi)
1653	return -ENOMEM;
1654
1655	applespi->spi = spi;
1656
1657	INIT_WORK(&applespi->work, applespi_worker);
1658
1659	/* store the driver data */
1660	spi_set_drvdata(spi, data: applespi);
1661
1662	/* create our buffers */
1663	applespi->tx_buffer = devm_kmalloc(dev: &spi->dev, APPLESPI_PACKET_SIZE,
1664	GFP_KERNEL);
1665	applespi->tx_status = devm_kmalloc(dev: &spi->dev, APPLESPI_STATUS_SIZE,
1666	GFP_KERNEL);
1667	applespi->rx_buffer = devm_kmalloc(dev: &spi->dev, APPLESPI_PACKET_SIZE,
1668	GFP_KERNEL);
1669	applespi->msg_buf = devm_kmalloc_array(dev: &spi->dev, MAX_PKTS_PER_MSG,
1670	APPLESPI_PACKET_SIZE,
1671	GFP_KERNEL);
1672
1673	if (!applespi->tx_buffer || !applespi->tx_status ||
1674	!applespi->rx_buffer || !applespi->msg_buf)
1675	return -ENOMEM;
1676
1677	/* set up our spi messages */
1678	applespi_setup_read_txfrs(applespi);
1679	applespi_setup_write_txfrs(applespi);
1680
1681	/* cache ACPI method handles */
1682	acpi_sts = acpi_get_handle(parent: spi_handle, pathname: "SIEN", ret_handle: &applespi->sien);
1683	if (ACPI_FAILURE(acpi_sts)) {
1684	dev_err(&applespi->spi->dev,
1685	"Failed to get SIEN ACPI method handle: %s\n",
1686	acpi_format_exception(acpi_sts));
1687	return -ENODEV;
1688	}
1689
1690	acpi_sts = acpi_get_handle(parent: spi_handle, pathname: "SIST", ret_handle: &applespi->sist);
1691	if (ACPI_FAILURE(acpi_sts)) {
1692	dev_err(&applespi->spi->dev,
1693	"Failed to get SIST ACPI method handle: %s\n",
1694	acpi_format_exception(acpi_sts));
1695	return -ENODEV;
1696	}
1697
1698	/* switch on the SPI interface */
1699	sts = applespi_setup_spi(applespi);
1700	if (sts)
1701	return sts;
1702
1703	sts = applespi_enable_spi(applespi);
1704	if (sts)
1705	return sts;
1706
1707	/* setup the keyboard input dev */
1708	applespi->keyboard_input_dev = devm_input_allocate_device(&spi->dev);
1709
1710	if (!applespi->keyboard_input_dev)
1711	return -ENOMEM;
1712
1713	applespi->keyboard_input_dev->name = "Apple SPI Keyboard";
1714	applespi->keyboard_input_dev->phys = "applespi/input0";
1715	applespi->keyboard_input_dev->dev.parent = &spi->dev;
1716	applespi->keyboard_input_dev->id.bustype = BUS_SPI;
1717
1718	applespi->keyboard_input_dev->evbit[0] =
1719	BIT_MASK(EV_KEY) | BIT_MASK(EV_LED) | BIT_MASK(EV_REP);
1720	applespi->keyboard_input_dev->ledbit[0] = BIT_MASK(LED_CAPSL);
1721
1722	input_set_drvdata(dev: applespi->keyboard_input_dev, data: applespi);
1723	applespi->keyboard_input_dev->event = applespi_event;
1724
1725	for (i = 0; i < ARRAY_SIZE(applespi_scancodes); i++)
1726	if (applespi_scancodes[i])
1727	input_set_capability(dev: applespi->keyboard_input_dev,
1728	EV_KEY, code: applespi_scancodes[i]);
1729
1730	for (i = 0; i < ARRAY_SIZE(applespi_controlcodes); i++)
1731	if (applespi_controlcodes[i])
1732	input_set_capability(dev: applespi->keyboard_input_dev,
1733	EV_KEY, code: applespi_controlcodes[i]);
1734
1735	for (i = 0; i < ARRAY_SIZE(applespi_fn_codes); i++)
1736	if (applespi_fn_codes[i].to)
1737	input_set_capability(dev: applespi->keyboard_input_dev,
1738	EV_KEY, code: applespi_fn_codes[i].to);
1739
1740	input_set_capability(dev: applespi->keyboard_input_dev, EV_KEY, KEY_FN);
1741
1742	sts = input_register_device(applespi->keyboard_input_dev);
1743	if (sts) {
1744	dev_err(&applespi->spi->dev,
1745	"Unable to register keyboard input device (%d)\n", sts);
1746	return -ENODEV;
1747	}
1748
1749	/*
1750	* The applespi device doesn't send interrupts normally (as is described
1751	* in its DSDT), but rather seems to use ACPI GPEs.
1752	*/
1753	acpi_sts = acpi_evaluate_integer(handle: spi_handle, pathname: "_GPE", NULL, data: &gpe);
1754	if (ACPI_FAILURE(acpi_sts)) {
1755	dev_err(&applespi->spi->dev,
1756	"Failed to obtain GPE for SPI slave device: %s\n",
1757	acpi_format_exception(acpi_sts));
1758	return -ENODEV;
1759	}
1760	applespi->gpe = (int)gpe;
1761
1762	acpi_sts = acpi_install_gpe_handler(NULL, gpe_number: applespi->gpe,
1763	ACPI_GPE_LEVEL_TRIGGERED,
1764	address: applespi_notify, context: applespi);
1765	if (ACPI_FAILURE(acpi_sts)) {
1766	dev_err(&applespi->spi->dev,
1767	"Failed to install GPE handler for GPE %d: %s\n",
1768	applespi->gpe, acpi_format_exception(acpi_sts));
1769	return -ENODEV;
1770	}
1771
1772	applespi->suspended = false;
1773
1774	acpi_sts = acpi_enable_gpe(NULL, gpe_number: applespi->gpe);
1775	if (ACPI_FAILURE(acpi_sts)) {
1776	dev_err(&applespi->spi->dev,
1777	"Failed to enable GPE handler for GPE %d: %s\n",
1778	applespi->gpe, acpi_format_exception(acpi_sts));
1779	acpi_remove_gpe_handler(NULL, gpe_number: applespi->gpe, address: applespi_notify);
1780	return -ENODEV;
1781	}
1782
1783	/* trigger touchpad setup */
1784	applespi_init(applespi, is_resume: false);
1785
1786	/*
1787	* By default this device is not enabled for wakeup; but USB keyboards
1788	* generally are, so the expectation is that by default the keyboard
1789	* will wake the system.
1790	*/
1791	device_wakeup_enable(dev: &spi->dev);
1792
1793	/* set up keyboard-backlight */
1794	sts = applespi_get_saved_bl_level(applespi);
1795	if (sts >= 0)
1796	applespi_set_bl_level(led_cdev: &applespi->backlight_info, value: sts);
1797
1798	applespi->backlight_info.name = "spi::kbd_backlight";
1799	applespi->backlight_info.default_trigger = "kbd-backlight";
1800	applespi->backlight_info.brightness_set = applespi_set_bl_level;
1801
1802	sts = devm_led_classdev_register(parent: &spi->dev, led_cdev: &applespi->backlight_info);
1803	if (sts)
1804	dev_warn(&applespi->spi->dev,
1805	"Unable to register keyboard backlight class dev (%d)\n",
1806	sts);
1807
1808	/* set up debugfs entries for touchpad dimensions logging */
1809	applespi->debugfs_root = debugfs_create_dir(name: "applespi", NULL);
1810
1811	debugfs_create_bool(name: "enable_tp_dim", mode: 0600, parent: applespi->debugfs_root,
1812	value: &applespi->debug_tp_dim);
1813
1814	debugfs_create_file(name: "tp_dim", mode: 0400, parent: applespi->debugfs_root, data: applespi,
1815	fops: &applespi_tp_dim_fops);
1816
1817	return 0;
1818	}
1819
1820	static void applespi_drain_writes(struct applespi_data *applespi)
1821	{
1822	unsigned long flags;
1823
1824	spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1825
1826	applespi->drain = true;
1827	wait_event_lock_irq(applespi->drain_complete, !applespi->write_active,
1828	applespi->cmd_msg_lock);
1829
1830	spin_unlock_irqrestore(lock: &applespi->cmd_msg_lock, flags);
1831	}
1832
1833	static void applespi_drain_reads(struct applespi_data *applespi)
1834	{
1835	unsigned long flags;
1836
1837	spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1838
1839	wait_event_lock_irq(applespi->drain_complete, !applespi->read_active,
1840	applespi->cmd_msg_lock);
1841
1842	applespi->suspended = true;
1843
1844	spin_unlock_irqrestore(lock: &applespi->cmd_msg_lock, flags);
1845	}
1846
1847	static void applespi_remove(struct spi_device *spi)
1848	{
1849	struct applespi_data *applespi = spi_get_drvdata(spi);
1850
1851	applespi_drain_writes(applespi);
1852
1853	acpi_disable_gpe(NULL, gpe_number: applespi->gpe);
1854	acpi_remove_gpe_handler(NULL, gpe_number: applespi->gpe, address: applespi_notify);
1855	device_wakeup_disable(dev: &spi->dev);
1856
1857	applespi_drain_reads(applespi);
1858
1859	debugfs_remove_recursive(dentry: applespi->debugfs_root);
1860	}
1861
1862	static void applespi_shutdown(struct spi_device *spi)
1863	{
1864	struct applespi_data *applespi = spi_get_drvdata(spi);
1865
1866	applespi_save_bl_level(applespi, level: applespi->have_bl_level);
1867	}
1868
1869	static int applespi_poweroff_late(struct device *dev)
1870	{
1871	struct spi_device *spi = to_spi_device(dev);
1872	struct applespi_data *applespi = spi_get_drvdata(spi);
1873
1874	applespi_save_bl_level(applespi, level: applespi->have_bl_level);
1875
1876	return 0;
1877	}
1878
1879	static int applespi_suspend(struct device *dev)
1880	{
1881	struct spi_device *spi = to_spi_device(dev);
1882	struct applespi_data *applespi = spi_get_drvdata(spi);
1883	acpi_status acpi_sts;
1884	int sts;
1885
1886	/* turn off caps-lock - it'll stay on otherwise */
1887	sts = applespi_set_capsl_led(applespi, capslock_on: false);
1888	if (sts)
1889	dev_warn(&applespi->spi->dev,
1890	"Failed to turn off caps-lock led (%d)\n", sts);
1891
1892	applespi_drain_writes(applespi);
1893
1894	/* disable the interrupt */
1895	acpi_sts = acpi_disable_gpe(NULL, gpe_number: applespi->gpe);
1896	if (ACPI_FAILURE(acpi_sts))
1897	dev_err(&applespi->spi->dev,
1898	"Failed to disable GPE handler for GPE %d: %s\n",
1899	applespi->gpe, acpi_format_exception(acpi_sts));
1900
1901	applespi_drain_reads(applespi);
1902
1903	return 0;
1904	}
1905
1906	static int applespi_resume(struct device *dev)
1907	{
1908	struct spi_device *spi = to_spi_device(dev);
1909	struct applespi_data *applespi = spi_get_drvdata(spi);
1910	acpi_status acpi_sts;
1911	unsigned long flags;
1912
1913	/* ensure our flags and state reflect a newly resumed device */
1914	spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1915
1916	applespi->drain = false;
1917	applespi->have_cl_led_on = false;
1918	applespi->have_bl_level = 0;
1919	applespi->cmd_msg_queued = 0;
1920	applespi->read_active = false;
1921	applespi->write_active = false;
1922
1923	applespi->suspended = false;
1924
1925	spin_unlock_irqrestore(lock: &applespi->cmd_msg_lock, flags);
1926
1927	/* switch on the SPI interface */
1928	applespi_enable_spi(applespi);
1929
1930	/* re-enable the interrupt */
1931	acpi_sts = acpi_enable_gpe(NULL, gpe_number: applespi->gpe);
1932	if (ACPI_FAILURE(acpi_sts))
1933	dev_err(&applespi->spi->dev,
1934	"Failed to re-enable GPE handler for GPE %d: %s\n",
1935	applespi->gpe, acpi_format_exception(acpi_sts));
1936
1937	/* switch the touchpad into multitouch mode */
1938	applespi_init(applespi, is_resume: true);
1939
1940	return 0;
1941	}
1942
1943	static const struct acpi_device_id applespi_acpi_match[] = {
1944	{ "APP000D", 0 },
1945	{ }
1946	};
1947	MODULE_DEVICE_TABLE(acpi, applespi_acpi_match);
1948
1949	static const struct dev_pm_ops applespi_pm_ops = {
1950	SYSTEM_SLEEP_PM_OPS(applespi_suspend, applespi_resume)
1951	.poweroff_late = pm_sleep_ptr(applespi_poweroff_late),
1952	};
1953
1954	static struct spi_driver applespi_driver = {
1955	.driver = {
1956	.name = "applespi",
1957	.acpi_match_table = applespi_acpi_match,
1958	.pm = pm_sleep_ptr(&applespi_pm_ops),
1959	},
1960	.probe = applespi_probe,
1961	.remove = applespi_remove,
1962	.shutdown = applespi_shutdown,
1963	};
1964
1965	module_spi_driver(applespi_driver)
1966
1967	MODULE_LICENSE("GPL v2");
1968	MODULE_DESCRIPTION("MacBook(Pro) SPI Keyboard/Touchpad driver");
1969	MODULE_AUTHOR("Federico Lorenzi");
1970	MODULE_AUTHOR("Ronald Tschalär");
1971