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 coordinate
138 * @abs_y: absolute y coordinate
139 * @rel_x: relative x coordinate
140 * @rel_y: relative y coordinate
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[];
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.
290 * @keyboard: Keyboard message
291 * @touchpad: Touchpad message
292 * @tp_info: Touchpad info (response)
293 * @tp_info_command: Touchpad info (CRC)
294 * @init_mt_command: Initialise Multitouch
295 * @capsl_command: Toggle caps-lock LED
296 * @bl_command: Keyboard brightness
306 struct keyboard_protocol keyboard;
307 struct touchpad_protocol touchpad;
308 struct touchpad_info_protocol tp_info;
309 struct command_protocol_tp_info tp_info_command;
310 struct command_protocol_mt_init init_mt_command;
311 struct command_protocol_capsl capsl_command;
312 struct command_protocol_bl bl_command;
317 /* type + zero + counter + rsp_buf_len + length */
318 #define MSG_HEADER_SIZE 8
321 * struct spi_packet - a complete spi packet; always 256 bytes. This carries
322 * the (parts of the) message in the data. But note that this does not
323 * necessarily contain a complete message, as in some cases (e.g. many
324 * fingers pressed) the message is split over multiple packets (see the
325 * @offset, @remaining, and @length fields). In general the data parts in
326 * spi_packet's are concatenated until @remaining is 0, and the result is an
329 * @flags: 0x40 = write (to device), 0x20 = read (from device); note that
330 * the response to a write still has 0x40.
331 * @device: 1 = keyboard, 2 = touchpad
332 * @offset: specifies the offset of this packet's data in the complete
333 * message; i.e. > 0 indicates this is a continuation packet (in
334 * the second packet for a message split over multiple packets
335 * this would then be the same as the @length in the first packet)
336 * @remaining: number of message bytes remaining in subsequents packets (in
337 * the first packet of a message split over two packets this would
338 * then be the same as the @length in the second packet)
339 * @length: length of the valid data in the @data in this packet
340 * @data: all or part of a message
341 * @crc16: crc over this whole structure minus this @crc16 field. This
342 * covers just this packet, even on multi-packet messages (in
343 * contrast to the crc in the message).
355 struct spi_settings {
356 u64 spi_cs_delay; /* cs-to-clk delay in us */
357 u64 reset_a2r_usec; /* active-to-receive delay? */
358 u64 reset_rec_usec; /* ? (cur val: 10) */
361 /* this mimics struct drm_rect */
362 struct applespi_tp_info {
369 struct applespi_data {
370 struct spi_device *spi;
371 struct spi_settings spi_settings;
372 struct input_dev *keyboard_input_dev;
373 struct input_dev *touchpad_input_dev;
380 unsigned int saved_msg_len;
382 struct applespi_tp_info tp_info;
384 u8 last_keys_pressed[MAX_ROLLOVER];
385 u8 last_keys_fn_pressed[MAX_ROLLOVER];
387 struct input_mt_pos pos[MAX_FINGERS];
388 int slots[MAX_FINGERS];
393 struct spi_transfer dl_t;
394 struct spi_transfer rd_t;
395 struct spi_message rd_m;
397 struct spi_transfer ww_t;
398 struct spi_transfer wd_t;
399 struct spi_transfer wr_t;
400 struct spi_transfer st_t;
401 struct spi_message wr_m;
403 bool want_tp_info_cmd;
404 bool want_mt_init_cmd;
407 unsigned int want_bl_level;
408 unsigned int have_bl_level;
409 unsigned int cmd_msg_cntr;
410 /* lock to protect the above parameters and flags below */
411 spinlock_t cmd_msg_lock;
413 enum applespi_evt_type cmd_evt_type;
415 struct led_classdev backlight_info;
419 wait_queue_head_t drain_complete;
423 struct work_struct work;
424 struct touchpad_info_protocol rcvd_tp_info;
426 struct dentry *debugfs_root;
435 static const unsigned char applespi_scancodes[] = {
437 KEY_A, KEY_B, KEY_C, KEY_D, KEY_E, KEY_F, KEY_G, KEY_H, KEY_I, KEY_J,
438 KEY_K, KEY_L, KEY_M, KEY_N, KEY_O, KEY_P, KEY_Q, KEY_R, KEY_S, KEY_T,
439 KEY_U, KEY_V, KEY_W, KEY_X, KEY_Y, KEY_Z,
440 KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_0,
441 KEY_ENTER, KEY_ESC, KEY_BACKSPACE, KEY_TAB, KEY_SPACE, KEY_MINUS,
442 KEY_EQUAL, KEY_LEFTBRACE, KEY_RIGHTBRACE, KEY_BACKSLASH, 0,
443 KEY_SEMICOLON, KEY_APOSTROPHE, KEY_GRAVE, KEY_COMMA, KEY_DOT, KEY_SLASH,
445 KEY_F1, KEY_F2, KEY_F3, KEY_F4, KEY_F5, KEY_F6, KEY_F7, KEY_F8, KEY_F9,
446 KEY_F10, KEY_F11, KEY_F12, 0, 0, 0, 0, 0, 0, 0, 0, 0,
447 KEY_RIGHT, KEY_LEFT, KEY_DOWN, KEY_UP,
448 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_102ND,
449 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
450 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_RO, 0, KEY_YEN, 0, 0, 0, 0, 0,
451 0, KEY_KATAKANAHIRAGANA, KEY_MUHENKAN
455 * This must have exactly as many entries as there are bits in
456 * struct keyboard_protocol.modifiers .
458 static const unsigned char applespi_controlcodes[] = {
469 struct applespi_key_translation {
475 static const struct applespi_key_translation applespi_fn_codes[] = {
476 { KEY_BACKSPACE, KEY_DELETE },
477 { KEY_ENTER, KEY_INSERT },
478 { KEY_F1, KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
479 { KEY_F2, KEY_BRIGHTNESSUP, APPLE_FLAG_FKEY },
480 { KEY_F3, KEY_SCALE, APPLE_FLAG_FKEY },
481 { KEY_F4, KEY_DASHBOARD, APPLE_FLAG_FKEY },
482 { KEY_F5, KEY_KBDILLUMDOWN, APPLE_FLAG_FKEY },
483 { KEY_F6, KEY_KBDILLUMUP, APPLE_FLAG_FKEY },
484 { KEY_F7, KEY_PREVIOUSSONG, APPLE_FLAG_FKEY },
485 { KEY_F8, KEY_PLAYPAUSE, APPLE_FLAG_FKEY },
486 { KEY_F9, KEY_NEXTSONG, APPLE_FLAG_FKEY },
487 { KEY_F10, KEY_MUTE, APPLE_FLAG_FKEY },
488 { KEY_F11, KEY_VOLUMEDOWN, APPLE_FLAG_FKEY },
489 { KEY_F12, KEY_VOLUMEUP, APPLE_FLAG_FKEY },
490 { KEY_RIGHT, KEY_END },
491 { KEY_LEFT, KEY_HOME },
492 { KEY_DOWN, KEY_PAGEDOWN },
493 { KEY_UP, KEY_PAGEUP },
497 static const struct applespi_key_translation apple_iso_keyboard[] = {
498 { KEY_GRAVE, KEY_102ND },
499 { KEY_102ND, KEY_GRAVE },
503 struct applespi_tp_model_info {
505 struct applespi_tp_info tp_info;
508 static const struct applespi_tp_model_info applespi_tp_models[] = {
510 .model = 0x04, /* MB8 MB9 MB10 */
511 .tp_info = { -5087, -182, 5579, 6089 },
514 .model = 0x05, /* MBP13,1 MBP13,2 MBP14,1 MBP14,2 */
515 .tp_info = { -6243, -170, 6749, 7685 },
518 .model = 0x06, /* MBP13,3 MBP14,3 */
519 .tp_info = { -7456, -163, 7976, 9283 },
524 typedef void (*applespi_trace_fun)(enum applespi_evt_type,
525 enum applespi_pkt_type, u8 *, size_t);
527 static applespi_trace_fun applespi_get_trace_fun(enum applespi_evt_type type)
531 return trace_applespi_tp_ini_cmd;
533 return trace_applespi_backlight_cmd;
535 return trace_applespi_caps_lock_cmd;
537 return trace_applespi_keyboard_data;
539 return trace_applespi_touchpad_data;
541 return trace_applespi_unknown_data;
543 WARN_ONCE(1, "Unknown msg type %d", type);
544 return trace_applespi_unknown_data;
548 static void applespi_setup_read_txfrs(struct applespi_data *applespi)
550 struct spi_message *msg = &applespi->rd_m;
551 struct spi_transfer *dl_t = &applespi->dl_t;
552 struct spi_transfer *rd_t = &applespi->rd_t;
554 memset(dl_t, 0, sizeof(*dl_t));
555 memset(rd_t, 0, sizeof(*rd_t));
557 dl_t->delay.value = applespi->spi_settings.spi_cs_delay;
558 dl_t->delay.unit = SPI_DELAY_UNIT_USECS;
560 rd_t->rx_buf = applespi->rx_buffer;
561 rd_t->len = APPLESPI_PACKET_SIZE;
563 spi_message_init(msg);
564 spi_message_add_tail(dl_t, msg);
565 spi_message_add_tail(rd_t, msg);
568 static void applespi_setup_write_txfrs(struct applespi_data *applespi)
570 struct spi_message *msg = &applespi->wr_m;
571 struct spi_transfer *wt_t = &applespi->ww_t;
572 struct spi_transfer *dl_t = &applespi->wd_t;
573 struct spi_transfer *wr_t = &applespi->wr_t;
574 struct spi_transfer *st_t = &applespi->st_t;
576 memset(wt_t, 0, sizeof(*wt_t));
577 memset(dl_t, 0, sizeof(*dl_t));
578 memset(wr_t, 0, sizeof(*wr_t));
579 memset(st_t, 0, sizeof(*st_t));
582 * All we need here is a delay at the beginning of the message before
583 * asserting cs. But the current spi API doesn't support this, so we
584 * end up with an extra unnecessary (but harmless) cs assertion and
587 wt_t->delay.value = SPI_RW_CHG_DELAY_US;
588 wt_t->delay.unit = SPI_DELAY_UNIT_USECS;
591 dl_t->delay.value = applespi->spi_settings.spi_cs_delay;
592 dl_t->delay.unit = SPI_DELAY_UNIT_USECS;
594 wr_t->tx_buf = applespi->tx_buffer;
595 wr_t->len = APPLESPI_PACKET_SIZE;
596 wr_t->delay.value = SPI_RW_CHG_DELAY_US;
597 wr_t->delay.unit = SPI_DELAY_UNIT_USECS;
599 st_t->rx_buf = applespi->tx_status;
600 st_t->len = APPLESPI_STATUS_SIZE;
602 spi_message_init(msg);
603 spi_message_add_tail(wt_t, msg);
604 spi_message_add_tail(dl_t, msg);
605 spi_message_add_tail(wr_t, msg);
606 spi_message_add_tail(st_t, msg);
609 static int applespi_async(struct applespi_data *applespi,
610 struct spi_message *message, void (*complete)(void *))
612 message->complete = complete;
613 message->context = applespi;
615 return spi_async(applespi->spi, message);
618 static inline bool applespi_check_write_status(struct applespi_data *applespi,
621 static u8 status_ok[] = { 0xac, 0x27, 0x68, 0xd5 };
624 dev_warn(&applespi->spi->dev, "Error writing to device: %d\n",
629 if (memcmp(applespi->tx_status, status_ok, APPLESPI_STATUS_SIZE)) {
630 dev_warn(&applespi->spi->dev, "Error writing to device: %*ph\n",
631 APPLESPI_STATUS_SIZE, applespi->tx_status);
638 static int applespi_get_spi_settings(struct applespi_data *applespi)
640 struct acpi_device *adev = ACPI_COMPANION(&applespi->spi->dev);
641 const union acpi_object *o;
642 struct spi_settings *settings = &applespi->spi_settings;
644 if (!acpi_dev_get_property(adev, "spiCSDelay", ACPI_TYPE_BUFFER, &o))
645 settings->spi_cs_delay = *(u64 *)o->buffer.pointer;
647 dev_warn(&applespi->spi->dev,
648 "Property spiCSDelay not found\n");
650 if (!acpi_dev_get_property(adev, "resetA2RUsec", ACPI_TYPE_BUFFER, &o))
651 settings->reset_a2r_usec = *(u64 *)o->buffer.pointer;
653 dev_warn(&applespi->spi->dev,
654 "Property resetA2RUsec not found\n");
656 if (!acpi_dev_get_property(adev, "resetRecUsec", ACPI_TYPE_BUFFER, &o))
657 settings->reset_rec_usec = *(u64 *)o->buffer.pointer;
659 dev_warn(&applespi->spi->dev,
660 "Property resetRecUsec not found\n");
662 dev_dbg(&applespi->spi->dev,
663 "SPI settings: spi_cs_delay=%llu reset_a2r_usec=%llu reset_rec_usec=%llu\n",
664 settings->spi_cs_delay, settings->reset_a2r_usec,
665 settings->reset_rec_usec);
670 static int applespi_setup_spi(struct applespi_data *applespi)
674 sts = applespi_get_spi_settings(applespi);
678 spin_lock_init(&applespi->cmd_msg_lock);
679 init_waitqueue_head(&applespi->drain_complete);
684 static int applespi_enable_spi(struct applespi_data *applespi)
686 acpi_status acpi_sts;
687 unsigned long long spi_status;
689 /* check if SPI is already enabled, so we can skip the delay below */
690 acpi_sts = acpi_evaluate_integer(applespi->sist, NULL, NULL,
692 if (ACPI_SUCCESS(acpi_sts) && spi_status)
695 /* SIEN(1) will enable SPI communication */
696 acpi_sts = acpi_execute_simple_method(applespi->sien, NULL, 1);
697 if (ACPI_FAILURE(acpi_sts)) {
698 dev_err(&applespi->spi->dev, "SIEN failed: %s\n",
699 acpi_format_exception(acpi_sts));
704 * Allow the SPI interface to come up before returning. Without this
705 * delay, the SPI commands to enable multitouch mode may not reach
706 * the trackpad controller, causing pointer movement to break upon
714 static int applespi_send_cmd_msg(struct applespi_data *applespi);
716 static void applespi_msg_complete(struct applespi_data *applespi,
717 bool is_write_msg, bool is_read_compl)
721 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
724 applespi->read_active = false;
726 applespi->write_active = false;
728 if (applespi->drain && !applespi->write_active)
729 wake_up_all(&applespi->drain_complete);
732 applespi->cmd_msg_queued = false;
733 applespi_send_cmd_msg(applespi);
736 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
739 static void applespi_async_write_complete(void *context)
741 struct applespi_data *applespi = context;
742 enum applespi_evt_type evt_type = applespi->cmd_evt_type;
744 applespi_get_trace_fun(evt_type)(evt_type, PT_WRITE,
746 APPLESPI_PACKET_SIZE);
747 applespi_get_trace_fun(evt_type)(evt_type, PT_STATUS,
749 APPLESPI_STATUS_SIZE);
751 if (!applespi_check_write_status(applespi, applespi->wr_m.status)) {
753 * If we got an error, we presumably won't get the expected
754 * response message either.
756 applespi_msg_complete(applespi, true, false);
760 static int applespi_send_cmd_msg(struct applespi_data *applespi)
764 struct spi_packet *packet = (struct spi_packet *)applespi->tx_buffer;
765 struct message *message = (struct message *)packet->data;
769 /* check if draining */
773 /* check whether send is in progress */
774 if (applespi->cmd_msg_queued)
778 memset(packet, 0, APPLESPI_PACKET_SIZE);
780 /* are we processing init commands? */
781 if (applespi->want_tp_info_cmd) {
782 applespi->want_tp_info_cmd = false;
783 applespi->want_mt_init_cmd = true;
784 applespi->cmd_evt_type = ET_CMD_TP_INI;
786 /* build init command */
787 device = PACKET_DEV_INFO;
789 message->type = cpu_to_le16(0x1020);
790 msg_len = sizeof(message->tp_info_command);
792 message->zero = 0x02;
793 message->rsp_buf_len = cpu_to_le16(0x0200);
795 } else if (applespi->want_mt_init_cmd) {
796 applespi->want_mt_init_cmd = false;
797 applespi->cmd_evt_type = ET_CMD_TP_INI;
799 /* build init command */
800 device = PACKET_DEV_TPAD;
802 message->type = cpu_to_le16(0x0252);
803 msg_len = sizeof(message->init_mt_command);
805 message->init_mt_command.cmd = cpu_to_le16(0x0102);
807 /* do we need caps-lock command? */
808 } else if (applespi->want_cl_led_on != applespi->have_cl_led_on) {
809 applespi->have_cl_led_on = applespi->want_cl_led_on;
810 applespi->cmd_evt_type = ET_CMD_CL;
812 /* build led command */
813 device = PACKET_DEV_KEYB;
815 message->type = cpu_to_le16(0x0151);
816 msg_len = sizeof(message->capsl_command);
818 message->capsl_command.unknown = 0x01;
819 message->capsl_command.led = applespi->have_cl_led_on ? 2 : 0;
821 /* do we need backlight command? */
822 } else if (applespi->want_bl_level != applespi->have_bl_level) {
823 applespi->have_bl_level = applespi->want_bl_level;
824 applespi->cmd_evt_type = ET_CMD_BL;
826 /* build command buffer */
827 device = PACKET_DEV_KEYB;
829 message->type = cpu_to_le16(0xB051);
830 msg_len = sizeof(message->bl_command);
832 message->bl_command.const1 = cpu_to_le16(0x01B0);
833 message->bl_command.level =
834 cpu_to_le16(applespi->have_bl_level);
836 if (applespi->have_bl_level > 0)
837 message->bl_command.const2 = cpu_to_le16(0x01F4);
839 message->bl_command.const2 = cpu_to_le16(0x0001);
841 /* everything's up-to-date */
846 /* finalize packet */
847 packet->flags = PACKET_TYPE_WRITE;
848 packet->device = device;
849 packet->length = cpu_to_le16(MSG_HEADER_SIZE + msg_len);
851 message->counter = applespi->cmd_msg_cntr++ % (U8_MAX + 1);
853 message->length = cpu_to_le16(msg_len - 2);
854 if (!message->rsp_buf_len)
855 message->rsp_buf_len = message->length;
857 crc = crc16(0, (u8 *)message, le16_to_cpu(packet->length) - 2);
858 put_unaligned_le16(crc, &message->data[msg_len - 2]);
860 crc = crc16(0, (u8 *)packet, sizeof(*packet) - 2);
861 packet->crc16 = cpu_to_le16(crc);
864 sts = applespi_async(applespi, &applespi->wr_m,
865 applespi_async_write_complete);
867 dev_warn(&applespi->spi->dev,
868 "Error queueing async write to device: %d\n", sts);
872 applespi->cmd_msg_queued = true;
873 applespi->write_active = true;
878 static void applespi_init(struct applespi_data *applespi, bool is_resume)
882 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
885 applespi->want_mt_init_cmd = true;
887 applespi->want_tp_info_cmd = true;
888 applespi_send_cmd_msg(applespi);
890 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
893 static int applespi_set_capsl_led(struct applespi_data *applespi,
899 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
901 applespi->want_cl_led_on = capslock_on;
902 sts = applespi_send_cmd_msg(applespi);
904 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
909 static void applespi_set_bl_level(struct led_classdev *led_cdev,
910 enum led_brightness value)
912 struct applespi_data *applespi =
913 container_of(led_cdev, struct applespi_data, backlight_info);
916 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
919 applespi->want_bl_level = value;
922 * The backlight does not turn on till level 32, so we scale
923 * the range here so that from a user's perspective it turns
926 applespi->want_bl_level =
927 ((value * KBD_BL_LEVEL_ADJ) / KBD_BL_LEVEL_SCALE +
931 applespi_send_cmd_msg(applespi);
933 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
936 static int applespi_event(struct input_dev *dev, unsigned int type,
937 unsigned int code, int value)
939 struct applespi_data *applespi = input_get_drvdata(dev);
943 applespi_set_capsl_led(applespi, !!test_bit(LED_CAPSL, dev->led));
950 /* lifted from the BCM5974 driver and renamed from raw2int */
951 /* convert 16-bit little endian to signed integer */
952 static inline int le16_to_int(__le16 x)
954 return (signed short)le16_to_cpu(x);
957 static void applespi_debug_update_dimensions(struct applespi_data *applespi,
958 const struct tp_finger *f)
960 applespi->tp_dim_min_x = min(applespi->tp_dim_min_x,
961 le16_to_int(f->abs_x));
962 applespi->tp_dim_max_x = max(applespi->tp_dim_max_x,
963 le16_to_int(f->abs_x));
964 applespi->tp_dim_min_y = min(applespi->tp_dim_min_y,
965 le16_to_int(f->abs_y));
966 applespi->tp_dim_max_y = max(applespi->tp_dim_max_y,
967 le16_to_int(f->abs_y));
970 static int applespi_tp_dim_open(struct inode *inode, struct file *file)
972 struct applespi_data *applespi = inode->i_private;
974 file->private_data = applespi;
976 snprintf(applespi->tp_dim_val, sizeof(applespi->tp_dim_val),
977 "0x%.4x %dx%d+%u+%u\n",
978 applespi->touchpad_input_dev->id.product,
979 applespi->tp_dim_min_x, applespi->tp_dim_min_y,
980 applespi->tp_dim_max_x - applespi->tp_dim_min_x,
981 applespi->tp_dim_max_y - applespi->tp_dim_min_y);
983 return nonseekable_open(inode, file);
986 static ssize_t applespi_tp_dim_read(struct file *file, char __user *buf,
987 size_t len, loff_t *off)
989 struct applespi_data *applespi = file->private_data;
991 return simple_read_from_buffer(buf, len, off, applespi->tp_dim_val,
992 strlen(applespi->tp_dim_val));
995 static const struct file_operations applespi_tp_dim_fops = {
996 .owner = THIS_MODULE,
997 .open = applespi_tp_dim_open,
998 .read = applespi_tp_dim_read,
1002 static void report_finger_data(struct input_dev *input, int slot,
1003 const struct input_mt_pos *pos,
1004 const struct tp_finger *f)
1006 input_mt_slot(input, slot);
1007 input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
1009 input_report_abs(input, ABS_MT_TOUCH_MAJOR,
1010 le16_to_int(f->touch_major) << 1);
1011 input_report_abs(input, ABS_MT_TOUCH_MINOR,
1012 le16_to_int(f->touch_minor) << 1);
1013 input_report_abs(input, ABS_MT_WIDTH_MAJOR,
1014 le16_to_int(f->tool_major) << 1);
1015 input_report_abs(input, ABS_MT_WIDTH_MINOR,
1016 le16_to_int(f->tool_minor) << 1);
1017 input_report_abs(input, ABS_MT_ORIENTATION,
1018 MAX_FINGER_ORIENTATION - le16_to_int(f->orientation));
1019 input_report_abs(input, ABS_MT_POSITION_X, pos->x);
1020 input_report_abs(input, ABS_MT_POSITION_Y, pos->y);
1023 static void report_tp_state(struct applespi_data *applespi,
1024 struct touchpad_protocol *t)
1026 const struct tp_finger *f;
1027 struct input_dev *input;
1028 const struct applespi_tp_info *tp_info = &applespi->tp_info;
1031 /* touchpad_input_dev is set async in worker */
1032 input = smp_load_acquire(&applespi->touchpad_input_dev);
1034 return; /* touchpad isn't initialized yet */
1038 for (i = 0; i < t->number_of_fingers; i++) {
1040 if (le16_to_int(f->touch_major) == 0)
1042 applespi->pos[n].x = le16_to_int(f->abs_x);
1043 applespi->pos[n].y = tp_info->y_min + tp_info->y_max -
1044 le16_to_int(f->abs_y);
1047 if (applespi->debug_tp_dim)
1048 applespi_debug_update_dimensions(applespi, f);
1051 input_mt_assign_slots(input, applespi->slots, applespi->pos, n, 0);
1053 for (i = 0; i < n; i++)
1054 report_finger_data(input, applespi->slots[i],
1055 &applespi->pos[i], &t->fingers[i]);
1057 input_mt_sync_frame(input);
1058 input_report_key(input, BTN_LEFT, t->clicked);
1063 static const struct applespi_key_translation *
1064 applespi_find_translation(const struct applespi_key_translation *table, u16 key)
1066 const struct applespi_key_translation *trans;
1068 for (trans = table; trans->from; trans++)
1069 if (trans->from == key)
1075 static unsigned int applespi_translate_fn_key(unsigned int key, int fn_pressed)
1077 const struct applespi_key_translation *trans;
1080 trans = applespi_find_translation(applespi_fn_codes, key);
1082 if (trans->flags & APPLE_FLAG_FKEY)
1083 do_translate = (fnmode == 2 && fn_pressed) ||
1084 (fnmode == 1 && !fn_pressed);
1086 do_translate = fn_pressed;
1095 static unsigned int applespi_translate_iso_layout(unsigned int key)
1097 const struct applespi_key_translation *trans;
1099 trans = applespi_find_translation(apple_iso_keyboard, key);
1106 static unsigned int applespi_code_to_key(u8 code, int fn_pressed)
1108 unsigned int key = applespi_scancodes[code];
1111 key = applespi_translate_fn_key(key, fn_pressed);
1113 key = applespi_translate_iso_layout(key);
1118 applespi_remap_fn_key(struct keyboard_protocol *keyboard_protocol)
1121 u8 bit = BIT((fnremap - 1) & 0x07);
1123 if (!fnremap || fnremap > ARRAY_SIZE(applespi_controlcodes) ||
1124 !applespi_controlcodes[fnremap - 1])
1127 tmp = keyboard_protocol->fn_pressed;
1128 keyboard_protocol->fn_pressed = !!(keyboard_protocol->modifiers & bit);
1130 keyboard_protocol->modifiers |= bit;
1132 keyboard_protocol->modifiers &= ~bit;
1136 applespi_handle_keyboard_event(struct applespi_data *applespi,
1137 struct keyboard_protocol *keyboard_protocol)
1142 compiletime_assert(ARRAY_SIZE(applespi_controlcodes) ==
1143 sizeof_field(struct keyboard_protocol, modifiers) * 8,
1144 "applespi_controlcodes has wrong number of entries");
1146 /* check for rollover overflow, which is signalled by all keys == 1 */
1147 if (!memchr_inv(keyboard_protocol->keys_pressed, 1, MAX_ROLLOVER))
1150 /* remap fn key if desired */
1151 applespi_remap_fn_key(keyboard_protocol);
1153 /* check released keys */
1154 for (i = 0; i < MAX_ROLLOVER; i++) {
1155 if (memchr(keyboard_protocol->keys_pressed,
1156 applespi->last_keys_pressed[i], MAX_ROLLOVER))
1157 continue; /* key is still pressed */
1159 key = applespi_code_to_key(applespi->last_keys_pressed[i],
1160 applespi->last_keys_fn_pressed[i]);
1161 input_report_key(applespi->keyboard_input_dev, key, 0);
1162 applespi->last_keys_fn_pressed[i] = 0;
1165 /* check pressed keys */
1166 for (i = 0; i < MAX_ROLLOVER; i++) {
1167 if (keyboard_protocol->keys_pressed[i] <
1168 ARRAY_SIZE(applespi_scancodes) &&
1169 keyboard_protocol->keys_pressed[i] > 0) {
1170 key = applespi_code_to_key(
1171 keyboard_protocol->keys_pressed[i],
1172 keyboard_protocol->fn_pressed);
1173 input_report_key(applespi->keyboard_input_dev, key, 1);
1174 applespi->last_keys_fn_pressed[i] =
1175 keyboard_protocol->fn_pressed;
1179 /* check control keys */
1180 for (i = 0; i < ARRAY_SIZE(applespi_controlcodes); i++) {
1181 if (keyboard_protocol->modifiers & BIT(i))
1182 input_report_key(applespi->keyboard_input_dev,
1183 applespi_controlcodes[i], 1);
1185 input_report_key(applespi->keyboard_input_dev,
1186 applespi_controlcodes[i], 0);
1189 /* check function key */
1190 if (keyboard_protocol->fn_pressed && !applespi->last_fn_pressed)
1191 input_report_key(applespi->keyboard_input_dev, KEY_FN, 1);
1192 else if (!keyboard_protocol->fn_pressed && applespi->last_fn_pressed)
1193 input_report_key(applespi->keyboard_input_dev, KEY_FN, 0);
1194 applespi->last_fn_pressed = keyboard_protocol->fn_pressed;
1197 input_sync(applespi->keyboard_input_dev);
1198 memcpy(&applespi->last_keys_pressed, keyboard_protocol->keys_pressed,
1199 sizeof(applespi->last_keys_pressed));
1202 static const struct applespi_tp_info *applespi_find_touchpad_info(u8 model)
1204 const struct applespi_tp_model_info *info;
1206 for (info = applespi_tp_models; info->model; info++) {
1207 if (info->model == model)
1208 return &info->tp_info;
1215 applespi_register_touchpad_device(struct applespi_data *applespi,
1216 struct touchpad_info_protocol *rcvd_tp_info)
1218 const struct applespi_tp_info *tp_info;
1219 struct input_dev *touchpad_input_dev;
1222 /* set up touchpad dimensions */
1223 tp_info = applespi_find_touchpad_info(rcvd_tp_info->model_no);
1225 dev_warn(&applespi->spi->dev,
1226 "Unknown touchpad model %x - falling back to MB8 touchpad\n",
1227 rcvd_tp_info->model_no);
1228 tp_info = &applespi_tp_models[0].tp_info;
1231 applespi->tp_info = *tp_info;
1233 if (touchpad_dimensions[0]) {
1236 sts = sscanf(touchpad_dimensions, "%dx%d+%u+%u", &x, &y, &w, &h);
1238 dev_info(&applespi->spi->dev,
1239 "Overriding touchpad dimensions from module param\n");
1240 applespi->tp_info.x_min = x;
1241 applespi->tp_info.y_min = y;
1242 applespi->tp_info.x_max = x + w;
1243 applespi->tp_info.y_max = y + h;
1245 dev_warn(&applespi->spi->dev,
1246 "Invalid touchpad dimensions '%s': must be in the form XxY+W+H\n",
1247 touchpad_dimensions);
1248 touchpad_dimensions[0] = '\0';
1251 if (!touchpad_dimensions[0]) {
1252 snprintf(touchpad_dimensions, sizeof(touchpad_dimensions),
1254 applespi->tp_info.x_min,
1255 applespi->tp_info.y_min,
1256 applespi->tp_info.x_max - applespi->tp_info.x_min,
1257 applespi->tp_info.y_max - applespi->tp_info.y_min);
1260 /* create touchpad input device */
1261 touchpad_input_dev = devm_input_allocate_device(&applespi->spi->dev);
1262 if (!touchpad_input_dev) {
1263 dev_err(&applespi->spi->dev,
1264 "Failed to allocate touchpad input device\n");
1268 touchpad_input_dev->name = "Apple SPI Touchpad";
1269 touchpad_input_dev->phys = "applespi/input1";
1270 touchpad_input_dev->dev.parent = &applespi->spi->dev;
1271 touchpad_input_dev->id.bustype = BUS_SPI;
1272 touchpad_input_dev->id.vendor = SYNAPTICS_VENDOR_ID;
1273 touchpad_input_dev->id.product =
1274 rcvd_tp_info->model_no << 8 | rcvd_tp_info->model_flags;
1276 /* basic properties */
1277 input_set_capability(touchpad_input_dev, EV_REL, REL_X);
1278 input_set_capability(touchpad_input_dev, EV_REL, REL_Y);
1280 __set_bit(INPUT_PROP_POINTER, touchpad_input_dev->propbit);
1281 __set_bit(INPUT_PROP_BUTTONPAD, touchpad_input_dev->propbit);
1283 /* finger touch area */
1284 input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MAJOR,
1286 input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MINOR,
1289 /* finger approach area */
1290 input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MAJOR,
1292 input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MINOR,
1295 /* finger orientation */
1296 input_set_abs_params(touchpad_input_dev, ABS_MT_ORIENTATION,
1297 -MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION,
1300 /* finger position */
1301 input_set_abs_params(touchpad_input_dev, ABS_MT_POSITION_X,
1302 applespi->tp_info.x_min, applespi->tp_info.x_max,
1304 input_set_abs_params(touchpad_input_dev, ABS_MT_POSITION_Y,
1305 applespi->tp_info.y_min, applespi->tp_info.y_max,
1308 /* touchpad button */
1309 input_set_capability(touchpad_input_dev, EV_KEY, BTN_LEFT);
1312 sts = input_mt_init_slots(touchpad_input_dev, MAX_FINGERS,
1313 INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
1316 dev_err(&applespi->spi->dev,
1317 "failed to initialize slots: %d", sts);
1321 /* register input device */
1322 sts = input_register_device(touchpad_input_dev);
1324 dev_err(&applespi->spi->dev,
1325 "Unable to register touchpad input device (%d)\n", sts);
1329 /* touchpad_input_dev is read async in spi callback */
1330 smp_store_release(&applespi->touchpad_input_dev, touchpad_input_dev);
1335 static void applespi_worker(struct work_struct *work)
1337 struct applespi_data *applespi =
1338 container_of(work, struct applespi_data, work);
1340 applespi_register_touchpad_device(applespi, &applespi->rcvd_tp_info);
1343 static void applespi_handle_cmd_response(struct applespi_data *applespi,
1344 struct spi_packet *packet,
1345 struct message *message)
1347 if (packet->device == PACKET_DEV_INFO &&
1348 le16_to_cpu(message->type) == 0x1020) {
1350 * We're not allowed to sleep here, but registering an input
1353 applespi->rcvd_tp_info = message->tp_info;
1354 schedule_work(&applespi->work);
1358 if (le16_to_cpu(message->length) != 0x0000) {
1359 dev_warn_ratelimited(&applespi->spi->dev,
1360 "Received unexpected write response: length=%x\n",
1361 le16_to_cpu(message->length));
1365 if (packet->device == PACKET_DEV_TPAD &&
1366 le16_to_cpu(message->type) == 0x0252 &&
1367 le16_to_cpu(message->rsp_buf_len) == 0x0002)
1368 dev_info(&applespi->spi->dev, "modeswitch done.\n");
1371 static bool applespi_verify_crc(struct applespi_data *applespi, u8 *buffer,
1376 crc = crc16(0, buffer, buflen);
1378 dev_warn_ratelimited(&applespi->spi->dev,
1379 "Received corrupted packet (crc mismatch)\n");
1380 trace_applespi_bad_crc(ET_RD_CRC, READ, buffer, buflen);
1388 static void applespi_debug_print_read_packet(struct applespi_data *applespi,
1389 struct spi_packet *packet)
1391 unsigned int evt_type;
1393 if (packet->flags == PACKET_TYPE_READ &&
1394 packet->device == PACKET_DEV_KEYB)
1395 evt_type = ET_RD_KEYB;
1396 else if (packet->flags == PACKET_TYPE_READ &&
1397 packet->device == PACKET_DEV_TPAD)
1398 evt_type = ET_RD_TPAD;
1399 else if (packet->flags == PACKET_TYPE_WRITE)
1400 evt_type = applespi->cmd_evt_type;
1402 evt_type = ET_RD_UNKN;
1404 applespi_get_trace_fun(evt_type)(evt_type, PT_READ, applespi->rx_buffer,
1405 APPLESPI_PACKET_SIZE);
1408 static void applespi_got_data(struct applespi_data *applespi)
1410 struct spi_packet *packet;
1411 struct message *message;
1412 unsigned int msg_len;
1417 /* process packet header */
1418 if (!applespi_verify_crc(applespi, applespi->rx_buffer,
1419 APPLESPI_PACKET_SIZE)) {
1420 unsigned long flags;
1422 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1424 if (applespi->drain) {
1425 applespi->read_active = false;
1426 applespi->write_active = false;
1428 wake_up_all(&applespi->drain_complete);
1431 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1436 packet = (struct spi_packet *)applespi->rx_buffer;
1438 applespi_debug_print_read_packet(applespi, packet);
1440 off = le16_to_cpu(packet->offset);
1441 rem = le16_to_cpu(packet->remaining);
1442 len = le16_to_cpu(packet->length);
1444 if (len > sizeof(packet->data)) {
1445 dev_warn_ratelimited(&applespi->spi->dev,
1446 "Received corrupted packet (invalid packet length %u)\n",
1451 /* handle multi-packet messages */
1452 if (rem > 0 || off > 0) {
1453 if (off != applespi->saved_msg_len) {
1454 dev_warn_ratelimited(&applespi->spi->dev,
1455 "Received unexpected offset (got %u, expected %u)\n",
1456 off, applespi->saved_msg_len);
1460 if (off + rem > MAX_PKTS_PER_MSG * APPLESPI_PACKET_SIZE) {
1461 dev_warn_ratelimited(&applespi->spi->dev,
1462 "Received message too large (size %u)\n",
1467 if (off + len > MAX_PKTS_PER_MSG * APPLESPI_PACKET_SIZE) {
1468 dev_warn_ratelimited(&applespi->spi->dev,
1469 "Received message too large (size %u)\n",
1474 memcpy(applespi->msg_buf + off, &packet->data, len);
1475 applespi->saved_msg_len += len;
1480 message = (struct message *)applespi->msg_buf;
1481 msg_len = applespi->saved_msg_len;
1483 message = (struct message *)&packet->data;
1487 /* got complete message - verify */
1488 if (!applespi_verify_crc(applespi, (u8 *)message, msg_len))
1491 if (le16_to_cpu(message->length) != msg_len - MSG_HEADER_SIZE - 2) {
1492 dev_warn_ratelimited(&applespi->spi->dev,
1493 "Received corrupted packet (invalid message length %u - expected %u)\n",
1494 le16_to_cpu(message->length),
1495 msg_len - MSG_HEADER_SIZE - 2);
1499 /* handle message */
1500 if (packet->flags == PACKET_TYPE_READ &&
1501 packet->device == PACKET_DEV_KEYB) {
1502 applespi_handle_keyboard_event(applespi, &message->keyboard);
1504 } else if (packet->flags == PACKET_TYPE_READ &&
1505 packet->device == PACKET_DEV_TPAD) {
1506 struct touchpad_protocol *tp;
1509 tp = &message->touchpad;
1510 tp_len = struct_size(tp, fingers, tp->number_of_fingers);
1512 if (le16_to_cpu(message->length) + 2 != tp_len) {
1513 dev_warn_ratelimited(&applespi->spi->dev,
1514 "Received corrupted packet (invalid message length %u - num-fingers %u, tp-len %zu)\n",
1515 le16_to_cpu(message->length),
1516 tp->number_of_fingers, tp_len);
1520 if (tp->number_of_fingers > MAX_FINGERS) {
1521 dev_warn_ratelimited(&applespi->spi->dev,
1522 "Number of reported fingers (%u) exceeds max (%u))\n",
1523 tp->number_of_fingers,
1525 tp->number_of_fingers = MAX_FINGERS;
1528 report_tp_state(applespi, tp);
1530 } else if (packet->flags == PACKET_TYPE_WRITE) {
1531 applespi_handle_cmd_response(applespi, packet, message);
1535 applespi->saved_msg_len = 0;
1537 applespi_msg_complete(applespi, packet->flags == PACKET_TYPE_WRITE,
1541 static void applespi_async_read_complete(void *context)
1543 struct applespi_data *applespi = context;
1545 if (applespi->rd_m.status < 0) {
1546 dev_warn(&applespi->spi->dev, "Error reading from device: %d\n",
1547 applespi->rd_m.status);
1549 * We don't actually know if this was a pure read, or a response
1550 * to a write. But this is a rare error condition that should
1551 * never occur, so clearing both flags to avoid deadlock.
1553 applespi_msg_complete(applespi, true, true);
1555 applespi_got_data(applespi);
1558 acpi_finish_gpe(NULL, applespi->gpe);
1561 static u32 applespi_notify(acpi_handle gpe_device, u32 gpe, void *context)
1563 struct applespi_data *applespi = context;
1565 unsigned long flags;
1567 trace_applespi_irq_received(ET_RD_IRQ, PT_READ);
1569 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1571 if (!applespi->suspended) {
1572 sts = applespi_async(applespi, &applespi->rd_m,
1573 applespi_async_read_complete);
1575 dev_warn(&applespi->spi->dev,
1576 "Error queueing async read to device: %d\n",
1579 applespi->read_active = true;
1582 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1584 return ACPI_INTERRUPT_HANDLED;
1587 static int applespi_get_saved_bl_level(struct applespi_data *applespi)
1589 struct efivar_entry *efivar_entry;
1591 unsigned long efi_data_len;
1594 efivar_entry = kmalloc(sizeof(*efivar_entry), GFP_KERNEL);
1598 memcpy(efivar_entry->var.VariableName, EFI_BL_LEVEL_NAME,
1599 sizeof(EFI_BL_LEVEL_NAME));
1600 efivar_entry->var.VendorGuid = EFI_BL_LEVEL_GUID;
1601 efi_data_len = sizeof(efi_data);
1603 sts = efivar_entry_get(efivar_entry, NULL, &efi_data_len, &efi_data);
1604 if (sts && sts != -ENOENT)
1605 dev_warn(&applespi->spi->dev,
1606 "Error getting backlight level from EFI vars: %d\n",
1609 kfree(efivar_entry);
1611 return sts ? sts : efi_data;
1614 static void applespi_save_bl_level(struct applespi_data *applespi,
1617 efi_guid_t efi_guid;
1619 unsigned long efi_data_len;
1623 /* Save keyboard backlight level */
1624 efi_guid = EFI_BL_LEVEL_GUID;
1625 efi_data = (u16)level;
1626 efi_data_len = sizeof(efi_data);
1627 efi_attr = EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS |
1628 EFI_VARIABLE_RUNTIME_ACCESS;
1630 sts = efivar_entry_set_safe((efi_char16_t *)EFI_BL_LEVEL_NAME, efi_guid,
1631 efi_attr, true, efi_data_len, &efi_data);
1633 dev_warn(&applespi->spi->dev,
1634 "Error saving backlight level to EFI vars: %d\n", sts);
1637 static int applespi_probe(struct spi_device *spi)
1639 struct applespi_data *applespi;
1640 acpi_handle spi_handle = ACPI_HANDLE(&spi->dev);
1641 acpi_status acpi_sts;
1643 unsigned long long gpe, usb_status;
1645 /* check if the USB interface is present and enabled already */
1646 acpi_sts = acpi_evaluate_integer(spi_handle, "UIST", NULL, &usb_status);
1647 if (ACPI_SUCCESS(acpi_sts) && usb_status) {
1648 /* let the USB driver take over instead */
1649 dev_info(&spi->dev, "USB interface already enabled\n");
1653 /* allocate driver data */
1654 applespi = devm_kzalloc(&spi->dev, sizeof(*applespi), GFP_KERNEL);
1658 applespi->spi = spi;
1660 INIT_WORK(&applespi->work, applespi_worker);
1662 /* store the driver data */
1663 spi_set_drvdata(spi, applespi);
1665 /* create our buffers */
1666 applespi->tx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1668 applespi->tx_status = devm_kmalloc(&spi->dev, APPLESPI_STATUS_SIZE,
1670 applespi->rx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1672 applespi->msg_buf = devm_kmalloc_array(&spi->dev, MAX_PKTS_PER_MSG,
1673 APPLESPI_PACKET_SIZE,
1676 if (!applespi->tx_buffer || !applespi->tx_status ||
1677 !applespi->rx_buffer || !applespi->msg_buf)
1680 /* set up our spi messages */
1681 applespi_setup_read_txfrs(applespi);
1682 applespi_setup_write_txfrs(applespi);
1684 /* cache ACPI method handles */
1685 acpi_sts = acpi_get_handle(spi_handle, "SIEN", &applespi->sien);
1686 if (ACPI_FAILURE(acpi_sts)) {
1687 dev_err(&applespi->spi->dev,
1688 "Failed to get SIEN ACPI method handle: %s\n",
1689 acpi_format_exception(acpi_sts));
1693 acpi_sts = acpi_get_handle(spi_handle, "SIST", &applespi->sist);
1694 if (ACPI_FAILURE(acpi_sts)) {
1695 dev_err(&applespi->spi->dev,
1696 "Failed to get SIST ACPI method handle: %s\n",
1697 acpi_format_exception(acpi_sts));
1701 /* switch on the SPI interface */
1702 sts = applespi_setup_spi(applespi);
1706 sts = applespi_enable_spi(applespi);
1710 /* setup the keyboard input dev */
1711 applespi->keyboard_input_dev = devm_input_allocate_device(&spi->dev);
1713 if (!applespi->keyboard_input_dev)
1716 applespi->keyboard_input_dev->name = "Apple SPI Keyboard";
1717 applespi->keyboard_input_dev->phys = "applespi/input0";
1718 applespi->keyboard_input_dev->dev.parent = &spi->dev;
1719 applespi->keyboard_input_dev->id.bustype = BUS_SPI;
1721 applespi->keyboard_input_dev->evbit[0] =
1722 BIT_MASK(EV_KEY) | BIT_MASK(EV_LED) | BIT_MASK(EV_REP);
1723 applespi->keyboard_input_dev->ledbit[0] = BIT_MASK(LED_CAPSL);
1725 input_set_drvdata(applespi->keyboard_input_dev, applespi);
1726 applespi->keyboard_input_dev->event = applespi_event;
1728 for (i = 0; i < ARRAY_SIZE(applespi_scancodes); i++)
1729 if (applespi_scancodes[i])
1730 input_set_capability(applespi->keyboard_input_dev,
1731 EV_KEY, applespi_scancodes[i]);
1733 for (i = 0; i < ARRAY_SIZE(applespi_controlcodes); i++)
1734 if (applespi_controlcodes[i])
1735 input_set_capability(applespi->keyboard_input_dev,
1736 EV_KEY, applespi_controlcodes[i]);
1738 for (i = 0; i < ARRAY_SIZE(applespi_fn_codes); i++)
1739 if (applespi_fn_codes[i].to)
1740 input_set_capability(applespi->keyboard_input_dev,
1741 EV_KEY, applespi_fn_codes[i].to);
1743 input_set_capability(applespi->keyboard_input_dev, EV_KEY, KEY_FN);
1745 sts = input_register_device(applespi->keyboard_input_dev);
1747 dev_err(&applespi->spi->dev,
1748 "Unable to register keyboard input device (%d)\n", sts);
1753 * The applespi device doesn't send interrupts normally (as is described
1754 * in its DSDT), but rather seems to use ACPI GPEs.
1756 acpi_sts = acpi_evaluate_integer(spi_handle, "_GPE", NULL, &gpe);
1757 if (ACPI_FAILURE(acpi_sts)) {
1758 dev_err(&applespi->spi->dev,
1759 "Failed to obtain GPE for SPI slave device: %s\n",
1760 acpi_format_exception(acpi_sts));
1763 applespi->gpe = (int)gpe;
1765 acpi_sts = acpi_install_gpe_handler(NULL, applespi->gpe,
1766 ACPI_GPE_LEVEL_TRIGGERED,
1767 applespi_notify, applespi);
1768 if (ACPI_FAILURE(acpi_sts)) {
1769 dev_err(&applespi->spi->dev,
1770 "Failed to install GPE handler for GPE %d: %s\n",
1771 applespi->gpe, acpi_format_exception(acpi_sts));
1775 applespi->suspended = false;
1777 acpi_sts = acpi_enable_gpe(NULL, applespi->gpe);
1778 if (ACPI_FAILURE(acpi_sts)) {
1779 dev_err(&applespi->spi->dev,
1780 "Failed to enable GPE handler for GPE %d: %s\n",
1781 applespi->gpe, acpi_format_exception(acpi_sts));
1782 acpi_remove_gpe_handler(NULL, applespi->gpe, applespi_notify);
1786 /* trigger touchpad setup */
1787 applespi_init(applespi, false);
1790 * By default this device is not enabled for wakeup; but USB keyboards
1791 * generally are, so the expectation is that by default the keyboard
1792 * will wake the system.
1794 device_wakeup_enable(&spi->dev);
1796 /* set up keyboard-backlight */
1797 sts = applespi_get_saved_bl_level(applespi);
1799 applespi_set_bl_level(&applespi->backlight_info, sts);
1801 applespi->backlight_info.name = "spi::kbd_backlight";
1802 applespi->backlight_info.default_trigger = "kbd-backlight";
1803 applespi->backlight_info.brightness_set = applespi_set_bl_level;
1805 sts = devm_led_classdev_register(&spi->dev, &applespi->backlight_info);
1807 dev_warn(&applespi->spi->dev,
1808 "Unable to register keyboard backlight class dev (%d)\n",
1811 /* set up debugfs entries for touchpad dimensions logging */
1812 applespi->debugfs_root = debugfs_create_dir("applespi", NULL);
1814 debugfs_create_bool("enable_tp_dim", 0600, applespi->debugfs_root,
1815 &applespi->debug_tp_dim);
1817 debugfs_create_file("tp_dim", 0400, applespi->debugfs_root, applespi,
1818 &applespi_tp_dim_fops);
1823 static void applespi_drain_writes(struct applespi_data *applespi)
1825 unsigned long flags;
1827 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1829 applespi->drain = true;
1830 wait_event_lock_irq(applespi->drain_complete, !applespi->write_active,
1831 applespi->cmd_msg_lock);
1833 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1836 static void applespi_drain_reads(struct applespi_data *applespi)
1838 unsigned long flags;
1840 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1842 wait_event_lock_irq(applespi->drain_complete, !applespi->read_active,
1843 applespi->cmd_msg_lock);
1845 applespi->suspended = true;
1847 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1850 static int applespi_remove(struct spi_device *spi)
1852 struct applespi_data *applespi = spi_get_drvdata(spi);
1854 applespi_drain_writes(applespi);
1856 acpi_disable_gpe(NULL, applespi->gpe);
1857 acpi_remove_gpe_handler(NULL, applespi->gpe, applespi_notify);
1858 device_wakeup_disable(&spi->dev);
1860 applespi_drain_reads(applespi);
1862 debugfs_remove_recursive(applespi->debugfs_root);
1867 static void applespi_shutdown(struct spi_device *spi)
1869 struct applespi_data *applespi = spi_get_drvdata(spi);
1871 applespi_save_bl_level(applespi, applespi->have_bl_level);
1874 static int applespi_poweroff_late(struct device *dev)
1876 struct spi_device *spi = to_spi_device(dev);
1877 struct applespi_data *applespi = spi_get_drvdata(spi);
1879 applespi_save_bl_level(applespi, applespi->have_bl_level);
1884 static int __maybe_unused applespi_suspend(struct device *dev)
1886 struct spi_device *spi = to_spi_device(dev);
1887 struct applespi_data *applespi = spi_get_drvdata(spi);
1888 acpi_status acpi_sts;
1891 /* turn off caps-lock - it'll stay on otherwise */
1892 sts = applespi_set_capsl_led(applespi, false);
1894 dev_warn(&applespi->spi->dev,
1895 "Failed to turn off caps-lock led (%d)\n", sts);
1897 applespi_drain_writes(applespi);
1899 /* disable the interrupt */
1900 acpi_sts = acpi_disable_gpe(NULL, applespi->gpe);
1901 if (ACPI_FAILURE(acpi_sts))
1902 dev_err(&applespi->spi->dev,
1903 "Failed to disable GPE handler for GPE %d: %s\n",
1904 applespi->gpe, acpi_format_exception(acpi_sts));
1906 applespi_drain_reads(applespi);
1911 static int __maybe_unused applespi_resume(struct device *dev)
1913 struct spi_device *spi = to_spi_device(dev);
1914 struct applespi_data *applespi = spi_get_drvdata(spi);
1915 acpi_status acpi_sts;
1916 unsigned long flags;
1918 /* ensure our flags and state reflect a newly resumed device */
1919 spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1921 applespi->drain = false;
1922 applespi->have_cl_led_on = false;
1923 applespi->have_bl_level = 0;
1924 applespi->cmd_msg_queued = false;
1925 applespi->read_active = false;
1926 applespi->write_active = false;
1928 applespi->suspended = false;
1930 spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1932 /* switch on the SPI interface */
1933 applespi_enable_spi(applespi);
1935 /* re-enable the interrupt */
1936 acpi_sts = acpi_enable_gpe(NULL, applespi->gpe);
1937 if (ACPI_FAILURE(acpi_sts))
1938 dev_err(&applespi->spi->dev,
1939 "Failed to re-enable GPE handler for GPE %d: %s\n",
1940 applespi->gpe, acpi_format_exception(acpi_sts));
1942 /* switch the touchpad into multitouch mode */
1943 applespi_init(applespi, true);
1948 static const struct acpi_device_id applespi_acpi_match[] = {
1952 MODULE_DEVICE_TABLE(acpi, applespi_acpi_match);
1954 static const struct dev_pm_ops applespi_pm_ops = {
1955 SET_SYSTEM_SLEEP_PM_OPS(applespi_suspend, applespi_resume)
1956 .poweroff_late = applespi_poweroff_late,
1959 static struct spi_driver applespi_driver = {
1962 .acpi_match_table = applespi_acpi_match,
1963 .pm = &applespi_pm_ops,
1965 .probe = applespi_probe,
1966 .remove = applespi_remove,
1967 .shutdown = applespi_shutdown,
1970 module_spi_driver(applespi_driver)
1972 MODULE_LICENSE("GPL v2");
1973 MODULE_DESCRIPTION("MacBook(Pro) SPI Keyboard/Touchpad driver");
1974 MODULE_AUTHOR("Federico Lorenzi");
1975 MODULE_AUTHOR("Ronald Tschalär");