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/leds.h>
52 #include <linux/module.h>
53 #include <linux/spinlock.h>
54 #include <linux/spi/spi.h>
55 #include <linux/wait.h>
56 #include <linux/workqueue.h>
58 #include <asm/barrier.h>
59 #include <asm/unaligned.h>
61 #define CREATE_TRACE_POINTS
63 #include "applespi_trace.h"
65 #define APPLESPI_PACKET_SIZE 256
66 #define APPLESPI_STATUS_SIZE 4
68 #define PACKET_TYPE_READ 0x20
69 #define PACKET_TYPE_WRITE 0x40
70 #define PACKET_DEV_KEYB 0x01
71 #define PACKET_DEV_TPAD 0x02
72 #define PACKET_DEV_INFO 0xd0
74 #define MAX_ROLLOVER 6
76 #define MAX_FINGERS 11
77 #define MAX_FINGER_ORIENTATION 16384
78 #define MAX_PKTS_PER_MSG 2
80 #define KBD_BL_LEVEL_MIN 32U
81 #define KBD_BL_LEVEL_MAX 255U
82 #define KBD_BL_LEVEL_SCALE 1000000U
83 #define KBD_BL_LEVEL_ADJ \
84 ((KBD_BL_LEVEL_MAX - KBD_BL_LEVEL_MIN) * KBD_BL_LEVEL_SCALE / 255U)
86 #define EFI_BL_LEVEL_NAME L"KeyboardBacklightLevel"
87 #define EFI_BL_LEVEL_GUID EFI_GUID(0xa076d2af, 0x9678, 0x4386, 0x8b, 0x58, 0x1f, 0xc8, 0xef, 0x04, 0x16, 0x19)
89 #define APPLE_FLAG_FKEY 0x01
91 #define SPI_RW_CHG_DELAY_US 100 /* from experimentation, in µs */
93 #define SYNAPTICS_VENDOR_ID 0x06cb
95 static unsigned int fnmode = 1;
96 module_param(fnmode, uint, 0644);
97 MODULE_PARM_DESC(fnmode, "Mode of Fn key on Apple keyboards (0 = disabled, [1] = fkeyslast, 2 = fkeysfirst)");
99 static unsigned int fnremap;
100 module_param(fnremap, uint, 0644);
101 MODULE_PARM_DESC(fnremap, "Remap Fn key ([0] = no-remap; 1 = left-ctrl, 2 = left-shift, 3 = left-alt, 4 = left-meta, 6 = right-shift, 7 = right-alt, 8 = right-meta)");
103 static bool iso_layout;
104 module_param(iso_layout, bool, 0644);
105 MODULE_PARM_DESC(iso_layout, "Enable/Disable hardcoded ISO-layout of the keyboard. ([0] = disabled, 1 = enabled)");
107 static char touchpad_dimensions[40];
108 module_param_string(touchpad_dimensions, touchpad_dimensions,
109 sizeof(touchpad_dimensions), 0444);
110 MODULE_PARM_DESC(touchpad_dimensions, "The pixel dimensions of the touchpad, as XxY+W+H .");
113 * struct keyboard_protocol - keyboard message.
114 * message.type = 0x0110, message.length = 0x000a
117 * @modifiers: bit-set of modifier/control keys pressed
119 * @keys_pressed: the (non-modifier) keys currently pressed
120 * @fn_pressed: whether the fn key is currently pressed
121 * @crc16: crc over the whole message struct (message header +
122 * this struct) minus this @crc16 field
124 struct keyboard_protocol {
128 u8 keys_pressed[MAX_ROLLOVER];
134 * struct tp_finger - single trackpad finger structure, le16-aligned
136 * @origin: zero when switching track finger
137 * @abs_x: absolute x coodinate
138 * @abs_y: absolute y coodinate
139 * @rel_x: relative x coodinate
140 * @rel_y: relative y coodinate
141 * @tool_major: tool area, major axis
142 * @tool_minor: tool area, minor axis
143 * @orientation: 16384 when point, else 15 bit angle
144 * @touch_major: touch area, major axis
145 * @touch_minor: touch area, minor axis
147 * @pressure: pressure on forcetouch touchpad
148 * @multi: one finger: varies, more fingers: constant
149 * @crc16: on last finger: crc over the whole message struct
150 * (i.e. message header + this struct) minus the last
151 * @crc16 field; unknown on all other fingers.
171 * struct touchpad_protocol - touchpad message.
172 * message.type = 0x0210
175 * @clicked: 1 if a button-click was detected, 0 otherwise
177 * @number_of_fingers: the number of fingers being reported in @fingers
178 * @clicked2: same as @clicked
180 * @fingers: the data for each finger
182 struct touchpad_protocol {
186 u8 number_of_fingers;
189 struct tp_finger fingers[0];
193 * struct command_protocol_tp_info - get touchpad info.
194 * message.type = 0x1020, message.length = 0x0000
196 * @crc16: crc over the whole message struct (message header +
197 * this struct) minus this @crc16 field
199 struct command_protocol_tp_info {
204 * struct touchpad_info - touchpad info response.
205 * message.type = 0x1020, message.length = 0x006e
208 * @model_flags: flags (vary by model number, but significance otherwise
210 * @model_no: the touchpad model number
212 * @crc16: crc over the whole message struct (message header +
213 * this struct) minus this @crc16 field
215 struct touchpad_info_protocol {
224 * struct command_protocol_mt_init - initialize multitouch.
225 * message.type = 0x0252, message.length = 0x0002
227 * @cmd: value: 0x0102
228 * @crc16: crc over the whole message struct (message header +
229 * this struct) minus this @crc16 field
231 struct command_protocol_mt_init {
237 * struct command_protocol_capsl - toggle caps-lock led
238 * message.type = 0x0151, message.length = 0x0002
240 * @unknown: value: 0x01 (length?)
242 * @crc16: crc over the whole message struct (message header +
243 * this struct) minus this @crc16 field
245 struct command_protocol_capsl {
252 * struct command_protocol_bl - set keyboard backlight brightness
253 * message.type = 0xB051, message.length = 0x0006
255 * @const1: value: 0x01B0
256 * @level: the brightness level to set
257 * @const2: value: 0x0001 (backlight off), 0x01F4 (backlight on)
258 * @crc16: crc over the whole message struct (message header +
259 * this struct) minus this @crc16 field
261 struct command_protocol_bl {
269 * struct message - a complete spi message.
271 * Each message begins with fixed header, followed by a message-type specific
272 * payload, and ends with a 16-bit crc. Because of the varying lengths of the
273 * payload, the crc is defined at the end of each payload struct, rather than
276 * @type: the message type
278 * @counter: incremented on each message, rolls over after 255; there is a
279 * separate counter for each message type.
280 * @rsp_buf_len:response buffer length (the exact nature of this field is quite
281 * speculative). On a request/write this is often the same as
282 * @length, though in some cases it has been seen to be much larger
283 * (e.g. 0x400); on a response/read this the same as on the
284 * request; for reads that are not responses it is 0.
285 * @length: length of the remainder of the data in the whole message
286 * structure (after re-assembly in case of being split over
287 * multiple spi-packets), minus the trailing crc. The total size
288 * of the message struct is therefore @length + 10.
297 struct keyboard_protocol keyboard;
298 struct touchpad_protocol touchpad;
299 struct touchpad_info_protocol tp_info;
300 struct command_protocol_tp_info tp_info_command;
301 struct command_protocol_mt_init init_mt_command;
302 struct command_protocol_capsl capsl_command;
303 struct command_protocol_bl bl_command;
308 /* type + zero + counter + rsp_buf_len + length */
309 #define MSG_HEADER_SIZE 8
312 * struct spi_packet - a complete spi packet; always 256 bytes. This carries
313 * the (parts of the) message in the data. But note that this does not
314 * necessarily contain a complete message, as in some cases (e.g. many
315 * fingers pressed) the message is split over multiple packets (see the
316 * @offset, @remaining, and @length fields). In general the data parts in
317 * spi_packet's are concatenated until @remaining is 0, and the result is an
320 * @flags: 0x40 = write (to device), 0x20 = read (from device); note that
321 * the response to a write still has 0x40.
322 * @device: 1 = keyboard, 2 = touchpad
323 * @offset: specifies the offset of this packet's data in the complete
324 * message; i.e. > 0 indicates this is a continuation packet (in
325 * the second packet for a message split over multiple packets
326 * this would then be the same as the @length in the first packet)
327 * @remaining: number of message bytes remaining in subsequents packets (in
328 * the first packet of a message split over two packets this would
329 * then be the same as the @length in the second packet)
330 * @length: length of the valid data in the @data in this packet
331 * @data: all or part of a message
332 * @crc16: crc over this whole structure minus this @crc16 field. This
333 * covers just this packet, even on multi-packet messages (in
334 * contrast to the crc in the message).
346 struct spi_settings {
347 u64 spi_cs_delay; /* cs-to-clk delay in us */
348 u64 reset_a2r_usec; /* active-to-receive delay? */
349 u64 reset_rec_usec; /* ? (cur val: 10) */
352 /* this mimics struct drm_rect */
353 struct applespi_tp_info {
360 struct applespi_data {
361 struct spi_device *spi;
362 struct spi_settings spi_settings;
363 struct input_dev *keyboard_input_dev;
364 struct input_dev *touchpad_input_dev;
371 unsigned int saved_msg_len;
373 struct applespi_tp_info tp_info;
375 u8 last_keys_pressed[MAX_ROLLOVER];
376 u8 last_keys_fn_pressed[MAX_ROLLOVER];
378 struct input_mt_pos pos[MAX_FINGERS];
379 int slots[MAX_FINGERS];
384 struct spi_transfer dl_t;
385 struct spi_transfer rd_t;
386 struct spi_message rd_m;
388 struct spi_transfer ww_t;
389 struct spi_transfer wd_t;
390 struct spi_transfer wr_t;
391 struct spi_transfer st_t;
392 struct spi_message wr_m;
394 bool want_tp_info_cmd;
395 bool want_mt_init_cmd;
398 unsigned int want_bl_level;
399 unsigned int have_bl_level;
400 unsigned int cmd_msg_cntr;
401 /* lock to protect the above parameters and flags below */
402 spinlock_t cmd_msg_lock;
404 enum applespi_evt_type cmd_evt_type;
406 struct led_classdev backlight_info;
410 wait_queue_head_t drain_complete;
414 struct work_struct work;
415 struct touchpad_info_protocol rcvd_tp_info;
417 struct dentry *debugfs_root;
426 static const unsigned char applespi_scancodes[] = {
428 KEY_A, KEY_B, KEY_C, KEY_D, KEY_E, KEY_F, KEY_G, KEY_H, KEY_I, KEY_J,
429 KEY_K, KEY_L, KEY_M, KEY_N, KEY_O, KEY_P, KEY_Q, KEY_R, KEY_S, KEY_T,
430 KEY_U, KEY_V, KEY_W, KEY_X, KEY_Y, KEY_Z,
431 KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0,
432 KEY_ENTER, KEY_ESC, KEY_BACKSPACE, KEY_TAB, KEY_SPACE, KEY_MINUS,
433 KEY_EQUAL, KEY_LEFTBRACE, KEY_RIGHTBRACE, KEY_BACKSLASH, 0,
434 KEY_SEMICOLON, KEY_APOSTROPHE, KEY_GRAVE, KEY_COMMA, KEY_DOT, KEY_SLASH,
436 KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9,
437 KEY_F10, KEY_F11, KEY_F12, 0, 0, 0, 0, 0, 0, 0, 0, 0,
438 KEY_RIGHT, KEY_LEFT, KEY_DOWN, KEY_UP,
439 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_102ND,
440 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
441 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_RO, 0, KEY_YEN, 0, 0, 0, 0, 0,
442 0, KEY_KATAKANAHIRAGANA, KEY_MUHENKAN
446 * This must have exactly as many entries as there are bits in
447 * struct keyboard_protocol.modifiers .
449 static const unsigned char applespi_controlcodes[] = {
460 struct applespi_key_translation {
466 static const struct applespi_key_translation applespi_fn_codes[] = {
467 { KEY_BACKSPACE, KEY_DELETE },
468 { KEY_ENTER, KEY_INSERT },
469 { KEY_F1, KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
470 { KEY_F2, KEY_BRIGHTNESSUP, APPLE_FLAG_FKEY },
471 { KEY_F3, KEY_SCALE, APPLE_FLAG_FKEY },
472 { KEY_F4, KEY_DASHBOARD, APPLE_FLAG_FKEY },
473 { KEY_F5, KEY_KBDILLUMDOWN, APPLE_FLAG_FKEY },
474 { KEY_F6, KEY_KBDILLUMUP, APPLE_FLAG_FKEY },
475 { KEY_F7, KEY_PREVIOUSSONG, APPLE_FLAG_FKEY },
476 { KEY_F8, KEY_PLAYPAUSE, APPLE_FLAG_FKEY },
477 { KEY_F9, KEY_NEXTSONG, APPLE_FLAG_FKEY },
478 { KEY_F10, KEY_MUTE, APPLE_FLAG_FKEY },
479 { KEY_F11, KEY_VOLUMEDOWN, APPLE_FLAG_FKEY },
480 { KEY_F12, KEY_VOLUMEUP, APPLE_FLAG_FKEY },
481 { KEY_RIGHT, KEY_END },
482 { KEY_LEFT, KEY_HOME },
483 { KEY_DOWN, KEY_PAGEDOWN },
484 { KEY_UP, KEY_PAGEUP },
488 static const struct applespi_key_translation apple_iso_keyboard[] = {
489 { KEY_GRAVE, KEY_102ND },
490 { KEY_102ND, KEY_GRAVE },
494 struct applespi_tp_model_info {
496 struct applespi_tp_info tp_info;
499 static const struct applespi_tp_model_info applespi_tp_models[] = {
501 .model = 0x04, /* MB8 MB9 MB10 */
502 .tp_info = { -5087, -182, 5579, 6089 },
505 .model = 0x05, /* MBP13,1 MBP13,2 MBP14,1 MBP14,2 */
506 .tp_info = { -6243, -170, 6749, 7685 },
509 .model = 0x06, /* MBP13,3 MBP14,3 */
510 .tp_info = { -7456, -163, 7976, 9283 },
515 typedef void (*applespi_trace_fun)(enum applespi_evt_type,
516 enum applespi_pkt_type, u8 *, size_t);
518 static applespi_trace_fun applespi_get_trace_fun(enum applespi_evt_type type)
522 return trace_applespi_tp_ini_cmd;
524 return trace_applespi_backlight_cmd;
526 return trace_applespi_caps_lock_cmd;
528 return trace_applespi_keyboard_data;
530 return trace_applespi_touchpad_data;
532 return trace_applespi_unknown_data;
534 WARN_ONCE(1, "Unknown msg type %d", type);
535 return trace_applespi_unknown_data;
539 static void applespi_setup_read_txfrs(struct applespi_data *applespi)
541 struct spi_message *msg = &applespi->rd_m;
542 struct spi_transfer *dl_t = &applespi->dl_t;
543 struct spi_transfer *rd_t = &applespi->rd_t;
545 memset(dl_t, 0, sizeof(*dl_t));
546 memset(rd_t, 0, sizeof(*rd_t));
548 dl_t->delay_usecs = applespi->spi_settings.spi_cs_delay;
550 rd_t->rx_buf = applespi->rx_buffer;
551 rd_t->len = APPLESPI_PACKET_SIZE;
553 spi_message_init(msg);
554 spi_message_add_tail(dl_t, msg);
555 spi_message_add_tail(rd_t, msg);
558 static void applespi_setup_write_txfrs(struct applespi_data *applespi)
560 struct spi_message *msg = &applespi->wr_m;
561 struct spi_transfer *wt_t = &applespi->ww_t;
562 struct spi_transfer *dl_t = &applespi->wd_t;
563 struct spi_transfer *wr_t = &applespi->wr_t;
564 struct spi_transfer *st_t = &applespi->st_t;
566 memset(wt_t, 0, sizeof(*wt_t));
567 memset(dl_t, 0, sizeof(*dl_t));
568 memset(wr_t, 0, sizeof(*wr_t));
569 memset(st_t, 0, sizeof(*st_t));
572 * All we need here is a delay at the beginning of the message before
573 * asserting cs. But the current spi API doesn't support this, so we
574 * end up with an extra unnecessary (but harmless) cs assertion and
577 wt_t->delay_usecs = SPI_RW_CHG_DELAY_US;
580 dl_t->delay_usecs = applespi->spi_settings.spi_cs_delay;
582 wr_t->tx_buf = applespi->tx_buffer;
583 wr_t->len = APPLESPI_PACKET_SIZE;
584 wr_t->delay_usecs = SPI_RW_CHG_DELAY_US;
586 st_t->rx_buf = applespi->tx_status;
587 st_t->len = APPLESPI_STATUS_SIZE;
589 spi_message_init(msg);
590 spi_message_add_tail(wt_t, msg);
591 spi_message_add_tail(dl_t, msg);
592 spi_message_add_tail(wr_t, msg);
593 spi_message_add_tail(st_t, msg);
596 static int applespi_async(struct applespi_data *applespi,
597 struct spi_message *message, void (*complete)(void *))
599 message->complete = complete;
600 message->context = applespi;
602 return spi_async(applespi->spi, message);
605 static inline bool applespi_check_write_status(struct applespi_data *applespi,
608 static u8 status_ok[] = { 0xac, 0x27, 0x68, 0xd5 };
611 dev_warn(&applespi->spi->dev, "Error writing to device: %d\n",
616 if (memcmp(applespi->tx_status, status_ok, APPLESPI_STATUS_SIZE)) {
617 dev_warn(&applespi->spi->dev, "Error writing to device: %*ph\n",
618 APPLESPI_STATUS_SIZE, applespi->tx_status);
625 static int applespi_get_spi_settings(struct applespi_data *applespi)
627 struct acpi_device *adev = ACPI_COMPANION(&applespi->spi->dev);
628 const union acpi_object *o;
629 struct spi_settings *settings = &applespi->spi_settings;
631 if (!acpi_dev_get_property(adev, "spiCSDelay", ACPI_TYPE_BUFFER, &o))
632 settings->spi_cs_delay = *(u64 *)o->buffer.pointer;
634 dev_warn(&applespi->spi->dev,
635 "Property spiCSDelay not found\n");
637 if (!acpi_dev_get_property(adev, "resetA2RUsec", ACPI_TYPE_BUFFER, &o))
638 settings->reset_a2r_usec = *(u64 *)o->buffer.pointer;
640 dev_warn(&applespi->spi->dev,
641 "Property resetA2RUsec not found\n");
643 if (!acpi_dev_get_property(adev, "resetRecUsec", ACPI_TYPE_BUFFER, &o))
644 settings->reset_rec_usec = *(u64 *)o->buffer.pointer;
646 dev_warn(&applespi->spi->dev,
647 "Property resetRecUsec not found\n");
649 dev_dbg(&applespi->spi->dev,
650 "SPI settings: spi_cs_delay=%llu reset_a2r_usec=%llu reset_rec_usec=%llu\n",
651 settings->spi_cs_delay, settings->reset_a2r_usec,
652 settings->reset_rec_usec);
657 static int applespi_setup_spi(struct applespi_data *applespi)
661 sts = applespi_get_spi_settings(applespi);
665 spin_lock_init(&applespi->cmd_msg_lock);
666 init_waitqueue_head(&applespi->drain_complete);
671 static int applespi_enable_spi(struct applespi_data *applespi)
673 acpi_status acpi_sts;
674 unsigned long long spi_status;
676 /* check if SPI is already enabled, so we can skip the delay below */
677 acpi_sts = acpi_evaluate_integer(applespi->sist, NULL, NULL,
679 if (ACPI_SUCCESS(acpi_sts) && spi_status)
682 /* SIEN(1) will enable SPI communication */
683 acpi_sts = acpi_execute_simple_method(applespi->sien, NULL, 1);
684 if (ACPI_FAILURE(acpi_sts)) {
685 dev_err(&applespi->spi->dev, "SIEN failed: %s\n",
686 acpi_format_exception(acpi_sts));
691 * Allow the SPI interface to come up before returning. Without this
692 * delay, the SPI commands to enable multitouch mode may not reach
693 * the trackpad controller, causing pointer movement to break upon
701 static int applespi_send_cmd_msg(struct applespi_data *applespi);
703 static void applespi_msg_complete(struct applespi_data *applespi,
704 bool is_write_msg, bool is_read_compl)
708 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
711 applespi->read_active = false;
713 applespi->write_active = false;
715 if (applespi->drain && !applespi->write_active)
716 wake_up_all(&applespi->drain_complete);
719 applespi->cmd_msg_queued = false;
720 applespi_send_cmd_msg(applespi);
723 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
726 static void applespi_async_write_complete(void *context)
728 struct applespi_data *applespi = context;
729 enum applespi_evt_type evt_type = applespi->cmd_evt_type;
731 applespi_get_trace_fun(evt_type)(evt_type, PT_WRITE,
733 APPLESPI_PACKET_SIZE);
734 applespi_get_trace_fun(evt_type)(evt_type, PT_STATUS,
736 APPLESPI_STATUS_SIZE);
738 if (!applespi_check_write_status(applespi, applespi->wr_m.status)) {
740 * If we got an error, we presumably won't get the expected
741 * response message either.
743 applespi_msg_complete(applespi, true, false);
747 static int applespi_send_cmd_msg(struct applespi_data *applespi)
751 struct spi_packet *packet = (struct spi_packet *)applespi->tx_buffer;
752 struct message *message = (struct message *)packet->data;
756 /* check if draining */
760 /* check whether send is in progress */
761 if (applespi->cmd_msg_queued)
765 memset(packet, 0, APPLESPI_PACKET_SIZE);
767 /* are we processing init commands? */
768 if (applespi->want_tp_info_cmd) {
769 applespi->want_tp_info_cmd = false;
770 applespi->want_mt_init_cmd = true;
771 applespi->cmd_evt_type = ET_CMD_TP_INI;
773 /* build init command */
774 device = PACKET_DEV_INFO;
776 message->type = cpu_to_le16(0x1020);
777 msg_len = sizeof(message->tp_info_command);
779 message->zero = 0x02;
780 message->rsp_buf_len = cpu_to_le16(0x0200);
782 } else if (applespi->want_mt_init_cmd) {
783 applespi->want_mt_init_cmd = false;
784 applespi->cmd_evt_type = ET_CMD_TP_INI;
786 /* build init command */
787 device = PACKET_DEV_TPAD;
789 message->type = cpu_to_le16(0x0252);
790 msg_len = sizeof(message->init_mt_command);
792 message->init_mt_command.cmd = cpu_to_le16(0x0102);
794 /* do we need caps-lock command? */
795 } else if (applespi->want_cl_led_on != applespi->have_cl_led_on) {
796 applespi->have_cl_led_on = applespi->want_cl_led_on;
797 applespi->cmd_evt_type = ET_CMD_CL;
799 /* build led command */
800 device = PACKET_DEV_KEYB;
802 message->type = cpu_to_le16(0x0151);
803 msg_len = sizeof(message->capsl_command);
805 message->capsl_command.unknown = 0x01;
806 message->capsl_command.led = applespi->have_cl_led_on ? 2 : 0;
808 /* do we need backlight command? */
809 } else if (applespi->want_bl_level != applespi->have_bl_level) {
810 applespi->have_bl_level = applespi->want_bl_level;
811 applespi->cmd_evt_type = ET_CMD_BL;
813 /* build command buffer */
814 device = PACKET_DEV_KEYB;
816 message->type = cpu_to_le16(0xB051);
817 msg_len = sizeof(message->bl_command);
819 message->bl_command.const1 = cpu_to_le16(0x01B0);
820 message->bl_command.level =
821 cpu_to_le16(applespi->have_bl_level);
823 if (applespi->have_bl_level > 0)
824 message->bl_command.const2 = cpu_to_le16(0x01F4);
826 message->bl_command.const2 = cpu_to_le16(0x0001);
828 /* everything's up-to-date */
833 /* finalize packet */
834 packet->flags = PACKET_TYPE_WRITE;
835 packet->device = device;
836 packet->length = cpu_to_le16(MSG_HEADER_SIZE + msg_len);
838 message->counter = applespi->cmd_msg_cntr++ % (U8_MAX + 1);
840 message->length = cpu_to_le16(msg_len - 2);
841 if (!message->rsp_buf_len)
842 message->rsp_buf_len = message->length;
844 crc = crc16(0, (u8 *)message, le16_to_cpu(packet->length) - 2);
845 put_unaligned_le16(crc, &message->data[msg_len - 2]);
847 crc = crc16(0, (u8 *)packet, sizeof(*packet) - 2);
848 packet->crc16 = cpu_to_le16(crc);
851 sts = applespi_async(applespi, &applespi->wr_m,
852 applespi_async_write_complete);
854 dev_warn(&applespi->spi->dev,
855 "Error queueing async write to device: %d\n", sts);
859 applespi->cmd_msg_queued = true;
860 applespi->write_active = true;
865 static void applespi_init(struct applespi_data *applespi, bool is_resume)
869 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
872 applespi->want_mt_init_cmd = true;
874 applespi->want_tp_info_cmd = true;
875 applespi_send_cmd_msg(applespi);
877 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
880 static int applespi_set_capsl_led(struct applespi_data *applespi,
886 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
888 applespi->want_cl_led_on = capslock_on;
889 sts = applespi_send_cmd_msg(applespi);
891 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
896 static void applespi_set_bl_level(struct led_classdev *led_cdev,
897 enum led_brightness value)
899 struct applespi_data *applespi =
900 container_of(led_cdev, struct applespi_data, backlight_info);
903 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
906 applespi->want_bl_level = value;
909 * The backlight does not turn on till level 32, so we scale
910 * the range here so that from a user's perspective it turns
913 applespi->want_bl_level =
914 ((value * KBD_BL_LEVEL_ADJ) / KBD_BL_LEVEL_SCALE +
918 applespi_send_cmd_msg(applespi);
920 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
923 static int applespi_event(struct input_dev *dev, unsigned int type,
924 unsigned int code, int value)
926 struct applespi_data *applespi = input_get_drvdata(dev);
930 applespi_set_capsl_led(applespi, !!test_bit(LED_CAPSL, dev->led));
937 /* lifted from the BCM5974 driver and renamed from raw2int */
938 /* convert 16-bit little endian to signed integer */
939 static inline int le16_to_int(__le16 x)
941 return (signed short)le16_to_cpu(x);
944 static void applespi_debug_update_dimensions(struct applespi_data *applespi,
945 const struct tp_finger *f)
947 applespi->tp_dim_min_x = min_t(int, applespi->tp_dim_min_x, f->abs_x);
948 applespi->tp_dim_max_x = max_t(int, applespi->tp_dim_max_x, f->abs_x);
949 applespi->tp_dim_min_y = min_t(int, applespi->tp_dim_min_y, f->abs_y);
950 applespi->tp_dim_max_y = max_t(int, applespi->tp_dim_max_y, f->abs_y);
953 static int applespi_tp_dim_open(struct inode *inode, struct file *file)
955 struct applespi_data *applespi = inode->i_private;
957 file->private_data = applespi;
959 snprintf(applespi->tp_dim_val, sizeof(applespi->tp_dim_val),
960 "0x%.4x %dx%d+%u+%u\n",
961 applespi->touchpad_input_dev->id.product,
962 applespi->tp_dim_min_x, applespi->tp_dim_min_y,
963 applespi->tp_dim_max_x - applespi->tp_dim_min_x,
964 applespi->tp_dim_max_y - applespi->tp_dim_min_y);
966 return nonseekable_open(inode, file);
969 static ssize_t applespi_tp_dim_read(struct file *file, char __user *buf,
970 size_t len, loff_t *off)
972 struct applespi_data *applespi = file->private_data;
974 return simple_read_from_buffer(buf, len, off, applespi->tp_dim_val,
975 strlen(applespi->tp_dim_val));
978 static const struct file_operations applespi_tp_dim_fops = {
979 .owner = THIS_MODULE,
980 .open = applespi_tp_dim_open,
981 .read = applespi_tp_dim_read,
985 static void report_finger_data(struct input_dev *input, int slot,
986 const struct input_mt_pos *pos,
987 const struct tp_finger *f)
989 input_mt_slot(input, slot);
990 input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
992 input_report_abs(input, ABS_MT_TOUCH_MAJOR,
993 le16_to_int(f->touch_major) << 1);
994 input_report_abs(input, ABS_MT_TOUCH_MINOR,
995 le16_to_int(f->touch_minor) << 1);
996 input_report_abs(input, ABS_MT_WIDTH_MAJOR,
997 le16_to_int(f->tool_major) << 1);
998 input_report_abs(input, ABS_MT_WIDTH_MINOR,
999 le16_to_int(f->tool_minor) << 1);
1000 input_report_abs(input, ABS_MT_ORIENTATION,
1001 MAX_FINGER_ORIENTATION - le16_to_int(f->orientation));
1002 input_report_abs(input, ABS_MT_POSITION_X, pos->x);
1003 input_report_abs(input, ABS_MT_POSITION_Y, pos->y);
1006 static void report_tp_state(struct applespi_data *applespi,
1007 struct touchpad_protocol *t)
1009 const struct tp_finger *f;
1010 struct input_dev *input;
1011 const struct applespi_tp_info *tp_info = &applespi->tp_info;
1014 /* touchpad_input_dev is set async in worker */
1015 input = smp_load_acquire(&applespi->touchpad_input_dev);
1017 return; /* touchpad isn't initialized yet */
1021 for (i = 0; i < t->number_of_fingers; i++) {
1023 if (le16_to_int(f->touch_major) == 0)
1025 applespi->pos[n].x = le16_to_int(f->abs_x);
1026 applespi->pos[n].y = tp_info->y_min + tp_info->y_max -
1027 le16_to_int(f->abs_y);
1030 if (applespi->debug_tp_dim)
1031 applespi_debug_update_dimensions(applespi, f);
1034 input_mt_assign_slots(input, applespi->slots, applespi->pos, n, 0);
1036 for (i = 0; i < n; i++)
1037 report_finger_data(input, applespi->slots[i],
1038 &applespi->pos[i], &t->fingers[i]);
1040 input_mt_sync_frame(input);
1041 input_report_key(input, BTN_LEFT, t->clicked);
1046 static const struct applespi_key_translation *
1047 applespi_find_translation(const struct applespi_key_translation *table, u16 key)
1049 const struct applespi_key_translation *trans;
1051 for (trans = table; trans->from; trans++)
1052 if (trans->from == key)
1058 static unsigned int applespi_translate_fn_key(unsigned int key, int fn_pressed)
1060 const struct applespi_key_translation *trans;
1063 trans = applespi_find_translation(applespi_fn_codes, key);
1065 if (trans->flags & APPLE_FLAG_FKEY)
1066 do_translate = (fnmode == 2 && fn_pressed) ||
1067 (fnmode == 1 && !fn_pressed);
1069 do_translate = fn_pressed;
1078 static unsigned int applespi_translate_iso_layout(unsigned int key)
1080 const struct applespi_key_translation *trans;
1082 trans = applespi_find_translation(apple_iso_keyboard, key);
1089 static unsigned int applespi_code_to_key(u8 code, int fn_pressed)
1091 unsigned int key = applespi_scancodes[code];
1094 key = applespi_translate_fn_key(key, fn_pressed);
1096 key = applespi_translate_iso_layout(key);
1101 applespi_remap_fn_key(struct keyboard_protocol *keyboard_protocol)
1104 u8 bit = BIT((fnremap - 1) & 0x07);
1106 if (!fnremap || fnremap > ARRAY_SIZE(applespi_controlcodes) ||
1107 !applespi_controlcodes[fnremap - 1])
1110 tmp = keyboard_protocol->fn_pressed;
1111 keyboard_protocol->fn_pressed = !!(keyboard_protocol->modifiers & bit);
1113 keyboard_protocol->modifiers |= bit;
1115 keyboard_protocol->modifiers &= ~bit;
1119 applespi_handle_keyboard_event(struct applespi_data *applespi,
1120 struct keyboard_protocol *keyboard_protocol)
1125 compiletime_assert(ARRAY_SIZE(applespi_controlcodes) ==
1126 sizeof_field(struct keyboard_protocol, modifiers) * 8,
1127 "applespi_controlcodes has wrong number of entries");
1129 /* check for rollover overflow, which is signalled by all keys == 1 */
1130 if (!memchr_inv(keyboard_protocol->keys_pressed, 1, MAX_ROLLOVER))
1133 /* remap fn key if desired */
1134 applespi_remap_fn_key(keyboard_protocol);
1136 /* check released keys */
1137 for (i = 0; i < MAX_ROLLOVER; i++) {
1138 if (memchr(keyboard_protocol->keys_pressed,
1139 applespi->last_keys_pressed[i], MAX_ROLLOVER))
1140 continue; /* key is still pressed */
1142 key = applespi_code_to_key(applespi->last_keys_pressed[i],
1143 applespi->last_keys_fn_pressed[i]);
1144 input_report_key(applespi->keyboard_input_dev, key, 0);
1145 applespi->last_keys_fn_pressed[i] = 0;
1148 /* check pressed keys */
1149 for (i = 0; i < MAX_ROLLOVER; i++) {
1150 if (keyboard_protocol->keys_pressed[i] <
1151 ARRAY_SIZE(applespi_scancodes) &&
1152 keyboard_protocol->keys_pressed[i] > 0) {
1153 key = applespi_code_to_key(
1154 keyboard_protocol->keys_pressed[i],
1155 keyboard_protocol->fn_pressed);
1156 input_report_key(applespi->keyboard_input_dev, key, 1);
1157 applespi->last_keys_fn_pressed[i] =
1158 keyboard_protocol->fn_pressed;
1162 /* check control keys */
1163 for (i = 0; i < ARRAY_SIZE(applespi_controlcodes); i++) {
1164 if (keyboard_protocol->modifiers & BIT(i))
1165 input_report_key(applespi->keyboard_input_dev,
1166 applespi_controlcodes[i], 1);
1168 input_report_key(applespi->keyboard_input_dev,
1169 applespi_controlcodes[i], 0);
1172 /* check function key */
1173 if (keyboard_protocol->fn_pressed && !applespi->last_fn_pressed)
1174 input_report_key(applespi->keyboard_input_dev, KEY_FN, 1);
1175 else if (!keyboard_protocol->fn_pressed && applespi->last_fn_pressed)
1176 input_report_key(applespi->keyboard_input_dev, KEY_FN, 0);
1177 applespi->last_fn_pressed = keyboard_protocol->fn_pressed;
1180 input_sync(applespi->keyboard_input_dev);
1181 memcpy(&applespi->last_keys_pressed, keyboard_protocol->keys_pressed,
1182 sizeof(applespi->last_keys_pressed));
1185 static const struct applespi_tp_info *applespi_find_touchpad_info(u8 model)
1187 const struct applespi_tp_model_info *info;
1189 for (info = applespi_tp_models; info->model; info++) {
1190 if (info->model == model)
1191 return &info->tp_info;
1198 applespi_register_touchpad_device(struct applespi_data *applespi,
1199 struct touchpad_info_protocol *rcvd_tp_info)
1201 const struct applespi_tp_info *tp_info;
1202 struct input_dev *touchpad_input_dev;
1205 /* set up touchpad dimensions */
1206 tp_info = applespi_find_touchpad_info(rcvd_tp_info->model_no);
1208 dev_warn(&applespi->spi->dev,
1209 "Unknown touchpad model %x - falling back to MB8 touchpad\n",
1210 rcvd_tp_info->model_no);
1211 tp_info = &applespi_tp_models[0].tp_info;
1214 applespi->tp_info = *tp_info;
1216 if (touchpad_dimensions[0]) {
1219 sts = sscanf(touchpad_dimensions, "%dx%d+%u+%u", &x, &y, &w, &h);
1221 dev_info(&applespi->spi->dev,
1222 "Overriding touchpad dimensions from module param\n");
1223 applespi->tp_info.x_min = x;
1224 applespi->tp_info.y_min = y;
1225 applespi->tp_info.x_max = x + w;
1226 applespi->tp_info.y_max = y + h;
1228 dev_warn(&applespi->spi->dev,
1229 "Invalid touchpad dimensions '%s': must be in the form XxY+W+H\n",
1230 touchpad_dimensions);
1231 touchpad_dimensions[0] = '\0';
1234 if (!touchpad_dimensions[0]) {
1235 snprintf(touchpad_dimensions, sizeof(touchpad_dimensions),
1237 applespi->tp_info.x_min,
1238 applespi->tp_info.y_min,
1239 applespi->tp_info.x_max - applespi->tp_info.x_min,
1240 applespi->tp_info.y_max - applespi->tp_info.y_min);
1243 /* create touchpad input device */
1244 touchpad_input_dev = devm_input_allocate_device(&applespi->spi->dev);
1245 if (!touchpad_input_dev) {
1246 dev_err(&applespi->spi->dev,
1247 "Failed to allocate touchpad input device\n");
1251 touchpad_input_dev->name = "Apple SPI Touchpad";
1252 touchpad_input_dev->phys = "applespi/input1";
1253 touchpad_input_dev->dev.parent = &applespi->spi->dev;
1254 touchpad_input_dev->id.bustype = BUS_SPI;
1255 touchpad_input_dev->id.vendor = SYNAPTICS_VENDOR_ID;
1256 touchpad_input_dev->id.product =
1257 rcvd_tp_info->model_no << 8 | rcvd_tp_info->model_flags;
1259 /* basic properties */
1260 input_set_capability(touchpad_input_dev, EV_REL, REL_X);
1261 input_set_capability(touchpad_input_dev, EV_REL, REL_Y);
1263 __set_bit(INPUT_PROP_POINTER, touchpad_input_dev->propbit);
1264 __set_bit(INPUT_PROP_BUTTONPAD, touchpad_input_dev->propbit);
1266 /* finger touch area */
1267 input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MAJOR,
1269 input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MINOR,
1272 /* finger approach area */
1273 input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MAJOR,
1275 input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MINOR,
1278 /* finger orientation */
1279 input_set_abs_params(touchpad_input_dev, ABS_MT_ORIENTATION,
1280 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION,
1283 /* finger position */
1284 input_set_abs_params(touchpad_input_dev, ABS_MT_POSITION_X,
1285 applespi->tp_info.x_min, applespi->tp_info.x_max,
1287 input_set_abs_params(touchpad_input_dev, ABS_MT_POSITION_Y,
1288 applespi->tp_info.y_min, applespi->tp_info.y_max,
1291 /* touchpad button */
1292 input_set_capability(touchpad_input_dev, EV_KEY, BTN_LEFT);
1295 sts = input_mt_init_slots(touchpad_input_dev, MAX_FINGERS,
1296 INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
1299 dev_err(&applespi->spi->dev,
1300 "failed to initialize slots: %d", sts);
1304 /* register input device */
1305 sts = input_register_device(touchpad_input_dev);
1307 dev_err(&applespi->spi->dev,
1308 "Unable to register touchpad input device (%d)\n", sts);
1312 /* touchpad_input_dev is read async in spi callback */
1313 smp_store_release(&applespi->touchpad_input_dev, touchpad_input_dev);
1318 static void applespi_worker(struct work_struct *work)
1320 struct applespi_data *applespi =
1321 container_of(work, struct applespi_data, work);
1323 applespi_register_touchpad_device(applespi, &applespi->rcvd_tp_info);
1326 static void applespi_handle_cmd_response(struct applespi_data *applespi,
1327 struct spi_packet *packet,
1328 struct message *message)
1330 if (packet->device == PACKET_DEV_INFO &&
1331 le16_to_cpu(message->type) == 0x1020) {
1333 * We're not allowed to sleep here, but registering an input
1336 applespi->rcvd_tp_info = message->tp_info;
1337 schedule_work(&applespi->work);
1341 if (le16_to_cpu(message->length) != 0x0000) {
1342 dev_warn_ratelimited(&applespi->spi->dev,
1343 "Received unexpected write response: length=%x\n",
1344 le16_to_cpu(message->length));
1348 if (packet->device == PACKET_DEV_TPAD &&
1349 le16_to_cpu(message->type) == 0x0252 &&
1350 le16_to_cpu(message->rsp_buf_len) == 0x0002)
1351 dev_info(&applespi->spi->dev, "modeswitch done.\n");
1354 static bool applespi_verify_crc(struct applespi_data *applespi, u8 *buffer,
1359 crc = crc16(0, buffer, buflen);
1361 dev_warn_ratelimited(&applespi->spi->dev,
1362 "Received corrupted packet (crc mismatch)\n");
1363 trace_applespi_bad_crc(ET_RD_CRC, READ, buffer, buflen);
1371 static void applespi_debug_print_read_packet(struct applespi_data *applespi,
1372 struct spi_packet *packet)
1374 unsigned int evt_type;
1376 if (packet->flags == PACKET_TYPE_READ &&
1377 packet->device == PACKET_DEV_KEYB)
1378 evt_type = ET_RD_KEYB;
1379 else if (packet->flags == PACKET_TYPE_READ &&
1380 packet->device == PACKET_DEV_TPAD)
1381 evt_type = ET_RD_TPAD;
1382 else if (packet->flags == PACKET_TYPE_WRITE)
1383 evt_type = applespi->cmd_evt_type;
1385 evt_type = ET_RD_UNKN;
1387 applespi_get_trace_fun(evt_type)(evt_type, PT_READ, applespi->rx_buffer,
1388 APPLESPI_PACKET_SIZE);
1391 static void applespi_got_data(struct applespi_data *applespi)
1393 struct spi_packet *packet;
1394 struct message *message;
1395 unsigned int msg_len;
1400 /* process packet header */
1401 if (!applespi_verify_crc(applespi, applespi->rx_buffer,
1402 APPLESPI_PACKET_SIZE)) {
1403 unsigned long flags;
1405 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1407 if (applespi->drain) {
1408 applespi->read_active = false;
1409 applespi->write_active = false;
1411 wake_up_all(&applespi->drain_complete);
1414 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1419 packet = (struct spi_packet *)applespi->rx_buffer;
1421 applespi_debug_print_read_packet(applespi, packet);
1423 off = le16_to_cpu(packet->offset);
1424 rem = le16_to_cpu(packet->remaining);
1425 len = le16_to_cpu(packet->length);
1427 if (len > sizeof(packet->data)) {
1428 dev_warn_ratelimited(&applespi->spi->dev,
1429 "Received corrupted packet (invalid packet length %u)\n",
1434 /* handle multi-packet messages */
1435 if (rem > 0 || off > 0) {
1436 if (off != applespi->saved_msg_len) {
1437 dev_warn_ratelimited(&applespi->spi->dev,
1438 "Received unexpected offset (got %u, expected %u)\n",
1439 off, applespi->saved_msg_len);
1443 if (off + rem > MAX_PKTS_PER_MSG * APPLESPI_PACKET_SIZE) {
1444 dev_warn_ratelimited(&applespi->spi->dev,
1445 "Received message too large (size %u)\n",
1450 if (off + len > MAX_PKTS_PER_MSG * APPLESPI_PACKET_SIZE) {
1451 dev_warn_ratelimited(&applespi->spi->dev,
1452 "Received message too large (size %u)\n",
1457 memcpy(applespi->msg_buf + off, &packet->data, len);
1458 applespi->saved_msg_len += len;
1463 message = (struct message *)applespi->msg_buf;
1464 msg_len = applespi->saved_msg_len;
1466 message = (struct message *)&packet->data;
1470 /* got complete message - verify */
1471 if (!applespi_verify_crc(applespi, (u8 *)message, msg_len))
1474 if (le16_to_cpu(message->length) != msg_len - MSG_HEADER_SIZE - 2) {
1475 dev_warn_ratelimited(&applespi->spi->dev,
1476 "Received corrupted packet (invalid message length %u - expected %u)\n",
1477 le16_to_cpu(message->length),
1478 msg_len - MSG_HEADER_SIZE - 2);
1482 /* handle message */
1483 if (packet->flags == PACKET_TYPE_READ &&
1484 packet->device == PACKET_DEV_KEYB) {
1485 applespi_handle_keyboard_event(applespi, &message->keyboard);
1487 } else if (packet->flags == PACKET_TYPE_READ &&
1488 packet->device == PACKET_DEV_TPAD) {
1489 struct touchpad_protocol *tp;
1492 tp = &message->touchpad;
1493 tp_len = sizeof(*tp) +
1494 tp->number_of_fingers * sizeof(tp->fingers[0]);
1496 if (le16_to_cpu(message->length) + 2 != tp_len) {
1497 dev_warn_ratelimited(&applespi->spi->dev,
1498 "Received corrupted packet (invalid message length %u - num-fingers %u, tp-len %zu)\n",
1499 le16_to_cpu(message->length),
1500 tp->number_of_fingers, tp_len);
1504 if (tp->number_of_fingers > MAX_FINGERS) {
1505 dev_warn_ratelimited(&applespi->spi->dev,
1506 "Number of reported fingers (%u) exceeds max (%u))\n",
1507 tp->number_of_fingers,
1509 tp->number_of_fingers = MAX_FINGERS;
1512 report_tp_state(applespi, tp);
1514 } else if (packet->flags == PACKET_TYPE_WRITE) {
1515 applespi_handle_cmd_response(applespi, packet, message);
1519 applespi->saved_msg_len = 0;
1521 applespi_msg_complete(applespi, packet->flags == PACKET_TYPE_WRITE,
1525 static void applespi_async_read_complete(void *context)
1527 struct applespi_data *applespi = context;
1529 if (applespi->rd_m.status < 0) {
1530 dev_warn(&applespi->spi->dev, "Error reading from device: %d\n",
1531 applespi->rd_m.status);
1533 * We don't actually know if this was a pure read, or a response
1534 * to a write. But this is a rare error condition that should
1535 * never occur, so clearing both flags to avoid deadlock.
1537 applespi_msg_complete(applespi, true, true);
1539 applespi_got_data(applespi);
1542 acpi_finish_gpe(NULL, applespi->gpe);
1545 static u32 applespi_notify(acpi_handle gpe_device, u32 gpe, void *context)
1547 struct applespi_data *applespi = context;
1549 unsigned long flags;
1551 trace_applespi_irq_received(ET_RD_IRQ, PT_READ);
1553 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1555 if (!applespi->suspended) {
1556 sts = applespi_async(applespi, &applespi->rd_m,
1557 applespi_async_read_complete);
1559 dev_warn(&applespi->spi->dev,
1560 "Error queueing async read to device: %d\n",
1563 applespi->read_active = true;
1566 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1568 return ACPI_INTERRUPT_HANDLED;
1571 static int applespi_get_saved_bl_level(struct applespi_data *applespi)
1573 struct efivar_entry *efivar_entry;
1575 unsigned long efi_data_len;
1578 efivar_entry = kmalloc(sizeof(*efivar_entry), GFP_KERNEL);
1582 memcpy(efivar_entry->var.VariableName, EFI_BL_LEVEL_NAME,
1583 sizeof(EFI_BL_LEVEL_NAME));
1584 efivar_entry->var.VendorGuid = EFI_BL_LEVEL_GUID;
1585 efi_data_len = sizeof(efi_data);
1587 sts = efivar_entry_get(efivar_entry, NULL, &efi_data_len, &efi_data);
1588 if (sts && sts != -ENOENT)
1589 dev_warn(&applespi->spi->dev,
1590 "Error getting backlight level from EFI vars: %d\n",
1593 kfree(efivar_entry);
1595 return sts ? sts : efi_data;
1598 static void applespi_save_bl_level(struct applespi_data *applespi,
1601 efi_guid_t efi_guid;
1603 unsigned long efi_data_len;
1607 /* Save keyboard backlight level */
1608 efi_guid = EFI_BL_LEVEL_GUID;
1609 efi_data = (u16)level;
1610 efi_data_len = sizeof(efi_data);
1611 efi_attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS |
1612 EFI_VARIABLE_RUNTIME_ACCESS;
1614 sts = efivar_entry_set_safe(EFI_BL_LEVEL_NAME, efi_guid, efi_attr, true,
1615 efi_data_len, &efi_data);
1617 dev_warn(&applespi->spi->dev,
1618 "Error saving backlight level to EFI vars: %d\n", sts);
1621 static int applespi_probe(struct spi_device *spi)
1623 struct applespi_data *applespi;
1624 acpi_handle spi_handle = ACPI_HANDLE(&spi->dev);
1625 acpi_status acpi_sts;
1627 unsigned long long gpe, usb_status;
1629 /* check if the USB interface is present and enabled already */
1630 acpi_sts = acpi_evaluate_integer(spi_handle, "UIST", NULL, &usb_status);
1631 if (ACPI_SUCCESS(acpi_sts) && usb_status) {
1632 /* let the USB driver take over instead */
1633 dev_info(&spi->dev, "USB interface already enabled\n");
1637 /* allocate driver data */
1638 applespi = devm_kzalloc(&spi->dev, sizeof(*applespi), GFP_KERNEL);
1642 applespi->spi = spi;
1644 INIT_WORK(&applespi->work, applespi_worker);
1646 /* store the driver data */
1647 spi_set_drvdata(spi, applespi);
1649 /* create our buffers */
1650 applespi->tx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1652 applespi->tx_status = devm_kmalloc(&spi->dev, APPLESPI_STATUS_SIZE,
1654 applespi->rx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1656 applespi->msg_buf = devm_kmalloc_array(&spi->dev, MAX_PKTS_PER_MSG,
1657 APPLESPI_PACKET_SIZE,
1660 if (!applespi->tx_buffer || !applespi->tx_status ||
1661 !applespi->rx_buffer || !applespi->msg_buf)
1664 /* set up our spi messages */
1665 applespi_setup_read_txfrs(applespi);
1666 applespi_setup_write_txfrs(applespi);
1668 /* cache ACPI method handles */
1669 acpi_sts = acpi_get_handle(spi_handle, "SIEN", &applespi->sien);
1670 if (ACPI_FAILURE(acpi_sts)) {
1671 dev_err(&applespi->spi->dev,
1672 "Failed to get SIEN ACPI method handle: %s\n",
1673 acpi_format_exception(acpi_sts));
1677 acpi_sts = acpi_get_handle(spi_handle, "SIST", &applespi->sist);
1678 if (ACPI_FAILURE(acpi_sts)) {
1679 dev_err(&applespi->spi->dev,
1680 "Failed to get SIST ACPI method handle: %s\n",
1681 acpi_format_exception(acpi_sts));
1685 /* switch on the SPI interface */
1686 sts = applespi_setup_spi(applespi);
1690 sts = applespi_enable_spi(applespi);
1694 /* setup the keyboard input dev */
1695 applespi->keyboard_input_dev = devm_input_allocate_device(&spi->dev);
1697 if (!applespi->keyboard_input_dev)
1700 applespi->keyboard_input_dev->name = "Apple SPI Keyboard";
1701 applespi->keyboard_input_dev->phys = "applespi/input0";
1702 applespi->keyboard_input_dev->dev.parent = &spi->dev;
1703 applespi->keyboard_input_dev->id.bustype = BUS_SPI;
1705 applespi->keyboard_input_dev->evbit[0] =
1706 BIT_MASK(EV_KEY) | BIT_MASK(EV_LED) | BIT_MASK(EV_REP);
1707 applespi->keyboard_input_dev->ledbit[0] = BIT_MASK(LED_CAPSL);
1709 input_set_drvdata(applespi->keyboard_input_dev, applespi);
1710 applespi->keyboard_input_dev->event = applespi_event;
1712 for (i = 0; i < ARRAY_SIZE(applespi_scancodes); i++)
1713 if (applespi_scancodes[i])
1714 input_set_capability(applespi->keyboard_input_dev,
1715 EV_KEY, applespi_scancodes[i]);
1717 for (i = 0; i < ARRAY_SIZE(applespi_controlcodes); i++)
1718 if (applespi_controlcodes[i])
1719 input_set_capability(applespi->keyboard_input_dev,
1720 EV_KEY, applespi_controlcodes[i]);
1722 for (i = 0; i < ARRAY_SIZE(applespi_fn_codes); i++)
1723 if (applespi_fn_codes[i].to)
1724 input_set_capability(applespi->keyboard_input_dev,
1725 EV_KEY, applespi_fn_codes[i].to);
1727 input_set_capability(applespi->keyboard_input_dev, EV_KEY, KEY_FN);
1729 sts = input_register_device(applespi->keyboard_input_dev);
1731 dev_err(&applespi->spi->dev,
1732 "Unable to register keyboard input device (%d)\n", sts);
1737 * The applespi device doesn't send interrupts normally (as is described
1738 * in its DSDT), but rather seems to use ACPI GPEs.
1740 acpi_sts = acpi_evaluate_integer(spi_handle, "_GPE", NULL, &gpe);
1741 if (ACPI_FAILURE(acpi_sts)) {
1742 dev_err(&applespi->spi->dev,
1743 "Failed to obtain GPE for SPI slave device: %s\n",
1744 acpi_format_exception(acpi_sts));
1747 applespi->gpe = (int)gpe;
1749 acpi_sts = acpi_install_gpe_handler(NULL, applespi->gpe,
1750 ACPI_GPE_LEVEL_TRIGGERED,
1751 applespi_notify, applespi);
1752 if (ACPI_FAILURE(acpi_sts)) {
1753 dev_err(&applespi->spi->dev,
1754 "Failed to install GPE handler for GPE %d: %s\n",
1755 applespi->gpe, acpi_format_exception(acpi_sts));
1759 applespi->suspended = false;
1761 acpi_sts = acpi_enable_gpe(NULL, applespi->gpe);
1762 if (ACPI_FAILURE(acpi_sts)) {
1763 dev_err(&applespi->spi->dev,
1764 "Failed to enable GPE handler for GPE %d: %s\n",
1765 applespi->gpe, acpi_format_exception(acpi_sts));
1766 acpi_remove_gpe_handler(NULL, applespi->gpe, applespi_notify);
1770 /* trigger touchpad setup */
1771 applespi_init(applespi, false);
1774 * By default this device is not enabled for wakeup; but USB keyboards
1775 * generally are, so the expectation is that by default the keyboard
1776 * will wake the system.
1778 device_wakeup_enable(&spi->dev);
1780 /* set up keyboard-backlight */
1781 sts = applespi_get_saved_bl_level(applespi);
1783 applespi_set_bl_level(&applespi->backlight_info, sts);
1785 applespi->backlight_info.name = "spi::kbd_backlight";
1786 applespi->backlight_info.default_trigger = "kbd-backlight";
1787 applespi->backlight_info.brightness_set = applespi_set_bl_level;
1789 sts = devm_led_classdev_register(&spi->dev, &applespi->backlight_info);
1791 dev_warn(&applespi->spi->dev,
1792 "Unable to register keyboard backlight class dev (%d)\n",
1795 /* set up debugfs entries for touchpad dimensions logging */
1796 applespi->debugfs_root = debugfs_create_dir("applespi", NULL);
1797 if (IS_ERR(applespi->debugfs_root)) {
1798 if (PTR_ERR(applespi->debugfs_root) != -ENODEV)
1799 dev_warn(&applespi->spi->dev,
1800 "Error creating debugfs root entry (%ld)\n",
1801 PTR_ERR(applespi->debugfs_root));
1805 ret = debugfs_create_bool("enable_tp_dim", 0600,
1806 applespi->debugfs_root,
1807 &applespi->debug_tp_dim);
1809 dev_dbg(&applespi->spi->dev,
1810 "Error creating debugfs entry enable_tp_dim (%ld)\n",
1813 ret = debugfs_create_file("tp_dim", 0400,
1814 applespi->debugfs_root, applespi,
1815 &applespi_tp_dim_fops);
1817 dev_dbg(&applespi->spi->dev,
1818 "Error creating debugfs entry tp_dim (%ld)\n",
1825 static void applespi_drain_writes(struct applespi_data *applespi)
1827 unsigned long flags;
1829 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1831 applespi->drain = true;
1832 wait_event_lock_irq(applespi->drain_complete, !applespi->write_active,
1833 applespi->cmd_msg_lock);
1835 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1838 static void applespi_drain_reads(struct applespi_data *applespi)
1840 unsigned long flags;
1842 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1844 wait_event_lock_irq(applespi->drain_complete, !applespi->read_active,
1845 applespi->cmd_msg_lock);
1847 applespi->suspended = true;
1849 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1852 static int applespi_remove(struct spi_device *spi)
1854 struct applespi_data *applespi = spi_get_drvdata(spi);
1856 applespi_drain_writes(applespi);
1858 acpi_disable_gpe(NULL, applespi->gpe);
1859 acpi_remove_gpe_handler(NULL, applespi->gpe, applespi_notify);
1860 device_wakeup_disable(&spi->dev);
1862 applespi_drain_reads(applespi);
1864 debugfs_remove_recursive(applespi->debugfs_root);
1869 static void applespi_shutdown(struct spi_device *spi)
1871 struct applespi_data *applespi = spi_get_drvdata(spi);
1873 applespi_save_bl_level(applespi, applespi->have_bl_level);
1876 static int applespi_poweroff_late(struct device *dev)
1878 struct spi_device *spi = to_spi_device(dev);
1879 struct applespi_data *applespi = spi_get_drvdata(spi);
1881 applespi_save_bl_level(applespi, applespi->have_bl_level);
1886 static int __maybe_unused applespi_suspend(struct device *dev)
1888 struct spi_device *spi = to_spi_device(dev);
1889 struct applespi_data *applespi = spi_get_drvdata(spi);
1890 acpi_status acpi_sts;
1893 /* turn off caps-lock - it'll stay on otherwise */
1894 sts = applespi_set_capsl_led(applespi, false);
1896 dev_warn(&applespi->spi->dev,
1897 "Failed to turn off caps-lock led (%d)\n", sts);
1899 applespi_drain_writes(applespi);
1901 /* disable the interrupt */
1902 acpi_sts = acpi_disable_gpe(NULL, applespi->gpe);
1903 if (ACPI_FAILURE(acpi_sts))
1904 dev_err(&applespi->spi->dev,
1905 "Failed to disable GPE handler for GPE %d: %s\n",
1906 applespi->gpe, acpi_format_exception(acpi_sts));
1908 applespi_drain_reads(applespi);
1913 static int __maybe_unused applespi_resume(struct device *dev)
1915 struct spi_device *spi = to_spi_device(dev);
1916 struct applespi_data *applespi = spi_get_drvdata(spi);
1917 acpi_status acpi_sts;
1918 unsigned long flags;
1920 /* ensure our flags and state reflect a newly resumed device */
1921 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1923 applespi->drain = false;
1924 applespi->have_cl_led_on = false;
1925 applespi->have_bl_level = 0;
1926 applespi->cmd_msg_queued = false;
1927 applespi->read_active = false;
1928 applespi->write_active = false;
1930 applespi->suspended = false;
1932 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1934 /* switch on the SPI interface */
1935 applespi_enable_spi(applespi);
1937 /* re-enable the interrupt */
1938 acpi_sts = acpi_enable_gpe(NULL, applespi->gpe);
1939 if (ACPI_FAILURE(acpi_sts))
1940 dev_err(&applespi->spi->dev,
1941 "Failed to re-enable GPE handler for GPE %d: %s\n",
1942 applespi->gpe, acpi_format_exception(acpi_sts));
1944 /* switch the touchpad into multitouch mode */
1945 applespi_init(applespi, true);
1950 static const struct acpi_device_id applespi_acpi_match[] = {
1954 MODULE_DEVICE_TABLE(acpi, applespi_acpi_match);
1956 const struct dev_pm_ops applespi_pm_ops = {
1957 SET_SYSTEM_SLEEP_PM_OPS(applespi_suspend, applespi_resume)
1958 .poweroff_late = applespi_poweroff_late,
1961 static struct spi_driver applespi_driver = {
1964 .acpi_match_table = applespi_acpi_match,
1965 .pm = &applespi_pm_ops,
1967 .probe = applespi_probe,
1968 .remove = applespi_remove,
1969 .shutdown = applespi_shutdown,
1972 module_spi_driver(applespi_driver)
1974 MODULE_LICENSE("GPL v2");
1975 MODULE_DESCRIPTION("MacBook(Pro) SPI Keyboard/Touchpad driver");
1976 MODULE_AUTHOR("Federico Lorenzi");
1977 MODULE_AUTHOR("Ronald Tschalär");