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
  96static unsigned int fnmode = 1;
  97module_param(fnmode, uint, 0644);
  98MODULE_PARM_DESC(fnmode, "Mode of Fn key on Apple keyboards (0 = disabled, [1] = fkeyslast, 2 = fkeysfirst)");
  99
 100static unsigned int fnremap;
 101module_param(fnremap, uint, 0644);
 102MODULE_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
 104static bool iso_layout;
 105module_param(iso_layout, bool, 0644);
 106MODULE_PARM_DESC(iso_layout, "Enable/Disable hardcoded ISO-layout of the keyboard. ([0] = disabled, 1 = enabled)");
 107
 108static char touchpad_dimensions[40];
 109module_param_string(touchpad_dimensions, touchpad_dimensions,
 110		    sizeof(touchpad_dimensions), 0444);
 111MODULE_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 */
 125struct 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 */
 154struct 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 */
 183struct 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 */
 200struct 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 */
 216struct 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 */
 232struct 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 */
 246struct 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 */
 262struct 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 */
 300struct 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 */
 346struct 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
 356struct 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 */
 363struct applespi_tp_info {
 364	int	x_min;
 365	int	y_min;
 366	int	x_max;
 367	int	y_max;
 368};
 369
 370struct 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
 436static 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 */
 459static 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
 470struct applespi_key_translation {
 471	u16 from;
 472	u16 to;
 473	u8 flags;
 474};
 475
 476static 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
 498static const struct applespi_key_translation apple_iso_keyboard[] = {
 499	{ KEY_GRAVE,	KEY_102ND },
 500	{ KEY_102ND,	KEY_GRAVE },
 501	{ }
 502};
 503
 504struct applespi_tp_model_info {
 505	u16			model;
 506	struct applespi_tp_info	tp_info;
 507};
 508
 509static 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
 525typedef void (*applespi_trace_fun)(enum applespi_evt_type,
 526				   enum applespi_pkt_type, u8 *, size_t);
 527
 528static 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
 549static 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
 569static 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
 610static 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
 619static 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
 639static 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
 671static 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
 685static 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
 715static int applespi_send_cmd_msg(struct applespi_data *applespi);
 716
 717static 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
 740static 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
 763static 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
 889static 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
 904static 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
 920static 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
 947static 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 */
 963static inline int le16_to_int(__le16 x)
 964{
 965	return (signed short)le16_to_cpu(x);
 966}
 967
 968static 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
 981static 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
 997static 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
1006static 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
1013static 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
1034static 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
1074static const struct applespi_key_translation *
1075applespi_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
1086static 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
1106static 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
1117static 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
1128static void
1129applespi_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
1146static void
1147applespi_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
1213static 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
1225static int
1226applespi_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
1346static 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
1354static 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
1382static 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
1399static 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
1419static 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
1545msg_complete:
1546	applespi->saved_msg_len = 0;
1547
1548	applespi_msg_complete(applespi, packet->flags == PACKET_TYPE_WRITE,
1549			      true);
1550}
1551
1552static 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
1572static 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
1598static 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
1615static 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
1634static 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(spi_handle, "UIST", NULL, &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(&spi->dev, 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, applespi);
1661
1662	/* create our buffers */
1663	applespi->tx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1664					   GFP_KERNEL);
1665	applespi->tx_status = devm_kmalloc(&spi->dev, APPLESPI_STATUS_SIZE,
1666					   GFP_KERNEL);
1667	applespi->rx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1668					   GFP_KERNEL);
1669	applespi->msg_buf = devm_kmalloc_array(&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(spi_handle, "SIEN", &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(spi_handle, "SIST", &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(applespi->keyboard_input_dev, 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(applespi->keyboard_input_dev,
1728					     EV_KEY, applespi_scancodes[i]);
1729
1730	for (i = 0; i < ARRAY_SIZE(applespi_controlcodes); i++)
1731		if (applespi_controlcodes[i])
1732			input_set_capability(applespi->keyboard_input_dev,
1733					     EV_KEY, 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(applespi->keyboard_input_dev,
1738					     EV_KEY, applespi_fn_codes[i].to);
1739
1740	input_set_capability(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(spi_handle, "_GPE", NULL, &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, applespi->gpe,
1763					    ACPI_GPE_LEVEL_TRIGGERED,
1764					    applespi_notify, 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, 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, applespi->gpe, applespi_notify);
1780		return -ENODEV;
1781	}
1782
1783	/* trigger touchpad setup */
1784	applespi_init(applespi, 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(&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(&applespi->backlight_info, 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(&spi->dev, &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("applespi", NULL);
1810
1811	debugfs_create_bool("enable_tp_dim", 0600, applespi->debugfs_root,
1812			    &applespi->debug_tp_dim);
1813
1814	debugfs_create_file("tp_dim", 0400, applespi->debugfs_root, applespi,
1815			    &applespi_tp_dim_fops);
1816
1817	return 0;
1818}
1819
1820static 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(&applespi->cmd_msg_lock, flags);
1831}
1832
1833static 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(&applespi->cmd_msg_lock, flags);
1845}
1846
1847static 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, applespi->gpe);
1854	acpi_remove_gpe_handler(NULL, applespi->gpe, applespi_notify);
1855	device_wakeup_disable(&spi->dev);
1856
1857	applespi_drain_reads(applespi);
1858
1859	debugfs_remove_recursive(applespi->debugfs_root);
 
 
1860}
1861
1862static void applespi_shutdown(struct spi_device *spi)
1863{
1864	struct applespi_data *applespi = spi_get_drvdata(spi);
1865
1866	applespi_save_bl_level(applespi, applespi->have_bl_level);
1867}
1868
1869static 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, applespi->have_bl_level);
1875
1876	return 0;
1877}
1878
1879static int __maybe_unused 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, 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, 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
1906static int __maybe_unused 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(&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, 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, true);
1939
1940	return 0;
1941}
1942
1943static const struct acpi_device_id applespi_acpi_match[] = {
1944	{ "APP000D", 0 },
1945	{ }
1946};
1947MODULE_DEVICE_TABLE(acpi, applespi_acpi_match);
1948
1949static const struct dev_pm_ops applespi_pm_ops = {
1950	SET_SYSTEM_SLEEP_PM_OPS(applespi_suspend, applespi_resume)
1951	.poweroff_late	= applespi_poweroff_late,
1952};
1953
1954static struct spi_driver applespi_driver = {
1955	.driver		= {
1956		.name			= "applespi",
1957		.acpi_match_table	= applespi_acpi_match,
1958		.pm			= &applespi_pm_ops,
1959	},
1960	.probe		= applespi_probe,
1961	.remove		= applespi_remove,
1962	.shutdown	= applespi_shutdown,
1963};
1964
1965module_spi_driver(applespi_driver)
1966
1967MODULE_LICENSE("GPL v2");
1968MODULE_DESCRIPTION("MacBook(Pro) SPI Keyboard/Touchpad driver");
1969MODULE_AUTHOR("Federico Lorenzi");
1970MODULE_AUTHOR("Ronald Tschalär");