1 // SPDX-License-Identifier: GPL-2.0
3 * MacBook (Pro) SPI keyboard and touchpad driver
5 * Copyright (c) 2015-2018 Federico Lorenzi
6 * Copyright (c) 2017-2018 Ronald Tschalär
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:
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.
24 * UIEN and UIST are only provided on models where the USB pins are connected.
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.
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.
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>
59 #include <asm/barrier.h>
60 #include <asm/unaligned.h>
62 #define CREATE_TRACE_POINTS
64 #include "applespi_trace.h"
66 #define APPLESPI_PACKET_SIZE 256
67 #define APPLESPI_STATUS_SIZE 4
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
75 #define MAX_ROLLOVER 6
77 #define MAX_FINGERS 11
78 #define MAX_FINGER_ORIENTATION 16384
79 #define MAX_PKTS_PER_MSG 2
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)
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)
90 #define APPLE_FLAG_FKEY 0x01
92 #define SPI_RW_CHG_DELAY_US 100 /* from experimentation, in µs */
94 #define SYNAPTICS_VENDOR_ID 0x06cb
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)");
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)");
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)");
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 .");
114 * struct keyboard_protocol - keyboard message.
115 * message.type = 0x0110, message.length = 0x000a
118 * @modifiers: bit-set of modifier/control keys pressed
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
125 struct keyboard_protocol {
129 u8 keys_pressed[MAX_ROLLOVER];
135 * struct tp_finger - single trackpad finger structure, le16-aligned
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
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.
172 * struct touchpad_protocol - touchpad message.
173 * message.type = 0x0210
176 * @clicked: 1 if a button-click was detected, 0 otherwise
178 * @number_of_fingers: the number of fingers being reported in @fingers
179 * @clicked2: same as @clicked
181 * @fingers: the data for each finger
183 struct touchpad_protocol {
187 u8 number_of_fingers;
190 struct tp_finger fingers[];
194 * struct command_protocol_tp_info - get touchpad info.
195 * message.type = 0x1020, message.length = 0x0000
197 * @crc16: crc over the whole message struct (message header +
198 * this struct) minus this @crc16 field
200 struct command_protocol_tp_info {
205 * struct touchpad_info_protocol - touchpad info response.
206 * message.type = 0x1020, message.length = 0x006e
209 * @model_flags: flags (vary by model number, but significance otherwise
211 * @model_no: the touchpad model number
213 * @crc16: crc over the whole message struct (message header +
214 * this struct) minus this @crc16 field
216 struct touchpad_info_protocol {
225 * struct command_protocol_mt_init - initialize multitouch.
226 * message.type = 0x0252, message.length = 0x0002
228 * @cmd: value: 0x0102
229 * @crc16: crc over the whole message struct (message header +
230 * this struct) minus this @crc16 field
232 struct command_protocol_mt_init {
238 * struct command_protocol_capsl - toggle caps-lock led
239 * message.type = 0x0151, message.length = 0x0002
241 * @unknown: value: 0x01 (length?)
243 * @crc16: crc over the whole message struct (message header +
244 * this struct) minus this @crc16 field
246 struct command_protocol_capsl {
253 * struct command_protocol_bl - set keyboard backlight brightness
254 * message.type = 0xB051, message.length = 0x0006
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
262 struct command_protocol_bl {
270 * struct message - a complete spi message.
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
277 * @type: the message type
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.
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
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);
318 /* type + zero + counter + rsp_buf_len + length */
319 #define MSG_HEADER_SIZE 8
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
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).
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) */
362 /* this mimics struct drm_rect */
363 struct applespi_tp_info {
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;
381 unsigned int saved_msg_len;
383 struct applespi_tp_info tp_info;
385 u8 last_keys_pressed[MAX_ROLLOVER];
386 u8 last_keys_fn_pressed[MAX_ROLLOVER];
388 struct input_mt_pos pos[MAX_FINGERS];
389 int slots[MAX_FINGERS];
394 struct spi_transfer dl_t;
395 struct spi_transfer rd_t;
396 struct spi_message rd_m;
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;
404 bool want_tp_info_cmd;
405 bool want_mt_init_cmd;
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;
416 struct led_classdev backlight_info;
420 wait_queue_head_t drain_complete;
424 struct work_struct work;
425 struct touchpad_info_protocol rcvd_tp_info;
427 struct dentry *debugfs_root;
436 static const unsigned char applespi_scancodes[] = {
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,
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
456 * This must have exactly as many entries as there are bits in
457 * struct keyboard_protocol.modifiers .
459 static const unsigned char applespi_controlcodes[] = {
470 struct applespi_key_translation {
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 },
498 static const struct applespi_key_translation apple_iso_keyboard[] = {
499 { KEY_GRAVE, KEY_102ND },
500 { KEY_102ND, KEY_GRAVE },
504 struct applespi_tp_model_info {
506 struct applespi_tp_info tp_info;
509 static const struct applespi_tp_model_info applespi_tp_models[] = {
511 .model = 0x04, /* MB8 MB9 MB10 */
512 .tp_info = { -5087, -182, 5579, 6089 },
515 .model = 0x05, /* MBP13,1 MBP13,2 MBP14,1 MBP14,2 */
516 .tp_info = { -6243, -170, 6749, 7685 },
519 .model = 0x06, /* MBP13,3 MBP14,3 */
520 .tp_info = { -7456, -163, 7976, 9283 },
525 typedef void (*applespi_trace_fun)(enum applespi_evt_type,
526 enum applespi_pkt_type, u8 *, size_t);
528 static applespi_trace_fun applespi_get_trace_fun(enum applespi_evt_type type)
532 return trace_applespi_tp_ini_cmd;
534 return trace_applespi_backlight_cmd;
536 return trace_applespi_caps_lock_cmd;
538 return trace_applespi_keyboard_data;
540 return trace_applespi_touchpad_data;
542 return trace_applespi_unknown_data;
544 WARN_ONCE(1, "Unknown msg type %d", type);
545 return trace_applespi_unknown_data;
549 static void applespi_setup_read_txfrs(struct applespi_data *applespi)
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;
555 memset(dl_t, 0, sizeof(*dl_t));
556 memset(rd_t, 0, sizeof(*rd_t));
558 dl_t->delay.value = applespi->spi_settings.spi_cs_delay;
559 dl_t->delay.unit = SPI_DELAY_UNIT_USECS;
561 rd_t->rx_buf = applespi->rx_buffer;
562 rd_t->len = APPLESPI_PACKET_SIZE;
564 spi_message_init(msg);
565 spi_message_add_tail(dl_t, msg);
566 spi_message_add_tail(rd_t, msg);
569 static void applespi_setup_write_txfrs(struct applespi_data *applespi)
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;
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));
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
588 wt_t->delay.value = SPI_RW_CHG_DELAY_US;
589 wt_t->delay.unit = SPI_DELAY_UNIT_USECS;
592 dl_t->delay.value = applespi->spi_settings.spi_cs_delay;
593 dl_t->delay.unit = SPI_DELAY_UNIT_USECS;
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;
600 st_t->rx_buf = applespi->tx_status;
601 st_t->len = APPLESPI_STATUS_SIZE;
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);
610 static int applespi_async(struct applespi_data *applespi,
611 struct spi_message *message, void (*complete)(void *))
613 message->complete = complete;
614 message->context = applespi;
616 return spi_async(applespi->spi, message);
619 static inline bool applespi_check_write_status(struct applespi_data *applespi,
622 static u8 status_ok[] = { 0xac, 0x27, 0x68, 0xd5 };
625 dev_warn(&applespi->spi->dev, "Error writing to device: %d\n",
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);
639 static int applespi_get_spi_settings(struct applespi_data *applespi)
641 struct acpi_device *adev = ACPI_COMPANION(&applespi->spi->dev);
642 const union acpi_object *o;
643 struct spi_settings *settings = &applespi->spi_settings;
645 if (!acpi_dev_get_property(adev, "spiCSDelay", ACPI_TYPE_BUFFER, &o))
646 settings->spi_cs_delay = *(u64 *)o->buffer.pointer;
648 dev_warn(&applespi->spi->dev,
649 "Property spiCSDelay not found\n");
651 if (!acpi_dev_get_property(adev, "resetA2RUsec", ACPI_TYPE_BUFFER, &o))
652 settings->reset_a2r_usec = *(u64 *)o->buffer.pointer;
654 dev_warn(&applespi->spi->dev,
655 "Property resetA2RUsec not found\n");
657 if (!acpi_dev_get_property(adev, "resetRecUsec", ACPI_TYPE_BUFFER, &o))
658 settings->reset_rec_usec = *(u64 *)o->buffer.pointer;
660 dev_warn(&applespi->spi->dev,
661 "Property resetRecUsec not found\n");
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);
671 static int applespi_setup_spi(struct applespi_data *applespi)
675 sts = applespi_get_spi_settings(applespi);
679 spin_lock_init(&applespi->cmd_msg_lock);
680 init_waitqueue_head(&applespi->drain_complete);
685 static int applespi_enable_spi(struct applespi_data *applespi)
687 acpi_status acpi_sts;
688 unsigned long long spi_status;
690 /* check if SPI is already enabled, so we can skip the delay below */
691 acpi_sts = acpi_evaluate_integer(applespi->sist, NULL, NULL,
693 if (ACPI_SUCCESS(acpi_sts) && spi_status)
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));
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
715 static int applespi_send_cmd_msg(struct applespi_data *applespi);
717 static void applespi_msg_complete(struct applespi_data *applespi,
718 bool is_write_msg, bool is_read_compl)
722 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
725 applespi->read_active = false;
727 applespi->write_active = false;
729 if (applespi->drain && !applespi->write_active)
730 wake_up_all(&applespi->drain_complete);
733 applespi->cmd_msg_queued = 0;
734 applespi_send_cmd_msg(applespi);
737 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
740 static void applespi_async_write_complete(void *context)
742 struct applespi_data *applespi = context;
743 enum applespi_evt_type evt_type = applespi->cmd_evt_type;
745 applespi_get_trace_fun(evt_type)(evt_type, PT_WRITE,
747 APPLESPI_PACKET_SIZE);
748 applespi_get_trace_fun(evt_type)(evt_type, PT_STATUS,
750 APPLESPI_STATUS_SIZE);
752 udelay(SPI_RW_CHG_DELAY_US);
754 if (!applespi_check_write_status(applespi, applespi->wr_m.status)) {
756 * If we got an error, we presumably won't get the expected
757 * response message either.
759 applespi_msg_complete(applespi, true, false);
763 static int applespi_send_cmd_msg(struct applespi_data *applespi)
767 struct spi_packet *packet = (struct spi_packet *)applespi->tx_buffer;
768 struct message *message = (struct message *)packet->data;
772 /* check if draining */
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)
781 dev_warn(&applespi->spi->dev, "Command %d timed out\n",
782 applespi->cmd_evt_type);
784 applespi->cmd_msg_queued = 0;
785 applespi->write_active = false;
789 memset(packet, 0, APPLESPI_PACKET_SIZE);
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;
797 /* build init command */
798 device = PACKET_DEV_INFO;
800 message->type = cpu_to_le16(0x1020);
801 msg_len = sizeof(message->tp_info_command);
803 message->zero = 0x02;
804 message->rsp_buf_len = cpu_to_le16(0x0200);
806 } else if (applespi->want_mt_init_cmd) {
807 applespi->want_mt_init_cmd = false;
808 applespi->cmd_evt_type = ET_CMD_TP_INI;
810 /* build init command */
811 device = PACKET_DEV_TPAD;
813 message->type = cpu_to_le16(0x0252);
814 msg_len = sizeof(message->init_mt_command);
816 message->init_mt_command.cmd = cpu_to_le16(0x0102);
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;
823 /* build led command */
824 device = PACKET_DEV_KEYB;
826 message->type = cpu_to_le16(0x0151);
827 msg_len = sizeof(message->capsl_command);
829 message->capsl_command.unknown = 0x01;
830 message->capsl_command.led = applespi->have_cl_led_on ? 2 : 0;
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;
837 /* build command buffer */
838 device = PACKET_DEV_KEYB;
840 message->type = cpu_to_le16(0xB051);
841 msg_len = sizeof(message->bl_command);
843 message->bl_command.const1 = cpu_to_le16(0x01B0);
844 message->bl_command.level =
845 cpu_to_le16(applespi->have_bl_level);
847 if (applespi->have_bl_level > 0)
848 message->bl_command.const2 = cpu_to_le16(0x01F4);
850 message->bl_command.const2 = cpu_to_le16(0x0001);
852 /* everything's up-to-date */
857 /* finalize packet */
858 packet->flags = PACKET_TYPE_WRITE;
859 packet->device = device;
860 packet->length = cpu_to_le16(MSG_HEADER_SIZE + msg_len);
862 message->counter = applespi->cmd_msg_cntr++ % (U8_MAX + 1);
864 message->length = cpu_to_le16(msg_len - 2);
865 if (!message->rsp_buf_len)
866 message->rsp_buf_len = message->length;
868 crc = crc16(0, (u8 *)message, le16_to_cpu(packet->length) - 2);
869 put_unaligned_le16(crc, &message->data[msg_len - 2]);
871 crc = crc16(0, (u8 *)packet, sizeof(*packet) - 2);
872 packet->crc16 = cpu_to_le16(crc);
875 sts = applespi_async(applespi, &applespi->wr_m,
876 applespi_async_write_complete);
878 dev_warn(&applespi->spi->dev,
879 "Error queueing async write to device: %d\n", sts);
883 applespi->cmd_msg_queued = ktime_get_coarse();
884 applespi->write_active = true;
889 static void applespi_init(struct applespi_data *applespi, bool is_resume)
893 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
896 applespi->want_mt_init_cmd = true;
898 applespi->want_tp_info_cmd = true;
899 applespi_send_cmd_msg(applespi);
901 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
904 static int applespi_set_capsl_led(struct applespi_data *applespi,
910 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
912 applespi->want_cl_led_on = capslock_on;
913 sts = applespi_send_cmd_msg(applespi);
915 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
920 static void applespi_set_bl_level(struct led_classdev *led_cdev,
921 enum led_brightness value)
923 struct applespi_data *applespi =
924 container_of(led_cdev, struct applespi_data, backlight_info);
927 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
930 applespi->want_bl_level = value;
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
937 applespi->want_bl_level =
938 ((value * KBD_BL_LEVEL_ADJ) / KBD_BL_LEVEL_SCALE +
942 applespi_send_cmd_msg(applespi);
944 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
947 static int applespi_event(struct input_dev *dev, unsigned int type,
948 unsigned int code, int value)
950 struct applespi_data *applespi = input_get_drvdata(dev);
954 applespi_set_capsl_led(applespi, !!test_bit(LED_CAPSL, dev->led));
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)
965 return (signed short)le16_to_cpu(x);
968 static void applespi_debug_update_dimensions(struct applespi_data *applespi,
969 const struct tp_finger *f)
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));
981 static int applespi_tp_dim_open(struct inode *inode, struct file *file)
983 struct applespi_data *applespi = inode->i_private;
985 file->private_data = applespi;
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);
994 return nonseekable_open(inode, file);
997 static ssize_t applespi_tp_dim_read(struct file *file, char __user *buf,
998 size_t len, loff_t *off)
1000 struct applespi_data *applespi = file->private_data;
1002 return simple_read_from_buffer(buf, len, off, applespi->tp_dim_val,
1003 strlen(applespi->tp_dim_val));
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,
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)
1017 input_mt_slot(input, slot);
1018 input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
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);
1034 static void report_tp_state(struct applespi_data *applespi,
1035 struct touchpad_protocol *t)
1037 const struct tp_finger *f;
1038 struct input_dev *input;
1039 const struct applespi_tp_info *tp_info = &applespi->tp_info;
1042 /* touchpad_input_dev is set async in worker */
1043 input = smp_load_acquire(&applespi->touchpad_input_dev);
1045 return; /* touchpad isn't initialized yet */
1049 for (i = 0; i < t->number_of_fingers; i++) {
1051 if (le16_to_int(f->touch_major) == 0)
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);
1058 if (applespi->debug_tp_dim)
1059 applespi_debug_update_dimensions(applespi, f);
1062 input_mt_assign_slots(input, applespi->slots, applespi->pos, n, 0);
1064 for (i = 0; i < n; i++)
1065 report_finger_data(input, applespi->slots[i],
1066 &applespi->pos[i], &t->fingers[i]);
1068 input_mt_sync_frame(input);
1069 input_report_key(input, BTN_LEFT, t->clicked);
1074 static const struct applespi_key_translation *
1075 applespi_find_translation(const struct applespi_key_translation *table, u16 key)
1077 const struct applespi_key_translation *trans;
1079 for (trans = table; trans->from; trans++)
1080 if (trans->from == key)
1086 static unsigned int applespi_translate_fn_key(unsigned int key, int fn_pressed)
1088 const struct applespi_key_translation *trans;
1091 trans = applespi_find_translation(applespi_fn_codes, key);
1093 if (trans->flags & APPLE_FLAG_FKEY)
1094 do_translate = (fnmode == 2 && fn_pressed) ||
1095 (fnmode == 1 && !fn_pressed);
1097 do_translate = fn_pressed;
1106 static unsigned int applespi_translate_iso_layout(unsigned int key)
1108 const struct applespi_key_translation *trans;
1110 trans = applespi_find_translation(apple_iso_keyboard, key);
1117 static unsigned int applespi_code_to_key(u8 code, int fn_pressed)
1119 unsigned int key = applespi_scancodes[code];
1122 key = applespi_translate_fn_key(key, fn_pressed);
1124 key = applespi_translate_iso_layout(key);
1129 applespi_remap_fn_key(struct keyboard_protocol *keyboard_protocol)
1132 u8 bit = BIT((fnremap - 1) & 0x07);
1134 if (!fnremap || fnremap > ARRAY_SIZE(applespi_controlcodes) ||
1135 !applespi_controlcodes[fnremap - 1])
1138 tmp = keyboard_protocol->fn_pressed;
1139 keyboard_protocol->fn_pressed = !!(keyboard_protocol->modifiers & bit);
1141 keyboard_protocol->modifiers |= bit;
1143 keyboard_protocol->modifiers &= ~bit;
1147 applespi_handle_keyboard_event(struct applespi_data *applespi,
1148 struct keyboard_protocol *keyboard_protocol)
1153 compiletime_assert(ARRAY_SIZE(applespi_controlcodes) ==
1154 sizeof_field(struct keyboard_protocol, modifiers) * 8,
1155 "applespi_controlcodes has wrong number of entries");
1157 /* check for rollover overflow, which is signalled by all keys == 1 */
1158 if (!memchr_inv(keyboard_protocol->keys_pressed, 1, MAX_ROLLOVER))
1161 /* remap fn key if desired */
1162 applespi_remap_fn_key(keyboard_protocol);
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 */
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;
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;
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);
1196 input_report_key(applespi->keyboard_input_dev,
1197 applespi_controlcodes[i], 0);
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;
1208 input_sync(applespi->keyboard_input_dev);
1209 memcpy(&applespi->last_keys_pressed, keyboard_protocol->keys_pressed,
1210 sizeof(applespi->last_keys_pressed));
1213 static const struct applespi_tp_info *applespi_find_touchpad_info(u8 model)
1215 const struct applespi_tp_model_info *info;
1217 for (info = applespi_tp_models; info->model; info++) {
1218 if (info->model == model)
1219 return &info->tp_info;
1226 applespi_register_touchpad_device(struct applespi_data *applespi,
1227 struct touchpad_info_protocol *rcvd_tp_info)
1229 const struct applespi_tp_info *tp_info;
1230 struct input_dev *touchpad_input_dev;
1233 /* set up touchpad dimensions */
1234 tp_info = applespi_find_touchpad_info(rcvd_tp_info->model_no);
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;
1242 applespi->tp_info = *tp_info;
1244 if (touchpad_dimensions[0]) {
1247 sts = sscanf(touchpad_dimensions, "%dx%d+%u+%u", &x, &y, &w, &h);
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;
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';
1262 if (!touchpad_dimensions[0]) {
1263 snprintf(touchpad_dimensions, sizeof(touchpad_dimensions),
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);
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");
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;
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);
1291 __set_bit(INPUT_PROP_POINTER, touchpad_input_dev->propbit);
1292 __set_bit(INPUT_PROP_BUTTONPAD, touchpad_input_dev->propbit);
1294 /* finger touch area */
1295 input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MAJOR,
1297 input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MINOR,
1300 /* finger approach area */
1301 input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MAJOR,
1303 input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MINOR,
1306 /* finger orientation */
1307 input_set_abs_params(touchpad_input_dev, ABS_MT_ORIENTATION,
1308 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION,
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,
1315 input_set_abs_params(touchpad_input_dev, ABS_MT_POSITION_Y,
1316 applespi->tp_info.y_min, applespi->tp_info.y_max,
1319 /* touchpad button */
1320 input_set_capability(touchpad_input_dev, EV_KEY, BTN_LEFT);
1323 sts = input_mt_init_slots(touchpad_input_dev, MAX_FINGERS,
1324 INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
1327 dev_err(&applespi->spi->dev,
1328 "failed to initialize slots: %d", sts);
1332 /* register input device */
1333 sts = input_register_device(touchpad_input_dev);
1335 dev_err(&applespi->spi->dev,
1336 "Unable to register touchpad input device (%d)\n", sts);
1340 /* touchpad_input_dev is read async in spi callback */
1341 smp_store_release(&applespi->touchpad_input_dev, touchpad_input_dev);
1346 static void applespi_worker(struct work_struct *work)
1348 struct applespi_data *applespi =
1349 container_of(work, struct applespi_data, work);
1351 applespi_register_touchpad_device(applespi, &applespi->rcvd_tp_info);
1354 static void applespi_handle_cmd_response(struct applespi_data *applespi,
1355 struct spi_packet *packet,
1356 struct message *message)
1358 if (packet->device == PACKET_DEV_INFO &&
1359 le16_to_cpu(message->type) == 0x1020) {
1361 * We're not allowed to sleep here, but registering an input
1364 applespi->rcvd_tp_info = message->tp_info;
1365 schedule_work(&applespi->work);
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));
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");
1382 static bool applespi_verify_crc(struct applespi_data *applespi, u8 *buffer,
1387 crc = crc16(0, buffer, buflen);
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);
1399 static void applespi_debug_print_read_packet(struct applespi_data *applespi,
1400 struct spi_packet *packet)
1402 unsigned int evt_type;
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;
1413 evt_type = ET_RD_UNKN;
1415 applespi_get_trace_fun(evt_type)(evt_type, PT_READ, applespi->rx_buffer,
1416 APPLESPI_PACKET_SIZE);
1419 static void applespi_got_data(struct applespi_data *applespi)
1421 struct spi_packet *packet;
1422 struct message *message;
1423 unsigned int msg_len;
1428 /* process packet header */
1429 if (!applespi_verify_crc(applespi, applespi->rx_buffer,
1430 APPLESPI_PACKET_SIZE)) {
1431 unsigned long flags;
1433 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1435 if (applespi->drain) {
1436 applespi->read_active = false;
1437 applespi->write_active = false;
1439 wake_up_all(&applespi->drain_complete);
1442 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1447 packet = (struct spi_packet *)applespi->rx_buffer;
1449 applespi_debug_print_read_packet(applespi, packet);
1451 off = le16_to_cpu(packet->offset);
1452 rem = le16_to_cpu(packet->remaining);
1453 len = le16_to_cpu(packet->length);
1455 if (len > sizeof(packet->data)) {
1456 dev_warn_ratelimited(&applespi->spi->dev,
1457 "Received corrupted packet (invalid packet length %u)\n",
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);
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",
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",
1485 memcpy(applespi->msg_buf + off, &packet->data, len);
1486 applespi->saved_msg_len += len;
1491 message = (struct message *)applespi->msg_buf;
1492 msg_len = applespi->saved_msg_len;
1494 message = (struct message *)&packet->data;
1498 /* got complete message - verify */
1499 if (!applespi_verify_crc(applespi, (u8 *)message, msg_len))
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);
1510 /* handle message */
1511 if (packet->flags == PACKET_TYPE_READ &&
1512 packet->device == PACKET_DEV_KEYB) {
1513 applespi_handle_keyboard_event(applespi, &message->keyboard);
1515 } else if (packet->flags == PACKET_TYPE_READ &&
1516 packet->device == PACKET_DEV_TPAD) {
1517 struct touchpad_protocol *tp;
1520 tp = &message->touchpad;
1521 tp_len = struct_size(tp, fingers, tp->number_of_fingers);
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);
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,
1536 tp->number_of_fingers = MAX_FINGERS;
1539 report_tp_state(applespi, tp);
1541 } else if (packet->flags == PACKET_TYPE_WRITE) {
1542 applespi_handle_cmd_response(applespi, packet, message);
1546 applespi->saved_msg_len = 0;
1548 applespi_msg_complete(applespi, packet->flags == PACKET_TYPE_WRITE,
1552 static void applespi_async_read_complete(void *context)
1554 struct applespi_data *applespi = context;
1556 if (applespi->rd_m.status < 0) {
1557 dev_warn(&applespi->spi->dev, "Error reading from device: %d\n",
1558 applespi->rd_m.status);
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.
1564 applespi_msg_complete(applespi, true, true);
1566 applespi_got_data(applespi);
1569 acpi_finish_gpe(NULL, applespi->gpe);
1572 static u32 applespi_notify(acpi_handle gpe_device, u32 gpe, void *context)
1574 struct applespi_data *applespi = context;
1576 unsigned long flags;
1578 trace_applespi_irq_received(ET_RD_IRQ, PT_READ);
1580 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1582 if (!applespi->suspended) {
1583 sts = applespi_async(applespi, &applespi->rd_m,
1584 applespi_async_read_complete);
1586 dev_warn(&applespi->spi->dev,
1587 "Error queueing async read to device: %d\n",
1590 applespi->read_active = true;
1593 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1595 return ACPI_INTERRUPT_HANDLED;
1598 static int applespi_get_saved_bl_level(struct applespi_data *applespi)
1600 efi_status_t sts = EFI_NOT_FOUND;
1602 unsigned long efi_data_len = sizeof(efi_data);
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",
1612 return sts != EFI_SUCCESS ? -ENODEV : efi_data;
1615 static void applespi_save_bl_level(struct applespi_data *applespi,
1618 efi_status_t sts = EFI_UNSUPPORTED;
1622 efi_data = (u16)level;
1623 efi_attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS |
1624 EFI_VARIABLE_RUNTIME_ACCESS;
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);
1634 static int applespi_probe(struct spi_device *spi)
1636 struct applespi_data *applespi;
1637 acpi_handle spi_handle = ACPI_HANDLE(&spi->dev);
1638 acpi_status acpi_sts;
1640 unsigned long long gpe, usb_status;
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");
1650 /* allocate driver data */
1651 applespi = devm_kzalloc(&spi->dev, sizeof(*applespi), GFP_KERNEL);
1655 applespi->spi = spi;
1657 INIT_WORK(&applespi->work, applespi_worker);
1659 /* store the driver data */
1660 spi_set_drvdata(spi, applespi);
1662 /* create our buffers */
1663 applespi->tx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1665 applespi->tx_status = devm_kmalloc(&spi->dev, APPLESPI_STATUS_SIZE,
1667 applespi->rx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1669 applespi->msg_buf = devm_kmalloc_array(&spi->dev, MAX_PKTS_PER_MSG,
1670 APPLESPI_PACKET_SIZE,
1673 if (!applespi->tx_buffer || !applespi->tx_status ||
1674 !applespi->rx_buffer || !applespi->msg_buf)
1677 /* set up our spi messages */
1678 applespi_setup_read_txfrs(applespi);
1679 applespi_setup_write_txfrs(applespi);
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));
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));
1698 /* switch on the SPI interface */
1699 sts = applespi_setup_spi(applespi);
1703 sts = applespi_enable_spi(applespi);
1707 /* setup the keyboard input dev */
1708 applespi->keyboard_input_dev = devm_input_allocate_device(&spi->dev);
1710 if (!applespi->keyboard_input_dev)
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;
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);
1722 input_set_drvdata(applespi->keyboard_input_dev, applespi);
1723 applespi->keyboard_input_dev->event = applespi_event;
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]);
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]);
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);
1740 input_set_capability(applespi->keyboard_input_dev, EV_KEY, KEY_FN);
1742 sts = input_register_device(applespi->keyboard_input_dev);
1744 dev_err(&applespi->spi->dev,
1745 "Unable to register keyboard input device (%d)\n", sts);
1750 * The applespi device doesn't send interrupts normally (as is described
1751 * in its DSDT), but rather seems to use ACPI GPEs.
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));
1760 applespi->gpe = (int)gpe;
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));
1772 applespi->suspended = false;
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);
1783 /* trigger touchpad setup */
1784 applespi_init(applespi, false);
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.
1791 device_wakeup_enable(&spi->dev);
1793 /* set up keyboard-backlight */
1794 sts = applespi_get_saved_bl_level(applespi);
1796 applespi_set_bl_level(&applespi->backlight_info, sts);
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;
1802 sts = devm_led_classdev_register(&spi->dev, &applespi->backlight_info);
1804 dev_warn(&applespi->spi->dev,
1805 "Unable to register keyboard backlight class dev (%d)\n",
1808 /* set up debugfs entries for touchpad dimensions logging */
1809 applespi->debugfs_root = debugfs_create_dir("applespi", NULL);
1811 debugfs_create_bool("enable_tp_dim", 0600, applespi->debugfs_root,
1812 &applespi->debug_tp_dim);
1814 debugfs_create_file("tp_dim", 0400, applespi->debugfs_root, applespi,
1815 &applespi_tp_dim_fops);
1820 static void applespi_drain_writes(struct applespi_data *applespi)
1822 unsigned long flags;
1824 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1826 applespi->drain = true;
1827 wait_event_lock_irq(applespi->drain_complete, !applespi->write_active,
1828 applespi->cmd_msg_lock);
1830 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1833 static void applespi_drain_reads(struct applespi_data *applespi)
1835 unsigned long flags;
1837 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1839 wait_event_lock_irq(applespi->drain_complete, !applespi->read_active,
1840 applespi->cmd_msg_lock);
1842 applespi->suspended = true;
1844 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1847 static void applespi_remove(struct spi_device *spi)
1849 struct applespi_data *applespi = spi_get_drvdata(spi);
1851 applespi_drain_writes(applespi);
1853 acpi_disable_gpe(NULL, applespi->gpe);
1854 acpi_remove_gpe_handler(NULL, applespi->gpe, applespi_notify);
1855 device_wakeup_disable(&spi->dev);
1857 applespi_drain_reads(applespi);
1859 debugfs_remove_recursive(applespi->debugfs_root);
1862 static void applespi_shutdown(struct spi_device *spi)
1864 struct applespi_data *applespi = spi_get_drvdata(spi);
1866 applespi_save_bl_level(applespi, applespi->have_bl_level);
1869 static int applespi_poweroff_late(struct device *dev)
1871 struct spi_device *spi = to_spi_device(dev);
1872 struct applespi_data *applespi = spi_get_drvdata(spi);
1874 applespi_save_bl_level(applespi, applespi->have_bl_level);
1879 static int applespi_suspend(struct device *dev)
1881 struct spi_device *spi = to_spi_device(dev);
1882 struct applespi_data *applespi = spi_get_drvdata(spi);
1883 acpi_status acpi_sts;
1886 /* turn off caps-lock - it'll stay on otherwise */
1887 sts = applespi_set_capsl_led(applespi, false);
1889 dev_warn(&applespi->spi->dev,
1890 "Failed to turn off caps-lock led (%d)\n", sts);
1892 applespi_drain_writes(applespi);
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));
1901 applespi_drain_reads(applespi);
1906 static int applespi_resume(struct device *dev)
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;
1913 /* ensure our flags and state reflect a newly resumed device */
1914 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
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;
1923 applespi->suspended = false;
1925 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1927 /* switch on the SPI interface */
1928 applespi_enable_spi(applespi);
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));
1937 /* switch the touchpad into multitouch mode */
1938 applespi_init(applespi, true);
1943 static const struct acpi_device_id applespi_acpi_match[] = {
1947 MODULE_DEVICE_TABLE(acpi, applespi_acpi_match);
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),
1954 static struct spi_driver applespi_driver = {
1957 .acpi_match_table = applespi_acpi_match,
1958 .pm = pm_sleep_ptr(&applespi_pm_ops),
1960 .probe = applespi_probe,
1961 .remove = applespi_remove,
1962 .shutdown = applespi_shutdown,
1965 module_spi_driver(applespi_driver)
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");