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[0];
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 - 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.
298 struct keyboard_protocol keyboard;
299 struct touchpad_protocol touchpad;
300 struct touchpad_info_protocol tp_info;
301 struct command_protocol_tp_info tp_info_command;
302 struct command_protocol_mt_init init_mt_command;
303 struct command_protocol_capsl capsl_command;
304 struct command_protocol_bl bl_command;
309 /* type + zero + counter + rsp_buf_len + length */
310 #define MSG_HEADER_SIZE 8
313 * struct spi_packet - a complete spi packet; always 256 bytes. This carries
314 * the (parts of the) message in the data. But note that this does not
315 * necessarily contain a complete message, as in some cases (e.g. many
316 * fingers pressed) the message is split over multiple packets (see the
317 * @offset, @remaining, and @length fields). In general the data parts in
318 * spi_packet's are concatenated until @remaining is 0, and the result is an
321 * @flags: 0x40 = write (to device), 0x20 = read (from device); note that
322 * the response to a write still has 0x40.
323 * @device: 1 = keyboard, 2 = touchpad
324 * @offset: specifies the offset of this packet's data in the complete
325 * message; i.e. > 0 indicates this is a continuation packet (in
326 * the second packet for a message split over multiple packets
327 * this would then be the same as the @length in the first packet)
328 * @remaining: number of message bytes remaining in subsequents packets (in
329 * the first packet of a message split over two packets this would
330 * then be the same as the @length in the second packet)
331 * @length: length of the valid data in the @data in this packet
332 * @data: all or part of a message
333 * @crc16: crc over this whole structure minus this @crc16 field. This
334 * covers just this packet, even on multi-packet messages (in
335 * contrast to the crc in the message).
347 struct spi_settings {
348 u64 spi_cs_delay; /* cs-to-clk delay in us */
349 u64 reset_a2r_usec; /* active-to-receive delay? */
350 u64 reset_rec_usec; /* ? (cur val: 10) */
353 /* this mimics struct drm_rect */
354 struct applespi_tp_info {
361 struct applespi_data {
362 struct spi_device *spi;
363 struct spi_settings spi_settings;
364 struct input_dev *keyboard_input_dev;
365 struct input_dev *touchpad_input_dev;
372 unsigned int saved_msg_len;
374 struct applespi_tp_info tp_info;
376 u8 last_keys_pressed[MAX_ROLLOVER];
377 u8 last_keys_fn_pressed[MAX_ROLLOVER];
379 struct input_mt_pos pos[MAX_FINGERS];
380 int slots[MAX_FINGERS];
385 struct spi_transfer dl_t;
386 struct spi_transfer rd_t;
387 struct spi_message rd_m;
389 struct spi_transfer ww_t;
390 struct spi_transfer wd_t;
391 struct spi_transfer wr_t;
392 struct spi_transfer st_t;
393 struct spi_message wr_m;
395 bool want_tp_info_cmd;
396 bool want_mt_init_cmd;
399 unsigned int want_bl_level;
400 unsigned int have_bl_level;
401 unsigned int cmd_msg_cntr;
402 /* lock to protect the above parameters and flags below */
403 spinlock_t cmd_msg_lock;
404 ktime_t cmd_msg_queued;
405 enum applespi_evt_type cmd_evt_type;
407 struct led_classdev backlight_info;
411 wait_queue_head_t drain_complete;
415 struct work_struct work;
416 struct touchpad_info_protocol rcvd_tp_info;
418 struct dentry *debugfs_root;
427 static const unsigned char applespi_scancodes[] = {
429 KEY_A, KEY_B, KEY_C, KEY_D, KEY_E, KEY_F, KEY_G, KEY_H, KEY_I, KEY_J,
430 KEY_K, KEY_L, KEY_M, KEY_N, KEY_O, KEY_P, KEY_Q, KEY_R, KEY_S, KEY_T,
431 KEY_U, KEY_V, KEY_W, KEY_X, KEY_Y, KEY_Z,
432 KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0,
433 KEY_ENTER, KEY_ESC, KEY_BACKSPACE, KEY_TAB, KEY_SPACE, KEY_MINUS,
434 KEY_EQUAL, KEY_LEFTBRACE, KEY_RIGHTBRACE, KEY_BACKSLASH, 0,
435 KEY_SEMICOLON, KEY_APOSTROPHE, KEY_GRAVE, KEY_COMMA, KEY_DOT, KEY_SLASH,
437 KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9,
438 KEY_F10, KEY_F11, KEY_F12, 0, 0, 0, 0, 0, 0, 0, 0, 0,
439 KEY_RIGHT, KEY_LEFT, KEY_DOWN, KEY_UP,
440 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_102ND,
441 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
442 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_RO, 0, KEY_YEN, 0, 0, 0, 0, 0,
443 0, KEY_KATAKANAHIRAGANA, KEY_MUHENKAN
447 * This must have exactly as many entries as there are bits in
448 * struct keyboard_protocol.modifiers .
450 static const unsigned char applespi_controlcodes[] = {
461 struct applespi_key_translation {
467 static const struct applespi_key_translation applespi_fn_codes[] = {
468 { KEY_BACKSPACE, KEY_DELETE },
469 { KEY_ENTER, KEY_INSERT },
470 { KEY_F1, KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
471 { KEY_F2, KEY_BRIGHTNESSUP, APPLE_FLAG_FKEY },
472 { KEY_F3, KEY_SCALE, APPLE_FLAG_FKEY },
473 { KEY_F4, KEY_DASHBOARD, APPLE_FLAG_FKEY },
474 { KEY_F5, KEY_KBDILLUMDOWN, APPLE_FLAG_FKEY },
475 { KEY_F6, KEY_KBDILLUMUP, APPLE_FLAG_FKEY },
476 { KEY_F7, KEY_PREVIOUSSONG, APPLE_FLAG_FKEY },
477 { KEY_F8, KEY_PLAYPAUSE, APPLE_FLAG_FKEY },
478 { KEY_F9, KEY_NEXTSONG, APPLE_FLAG_FKEY },
479 { KEY_F10, KEY_MUTE, APPLE_FLAG_FKEY },
480 { KEY_F11, KEY_VOLUMEDOWN, APPLE_FLAG_FKEY },
481 { KEY_F12, KEY_VOLUMEUP, APPLE_FLAG_FKEY },
482 { KEY_RIGHT, KEY_END },
483 { KEY_LEFT, KEY_HOME },
484 { KEY_DOWN, KEY_PAGEDOWN },
485 { KEY_UP, KEY_PAGEUP },
489 static const struct applespi_key_translation apple_iso_keyboard[] = {
490 { KEY_GRAVE, KEY_102ND },
491 { KEY_102ND, KEY_GRAVE },
495 struct applespi_tp_model_info {
497 struct applespi_tp_info tp_info;
500 static const struct applespi_tp_model_info applespi_tp_models[] = {
502 .model = 0x04, /* MB8 MB9 MB10 */
503 .tp_info = { -5087, -182, 5579, 6089 },
506 .model = 0x05, /* MBP13,1 MBP13,2 MBP14,1 MBP14,2 */
507 .tp_info = { -6243, -170, 6749, 7685 },
510 .model = 0x06, /* MBP13,3 MBP14,3 */
511 .tp_info = { -7456, -163, 7976, 9283 },
516 typedef void (*applespi_trace_fun)(enum applespi_evt_type,
517 enum applespi_pkt_type, u8 *, size_t);
519 static applespi_trace_fun applespi_get_trace_fun(enum applespi_evt_type type)
523 return trace_applespi_tp_ini_cmd;
525 return trace_applespi_backlight_cmd;
527 return trace_applespi_caps_lock_cmd;
529 return trace_applespi_keyboard_data;
531 return trace_applespi_touchpad_data;
533 return trace_applespi_unknown_data;
535 WARN_ONCE(1, "Unknown msg type %d", type);
536 return trace_applespi_unknown_data;
540 static void applespi_setup_read_txfrs(struct applespi_data *applespi)
542 struct spi_message *msg = &applespi->rd_m;
543 struct spi_transfer *dl_t = &applespi->dl_t;
544 struct spi_transfer *rd_t = &applespi->rd_t;
546 memset(dl_t, 0, sizeof(*dl_t));
547 memset(rd_t, 0, sizeof(*rd_t));
549 dl_t->delay_usecs = applespi->spi_settings.spi_cs_delay;
551 rd_t->rx_buf = applespi->rx_buffer;
552 rd_t->len = APPLESPI_PACKET_SIZE;
554 spi_message_init(msg);
555 spi_message_add_tail(dl_t, msg);
556 spi_message_add_tail(rd_t, msg);
559 static void applespi_setup_write_txfrs(struct applespi_data *applespi)
561 struct spi_message *msg = &applespi->wr_m;
562 struct spi_transfer *wt_t = &applespi->ww_t;
563 struct spi_transfer *dl_t = &applespi->wd_t;
564 struct spi_transfer *wr_t = &applespi->wr_t;
565 struct spi_transfer *st_t = &applespi->st_t;
567 memset(wt_t, 0, sizeof(*wt_t));
568 memset(dl_t, 0, sizeof(*dl_t));
569 memset(wr_t, 0, sizeof(*wr_t));
570 memset(st_t, 0, sizeof(*st_t));
573 * All we need here is a delay at the beginning of the message before
574 * asserting cs. But the current spi API doesn't support this, so we
575 * end up with an extra unnecessary (but harmless) cs assertion and
578 wt_t->delay_usecs = SPI_RW_CHG_DELAY_US;
581 dl_t->delay_usecs = applespi->spi_settings.spi_cs_delay;
583 wr_t->tx_buf = applespi->tx_buffer;
584 wr_t->len = APPLESPI_PACKET_SIZE;
585 wr_t->delay_usecs = SPI_RW_CHG_DELAY_US;
587 st_t->rx_buf = applespi->tx_status;
588 st_t->len = APPLESPI_STATUS_SIZE;
590 spi_message_init(msg);
591 spi_message_add_tail(wt_t, msg);
592 spi_message_add_tail(dl_t, msg);
593 spi_message_add_tail(wr_t, msg);
594 spi_message_add_tail(st_t, msg);
597 static int applespi_async(struct applespi_data *applespi,
598 struct spi_message *message, void (*complete)(void *))
600 message->complete = complete;
601 message->context = applespi;
603 return spi_async(applespi->spi, message);
606 static inline bool applespi_check_write_status(struct applespi_data *applespi,
609 static u8 status_ok[] = { 0xac, 0x27, 0x68, 0xd5 };
612 dev_warn(&applespi->spi->dev, "Error writing to device: %d\n",
617 if (memcmp(applespi->tx_status, status_ok, APPLESPI_STATUS_SIZE)) {
618 dev_warn(&applespi->spi->dev, "Error writing to device: %*ph\n",
619 APPLESPI_STATUS_SIZE, applespi->tx_status);
626 static int applespi_get_spi_settings(struct applespi_data *applespi)
628 struct acpi_device *adev = ACPI_COMPANION(&applespi->spi->dev);
629 const union acpi_object *o;
630 struct spi_settings *settings = &applespi->spi_settings;
632 if (!acpi_dev_get_property(adev, "spiCSDelay", ACPI_TYPE_BUFFER, &o))
633 settings->spi_cs_delay = *(u64 *)o->buffer.pointer;
635 dev_warn(&applespi->spi->dev,
636 "Property spiCSDelay not found\n");
638 if (!acpi_dev_get_property(adev, "resetA2RUsec", ACPI_TYPE_BUFFER, &o))
639 settings->reset_a2r_usec = *(u64 *)o->buffer.pointer;
641 dev_warn(&applespi->spi->dev,
642 "Property resetA2RUsec not found\n");
644 if (!acpi_dev_get_property(adev, "resetRecUsec", ACPI_TYPE_BUFFER, &o))
645 settings->reset_rec_usec = *(u64 *)o->buffer.pointer;
647 dev_warn(&applespi->spi->dev,
648 "Property resetRecUsec not found\n");
650 dev_dbg(&applespi->spi->dev,
651 "SPI settings: spi_cs_delay=%llu reset_a2r_usec=%llu reset_rec_usec=%llu\n",
652 settings->spi_cs_delay, settings->reset_a2r_usec,
653 settings->reset_rec_usec);
658 static int applespi_setup_spi(struct applespi_data *applespi)
662 sts = applespi_get_spi_settings(applespi);
666 spin_lock_init(&applespi->cmd_msg_lock);
667 init_waitqueue_head(&applespi->drain_complete);
672 static int applespi_enable_spi(struct applespi_data *applespi)
674 acpi_status acpi_sts;
675 unsigned long long spi_status;
677 /* check if SPI is already enabled, so we can skip the delay below */
678 acpi_sts = acpi_evaluate_integer(applespi->sist, NULL, NULL,
680 if (ACPI_SUCCESS(acpi_sts) && spi_status)
683 /* SIEN(1) will enable SPI communication */
684 acpi_sts = acpi_execute_simple_method(applespi->sien, NULL, 1);
685 if (ACPI_FAILURE(acpi_sts)) {
686 dev_err(&applespi->spi->dev, "SIEN failed: %s\n",
687 acpi_format_exception(acpi_sts));
692 * Allow the SPI interface to come up before returning. Without this
693 * delay, the SPI commands to enable multitouch mode may not reach
694 * the trackpad controller, causing pointer movement to break upon
702 static int applespi_send_cmd_msg(struct applespi_data *applespi);
704 static void applespi_msg_complete(struct applespi_data *applespi,
705 bool is_write_msg, bool is_read_compl)
709 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
712 applespi->read_active = false;
714 applespi->write_active = false;
716 if (applespi->drain && !applespi->write_active)
717 wake_up_all(&applespi->drain_complete);
720 applespi->cmd_msg_queued = 0;
721 applespi_send_cmd_msg(applespi);
724 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
727 static void applespi_async_write_complete(void *context)
729 struct applespi_data *applespi = context;
730 enum applespi_evt_type evt_type = applespi->cmd_evt_type;
732 applespi_get_trace_fun(evt_type)(evt_type, PT_WRITE,
734 APPLESPI_PACKET_SIZE);
735 applespi_get_trace_fun(evt_type)(evt_type, PT_STATUS,
737 APPLESPI_STATUS_SIZE);
739 if (!applespi_check_write_status(applespi, applespi->wr_m.status)) {
741 * If we got an error, we presumably won't get the expected
742 * response message either.
744 applespi_msg_complete(applespi, true, false);
748 static int applespi_send_cmd_msg(struct applespi_data *applespi)
752 struct spi_packet *packet = (struct spi_packet *)applespi->tx_buffer;
753 struct message *message = (struct message *)packet->data;
757 /* check if draining */
761 /* check whether send is in progress */
762 if (applespi->cmd_msg_queued) {
763 if (ktime_ms_delta(ktime_get(), applespi->cmd_msg_queued) < 1000)
766 dev_warn(&applespi->spi->dev, "Command %d timed out\n",
767 applespi->cmd_evt_type);
769 applespi->cmd_msg_queued = 0;
770 applespi->write_active = false;
774 memset(packet, 0, APPLESPI_PACKET_SIZE);
776 /* are we processing init commands? */
777 if (applespi->want_tp_info_cmd) {
778 applespi->want_tp_info_cmd = false;
779 applespi->want_mt_init_cmd = true;
780 applespi->cmd_evt_type = ET_CMD_TP_INI;
782 /* build init command */
783 device = PACKET_DEV_INFO;
785 message->type = cpu_to_le16(0x1020);
786 msg_len = sizeof(message->tp_info_command);
788 message->zero = 0x02;
789 message->rsp_buf_len = cpu_to_le16(0x0200);
791 } else if (applespi->want_mt_init_cmd) {
792 applespi->want_mt_init_cmd = false;
793 applespi->cmd_evt_type = ET_CMD_TP_INI;
795 /* build init command */
796 device = PACKET_DEV_TPAD;
798 message->type = cpu_to_le16(0x0252);
799 msg_len = sizeof(message->init_mt_command);
801 message->init_mt_command.cmd = cpu_to_le16(0x0102);
803 /* do we need caps-lock command? */
804 } else if (applespi->want_cl_led_on != applespi->have_cl_led_on) {
805 applespi->have_cl_led_on = applespi->want_cl_led_on;
806 applespi->cmd_evt_type = ET_CMD_CL;
808 /* build led command */
809 device = PACKET_DEV_KEYB;
811 message->type = cpu_to_le16(0x0151);
812 msg_len = sizeof(message->capsl_command);
814 message->capsl_command.unknown = 0x01;
815 message->capsl_command.led = applespi->have_cl_led_on ? 2 : 0;
817 /* do we need backlight command? */
818 } else if (applespi->want_bl_level != applespi->have_bl_level) {
819 applespi->have_bl_level = applespi->want_bl_level;
820 applespi->cmd_evt_type = ET_CMD_BL;
822 /* build command buffer */
823 device = PACKET_DEV_KEYB;
825 message->type = cpu_to_le16(0xB051);
826 msg_len = sizeof(message->bl_command);
828 message->bl_command.const1 = cpu_to_le16(0x01B0);
829 message->bl_command.level =
830 cpu_to_le16(applespi->have_bl_level);
832 if (applespi->have_bl_level > 0)
833 message->bl_command.const2 = cpu_to_le16(0x01F4);
835 message->bl_command.const2 = cpu_to_le16(0x0001);
837 /* everything's up-to-date */
842 /* finalize packet */
843 packet->flags = PACKET_TYPE_WRITE;
844 packet->device = device;
845 packet->length = cpu_to_le16(MSG_HEADER_SIZE + msg_len);
847 message->counter = applespi->cmd_msg_cntr++ % (U8_MAX + 1);
849 message->length = cpu_to_le16(msg_len - 2);
850 if (!message->rsp_buf_len)
851 message->rsp_buf_len = message->length;
853 crc = crc16(0, (u8 *)message, le16_to_cpu(packet->length) - 2);
854 put_unaligned_le16(crc, &message->data[msg_len - 2]);
856 crc = crc16(0, (u8 *)packet, sizeof(*packet) - 2);
857 packet->crc16 = cpu_to_le16(crc);
860 sts = applespi_async(applespi, &applespi->wr_m,
861 applespi_async_write_complete);
863 dev_warn(&applespi->spi->dev,
864 "Error queueing async write to device: %d\n", sts);
868 applespi->cmd_msg_queued = ktime_get_coarse();
869 applespi->write_active = true;
874 static void applespi_init(struct applespi_data *applespi, bool is_resume)
878 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
881 applespi->want_mt_init_cmd = true;
883 applespi->want_tp_info_cmd = true;
884 applespi_send_cmd_msg(applespi);
886 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
889 static int applespi_set_capsl_led(struct applespi_data *applespi,
895 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
897 applespi->want_cl_led_on = capslock_on;
898 sts = applespi_send_cmd_msg(applespi);
900 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
905 static void applespi_set_bl_level(struct led_classdev *led_cdev,
906 enum led_brightness value)
908 struct applespi_data *applespi =
909 container_of(led_cdev, struct applespi_data, backlight_info);
912 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
915 applespi->want_bl_level = value;
918 * The backlight does not turn on till level 32, so we scale
919 * the range here so that from a user's perspective it turns
922 applespi->want_bl_level =
923 ((value * KBD_BL_LEVEL_ADJ) / KBD_BL_LEVEL_SCALE +
927 applespi_send_cmd_msg(applespi);
929 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
932 static int applespi_event(struct input_dev *dev, unsigned int type,
933 unsigned int code, int value)
935 struct applespi_data *applespi = input_get_drvdata(dev);
939 applespi_set_capsl_led(applespi, !!test_bit(LED_CAPSL, dev->led));
946 /* lifted from the BCM5974 driver and renamed from raw2int */
947 /* convert 16-bit little endian to signed integer */
948 static inline int le16_to_int(__le16 x)
950 return (signed short)le16_to_cpu(x);
953 static void applespi_debug_update_dimensions(struct applespi_data *applespi,
954 const struct tp_finger *f)
956 applespi->tp_dim_min_x = min(applespi->tp_dim_min_x,
957 le16_to_int(f->abs_x));
958 applespi->tp_dim_max_x = max(applespi->tp_dim_max_x,
959 le16_to_int(f->abs_x));
960 applespi->tp_dim_min_y = min(applespi->tp_dim_min_y,
961 le16_to_int(f->abs_y));
962 applespi->tp_dim_max_y = max(applespi->tp_dim_max_y,
963 le16_to_int(f->abs_y));
966 static int applespi_tp_dim_open(struct inode *inode, struct file *file)
968 struct applespi_data *applespi = inode->i_private;
970 file->private_data = applespi;
972 snprintf(applespi->tp_dim_val, sizeof(applespi->tp_dim_val),
973 "0x%.4x %dx%d+%u+%u\n",
974 applespi->touchpad_input_dev->id.product,
975 applespi->tp_dim_min_x, applespi->tp_dim_min_y,
976 applespi->tp_dim_max_x - applespi->tp_dim_min_x,
977 applespi->tp_dim_max_y - applespi->tp_dim_min_y);
979 return nonseekable_open(inode, file);
982 static ssize_t applespi_tp_dim_read(struct file *file, char __user *buf,
983 size_t len, loff_t *off)
985 struct applespi_data *applespi = file->private_data;
987 return simple_read_from_buffer(buf, len, off, applespi->tp_dim_val,
988 strlen(applespi->tp_dim_val));
991 static const struct file_operations applespi_tp_dim_fops = {
992 .owner = THIS_MODULE,
993 .open = applespi_tp_dim_open,
994 .read = applespi_tp_dim_read,
998 static void report_finger_data(struct input_dev *input, int slot,
999 const struct input_mt_pos *pos,
1000 const struct tp_finger *f)
1002 input_mt_slot(input, slot);
1003 input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
1005 input_report_abs(input, ABS_MT_TOUCH_MAJOR,
1006 le16_to_int(f->touch_major) << 1);
1007 input_report_abs(input, ABS_MT_TOUCH_MINOR,
1008 le16_to_int(f->touch_minor) << 1);
1009 input_report_abs(input, ABS_MT_WIDTH_MAJOR,
1010 le16_to_int(f->tool_major) << 1);
1011 input_report_abs(input, ABS_MT_WIDTH_MINOR,
1012 le16_to_int(f->tool_minor) << 1);
1013 input_report_abs(input, ABS_MT_ORIENTATION,
1014 MAX_FINGER_ORIENTATION - le16_to_int(f->orientation));
1015 input_report_abs(input, ABS_MT_POSITION_X, pos->x);
1016 input_report_abs(input, ABS_MT_POSITION_Y, pos->y);
1019 static void report_tp_state(struct applespi_data *applespi,
1020 struct touchpad_protocol *t)
1022 const struct tp_finger *f;
1023 struct input_dev *input;
1024 const struct applespi_tp_info *tp_info = &applespi->tp_info;
1027 /* touchpad_input_dev is set async in worker */
1028 input = smp_load_acquire(&applespi->touchpad_input_dev);
1030 return; /* touchpad isn't initialized yet */
1034 for (i = 0; i < t->number_of_fingers; i++) {
1036 if (le16_to_int(f->touch_major) == 0)
1038 applespi->pos[n].x = le16_to_int(f->abs_x);
1039 applespi->pos[n].y = tp_info->y_min + tp_info->y_max -
1040 le16_to_int(f->abs_y);
1043 if (applespi->debug_tp_dim)
1044 applespi_debug_update_dimensions(applespi, f);
1047 input_mt_assign_slots(input, applespi->slots, applespi->pos, n, 0);
1049 for (i = 0; i < n; i++)
1050 report_finger_data(input, applespi->slots[i],
1051 &applespi->pos[i], &t->fingers[i]);
1053 input_mt_sync_frame(input);
1054 input_report_key(input, BTN_LEFT, t->clicked);
1059 static const struct applespi_key_translation *
1060 applespi_find_translation(const struct applespi_key_translation *table, u16 key)
1062 const struct applespi_key_translation *trans;
1064 for (trans = table; trans->from; trans++)
1065 if (trans->from == key)
1071 static unsigned int applespi_translate_fn_key(unsigned int key, int fn_pressed)
1073 const struct applespi_key_translation *trans;
1076 trans = applespi_find_translation(applespi_fn_codes, key);
1078 if (trans->flags & APPLE_FLAG_FKEY)
1079 do_translate = (fnmode == 2 && fn_pressed) ||
1080 (fnmode == 1 && !fn_pressed);
1082 do_translate = fn_pressed;
1091 static unsigned int applespi_translate_iso_layout(unsigned int key)
1093 const struct applespi_key_translation *trans;
1095 trans = applespi_find_translation(apple_iso_keyboard, key);
1102 static unsigned int applespi_code_to_key(u8 code, int fn_pressed)
1104 unsigned int key = applespi_scancodes[code];
1107 key = applespi_translate_fn_key(key, fn_pressed);
1109 key = applespi_translate_iso_layout(key);
1114 applespi_remap_fn_key(struct keyboard_protocol *keyboard_protocol)
1117 u8 bit = BIT((fnremap - 1) & 0x07);
1119 if (!fnremap || fnremap > ARRAY_SIZE(applespi_controlcodes) ||
1120 !applespi_controlcodes[fnremap - 1])
1123 tmp = keyboard_protocol->fn_pressed;
1124 keyboard_protocol->fn_pressed = !!(keyboard_protocol->modifiers & bit);
1126 keyboard_protocol->modifiers |= bit;
1128 keyboard_protocol->modifiers &= ~bit;
1132 applespi_handle_keyboard_event(struct applespi_data *applespi,
1133 struct keyboard_protocol *keyboard_protocol)
1138 compiletime_assert(ARRAY_SIZE(applespi_controlcodes) ==
1139 sizeof_field(struct keyboard_protocol, modifiers) * 8,
1140 "applespi_controlcodes has wrong number of entries");
1142 /* check for rollover overflow, which is signalled by all keys == 1 */
1143 if (!memchr_inv(keyboard_protocol->keys_pressed, 1, MAX_ROLLOVER))
1146 /* remap fn key if desired */
1147 applespi_remap_fn_key(keyboard_protocol);
1149 /* check released keys */
1150 for (i = 0; i < MAX_ROLLOVER; i++) {
1151 if (memchr(keyboard_protocol->keys_pressed,
1152 applespi->last_keys_pressed[i], MAX_ROLLOVER))
1153 continue; /* key is still pressed */
1155 key = applespi_code_to_key(applespi->last_keys_pressed[i],
1156 applespi->last_keys_fn_pressed[i]);
1157 input_report_key(applespi->keyboard_input_dev, key, 0);
1158 applespi->last_keys_fn_pressed[i] = 0;
1161 /* check pressed keys */
1162 for (i = 0; i < MAX_ROLLOVER; i++) {
1163 if (keyboard_protocol->keys_pressed[i] <
1164 ARRAY_SIZE(applespi_scancodes) &&
1165 keyboard_protocol->keys_pressed[i] > 0) {
1166 key = applespi_code_to_key(
1167 keyboard_protocol->keys_pressed[i],
1168 keyboard_protocol->fn_pressed);
1169 input_report_key(applespi->keyboard_input_dev, key, 1);
1170 applespi->last_keys_fn_pressed[i] =
1171 keyboard_protocol->fn_pressed;
1175 /* check control keys */
1176 for (i = 0; i < ARRAY_SIZE(applespi_controlcodes); i++) {
1177 if (keyboard_protocol->modifiers & BIT(i))
1178 input_report_key(applespi->keyboard_input_dev,
1179 applespi_controlcodes[i], 1);
1181 input_report_key(applespi->keyboard_input_dev,
1182 applespi_controlcodes[i], 0);
1185 /* check function key */
1186 if (keyboard_protocol->fn_pressed && !applespi->last_fn_pressed)
1187 input_report_key(applespi->keyboard_input_dev, KEY_FN, 1);
1188 else if (!keyboard_protocol->fn_pressed && applespi->last_fn_pressed)
1189 input_report_key(applespi->keyboard_input_dev, KEY_FN, 0);
1190 applespi->last_fn_pressed = keyboard_protocol->fn_pressed;
1193 input_sync(applespi->keyboard_input_dev);
1194 memcpy(&applespi->last_keys_pressed, keyboard_protocol->keys_pressed,
1195 sizeof(applespi->last_keys_pressed));
1198 static const struct applespi_tp_info *applespi_find_touchpad_info(u8 model)
1200 const struct applespi_tp_model_info *info;
1202 for (info = applespi_tp_models; info->model; info++) {
1203 if (info->model == model)
1204 return &info->tp_info;
1211 applespi_register_touchpad_device(struct applespi_data *applespi,
1212 struct touchpad_info_protocol *rcvd_tp_info)
1214 const struct applespi_tp_info *tp_info;
1215 struct input_dev *touchpad_input_dev;
1218 /* set up touchpad dimensions */
1219 tp_info = applespi_find_touchpad_info(rcvd_tp_info->model_no);
1221 dev_warn(&applespi->spi->dev,
1222 "Unknown touchpad model %x - falling back to MB8 touchpad\n",
1223 rcvd_tp_info->model_no);
1224 tp_info = &applespi_tp_models[0].tp_info;
1227 applespi->tp_info = *tp_info;
1229 if (touchpad_dimensions[0]) {
1232 sts = sscanf(touchpad_dimensions, "%dx%d+%u+%u", &x, &y, &w, &h);
1234 dev_info(&applespi->spi->dev,
1235 "Overriding touchpad dimensions from module param\n");
1236 applespi->tp_info.x_min = x;
1237 applespi->tp_info.y_min = y;
1238 applespi->tp_info.x_max = x + w;
1239 applespi->tp_info.y_max = y + h;
1241 dev_warn(&applespi->spi->dev,
1242 "Invalid touchpad dimensions '%s': must be in the form XxY+W+H\n",
1243 touchpad_dimensions);
1244 touchpad_dimensions[0] = '\0';
1247 if (!touchpad_dimensions[0]) {
1248 snprintf(touchpad_dimensions, sizeof(touchpad_dimensions),
1250 applespi->tp_info.x_min,
1251 applespi->tp_info.y_min,
1252 applespi->tp_info.x_max - applespi->tp_info.x_min,
1253 applespi->tp_info.y_max - applespi->tp_info.y_min);
1256 /* create touchpad input device */
1257 touchpad_input_dev = devm_input_allocate_device(&applespi->spi->dev);
1258 if (!touchpad_input_dev) {
1259 dev_err(&applespi->spi->dev,
1260 "Failed to allocate touchpad input device\n");
1264 touchpad_input_dev->name = "Apple SPI Touchpad";
1265 touchpad_input_dev->phys = "applespi/input1";
1266 touchpad_input_dev->dev.parent = &applespi->spi->dev;
1267 touchpad_input_dev->id.bustype = BUS_SPI;
1268 touchpad_input_dev->id.vendor = SYNAPTICS_VENDOR_ID;
1269 touchpad_input_dev->id.product =
1270 rcvd_tp_info->model_no << 8 | rcvd_tp_info->model_flags;
1272 /* basic properties */
1273 input_set_capability(touchpad_input_dev, EV_REL, REL_X);
1274 input_set_capability(touchpad_input_dev, EV_REL, REL_Y);
1276 __set_bit(INPUT_PROP_POINTER, touchpad_input_dev->propbit);
1277 __set_bit(INPUT_PROP_BUTTONPAD, touchpad_input_dev->propbit);
1279 /* finger touch area */
1280 input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MAJOR,
1282 input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MINOR,
1285 /* finger approach area */
1286 input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MAJOR,
1288 input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MINOR,
1291 /* finger orientation */
1292 input_set_abs_params(touchpad_input_dev, ABS_MT_ORIENTATION,
1293 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION,
1296 /* finger position */
1297 input_set_abs_params(touchpad_input_dev, ABS_MT_POSITION_X,
1298 applespi->tp_info.x_min, applespi->tp_info.x_max,
1300 input_set_abs_params(touchpad_input_dev, ABS_MT_POSITION_Y,
1301 applespi->tp_info.y_min, applespi->tp_info.y_max,
1304 /* touchpad button */
1305 input_set_capability(touchpad_input_dev, EV_KEY, BTN_LEFT);
1308 sts = input_mt_init_slots(touchpad_input_dev, MAX_FINGERS,
1309 INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
1312 dev_err(&applespi->spi->dev,
1313 "failed to initialize slots: %d", sts);
1317 /* register input device */
1318 sts = input_register_device(touchpad_input_dev);
1320 dev_err(&applespi->spi->dev,
1321 "Unable to register touchpad input device (%d)\n", sts);
1325 /* touchpad_input_dev is read async in spi callback */
1326 smp_store_release(&applespi->touchpad_input_dev, touchpad_input_dev);
1331 static void applespi_worker(struct work_struct *work)
1333 struct applespi_data *applespi =
1334 container_of(work, struct applespi_data, work);
1336 applespi_register_touchpad_device(applespi, &applespi->rcvd_tp_info);
1339 static void applespi_handle_cmd_response(struct applespi_data *applespi,
1340 struct spi_packet *packet,
1341 struct message *message)
1343 if (packet->device == PACKET_DEV_INFO &&
1344 le16_to_cpu(message->type) == 0x1020) {
1346 * We're not allowed to sleep here, but registering an input
1349 applespi->rcvd_tp_info = message->tp_info;
1350 schedule_work(&applespi->work);
1354 if (le16_to_cpu(message->length) != 0x0000) {
1355 dev_warn_ratelimited(&applespi->spi->dev,
1356 "Received unexpected write response: length=%x\n",
1357 le16_to_cpu(message->length));
1361 if (packet->device == PACKET_DEV_TPAD &&
1362 le16_to_cpu(message->type) == 0x0252 &&
1363 le16_to_cpu(message->rsp_buf_len) == 0x0002)
1364 dev_info(&applespi->spi->dev, "modeswitch done.\n");
1367 static bool applespi_verify_crc(struct applespi_data *applespi, u8 *buffer,
1372 crc = crc16(0, buffer, buflen);
1374 dev_warn_ratelimited(&applespi->spi->dev,
1375 "Received corrupted packet (crc mismatch)\n");
1376 trace_applespi_bad_crc(ET_RD_CRC, READ, buffer, buflen);
1384 static void applespi_debug_print_read_packet(struct applespi_data *applespi,
1385 struct spi_packet *packet)
1387 unsigned int evt_type;
1389 if (packet->flags == PACKET_TYPE_READ &&
1390 packet->device == PACKET_DEV_KEYB)
1391 evt_type = ET_RD_KEYB;
1392 else if (packet->flags == PACKET_TYPE_READ &&
1393 packet->device == PACKET_DEV_TPAD)
1394 evt_type = ET_RD_TPAD;
1395 else if (packet->flags == PACKET_TYPE_WRITE)
1396 evt_type = applespi->cmd_evt_type;
1398 evt_type = ET_RD_UNKN;
1400 applespi_get_trace_fun(evt_type)(evt_type, PT_READ, applespi->rx_buffer,
1401 APPLESPI_PACKET_SIZE);
1404 static void applespi_got_data(struct applespi_data *applespi)
1406 struct spi_packet *packet;
1407 struct message *message;
1408 unsigned int msg_len;
1413 /* process packet header */
1414 if (!applespi_verify_crc(applespi, applespi->rx_buffer,
1415 APPLESPI_PACKET_SIZE)) {
1416 unsigned long flags;
1418 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1420 if (applespi->drain) {
1421 applespi->read_active = false;
1422 applespi->write_active = false;
1424 wake_up_all(&applespi->drain_complete);
1427 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1432 packet = (struct spi_packet *)applespi->rx_buffer;
1434 applespi_debug_print_read_packet(applespi, packet);
1436 off = le16_to_cpu(packet->offset);
1437 rem = le16_to_cpu(packet->remaining);
1438 len = le16_to_cpu(packet->length);
1440 if (len > sizeof(packet->data)) {
1441 dev_warn_ratelimited(&applespi->spi->dev,
1442 "Received corrupted packet (invalid packet length %u)\n",
1447 /* handle multi-packet messages */
1448 if (rem > 0 || off > 0) {
1449 if (off != applespi->saved_msg_len) {
1450 dev_warn_ratelimited(&applespi->spi->dev,
1451 "Received unexpected offset (got %u, expected %u)\n",
1452 off, applespi->saved_msg_len);
1456 if (off + rem > MAX_PKTS_PER_MSG * APPLESPI_PACKET_SIZE) {
1457 dev_warn_ratelimited(&applespi->spi->dev,
1458 "Received message too large (size %u)\n",
1463 if (off + len > MAX_PKTS_PER_MSG * APPLESPI_PACKET_SIZE) {
1464 dev_warn_ratelimited(&applespi->spi->dev,
1465 "Received message too large (size %u)\n",
1470 memcpy(applespi->msg_buf + off, &packet->data, len);
1471 applespi->saved_msg_len += len;
1476 message = (struct message *)applespi->msg_buf;
1477 msg_len = applespi->saved_msg_len;
1479 message = (struct message *)&packet->data;
1483 /* got complete message - verify */
1484 if (!applespi_verify_crc(applespi, (u8 *)message, msg_len))
1487 if (le16_to_cpu(message->length) != msg_len - MSG_HEADER_SIZE - 2) {
1488 dev_warn_ratelimited(&applespi->spi->dev,
1489 "Received corrupted packet (invalid message length %u - expected %u)\n",
1490 le16_to_cpu(message->length),
1491 msg_len - MSG_HEADER_SIZE - 2);
1495 /* handle message */
1496 if (packet->flags == PACKET_TYPE_READ &&
1497 packet->device == PACKET_DEV_KEYB) {
1498 applespi_handle_keyboard_event(applespi, &message->keyboard);
1500 } else if (packet->flags == PACKET_TYPE_READ &&
1501 packet->device == PACKET_DEV_TPAD) {
1502 struct touchpad_protocol *tp;
1505 tp = &message->touchpad;
1506 tp_len = struct_size(tp, fingers, tp->number_of_fingers);
1508 if (le16_to_cpu(message->length) + 2 != tp_len) {
1509 dev_warn_ratelimited(&applespi->spi->dev,
1510 "Received corrupted packet (invalid message length %u - num-fingers %u, tp-len %zu)\n",
1511 le16_to_cpu(message->length),
1512 tp->number_of_fingers, tp_len);
1516 if (tp->number_of_fingers > MAX_FINGERS) {
1517 dev_warn_ratelimited(&applespi->spi->dev,
1518 "Number of reported fingers (%u) exceeds max (%u))\n",
1519 tp->number_of_fingers,
1521 tp->number_of_fingers = MAX_FINGERS;
1524 report_tp_state(applespi, tp);
1526 } else if (packet->flags == PACKET_TYPE_WRITE) {
1527 applespi_handle_cmd_response(applespi, packet, message);
1531 applespi->saved_msg_len = 0;
1533 applespi_msg_complete(applespi, packet->flags == PACKET_TYPE_WRITE,
1537 static void applespi_async_read_complete(void *context)
1539 struct applespi_data *applespi = context;
1541 if (applespi->rd_m.status < 0) {
1542 dev_warn(&applespi->spi->dev, "Error reading from device: %d\n",
1543 applespi->rd_m.status);
1545 * We don't actually know if this was a pure read, or a response
1546 * to a write. But this is a rare error condition that should
1547 * never occur, so clearing both flags to avoid deadlock.
1549 applespi_msg_complete(applespi, true, true);
1551 applespi_got_data(applespi);
1554 acpi_finish_gpe(NULL, applespi->gpe);
1557 static u32 applespi_notify(acpi_handle gpe_device, u32 gpe, void *context)
1559 struct applespi_data *applespi = context;
1561 unsigned long flags;
1563 trace_applespi_irq_received(ET_RD_IRQ, PT_READ);
1565 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1567 if (!applespi->suspended) {
1568 sts = applespi_async(applespi, &applespi->rd_m,
1569 applespi_async_read_complete);
1571 dev_warn(&applespi->spi->dev,
1572 "Error queueing async read to device: %d\n",
1575 applespi->read_active = true;
1578 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1580 return ACPI_INTERRUPT_HANDLED;
1583 static int applespi_get_saved_bl_level(struct applespi_data *applespi)
1585 struct efivar_entry *efivar_entry;
1587 unsigned long efi_data_len;
1590 efivar_entry = kmalloc(sizeof(*efivar_entry), GFP_KERNEL);
1594 memcpy(efivar_entry->var.VariableName, EFI_BL_LEVEL_NAME,
1595 sizeof(EFI_BL_LEVEL_NAME));
1596 efivar_entry->var.VendorGuid = EFI_BL_LEVEL_GUID;
1597 efi_data_len = sizeof(efi_data);
1599 sts = efivar_entry_get(efivar_entry, NULL, &efi_data_len, &efi_data);
1600 if (sts && sts != -ENOENT)
1601 dev_warn(&applespi->spi->dev,
1602 "Error getting backlight level from EFI vars: %d\n",
1605 kfree(efivar_entry);
1607 return sts ? sts : efi_data;
1610 static void applespi_save_bl_level(struct applespi_data *applespi,
1613 efi_guid_t efi_guid;
1615 unsigned long efi_data_len;
1619 /* Save keyboard backlight level */
1620 efi_guid = EFI_BL_LEVEL_GUID;
1621 efi_data = (u16)level;
1622 efi_data_len = sizeof(efi_data);
1623 efi_attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS |
1624 EFI_VARIABLE_RUNTIME_ACCESS;
1626 sts = efivar_entry_set_safe((efi_char16_t *)EFI_BL_LEVEL_NAME, efi_guid,
1627 efi_attr, true, efi_data_len, &efi_data);
1629 dev_warn(&applespi->spi->dev,
1630 "Error saving backlight level to EFI vars: %d\n", sts);
1633 static int applespi_probe(struct spi_device *spi)
1635 struct applespi_data *applespi;
1636 acpi_handle spi_handle = ACPI_HANDLE(&spi->dev);
1637 acpi_status acpi_sts;
1639 unsigned long long gpe, usb_status;
1641 /* check if the USB interface is present and enabled already */
1642 acpi_sts = acpi_evaluate_integer(spi_handle, "UIST", NULL, &usb_status);
1643 if (ACPI_SUCCESS(acpi_sts) && usb_status) {
1644 /* let the USB driver take over instead */
1645 dev_info(&spi->dev, "USB interface already enabled\n");
1649 /* allocate driver data */
1650 applespi = devm_kzalloc(&spi->dev, sizeof(*applespi), GFP_KERNEL);
1654 applespi->spi = spi;
1656 INIT_WORK(&applespi->work, applespi_worker);
1658 /* store the driver data */
1659 spi_set_drvdata(spi, applespi);
1661 /* create our buffers */
1662 applespi->tx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1664 applespi->tx_status = devm_kmalloc(&spi->dev, APPLESPI_STATUS_SIZE,
1666 applespi->rx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1668 applespi->msg_buf = devm_kmalloc_array(&spi->dev, MAX_PKTS_PER_MSG,
1669 APPLESPI_PACKET_SIZE,
1672 if (!applespi->tx_buffer || !applespi->tx_status ||
1673 !applespi->rx_buffer || !applespi->msg_buf)
1676 /* set up our spi messages */
1677 applespi_setup_read_txfrs(applespi);
1678 applespi_setup_write_txfrs(applespi);
1680 /* cache ACPI method handles */
1681 acpi_sts = acpi_get_handle(spi_handle, "SIEN", &applespi->sien);
1682 if (ACPI_FAILURE(acpi_sts)) {
1683 dev_err(&applespi->spi->dev,
1684 "Failed to get SIEN ACPI method handle: %s\n",
1685 acpi_format_exception(acpi_sts));
1689 acpi_sts = acpi_get_handle(spi_handle, "SIST", &applespi->sist);
1690 if (ACPI_FAILURE(acpi_sts)) {
1691 dev_err(&applespi->spi->dev,
1692 "Failed to get SIST ACPI method handle: %s\n",
1693 acpi_format_exception(acpi_sts));
1697 /* switch on the SPI interface */
1698 sts = applespi_setup_spi(applespi);
1702 sts = applespi_enable_spi(applespi);
1706 /* setup the keyboard input dev */
1707 applespi->keyboard_input_dev = devm_input_allocate_device(&spi->dev);
1709 if (!applespi->keyboard_input_dev)
1712 applespi->keyboard_input_dev->name = "Apple SPI Keyboard";
1713 applespi->keyboard_input_dev->phys = "applespi/input0";
1714 applespi->keyboard_input_dev->dev.parent = &spi->dev;
1715 applespi->keyboard_input_dev->id.bustype = BUS_SPI;
1717 applespi->keyboard_input_dev->evbit[0] =
1718 BIT_MASK(EV_KEY) | BIT_MASK(EV_LED) | BIT_MASK(EV_REP);
1719 applespi->keyboard_input_dev->ledbit[0] = BIT_MASK(LED_CAPSL);
1721 input_set_drvdata(applespi->keyboard_input_dev, applespi);
1722 applespi->keyboard_input_dev->event = applespi_event;
1724 for (i = 0; i < ARRAY_SIZE(applespi_scancodes); i++)
1725 if (applespi_scancodes[i])
1726 input_set_capability(applespi->keyboard_input_dev,
1727 EV_KEY, applespi_scancodes[i]);
1729 for (i = 0; i < ARRAY_SIZE(applespi_controlcodes); i++)
1730 if (applespi_controlcodes[i])
1731 input_set_capability(applespi->keyboard_input_dev,
1732 EV_KEY, applespi_controlcodes[i]);
1734 for (i = 0; i < ARRAY_SIZE(applespi_fn_codes); i++)
1735 if (applespi_fn_codes[i].to)
1736 input_set_capability(applespi->keyboard_input_dev,
1737 EV_KEY, applespi_fn_codes[i].to);
1739 input_set_capability(applespi->keyboard_input_dev, EV_KEY, KEY_FN);
1741 sts = input_register_device(applespi->keyboard_input_dev);
1743 dev_err(&applespi->spi->dev,
1744 "Unable to register keyboard input device (%d)\n", sts);
1749 * The applespi device doesn't send interrupts normally (as is described
1750 * in its DSDT), but rather seems to use ACPI GPEs.
1752 acpi_sts = acpi_evaluate_integer(spi_handle, "_GPE", NULL, &gpe);
1753 if (ACPI_FAILURE(acpi_sts)) {
1754 dev_err(&applespi->spi->dev,
1755 "Failed to obtain GPE for SPI slave device: %s\n",
1756 acpi_format_exception(acpi_sts));
1759 applespi->gpe = (int)gpe;
1761 acpi_sts = acpi_install_gpe_handler(NULL, applespi->gpe,
1762 ACPI_GPE_LEVEL_TRIGGERED,
1763 applespi_notify, applespi);
1764 if (ACPI_FAILURE(acpi_sts)) {
1765 dev_err(&applespi->spi->dev,
1766 "Failed to install GPE handler for GPE %d: %s\n",
1767 applespi->gpe, acpi_format_exception(acpi_sts));
1771 applespi->suspended = false;
1773 acpi_sts = acpi_enable_gpe(NULL, applespi->gpe);
1774 if (ACPI_FAILURE(acpi_sts)) {
1775 dev_err(&applespi->spi->dev,
1776 "Failed to enable GPE handler for GPE %d: %s\n",
1777 applespi->gpe, acpi_format_exception(acpi_sts));
1778 acpi_remove_gpe_handler(NULL, applespi->gpe, applespi_notify);
1782 /* trigger touchpad setup */
1783 applespi_init(applespi, false);
1786 * By default this device is not enabled for wakeup; but USB keyboards
1787 * generally are, so the expectation is that by default the keyboard
1788 * will wake the system.
1790 device_wakeup_enable(&spi->dev);
1792 /* set up keyboard-backlight */
1793 sts = applespi_get_saved_bl_level(applespi);
1795 applespi_set_bl_level(&applespi->backlight_info, sts);
1797 applespi->backlight_info.name = "spi::kbd_backlight";
1798 applespi->backlight_info.default_trigger = "kbd-backlight";
1799 applespi->backlight_info.brightness_set = applespi_set_bl_level;
1801 sts = devm_led_classdev_register(&spi->dev, &applespi->backlight_info);
1803 dev_warn(&applespi->spi->dev,
1804 "Unable to register keyboard backlight class dev (%d)\n",
1807 /* set up debugfs entries for touchpad dimensions logging */
1808 applespi->debugfs_root = debugfs_create_dir("applespi", NULL);
1810 debugfs_create_bool("enable_tp_dim", 0600, applespi->debugfs_root,
1811 &applespi->debug_tp_dim);
1813 debugfs_create_file("tp_dim", 0400, applespi->debugfs_root, applespi,
1814 &applespi_tp_dim_fops);
1819 static void applespi_drain_writes(struct applespi_data *applespi)
1821 unsigned long flags;
1823 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1825 applespi->drain = true;
1826 wait_event_lock_irq(applespi->drain_complete, !applespi->write_active,
1827 applespi->cmd_msg_lock);
1829 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1832 static void applespi_drain_reads(struct applespi_data *applespi)
1834 unsigned long flags;
1836 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1838 wait_event_lock_irq(applespi->drain_complete, !applespi->read_active,
1839 applespi->cmd_msg_lock);
1841 applespi->suspended = true;
1843 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1846 static int applespi_remove(struct spi_device *spi)
1848 struct applespi_data *applespi = spi_get_drvdata(spi);
1850 applespi_drain_writes(applespi);
1852 acpi_disable_gpe(NULL, applespi->gpe);
1853 acpi_remove_gpe_handler(NULL, applespi->gpe, applespi_notify);
1854 device_wakeup_disable(&spi->dev);
1856 applespi_drain_reads(applespi);
1858 debugfs_remove_recursive(applespi->debugfs_root);
1863 static void applespi_shutdown(struct spi_device *spi)
1865 struct applespi_data *applespi = spi_get_drvdata(spi);
1867 applespi_save_bl_level(applespi, applespi->have_bl_level);
1870 static int applespi_poweroff_late(struct device *dev)
1872 struct spi_device *spi = to_spi_device(dev);
1873 struct applespi_data *applespi = spi_get_drvdata(spi);
1875 applespi_save_bl_level(applespi, applespi->have_bl_level);
1880 static int __maybe_unused applespi_suspend(struct device *dev)
1882 struct spi_device *spi = to_spi_device(dev);
1883 struct applespi_data *applespi = spi_get_drvdata(spi);
1884 acpi_status acpi_sts;
1887 /* turn off caps-lock - it'll stay on otherwise */
1888 sts = applespi_set_capsl_led(applespi, false);
1890 dev_warn(&applespi->spi->dev,
1891 "Failed to turn off caps-lock led (%d)\n", sts);
1893 applespi_drain_writes(applespi);
1895 /* disable the interrupt */
1896 acpi_sts = acpi_disable_gpe(NULL, applespi->gpe);
1897 if (ACPI_FAILURE(acpi_sts))
1898 dev_err(&applespi->spi->dev,
1899 "Failed to disable GPE handler for GPE %d: %s\n",
1900 applespi->gpe, acpi_format_exception(acpi_sts));
1902 applespi_drain_reads(applespi);
1907 static int __maybe_unused applespi_resume(struct device *dev)
1909 struct spi_device *spi = to_spi_device(dev);
1910 struct applespi_data *applespi = spi_get_drvdata(spi);
1911 acpi_status acpi_sts;
1912 unsigned long flags;
1914 /* ensure our flags and state reflect a newly resumed device */
1915 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1917 applespi->drain = false;
1918 applespi->have_cl_led_on = false;
1919 applespi->have_bl_level = 0;
1920 applespi->cmd_msg_queued = 0;
1921 applespi->read_active = false;
1922 applespi->write_active = false;
1924 applespi->suspended = false;
1926 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1928 /* switch on the SPI interface */
1929 applespi_enable_spi(applespi);
1931 /* re-enable the interrupt */
1932 acpi_sts = acpi_enable_gpe(NULL, applespi->gpe);
1933 if (ACPI_FAILURE(acpi_sts))
1934 dev_err(&applespi->spi->dev,
1935 "Failed to re-enable GPE handler for GPE %d: %s\n",
1936 applespi->gpe, acpi_format_exception(acpi_sts));
1938 /* switch the touchpad into multitouch mode */
1939 applespi_init(applespi, true);
1944 static const struct acpi_device_id applespi_acpi_match[] = {
1948 MODULE_DEVICE_TABLE(acpi, applespi_acpi_match);
1950 static const struct dev_pm_ops applespi_pm_ops = {
1951 SET_SYSTEM_SLEEP_PM_OPS(applespi_suspend, applespi_resume)
1952 .poweroff_late = applespi_poweroff_late,
1955 static struct spi_driver applespi_driver = {
1958 .acpi_match_table = applespi_acpi_match,
1959 .pm = &applespi_pm_ops,
1961 .probe = applespi_probe,
1962 .remove = applespi_remove,
1963 .shutdown = applespi_shutdown,
1966 module_spi_driver(applespi_driver)
1968 MODULE_LICENSE("GPL v2");
1969 MODULE_DESCRIPTION("MacBook(Pro) SPI Keyboard/Touchpad driver");
1970 MODULE_AUTHOR("Federico Lorenzi");
1971 MODULE_AUTHOR("Ronald Tschalär");