Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
Pull more input updates from Dmitry Torokhov:
- Apple SPI keyboard and trackpad driver for newer Macs
- ALPS driver will ignore trackpoint-only devices to give the
trackpoint driver a chance to handle them properly
- another Lenovo is switched over to SMbus from PS/2
- assorted driver fixups.
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input:
Input: alps - fix a mismatch between a condition check and its comment
Input: psmouse - fix build error of multiple definition
Input: applespi - remove set but not used variables 'sts'
Input: add Apple SPI keyboard and trackpad driver
Input: alps - don't handle ALPS cs19 trackpoint-only device
Input: hyperv-keyboard - remove dependencies on PAGE_SIZE for ring buffer
Input: adp5589 - initialize GPIO controller parent device
Input: iforce - remove empty multiline comments
Input: synaptics - fix misuse of strlcpy
Input: auo-pixcir-ts - switch to using devm_add_action_or_reset()
Input: gtco - bounds check collection indent level
Input: mtk-pmic-keys - add of_node_put() before return
Input: sun4i-lradc-keys - add of_node_put() before return
Input: synaptics - whitelist Lenovo T580 SMBus intertouch
+2183
-29
-3
drivers/input/joystick/iforce/iforce-ff.c
-3
drivers/input/joystick/iforce/iforce-ff.c
-3
drivers/input/joystick/iforce/iforce-main.c
-3
drivers/input/joystick/iforce/iforce-main.c
-3
drivers/input/joystick/iforce/iforce-packets.c
-3
drivers/input/joystick/iforce/iforce-packets.c
-3
drivers/input/joystick/iforce/iforce-serio.c
-3
drivers/input/joystick/iforce/iforce-serio.c
-3
drivers/input/joystick/iforce/iforce-usb.c
-3
drivers/input/joystick/iforce/iforce-usb.c
-3
drivers/input/joystick/iforce/iforce.h
-3
drivers/input/joystick/iforce/iforce.h
+16
drivers/input/keyboard/Kconfig
+16
drivers/input/keyboard/Kconfig
···
71
71
config ATARI_KBD_CORE
72
72
bool
73
73
74
+
config KEYBOARD_APPLESPI
75
+
tristate "Apple SPI keyboard and trackpad"
76
+
depends on ACPI && EFI
77
+
depends on SPI
78
+
depends on X86 || COMPILE_TEST
79
+
help
80
+
Say Y here if you are running Linux on any Apple MacBook8,1 or later,
81
+
or any MacBookPro13,* or MacBookPro14,*.
82
+
83
+
You will also need to enable appropriate SPI master controllers:
84
+
spi_pxa2xx_platform and spi_pxa2xx_pci for MacBook8,1, and
85
+
spi_pxa2xx_platform and intel_lpss_pci for the rest.
86
+
87
+
To compile this driver as a module, choose M here: the
88
+
module will be called applespi.
89
+
74
90
config KEYBOARD_ATARI
75
91
tristate "Atari keyboard"
76
92
depends on ATARI
+1
drivers/input/keyboard/Makefile
+1
drivers/input/keyboard/Makefile
···
10
10
obj-$(CONFIG_KEYBOARD_ADP5588) += adp5588-keys.o
11
11
obj-$(CONFIG_KEYBOARD_ADP5589) += adp5589-keys.o
12
12
obj-$(CONFIG_KEYBOARD_AMIGA) += amikbd.o
13
+
obj-$(CONFIG_KEYBOARD_APPLESPI) += applespi.o
13
14
obj-$(CONFIG_KEYBOARD_ATARI) += atakbd.o
14
15
obj-$(CONFIG_KEYBOARD_ATKBD) += atkbd.o
15
16
obj-$(CONFIG_KEYBOARD_BCM) += bcm-keypad.o
+1
drivers/input/keyboard/adp5589-keys.c
+1
drivers/input/keyboard/adp5589-keys.c
+1977
drivers/input/keyboard/applespi.c
+1977
drivers/input/keyboard/applespi.c
···
1
+
// SPDX-License-Identifier: GPL-2.0
2
+
/*
3
+
* MacBook (Pro) SPI keyboard and touchpad driver
4
+
*
5
+
* Copyright (c) 2015-2018 Federico Lorenzi
6
+
* Copyright (c) 2017-2018 Ronald Tschalär
7
+
*/
8
+
9
+
/*
10
+
* The keyboard and touchpad controller on the MacBookAir6, MacBookPro12,
11
+
* MacBook8 and newer can be driven either by USB or SPI. However the USB
12
+
* pins are only connected on the MacBookAir6 and 7 and the MacBookPro12.
13
+
* All others need this driver. The interface is selected using ACPI methods:
14
+
*
15
+
* * UIEN ("USB Interface Enable"): If invoked with argument 1, disables SPI
16
+
* and enables USB. If invoked with argument 0, disables USB.
17
+
* * UIST ("USB Interface Status"): Returns 1 if USB is enabled, 0 otherwise.
18
+
* * SIEN ("SPI Interface Enable"): If invoked with argument 1, disables USB
19
+
* and enables SPI. If invoked with argument 0, disables SPI.
20
+
* * SIST ("SPI Interface Status"): Returns 1 if SPI is enabled, 0 otherwise.
21
+
* * ISOL: Resets the four GPIO pins used for SPI. Intended to be invoked with
22
+
* argument 1, then once more with argument 0.
23
+
*
24
+
* UIEN and UIST are only provided on models where the USB pins are connected.
25
+
*
26
+
* SPI-based Protocol
27
+
* ------------------
28
+
*
29
+
* The device and driver exchange messages (struct message); each message is
30
+
* encapsulated in one or more packets (struct spi_packet). There are two types
31
+
* of exchanges: reads, and writes. A read is signaled by a GPE, upon which one
32
+
* message can be read from the device. A write exchange consists of writing a
33
+
* command message, immediately reading a short status packet, and then, upon
34
+
* receiving a GPE, reading the response message. Write exchanges cannot be
35
+
* interleaved, i.e. a new write exchange must not be started till the previous
36
+
* write exchange is complete. Whether a received message is part of a read or
37
+
* write exchange is indicated in the encapsulating packet's flags field.
38
+
*
39
+
* A single message may be too large to fit in a single packet (which has a
40
+
* fixed, 256-byte size). In that case it will be split over multiple,
41
+
* consecutive packets.
42
+
*/
43
+
44
+
#include <linux/acpi.h>
45
+
#include <linux/crc16.h>
46
+
#include <linux/debugfs.h>
47
+
#include <linux/delay.h>
48
+
#include <linux/efi.h>
49
+
#include <linux/input.h>
50
+
#include <linux/input/mt.h>
51
+
#include <linux/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>
57
+
58
+
#include <asm/barrier.h>
59
+
#include <asm/unaligned.h>
60
+
61
+
#define CREATE_TRACE_POINTS
62
+
#include "applespi.h"
63
+
#include "applespi_trace.h"
64
+
65
+
#define APPLESPI_PACKET_SIZE 256
66
+
#define APPLESPI_STATUS_SIZE 4
67
+
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
73
+
74
+
#define MAX_ROLLOVER 6
75
+
76
+
#define MAX_FINGERS 11
77
+
#define MAX_FINGER_ORIENTATION 16384
78
+
#define MAX_PKTS_PER_MSG 2
79
+
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)
85
+
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)
88
+
89
+
#define APPLE_FLAG_FKEY 0x01
90
+
91
+
#define SPI_RW_CHG_DELAY_US 100 /* from experimentation, in µs */
92
+
93
+
#define SYNAPTICS_VENDOR_ID 0x06cb
94
+
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)");
98
+
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)");
102
+
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)");
106
+
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 .");
111
+
112
+
/**
113
+
* struct keyboard_protocol - keyboard message.
114
+
* message.type = 0x0110, message.length = 0x000a
115
+
*
116
+
* @unknown1: unknown
117
+
* @modifiers: bit-set of modifier/control keys pressed
118
+
* @unknown2: unknown
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
123
+
*/
124
+
struct keyboard_protocol {
125
+
u8 unknown1;
126
+
u8 modifiers;
127
+
u8 unknown2;
128
+
u8 keys_pressed[MAX_ROLLOVER];
129
+
u8 fn_pressed;
130
+
__le16 crc16;
131
+
};
132
+
133
+
/**
134
+
* struct tp_finger - single trackpad finger structure, le16-aligned
135
+
*
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
146
+
* @unused: zeros
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.
152
+
*/
153
+
struct tp_finger {
154
+
__le16 origin;
155
+
__le16 abs_x;
156
+
__le16 abs_y;
157
+
__le16 rel_x;
158
+
__le16 rel_y;
159
+
__le16 tool_major;
160
+
__le16 tool_minor;
161
+
__le16 orientation;
162
+
__le16 touch_major;
163
+
__le16 touch_minor;
164
+
__le16 unused[2];
165
+
__le16 pressure;
166
+
__le16 multi;
167
+
__le16 crc16;
168
+
};
169
+
170
+
/**
171
+
* struct touchpad_protocol - touchpad message.
172
+
* message.type = 0x0210
173
+
*
174
+
* @unknown1: unknown
175
+
* @clicked: 1 if a button-click was detected, 0 otherwise
176
+
* @unknown2: unknown
177
+
* @number_of_fingers: the number of fingers being reported in @fingers
178
+
* @clicked2: same as @clicked
179
+
* @unknown3: unknown
180
+
* @fingers: the data for each finger
181
+
*/
182
+
struct touchpad_protocol {
183
+
u8 unknown1[1];
184
+
u8 clicked;
185
+
u8 unknown2[28];
186
+
u8 number_of_fingers;
187
+
u8 clicked2;
188
+
u8 unknown3[16];
189
+
struct tp_finger fingers[0];
190
+
};
191
+
192
+
/**
193
+
* struct command_protocol_tp_info - get touchpad info.
194
+
* message.type = 0x1020, message.length = 0x0000
195
+
*
196
+
* @crc16: crc over the whole message struct (message header +
197
+
* this struct) minus this @crc16 field
198
+
*/
199
+
struct command_protocol_tp_info {
200
+
__le16 crc16;
201
+
};
202
+
203
+
/**
204
+
* struct touchpad_info - touchpad info response.
205
+
* message.type = 0x1020, message.length = 0x006e
206
+
*
207
+
* @unknown1: unknown
208
+
* @model_flags: flags (vary by model number, but significance otherwise
209
+
* unknown)
210
+
* @model_no: the touchpad model number
211
+
* @unknown2: unknown
212
+
* @crc16: crc over the whole message struct (message header +
213
+
* this struct) minus this @crc16 field
214
+
*/
215
+
struct touchpad_info_protocol {
216
+
u8 unknown1[105];
217
+
u8 model_flags;
218
+
u8 model_no;
219
+
u8 unknown2[3];
220
+
__le16 crc16;
221
+
};
222
+
223
+
/**
224
+
* struct command_protocol_mt_init - initialize multitouch.
225
+
* message.type = 0x0252, message.length = 0x0002
226
+
*
227
+
* @cmd: value: 0x0102
228
+
* @crc16: crc over the whole message struct (message header +
229
+
* this struct) minus this @crc16 field
230
+
*/
231
+
struct command_protocol_mt_init {
232
+
__le16 cmd;
233
+
__le16 crc16;
234
+
};
235
+
236
+
/**
237
+
* struct command_protocol_capsl - toggle caps-lock led
238
+
* message.type = 0x0151, message.length = 0x0002
239
+
*
240
+
* @unknown: value: 0x01 (length?)
241
+
* @led: 0 off, 2 on
242
+
* @crc16: crc over the whole message struct (message header +
243
+
* this struct) minus this @crc16 field
244
+
*/
245
+
struct command_protocol_capsl {
246
+
u8 unknown;
247
+
u8 led;
248
+
__le16 crc16;
249
+
};
250
+
251
+
/**
252
+
* struct command_protocol_bl - set keyboard backlight brightness
253
+
* message.type = 0xB051, message.length = 0x0006
254
+
*
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
260
+
*/
261
+
struct command_protocol_bl {
262
+
__le16 const1;
263
+
__le16 level;
264
+
__le16 const2;
265
+
__le16 crc16;
266
+
};
267
+
268
+
/**
269
+
* struct message - a complete spi message.
270
+
*
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
274
+
* in this struct.
275
+
*
276
+
* @type: the message type
277
+
* @zero: always 0
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.
289
+
*/
290
+
struct message {
291
+
__le16 type;
292
+
u8 zero;
293
+
u8 counter;
294
+
__le16 rsp_buf_len;
295
+
__le16 length;
296
+
union {
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;
304
+
u8 data[0];
305
+
};
306
+
};
307
+
308
+
/* type + zero + counter + rsp_buf_len + length */
309
+
#define MSG_HEADER_SIZE 8
310
+
311
+
/**
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
318
+
* message.
319
+
*
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).
335
+
*/
336
+
struct spi_packet {
337
+
u8 flags;
338
+
u8 device;
339
+
__le16 offset;
340
+
__le16 remaining;
341
+
__le16 length;
342
+
u8 data[246];
343
+
__le16 crc16;
344
+
};
345
+
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) */
350
+
};
351
+
352
+
/* this mimics struct drm_rect */
353
+
struct applespi_tp_info {
354
+
int x_min;
355
+
int y_min;
356
+
int x_max;
357
+
int y_max;
358
+
};
359
+
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;
365
+
366
+
u8 *tx_buffer;
367
+
u8 *tx_status;
368
+
u8 *rx_buffer;
369
+
370
+
u8 *msg_buf;
371
+
unsigned int saved_msg_len;
372
+
373
+
struct applespi_tp_info tp_info;
374
+
375
+
u8 last_keys_pressed[MAX_ROLLOVER];
376
+
u8 last_keys_fn_pressed[MAX_ROLLOVER];
377
+
u8 last_fn_pressed;
378
+
struct input_mt_pos pos[MAX_FINGERS];
379
+
int slots[MAX_FINGERS];
380
+
int gpe;
381
+
acpi_handle sien;
382
+
acpi_handle sist;
383
+
384
+
struct spi_transfer dl_t;
385
+
struct spi_transfer rd_t;
386
+
struct spi_message rd_m;
387
+
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;
393
+
394
+
bool want_tp_info_cmd;
395
+
bool want_mt_init_cmd;
396
+
bool want_cl_led_on;
397
+
bool have_cl_led_on;
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;
403
+
bool cmd_msg_queued;
404
+
enum applespi_evt_type cmd_evt_type;
405
+
406
+
struct led_classdev backlight_info;
407
+
408
+
bool suspended;
409
+
bool drain;
410
+
wait_queue_head_t drain_complete;
411
+
bool read_active;
412
+
bool write_active;
413
+
414
+
struct work_struct work;
415
+
struct touchpad_info_protocol rcvd_tp_info;
416
+
417
+
struct dentry *debugfs_root;
418
+
bool debug_tp_dim;
419
+
char tp_dim_val[40];
420
+
int tp_dim_min_x;
421
+
int tp_dim_max_x;
422
+
int tp_dim_min_y;
423
+
int tp_dim_max_y;
424
+
};
425
+
426
+
static const unsigned char applespi_scancodes[] = {
427
+
0, 0, 0, 0,
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,
435
+
KEY_CAPSLOCK,
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
443
+
};
444
+
445
+
/*
446
+
* This must have exactly as many entries as there are bits in
447
+
* struct keyboard_protocol.modifiers .
448
+
*/
449
+
static const unsigned char applespi_controlcodes[] = {
450
+
KEY_LEFTCTRL,
451
+
KEY_LEFTSHIFT,
452
+
KEY_LEFTALT,
453
+
KEY_LEFTMETA,
454
+
0,
455
+
KEY_RIGHTSHIFT,
456
+
KEY_RIGHTALT,
457
+
KEY_RIGHTMETA
458
+
};
459
+
460
+
struct applespi_key_translation {
461
+
u16 from;
462
+
u16 to;
463
+
u8 flags;
464
+
};
465
+
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 },
485
+
{ }
486
+
};
487
+
488
+
static const struct applespi_key_translation apple_iso_keyboard[] = {
489
+
{ KEY_GRAVE, KEY_102ND },
490
+
{ KEY_102ND, KEY_GRAVE },
491
+
{ }
492
+
};
493
+
494
+
struct applespi_tp_model_info {
495
+
u16 model;
496
+
struct applespi_tp_info tp_info;
497
+
};
498
+
499
+
static const struct applespi_tp_model_info applespi_tp_models[] = {
500
+
{
501
+
.model = 0x04, /* MB8 MB9 MB10 */
502
+
.tp_info = { -5087, -182, 5579, 6089 },
503
+
},
504
+
{
505
+
.model = 0x05, /* MBP13,1 MBP13,2 MBP14,1 MBP14,2 */
506
+
.tp_info = { -6243, -170, 6749, 7685 },
507
+
},
508
+
{
509
+
.model = 0x06, /* MBP13,3 MBP14,3 */
510
+
.tp_info = { -7456, -163, 7976, 9283 },
511
+
},
512
+
{}
513
+
};
514
+
515
+
typedef void (*applespi_trace_fun)(enum applespi_evt_type,
516
+
enum applespi_pkt_type, u8 *, size_t);
517
+
518
+
static applespi_trace_fun applespi_get_trace_fun(enum applespi_evt_type type)
519
+
{
520
+
switch (type) {
521
+
case ET_CMD_TP_INI:
522
+
return trace_applespi_tp_ini_cmd;
523
+
case ET_CMD_BL:
524
+
return trace_applespi_backlight_cmd;
525
+
case ET_CMD_CL:
526
+
return trace_applespi_caps_lock_cmd;
527
+
case ET_RD_KEYB:
528
+
return trace_applespi_keyboard_data;
529
+
case ET_RD_TPAD:
530
+
return trace_applespi_touchpad_data;
531
+
case ET_RD_UNKN:
532
+
return trace_applespi_unknown_data;
533
+
default:
534
+
WARN_ONCE(1, "Unknown msg type %d", type);
535
+
return trace_applespi_unknown_data;
536
+
}
537
+
}
538
+
539
+
static void applespi_setup_read_txfrs(struct applespi_data *applespi)
540
+
{
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;
544
+
545
+
memset(dl_t, 0, sizeof(*dl_t));
546
+
memset(rd_t, 0, sizeof(*rd_t));
547
+
548
+
dl_t->delay_usecs = applespi->spi_settings.spi_cs_delay;
549
+
550
+
rd_t->rx_buf = applespi->rx_buffer;
551
+
rd_t->len = APPLESPI_PACKET_SIZE;
552
+
553
+
spi_message_init(msg);
554
+
spi_message_add_tail(dl_t, msg);
555
+
spi_message_add_tail(rd_t, msg);
556
+
}
557
+
558
+
static void applespi_setup_write_txfrs(struct applespi_data *applespi)
559
+
{
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;
565
+
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));
570
+
571
+
/*
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
575
+
* deassertion.
576
+
*/
577
+
wt_t->delay_usecs = SPI_RW_CHG_DELAY_US;
578
+
wt_t->cs_change = 1;
579
+
580
+
dl_t->delay_usecs = applespi->spi_settings.spi_cs_delay;
581
+
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;
585
+
586
+
st_t->rx_buf = applespi->tx_status;
587
+
st_t->len = APPLESPI_STATUS_SIZE;
588
+
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);
594
+
}
595
+
596
+
static int applespi_async(struct applespi_data *applespi,
597
+
struct spi_message *message, void (*complete)(void *))
598
+
{
599
+
message->complete = complete;
600
+
message->context = applespi;
601
+
602
+
return spi_async(applespi->spi, message);
603
+
}
604
+
605
+
static inline bool applespi_check_write_status(struct applespi_data *applespi,
606
+
int sts)
607
+
{
608
+
static u8 status_ok[] = { 0xac, 0x27, 0x68, 0xd5 };
609
+
610
+
if (sts < 0) {
611
+
dev_warn(&applespi->spi->dev, "Error writing to device: %d\n",
612
+
sts);
613
+
return false;
614
+
}
615
+
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);
619
+
return false;
620
+
}
621
+
622
+
return true;
623
+
}
624
+
625
+
static int applespi_get_spi_settings(struct applespi_data *applespi)
626
+
{
627
+
struct acpi_device *adev = ACPI_COMPANION(&applespi->spi->dev);
628
+
const union acpi_object *o;
629
+
struct spi_settings *settings = &applespi->spi_settings;
630
+
631
+
if (!acpi_dev_get_property(adev, "spiCSDelay", ACPI_TYPE_BUFFER, &o))
632
+
settings->spi_cs_delay = *(u64 *)o->buffer.pointer;
633
+
else
634
+
dev_warn(&applespi->spi->dev,
635
+
"Property spiCSDelay not found\n");
636
+
637
+
if (!acpi_dev_get_property(adev, "resetA2RUsec", ACPI_TYPE_BUFFER, &o))
638
+
settings->reset_a2r_usec = *(u64 *)o->buffer.pointer;
639
+
else
640
+
dev_warn(&applespi->spi->dev,
641
+
"Property resetA2RUsec not found\n");
642
+
643
+
if (!acpi_dev_get_property(adev, "resetRecUsec", ACPI_TYPE_BUFFER, &o))
644
+
settings->reset_rec_usec = *(u64 *)o->buffer.pointer;
645
+
else
646
+
dev_warn(&applespi->spi->dev,
647
+
"Property resetRecUsec not found\n");
648
+
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);
653
+
654
+
return 0;
655
+
}
656
+
657
+
static int applespi_setup_spi(struct applespi_data *applespi)
658
+
{
659
+
int sts;
660
+
661
+
sts = applespi_get_spi_settings(applespi);
662
+
if (sts)
663
+
return sts;
664
+
665
+
spin_lock_init(&applespi->cmd_msg_lock);
666
+
init_waitqueue_head(&applespi->drain_complete);
667
+
668
+
return 0;
669
+
}
670
+
671
+
static int applespi_enable_spi(struct applespi_data *applespi)
672
+
{
673
+
acpi_status acpi_sts;
674
+
unsigned long long spi_status;
675
+
676
+
/* check if SPI is already enabled, so we can skip the delay below */
677
+
acpi_sts = acpi_evaluate_integer(applespi->sist, NULL, NULL,
678
+
&spi_status);
679
+
if (ACPI_SUCCESS(acpi_sts) && spi_status)
680
+
return 0;
681
+
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));
687
+
return -ENODEV;
688
+
}
689
+
690
+
/*
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
694
+
* resume from sleep.
695
+
*/
696
+
msleep(50);
697
+
698
+
return 0;
699
+
}
700
+
701
+
static int applespi_send_cmd_msg(struct applespi_data *applespi);
702
+
703
+
static void applespi_msg_complete(struct applespi_data *applespi,
704
+
bool is_write_msg, bool is_read_compl)
705
+
{
706
+
unsigned long flags;
707
+
708
+
spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
709
+
710
+
if (is_read_compl)
711
+
applespi->read_active = false;
712
+
if (is_write_msg)
713
+
applespi->write_active = false;
714
+
715
+
if (applespi->drain && !applespi->write_active)
716
+
wake_up_all(&applespi->drain_complete);
717
+
718
+
if (is_write_msg) {
719
+
applespi->cmd_msg_queued = false;
720
+
applespi_send_cmd_msg(applespi);
721
+
}
722
+
723
+
spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
724
+
}
725
+
726
+
static void applespi_async_write_complete(void *context)
727
+
{
728
+
struct applespi_data *applespi = context;
729
+
enum applespi_evt_type evt_type = applespi->cmd_evt_type;
730
+
731
+
applespi_get_trace_fun(evt_type)(evt_type, PT_WRITE,
732
+
applespi->tx_buffer,
733
+
APPLESPI_PACKET_SIZE);
734
+
applespi_get_trace_fun(evt_type)(evt_type, PT_STATUS,
735
+
applespi->tx_status,
736
+
APPLESPI_STATUS_SIZE);
737
+
738
+
if (!applespi_check_write_status(applespi, applespi->wr_m.status)) {
739
+
/*
740
+
* If we got an error, we presumably won't get the expected
741
+
* response message either.
742
+
*/
743
+
applespi_msg_complete(applespi, true, false);
744
+
}
745
+
}
746
+
747
+
static int applespi_send_cmd_msg(struct applespi_data *applespi)
748
+
{
749
+
u16 crc;
750
+
int sts;
751
+
struct spi_packet *packet = (struct spi_packet *)applespi->tx_buffer;
752
+
struct message *message = (struct message *)packet->data;
753
+
u16 msg_len;
754
+
u8 device;
755
+
756
+
/* check if draining */
757
+
if (applespi->drain)
758
+
return 0;
759
+
760
+
/* check whether send is in progress */
761
+
if (applespi->cmd_msg_queued)
762
+
return 0;
763
+
764
+
/* set up packet */
765
+
memset(packet, 0, APPLESPI_PACKET_SIZE);
766
+
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;
772
+
773
+
/* build init command */
774
+
device = PACKET_DEV_INFO;
775
+
776
+
message->type = cpu_to_le16(0x1020);
777
+
msg_len = sizeof(message->tp_info_command);
778
+
779
+
message->zero = 0x02;
780
+
message->rsp_buf_len = cpu_to_le16(0x0200);
781
+
782
+
} else if (applespi->want_mt_init_cmd) {
783
+
applespi->want_mt_init_cmd = false;
784
+
applespi->cmd_evt_type = ET_CMD_TP_INI;
785
+
786
+
/* build init command */
787
+
device = PACKET_DEV_TPAD;
788
+
789
+
message->type = cpu_to_le16(0x0252);
790
+
msg_len = sizeof(message->init_mt_command);
791
+
792
+
message->init_mt_command.cmd = cpu_to_le16(0x0102);
793
+
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;
798
+
799
+
/* build led command */
800
+
device = PACKET_DEV_KEYB;
801
+
802
+
message->type = cpu_to_le16(0x0151);
803
+
msg_len = sizeof(message->capsl_command);
804
+
805
+
message->capsl_command.unknown = 0x01;
806
+
message->capsl_command.led = applespi->have_cl_led_on ? 2 : 0;
807
+
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;
812
+
813
+
/* build command buffer */
814
+
device = PACKET_DEV_KEYB;
815
+
816
+
message->type = cpu_to_le16(0xB051);
817
+
msg_len = sizeof(message->bl_command);
818
+
819
+
message->bl_command.const1 = cpu_to_le16(0x01B0);
820
+
message->bl_command.level =
821
+
cpu_to_le16(applespi->have_bl_level);
822
+
823
+
if (applespi->have_bl_level > 0)
824
+
message->bl_command.const2 = cpu_to_le16(0x01F4);
825
+
else
826
+
message->bl_command.const2 = cpu_to_le16(0x0001);
827
+
828
+
/* everything's up-to-date */
829
+
} else {
830
+
return 0;
831
+
}
832
+
833
+
/* finalize packet */
834
+
packet->flags = PACKET_TYPE_WRITE;
835
+
packet->device = device;
836
+
packet->length = cpu_to_le16(MSG_HEADER_SIZE + msg_len);
837
+
838
+
message->counter = applespi->cmd_msg_cntr++ % (U8_MAX + 1);
839
+
840
+
message->length = cpu_to_le16(msg_len - 2);
841
+
if (!message->rsp_buf_len)
842
+
message->rsp_buf_len = message->length;
843
+
844
+
crc = crc16(0, (u8 *)message, le16_to_cpu(packet->length) - 2);
845
+
put_unaligned_le16(crc, &message->data[msg_len - 2]);
846
+
847
+
crc = crc16(0, (u8 *)packet, sizeof(*packet) - 2);
848
+
packet->crc16 = cpu_to_le16(crc);
849
+
850
+
/* send command */
851
+
sts = applespi_async(applespi, &applespi->wr_m,
852
+
applespi_async_write_complete);
853
+
if (sts) {
854
+
dev_warn(&applespi->spi->dev,
855
+
"Error queueing async write to device: %d\n", sts);
856
+
return sts;
857
+
}
858
+
859
+
applespi->cmd_msg_queued = true;
860
+
applespi->write_active = true;
861
+
862
+
return 0;
863
+
}
864
+
865
+
static void applespi_init(struct applespi_data *applespi, bool is_resume)
866
+
{
867
+
unsigned long flags;
868
+
869
+
spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
870
+
871
+
if (is_resume)
872
+
applespi->want_mt_init_cmd = true;
873
+
else
874
+
applespi->want_tp_info_cmd = true;
875
+
applespi_send_cmd_msg(applespi);
876
+
877
+
spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
878
+
}
879
+
880
+
static int applespi_set_capsl_led(struct applespi_data *applespi,
881
+
bool capslock_on)
882
+
{
883
+
unsigned long flags;
884
+
int sts;
885
+
886
+
spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
887
+
888
+
applespi->want_cl_led_on = capslock_on;
889
+
sts = applespi_send_cmd_msg(applespi);
890
+
891
+
spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
892
+
893
+
return sts;
894
+
}
895
+
896
+
static void applespi_set_bl_level(struct led_classdev *led_cdev,
897
+
enum led_brightness value)
898
+
{
899
+
struct applespi_data *applespi =
900
+
container_of(led_cdev, struct applespi_data, backlight_info);
901
+
unsigned long flags;
902
+
903
+
spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
904
+
905
+
if (value == 0) {
906
+
applespi->want_bl_level = value;
907
+
} else {
908
+
/*
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
911
+
* on at 1.
912
+
*/
913
+
applespi->want_bl_level =
914
+
((value * KBD_BL_LEVEL_ADJ) / KBD_BL_LEVEL_SCALE +
915
+
KBD_BL_LEVEL_MIN);
916
+
}
917
+
918
+
applespi_send_cmd_msg(applespi);
919
+
920
+
spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
921
+
}
922
+
923
+
static int applespi_event(struct input_dev *dev, unsigned int type,
924
+
unsigned int code, int value)
925
+
{
926
+
struct applespi_data *applespi = input_get_drvdata(dev);
927
+
928
+
switch (type) {
929
+
case EV_LED:
930
+
applespi_set_capsl_led(applespi, !!test_bit(LED_CAPSL, dev->led));
931
+
return 0;
932
+
}
933
+
934
+
return -EINVAL;
935
+
}
936
+
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)
940
+
{
941
+
return (signed short)le16_to_cpu(x);
942
+
}
943
+
944
+
static void applespi_debug_update_dimensions(struct applespi_data *applespi,
945
+
const struct tp_finger *f)
946
+
{
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);
951
+
}
952
+
953
+
static int applespi_tp_dim_open(struct inode *inode, struct file *file)
954
+
{
955
+
struct applespi_data *applespi = inode->i_private;
956
+
957
+
file->private_data = applespi;
958
+
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);
965
+
966
+
return nonseekable_open(inode, file);
967
+
}
968
+
969
+
static ssize_t applespi_tp_dim_read(struct file *file, char __user *buf,
970
+
size_t len, loff_t *off)
971
+
{
972
+
struct applespi_data *applespi = file->private_data;
973
+
974
+
return simple_read_from_buffer(buf, len, off, applespi->tp_dim_val,
975
+
strlen(applespi->tp_dim_val));
976
+
}
977
+
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,
982
+
.llseek = no_llseek,
983
+
};
984
+
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)
988
+
{
989
+
input_mt_slot(input, slot);
990
+
input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
991
+
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);
1004
+
}
1005
+
1006
+
static void report_tp_state(struct applespi_data *applespi,
1007
+
struct touchpad_protocol *t)
1008
+
{
1009
+
const struct tp_finger *f;
1010
+
struct input_dev *input;
1011
+
const struct applespi_tp_info *tp_info = &applespi->tp_info;
1012
+
int i, n;
1013
+
1014
+
/* touchpad_input_dev is set async in worker */
1015
+
input = smp_load_acquire(&applespi->touchpad_input_dev);
1016
+
if (!input)
1017
+
return; /* touchpad isn't initialized yet */
1018
+
1019
+
n = 0;
1020
+
1021
+
for (i = 0; i < t->number_of_fingers; i++) {
1022
+
f = &t->fingers[i];
1023
+
if (le16_to_int(f->touch_major) == 0)
1024
+
continue;
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);
1028
+
n++;
1029
+
1030
+
if (applespi->debug_tp_dim)
1031
+
applespi_debug_update_dimensions(applespi, f);
1032
+
}
1033
+
1034
+
input_mt_assign_slots(input, applespi->slots, applespi->pos, n, 0);
1035
+
1036
+
for (i = 0; i < n; i++)
1037
+
report_finger_data(input, applespi->slots[i],
1038
+
&applespi->pos[i], &t->fingers[i]);
1039
+
1040
+
input_mt_sync_frame(input);
1041
+
input_report_key(input, BTN_LEFT, t->clicked);
1042
+
1043
+
input_sync(input);
1044
+
}
1045
+
1046
+
static const struct applespi_key_translation *
1047
+
applespi_find_translation(const struct applespi_key_translation *table, u16 key)
1048
+
{
1049
+
const struct applespi_key_translation *trans;
1050
+
1051
+
for (trans = table; trans->from; trans++)
1052
+
if (trans->from == key)
1053
+
return trans;
1054
+
1055
+
return NULL;
1056
+
}
1057
+
1058
+
static unsigned int applespi_translate_fn_key(unsigned int key, int fn_pressed)
1059
+
{
1060
+
const struct applespi_key_translation *trans;
1061
+
int do_translate;
1062
+
1063
+
trans = applespi_find_translation(applespi_fn_codes, key);
1064
+
if (trans) {
1065
+
if (trans->flags & APPLE_FLAG_FKEY)
1066
+
do_translate = (fnmode == 2 && fn_pressed) ||
1067
+
(fnmode == 1 && !fn_pressed);
1068
+
else
1069
+
do_translate = fn_pressed;
1070
+
1071
+
if (do_translate)
1072
+
key = trans->to;
1073
+
}
1074
+
1075
+
return key;
1076
+
}
1077
+
1078
+
static unsigned int applespi_translate_iso_layout(unsigned int key)
1079
+
{
1080
+
const struct applespi_key_translation *trans;
1081
+
1082
+
trans = applespi_find_translation(apple_iso_keyboard, key);
1083
+
if (trans)
1084
+
key = trans->to;
1085
+
1086
+
return key;
1087
+
}
1088
+
1089
+
static unsigned int applespi_code_to_key(u8 code, int fn_pressed)
1090
+
{
1091
+
unsigned int key = applespi_scancodes[code];
1092
+
1093
+
if (fnmode)
1094
+
key = applespi_translate_fn_key(key, fn_pressed);
1095
+
if (iso_layout)
1096
+
key = applespi_translate_iso_layout(key);
1097
+
return key;
1098
+
}
1099
+
1100
+
static void
1101
+
applespi_remap_fn_key(struct keyboard_protocol *keyboard_protocol)
1102
+
{
1103
+
unsigned char tmp;
1104
+
u8 bit = BIT((fnremap - 1) & 0x07);
1105
+
1106
+
if (!fnremap || fnremap > ARRAY_SIZE(applespi_controlcodes) ||
1107
+
!applespi_controlcodes[fnremap - 1])
1108
+
return;
1109
+
1110
+
tmp = keyboard_protocol->fn_pressed;
1111
+
keyboard_protocol->fn_pressed = !!(keyboard_protocol->modifiers & bit);
1112
+
if (tmp)
1113
+
keyboard_protocol->modifiers |= bit;
1114
+
else
1115
+
keyboard_protocol->modifiers &= ~bit;
1116
+
}
1117
+
1118
+
static void
1119
+
applespi_handle_keyboard_event(struct applespi_data *applespi,
1120
+
struct keyboard_protocol *keyboard_protocol)
1121
+
{
1122
+
unsigned int key;
1123
+
int i;
1124
+
1125
+
compiletime_assert(ARRAY_SIZE(applespi_controlcodes) ==
1126
+
sizeof_field(struct keyboard_protocol, modifiers) * 8,
1127
+
"applespi_controlcodes has wrong number of entries");
1128
+
1129
+
/* check for rollover overflow, which is signalled by all keys == 1 */
1130
+
if (!memchr_inv(keyboard_protocol->keys_pressed, 1, MAX_ROLLOVER))
1131
+
return;
1132
+
1133
+
/* remap fn key if desired */
1134
+
applespi_remap_fn_key(keyboard_protocol);
1135
+
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 */
1141
+
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;
1146
+
}
1147
+
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;
1159
+
}
1160
+
}
1161
+
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);
1167
+
else
1168
+
input_report_key(applespi->keyboard_input_dev,
1169
+
applespi_controlcodes[i], 0);
1170
+
}
1171
+
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;
1178
+
1179
+
/* done */
1180
+
input_sync(applespi->keyboard_input_dev);
1181
+
memcpy(&applespi->last_keys_pressed, keyboard_protocol->keys_pressed,
1182
+
sizeof(applespi->last_keys_pressed));
1183
+
}
1184
+
1185
+
static const struct applespi_tp_info *applespi_find_touchpad_info(u8 model)
1186
+
{
1187
+
const struct applespi_tp_model_info *info;
1188
+
1189
+
for (info = applespi_tp_models; info->model; info++) {
1190
+
if (info->model == model)
1191
+
return &info->tp_info;
1192
+
}
1193
+
1194
+
return NULL;
1195
+
}
1196
+
1197
+
static int
1198
+
applespi_register_touchpad_device(struct applespi_data *applespi,
1199
+
struct touchpad_info_protocol *rcvd_tp_info)
1200
+
{
1201
+
const struct applespi_tp_info *tp_info;
1202
+
struct input_dev *touchpad_input_dev;
1203
+
int sts;
1204
+
1205
+
/* set up touchpad dimensions */
1206
+
tp_info = applespi_find_touchpad_info(rcvd_tp_info->model_no);
1207
+
if (!tp_info) {
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;
1212
+
}
1213
+
1214
+
applespi->tp_info = *tp_info;
1215
+
1216
+
if (touchpad_dimensions[0]) {
1217
+
int x, y, w, h;
1218
+
1219
+
sts = sscanf(touchpad_dimensions, "%dx%d+%u+%u", &x, &y, &w, &h);
1220
+
if (sts == 4) {
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;
1227
+
} else {
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';
1232
+
}
1233
+
}
1234
+
if (!touchpad_dimensions[0]) {
1235
+
snprintf(touchpad_dimensions, sizeof(touchpad_dimensions),
1236
+
"%dx%d+%u+%u",
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);
1241
+
}
1242
+
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");
1248
+
return -ENOMEM;
1249
+
}
1250
+
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;
1258
+
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);
1262
+
1263
+
__set_bit(INPUT_PROP_POINTER, touchpad_input_dev->propbit);
1264
+
__set_bit(INPUT_PROP_BUTTONPAD, touchpad_input_dev->propbit);
1265
+
1266
+
/* finger touch area */
1267
+
input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MAJOR,
1268
+
0, 5000, 0, 0);
1269
+
input_set_abs_params(touchpad_input_dev, ABS_MT_TOUCH_MINOR,
1270
+
0, 5000, 0, 0);
1271
+
1272
+
/* finger approach area */
1273
+
input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MAJOR,
1274
+
0, 5000, 0, 0);
1275
+
input_set_abs_params(touchpad_input_dev, ABS_MT_WIDTH_MINOR,
1276
+
0, 5000, 0, 0);
1277
+
1278
+
/* finger orientation */
1279
+
input_set_abs_params(touchpad_input_dev, ABS_MT_ORIENTATION,
1280
+
-MAX_FINGER_ORIENTATION, MAX_FINGER_ORIENTATION,
1281
+
0, 0);
1282
+
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,
1286
+
0, 0);
1287
+
input_set_abs_params(touchpad_input_dev, ABS_MT_POSITION_Y,
1288
+
applespi->tp_info.y_min, applespi->tp_info.y_max,
1289
+
0, 0);
1290
+
1291
+
/* touchpad button */
1292
+
input_set_capability(touchpad_input_dev, EV_KEY, BTN_LEFT);
1293
+
1294
+
/* multitouch */
1295
+
sts = input_mt_init_slots(touchpad_input_dev, MAX_FINGERS,
1296
+
INPUT_MT_POINTER | INPUT_MT_DROP_UNUSED |
1297
+
INPUT_MT_TRACK);
1298
+
if (sts) {
1299
+
dev_err(&applespi->spi->dev,
1300
+
"failed to initialize slots: %d", sts);
1301
+
return sts;
1302
+
}
1303
+
1304
+
/* register input device */
1305
+
sts = input_register_device(touchpad_input_dev);
1306
+
if (sts) {
1307
+
dev_err(&applespi->spi->dev,
1308
+
"Unable to register touchpad input device (%d)\n", sts);
1309
+
return sts;
1310
+
}
1311
+
1312
+
/* touchpad_input_dev is read async in spi callback */
1313
+
smp_store_release(&applespi->touchpad_input_dev, touchpad_input_dev);
1314
+
1315
+
return 0;
1316
+
}
1317
+
1318
+
static void applespi_worker(struct work_struct *work)
1319
+
{
1320
+
struct applespi_data *applespi =
1321
+
container_of(work, struct applespi_data, work);
1322
+
1323
+
applespi_register_touchpad_device(applespi, &applespi->rcvd_tp_info);
1324
+
}
1325
+
1326
+
static void applespi_handle_cmd_response(struct applespi_data *applespi,
1327
+
struct spi_packet *packet,
1328
+
struct message *message)
1329
+
{
1330
+
if (packet->device == PACKET_DEV_INFO &&
1331
+
le16_to_cpu(message->type) == 0x1020) {
1332
+
/*
1333
+
* We're not allowed to sleep here, but registering an input
1334
+
* device can sleep.
1335
+
*/
1336
+
applespi->rcvd_tp_info = message->tp_info;
1337
+
schedule_work(&applespi->work);
1338
+
return;
1339
+
}
1340
+
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));
1345
+
return;
1346
+
}
1347
+
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");
1352
+
}
1353
+
1354
+
static bool applespi_verify_crc(struct applespi_data *applespi, u8 *buffer,
1355
+
size_t buflen)
1356
+
{
1357
+
u16 crc;
1358
+
1359
+
crc = crc16(0, buffer, buflen);
1360
+
if (crc) {
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);
1364
+
1365
+
return false;
1366
+
}
1367
+
1368
+
return true;
1369
+
}
1370
+
1371
+
static void applespi_debug_print_read_packet(struct applespi_data *applespi,
1372
+
struct spi_packet *packet)
1373
+
{
1374
+
unsigned int evt_type;
1375
+
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;
1384
+
else
1385
+
evt_type = ET_RD_UNKN;
1386
+
1387
+
applespi_get_trace_fun(evt_type)(evt_type, PT_READ, applespi->rx_buffer,
1388
+
APPLESPI_PACKET_SIZE);
1389
+
}
1390
+
1391
+
static void applespi_got_data(struct applespi_data *applespi)
1392
+
{
1393
+
struct spi_packet *packet;
1394
+
struct message *message;
1395
+
unsigned int msg_len;
1396
+
unsigned int off;
1397
+
unsigned int rem;
1398
+
unsigned int len;
1399
+
1400
+
/* process packet header */
1401
+
if (!applespi_verify_crc(applespi, applespi->rx_buffer,
1402
+
APPLESPI_PACKET_SIZE)) {
1403
+
unsigned long flags;
1404
+
1405
+
spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1406
+
1407
+
if (applespi->drain) {
1408
+
applespi->read_active = false;
1409
+
applespi->write_active = false;
1410
+
1411
+
wake_up_all(&applespi->drain_complete);
1412
+
}
1413
+
1414
+
spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1415
+
1416
+
return;
1417
+
}
1418
+
1419
+
packet = (struct spi_packet *)applespi->rx_buffer;
1420
+
1421
+
applespi_debug_print_read_packet(applespi, packet);
1422
+
1423
+
off = le16_to_cpu(packet->offset);
1424
+
rem = le16_to_cpu(packet->remaining);
1425
+
len = le16_to_cpu(packet->length);
1426
+
1427
+
if (len > sizeof(packet->data)) {
1428
+
dev_warn_ratelimited(&applespi->spi->dev,
1429
+
"Received corrupted packet (invalid packet length %u)\n",
1430
+
len);
1431
+
goto msg_complete;
1432
+
}
1433
+
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);
1440
+
goto msg_complete;
1441
+
}
1442
+
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",
1446
+
off + rem);
1447
+
goto msg_complete;
1448
+
}
1449
+
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",
1453
+
off + len);
1454
+
goto msg_complete;
1455
+
}
1456
+
1457
+
memcpy(applespi->msg_buf + off, &packet->data, len);
1458
+
applespi->saved_msg_len += len;
1459
+
1460
+
if (rem > 0)
1461
+
return;
1462
+
1463
+
message = (struct message *)applespi->msg_buf;
1464
+
msg_len = applespi->saved_msg_len;
1465
+
} else {
1466
+
message = (struct message *)&packet->data;
1467
+
msg_len = len;
1468
+
}
1469
+
1470
+
/* got complete message - verify */
1471
+
if (!applespi_verify_crc(applespi, (u8 *)message, msg_len))
1472
+
goto msg_complete;
1473
+
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);
1479
+
goto msg_complete;
1480
+
}
1481
+
1482
+
/* handle message */
1483
+
if (packet->flags == PACKET_TYPE_READ &&
1484
+
packet->device == PACKET_DEV_KEYB) {
1485
+
applespi_handle_keyboard_event(applespi, &message->keyboard);
1486
+
1487
+
} else if (packet->flags == PACKET_TYPE_READ &&
1488
+
packet->device == PACKET_DEV_TPAD) {
1489
+
struct touchpad_protocol *tp;
1490
+
size_t tp_len;
1491
+
1492
+
tp = &message->touchpad;
1493
+
tp_len = sizeof(*tp) +
1494
+
tp->number_of_fingers * sizeof(tp->fingers[0]);
1495
+
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);
1501
+
goto msg_complete;
1502
+
}
1503
+
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,
1508
+
MAX_FINGERS);
1509
+
tp->number_of_fingers = MAX_FINGERS;
1510
+
}
1511
+
1512
+
report_tp_state(applespi, tp);
1513
+
1514
+
} else if (packet->flags == PACKET_TYPE_WRITE) {
1515
+
applespi_handle_cmd_response(applespi, packet, message);
1516
+
}
1517
+
1518
+
msg_complete:
1519
+
applespi->saved_msg_len = 0;
1520
+
1521
+
applespi_msg_complete(applespi, packet->flags == PACKET_TYPE_WRITE,
1522
+
true);
1523
+
}
1524
+
1525
+
static void applespi_async_read_complete(void *context)
1526
+
{
1527
+
struct applespi_data *applespi = context;
1528
+
1529
+
if (applespi->rd_m.status < 0) {
1530
+
dev_warn(&applespi->spi->dev, "Error reading from device: %d\n",
1531
+
applespi->rd_m.status);
1532
+
/*
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.
1536
+
*/
1537
+
applespi_msg_complete(applespi, true, true);
1538
+
} else {
1539
+
applespi_got_data(applespi);
1540
+
}
1541
+
1542
+
acpi_finish_gpe(NULL, applespi->gpe);
1543
+
}
1544
+
1545
+
static u32 applespi_notify(acpi_handle gpe_device, u32 gpe, void *context)
1546
+
{
1547
+
struct applespi_data *applespi = context;
1548
+
int sts;
1549
+
unsigned long flags;
1550
+
1551
+
trace_applespi_irq_received(ET_RD_IRQ, PT_READ);
1552
+
1553
+
spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1554
+
1555
+
if (!applespi->suspended) {
1556
+
sts = applespi_async(applespi, &applespi->rd_m,
1557
+
applespi_async_read_complete);
1558
+
if (sts)
1559
+
dev_warn(&applespi->spi->dev,
1560
+
"Error queueing async read to device: %d\n",
1561
+
sts);
1562
+
else
1563
+
applespi->read_active = true;
1564
+
}
1565
+
1566
+
spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1567
+
1568
+
return ACPI_INTERRUPT_HANDLED;
1569
+
}
1570
+
1571
+
static int applespi_get_saved_bl_level(struct applespi_data *applespi)
1572
+
{
1573
+
struct efivar_entry *efivar_entry;
1574
+
u16 efi_data = 0;
1575
+
unsigned long efi_data_len;
1576
+
int sts;
1577
+
1578
+
efivar_entry = kmalloc(sizeof(*efivar_entry), GFP_KERNEL);
1579
+
if (!efivar_entry)
1580
+
return -ENOMEM;
1581
+
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);
1586
+
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",
1591
+
sts);
1592
+
1593
+
kfree(efivar_entry);
1594
+
1595
+
return sts ? sts : efi_data;
1596
+
}
1597
+
1598
+
static void applespi_save_bl_level(struct applespi_data *applespi,
1599
+
unsigned int level)
1600
+
{
1601
+
efi_guid_t efi_guid;
1602
+
u32 efi_attr;
1603
+
unsigned long efi_data_len;
1604
+
u16 efi_data;
1605
+
int sts;
1606
+
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;
1613
+
1614
+
sts = efivar_entry_set_safe(EFI_BL_LEVEL_NAME, efi_guid, efi_attr, true,
1615
+
efi_data_len, &efi_data);
1616
+
if (sts)
1617
+
dev_warn(&applespi->spi->dev,
1618
+
"Error saving backlight level to EFI vars: %d\n", sts);
1619
+
}
1620
+
1621
+
static int applespi_probe(struct spi_device *spi)
1622
+
{
1623
+
struct applespi_data *applespi;
1624
+
acpi_handle spi_handle = ACPI_HANDLE(&spi->dev);
1625
+
acpi_status acpi_sts;
1626
+
int sts, i;
1627
+
unsigned long long gpe, usb_status;
1628
+
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");
1634
+
return -ENODEV;
1635
+
}
1636
+
1637
+
/* allocate driver data */
1638
+
applespi = devm_kzalloc(&spi->dev, sizeof(*applespi), GFP_KERNEL);
1639
+
if (!applespi)
1640
+
return -ENOMEM;
1641
+
1642
+
applespi->spi = spi;
1643
+
1644
+
INIT_WORK(&applespi->work, applespi_worker);
1645
+
1646
+
/* store the driver data */
1647
+
spi_set_drvdata(spi, applespi);
1648
+
1649
+
/* create our buffers */
1650
+
applespi->tx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1651
+
GFP_KERNEL);
1652
+
applespi->tx_status = devm_kmalloc(&spi->dev, APPLESPI_STATUS_SIZE,
1653
+
GFP_KERNEL);
1654
+
applespi->rx_buffer = devm_kmalloc(&spi->dev, APPLESPI_PACKET_SIZE,
1655
+
GFP_KERNEL);
1656
+
applespi->msg_buf = devm_kmalloc_array(&spi->dev, MAX_PKTS_PER_MSG,
1657
+
APPLESPI_PACKET_SIZE,
1658
+
GFP_KERNEL);
1659
+
1660
+
if (!applespi->tx_buffer || !applespi->tx_status ||
1661
+
!applespi->rx_buffer || !applespi->msg_buf)
1662
+
return -ENOMEM;
1663
+
1664
+
/* set up our spi messages */
1665
+
applespi_setup_read_txfrs(applespi);
1666
+
applespi_setup_write_txfrs(applespi);
1667
+
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));
1674
+
return -ENODEV;
1675
+
}
1676
+
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));
1682
+
return -ENODEV;
1683
+
}
1684
+
1685
+
/* switch on the SPI interface */
1686
+
sts = applespi_setup_spi(applespi);
1687
+
if (sts)
1688
+
return sts;
1689
+
1690
+
sts = applespi_enable_spi(applespi);
1691
+
if (sts)
1692
+
return sts;
1693
+
1694
+
/* setup the keyboard input dev */
1695
+
applespi->keyboard_input_dev = devm_input_allocate_device(&spi->dev);
1696
+
1697
+
if (!applespi->keyboard_input_dev)
1698
+
return -ENOMEM;
1699
+
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;
1704
+
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);
1708
+
1709
+
input_set_drvdata(applespi->keyboard_input_dev, applespi);
1710
+
applespi->keyboard_input_dev->event = applespi_event;
1711
+
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]);
1716
+
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]);
1721
+
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);
1726
+
1727
+
input_set_capability(applespi->keyboard_input_dev, EV_KEY, KEY_FN);
1728
+
1729
+
sts = input_register_device(applespi->keyboard_input_dev);
1730
+
if (sts) {
1731
+
dev_err(&applespi->spi->dev,
1732
+
"Unable to register keyboard input device (%d)\n", sts);
1733
+
return -ENODEV;
1734
+
}
1735
+
1736
+
/*
1737
+
* The applespi device doesn't send interrupts normally (as is described
1738
+
* in its DSDT), but rather seems to use ACPI GPEs.
1739
+
*/
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));
1745
+
return -ENODEV;
1746
+
}
1747
+
applespi->gpe = (int)gpe;
1748
+
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));
1756
+
return -ENODEV;
1757
+
}
1758
+
1759
+
applespi->suspended = false;
1760
+
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);
1767
+
return -ENODEV;
1768
+
}
1769
+
1770
+
/* trigger touchpad setup */
1771
+
applespi_init(applespi, false);
1772
+
1773
+
/*
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.
1777
+
*/
1778
+
device_wakeup_enable(&spi->dev);
1779
+
1780
+
/* set up keyboard-backlight */
1781
+
sts = applespi_get_saved_bl_level(applespi);
1782
+
if (sts >= 0)
1783
+
applespi_set_bl_level(&applespi->backlight_info, sts);
1784
+
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;
1788
+
1789
+
sts = devm_led_classdev_register(&spi->dev, &applespi->backlight_info);
1790
+
if (sts)
1791
+
dev_warn(&applespi->spi->dev,
1792
+
"Unable to register keyboard backlight class dev (%d)\n",
1793
+
sts);
1794
+
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));
1802
+
} else {
1803
+
struct dentry *ret;
1804
+
1805
+
ret = debugfs_create_bool("enable_tp_dim", 0600,
1806
+
applespi->debugfs_root,
1807
+
&applespi->debug_tp_dim);
1808
+
if (IS_ERR(ret))
1809
+
dev_dbg(&applespi->spi->dev,
1810
+
"Error creating debugfs entry enable_tp_dim (%ld)\n",
1811
+
PTR_ERR(ret));
1812
+
1813
+
ret = debugfs_create_file("tp_dim", 0400,
1814
+
applespi->debugfs_root, applespi,
1815
+
&applespi_tp_dim_fops);
1816
+
if (IS_ERR(ret))
1817
+
dev_dbg(&applespi->spi->dev,
1818
+
"Error creating debugfs entry tp_dim (%ld)\n",
1819
+
PTR_ERR(ret));
1820
+
}
1821
+
1822
+
return 0;
1823
+
}
1824
+
1825
+
static void applespi_drain_writes(struct applespi_data *applespi)
1826
+
{
1827
+
unsigned long flags;
1828
+
1829
+
spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1830
+
1831
+
applespi->drain = true;
1832
+
wait_event_lock_irq(applespi->drain_complete, !applespi->write_active,
1833
+
applespi->cmd_msg_lock);
1834
+
1835
+
spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1836
+
}
1837
+
1838
+
static void applespi_drain_reads(struct applespi_data *applespi)
1839
+
{
1840
+
unsigned long flags;
1841
+
1842
+
spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1843
+
1844
+
wait_event_lock_irq(applespi->drain_complete, !applespi->read_active,
1845
+
applespi->cmd_msg_lock);
1846
+
1847
+
applespi->suspended = true;
1848
+
1849
+
spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1850
+
}
1851
+
1852
+
static int applespi_remove(struct spi_device *spi)
1853
+
{
1854
+
struct applespi_data *applespi = spi_get_drvdata(spi);
1855
+
1856
+
applespi_drain_writes(applespi);
1857
+
1858
+
acpi_disable_gpe(NULL, applespi->gpe);
1859
+
acpi_remove_gpe_handler(NULL, applespi->gpe, applespi_notify);
1860
+
device_wakeup_disable(&spi->dev);
1861
+
1862
+
applespi_drain_reads(applespi);
1863
+
1864
+
debugfs_remove_recursive(applespi->debugfs_root);
1865
+
1866
+
return 0;
1867
+
}
1868
+
1869
+
static void applespi_shutdown(struct spi_device *spi)
1870
+
{
1871
+
struct applespi_data *applespi = spi_get_drvdata(spi);
1872
+
1873
+
applespi_save_bl_level(applespi, applespi->have_bl_level);
1874
+
}
1875
+
1876
+
static int applespi_poweroff_late(struct device *dev)
1877
+
{
1878
+
struct spi_device *spi = to_spi_device(dev);
1879
+
struct applespi_data *applespi = spi_get_drvdata(spi);
1880
+
1881
+
applespi_save_bl_level(applespi, applespi->have_bl_level);
1882
+
1883
+
return 0;
1884
+
}
1885
+
1886
+
static int __maybe_unused applespi_suspend(struct device *dev)
1887
+
{
1888
+
struct spi_device *spi = to_spi_device(dev);
1889
+
struct applespi_data *applespi = spi_get_drvdata(spi);
1890
+
acpi_status acpi_sts;
1891
+
int sts;
1892
+
1893
+
/* turn off caps-lock - it'll stay on otherwise */
1894
+
sts = applespi_set_capsl_led(applespi, false);
1895
+
if (sts)
1896
+
dev_warn(&applespi->spi->dev,
1897
+
"Failed to turn off caps-lock led (%d)\n", sts);
1898
+
1899
+
applespi_drain_writes(applespi);
1900
+
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));
1907
+
1908
+
applespi_drain_reads(applespi);
1909
+
1910
+
return 0;
1911
+
}
1912
+
1913
+
static int __maybe_unused applespi_resume(struct device *dev)
1914
+
{
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;
1919
+
1920
+
/* ensure our flags and state reflect a newly resumed device */
1921
+
spin_lock_irqsave(&applespi->cmd_msg_lock, flags);
1922
+
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;
1929
+
1930
+
applespi->suspended = false;
1931
+
1932
+
spin_unlock_irqrestore(&applespi->cmd_msg_lock, flags);
1933
+
1934
+
/* switch on the SPI interface */
1935
+
applespi_enable_spi(applespi);
1936
+
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));
1943
+
1944
+
/* switch the touchpad into multitouch mode */
1945
+
applespi_init(applespi, true);
1946
+
1947
+
return 0;
1948
+
}
1949
+
1950
+
static const struct acpi_device_id applespi_acpi_match[] = {
1951
+
{ "APP000D", 0 },
1952
+
{ }
1953
+
};
1954
+
MODULE_DEVICE_TABLE(acpi, applespi_acpi_match);
1955
+
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,
1959
+
};
1960
+
1961
+
static struct spi_driver applespi_driver = {
1962
+
.driver = {
1963
+
.name = "applespi",
1964
+
.acpi_match_table = applespi_acpi_match,
1965
+
.pm = &applespi_pm_ops,
1966
+
},
1967
+
.probe = applespi_probe,
1968
+
.remove = applespi_remove,
1969
+
.shutdown = applespi_shutdown,
1970
+
};
1971
+
1972
+
module_spi_driver(applespi_driver)
1973
+
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");
+29
drivers/input/keyboard/applespi.h
+29
drivers/input/keyboard/applespi.h
···
1
+
/* SPDX-License-Identifier: GPL-2.0 */
2
+
/*
3
+
* MacBook (Pro) SPI keyboard and touchpad driver
4
+
*
5
+
* Copyright (c) 2015-2019 Federico Lorenzi
6
+
* Copyright (c) 2017-2019 Ronald Tschalär
7
+
*/
8
+
9
+
#ifndef _APPLESPI_H_
10
+
#define _APPLESPI_H_
11
+
12
+
enum applespi_evt_type {
13
+
ET_CMD_TP_INI = BIT(0),
14
+
ET_CMD_BL = BIT(1),
15
+
ET_CMD_CL = BIT(2),
16
+
ET_RD_KEYB = BIT(8),
17
+
ET_RD_TPAD = BIT(9),
18
+
ET_RD_UNKN = BIT(10),
19
+
ET_RD_IRQ = BIT(11),
20
+
ET_RD_CRC = BIT(12),
21
+
};
22
+
23
+
enum applespi_pkt_type {
24
+
PT_READ,
25
+
PT_WRITE,
26
+
PT_STATUS,
27
+
};
28
+
29
+
#endif /* _APPLESPI_H_ */
+93
drivers/input/keyboard/applespi_trace.h
+93
drivers/input/keyboard/applespi_trace.h
···
1
+
/* SPDX-License-Identifier: GPL-2.0 */
2
+
/*
3
+
* MacBook (Pro) SPI keyboard and touchpad driver
4
+
*
5
+
* Copyright (c) 2015-2019 Federico Lorenzi
6
+
* Copyright (c) 2017-2019 Ronald Tschalär
7
+
*/
8
+
9
+
#undef TRACE_SYSTEM
10
+
#define TRACE_SYSTEM applespi
11
+
12
+
#if !defined(_APPLESPI_TRACE_H_) || defined(TRACE_HEADER_MULTI_READ)
13
+
#define _APPLESPI_TRACE_H_
14
+
15
+
#include <linux/types.h>
16
+
#include <linux/tracepoint.h>
17
+
18
+
#include "applespi.h"
19
+
20
+
DECLARE_EVENT_CLASS(dump_message_template,
21
+
TP_PROTO(enum applespi_evt_type evt_type,
22
+
enum applespi_pkt_type pkt_type,
23
+
u8 *buf,
24
+
size_t len),
25
+
26
+
TP_ARGS(evt_type, pkt_type, buf, len),
27
+
28
+
TP_STRUCT__entry(
29
+
__field(enum applespi_evt_type, evt_type)
30
+
__field(enum applespi_pkt_type, pkt_type)
31
+
__field(size_t, len)
32
+
__dynamic_array(u8, buf, len)
33
+
),
34
+
35
+
TP_fast_assign(
36
+
__entry->evt_type = evt_type;
37
+
__entry->pkt_type = pkt_type;
38
+
__entry->len = len;
39
+
memcpy(__get_dynamic_array(buf), buf, len);
40
+
),
41
+
42
+
TP_printk("%-6s: %s",
43
+
__print_symbolic(__entry->pkt_type,
44
+
{ PT_READ, "read" },
45
+
{ PT_WRITE, "write" },
46
+
{ PT_STATUS, "status" }
47
+
),
48
+
__print_hex(__get_dynamic_array(buf), __entry->len))
49
+
);
50
+
51
+
#define DEFINE_DUMP_MESSAGE_EVENT(name) \
52
+
DEFINE_EVENT(dump_message_template, name, \
53
+
TP_PROTO(enum applespi_evt_type evt_type, \
54
+
enum applespi_pkt_type pkt_type, \
55
+
u8 *buf, \
56
+
size_t len), \
57
+
TP_ARGS(evt_type, pkt_type, buf, len) \
58
+
)
59
+
60
+
DEFINE_DUMP_MESSAGE_EVENT(applespi_tp_ini_cmd);
61
+
DEFINE_DUMP_MESSAGE_EVENT(applespi_backlight_cmd);
62
+
DEFINE_DUMP_MESSAGE_EVENT(applespi_caps_lock_cmd);
63
+
DEFINE_DUMP_MESSAGE_EVENT(applespi_keyboard_data);
64
+
DEFINE_DUMP_MESSAGE_EVENT(applespi_touchpad_data);
65
+
DEFINE_DUMP_MESSAGE_EVENT(applespi_unknown_data);
66
+
DEFINE_DUMP_MESSAGE_EVENT(applespi_bad_crc);
67
+
68
+
TRACE_EVENT(applespi_irq_received,
69
+
TP_PROTO(enum applespi_evt_type evt_type,
70
+
enum applespi_pkt_type pkt_type),
71
+
72
+
TP_ARGS(evt_type, pkt_type),
73
+
74
+
TP_STRUCT__entry(
75
+
__field(enum applespi_evt_type, evt_type)
76
+
__field(enum applespi_pkt_type, pkt_type)
77
+
),
78
+
79
+
TP_fast_assign(
80
+
__entry->evt_type = evt_type;
81
+
__entry->pkt_type = pkt_type;
82
+
),
83
+
84
+
"\n"
85
+
);
86
+
87
+
#endif /* _APPLESPI_TRACE_H_ */
88
+
89
+
/* This part must be outside protection */
90
+
#undef TRACE_INCLUDE_PATH
91
+
#define TRACE_INCLUDE_PATH ../../drivers/input/keyboard
92
+
#define TRACE_INCLUDE_FILE applespi_trace
93
+
#include <trace/define_trace.h>
+7
-2
drivers/input/keyboard/mtk-pmic-keys.c
+7
-2
drivers/input/keyboard/mtk-pmic-keys.c
···
277
277
keys->keys[index].regs = &mtk_pmic_regs->keys_regs[index];
278
278
279
279
keys->keys[index].irq = platform_get_irq(pdev, index);
280
-
if (keys->keys[index].irq < 0)
280
+
if (keys->keys[index].irq < 0) {
281
+
of_node_put(child);
281
282
return keys->keys[index].irq;
283
+
}
282
284
283
285
error = of_property_read_u32(child,
284
286
"linux,keycodes", &keys->keys[index].keycode);
···
288
286
dev_err(keys->dev,
289
287
"failed to read key:%d linux,keycode property: %d\n",
290
288
index, error);
289
+
of_node_put(child);
291
290
return error;
292
291
}
293
292
···
296
293
keys->keys[index].wakeup = true;
297
294
298
295
error = mtk_pmic_key_setup(keys, &keys->keys[index]);
299
-
if (error)
296
+
if (error) {
297
+
of_node_put(child);
300
298
return error;
299
+
}
301
300
302
301
index++;
303
302
}
+3
drivers/input/keyboard/sun4i-lradc-keys.c
+3
drivers/input/keyboard/sun4i-lradc-keys.c
···
198
198
error = of_property_read_u32(pp, "channel", &channel);
199
199
if (error || channel != 0) {
200
200
dev_err(dev, "%pOFn: Inval channel prop\n", pp);
201
+
of_node_put(pp);
201
202
return -EINVAL;
202
203
}
203
204
204
205
error = of_property_read_u32(pp, "voltage", &map->voltage);
205
206
if (error) {
206
207
dev_err(dev, "%pOFn: Inval voltage prop\n", pp);
208
+
of_node_put(pp);
207
209
return -EINVAL;
208
210
}
209
211
210
212
error = of_property_read_u32(pp, "linux,code", &map->keycode);
211
213
if (error) {
212
214
dev_err(dev, "%pOFn: Inval linux,code prop\n", pp);
215
+
of_node_put(pp);
213
216
return -EINVAL;
214
217
}
215
218
+32
drivers/input/mouse/alps.c
+32
drivers/input/mouse/alps.c
···
21
21
22
22
#include "psmouse.h"
23
23
#include "alps.h"
24
+
#include "trackpoint.h"
24
25
25
26
/*
26
27
* Definitions for ALPS version 3 and 4 command mode protocol
···
2862
2861
return NULL;
2863
2862
}
2864
2863
2864
+
static bool alps_is_cs19_trackpoint(struct psmouse *psmouse)
2865
+
{
2866
+
u8 param[2] = { 0 };
2867
+
2868
+
if (ps2_command(&psmouse->ps2dev,
2869
+
param, MAKE_PS2_CMD(0, 2, TP_READ_ID)))
2870
+
return false;
2871
+
2872
+
/*
2873
+
* param[0] contains the trackpoint device variant_id while
2874
+
* param[1] contains the firmware_id. So far all alps
2875
+
* trackpoint-only devices have their variant_ids equal
2876
+
* TP_VARIANT_ALPS and their firmware_ids are in 0x20~0x2f range.
2877
+
*/
2878
+
return param[0] == TP_VARIANT_ALPS && ((param[1] & 0xf0) == 0x20);
2879
+
}
2880
+
2865
2881
static int alps_identify(struct psmouse *psmouse, struct alps_data *priv)
2866
2882
{
2867
2883
const struct alps_protocol_info *protocol;
···
3178
3160
error = alps_identify(psmouse, NULL);
3179
3161
if (error)
3180
3162
return error;
3163
+
3164
+
/*
3165
+
* ALPS cs19 is a trackpoint-only device, and uses different
3166
+
* protocol than DualPoint ones, so we return -EINVAL here and let
3167
+
* trackpoint.c drive this device. If the trackpoint driver is not
3168
+
* enabled, the device will fall back to a bare PS/2 mouse.
3169
+
* If ps2_command() fails here, we depend on the immediately
3170
+
* followed psmouse_reset() to reset the device to normal state.
3171
+
*/
3172
+
if (alps_is_cs19_trackpoint(psmouse)) {
3173
+
psmouse_dbg(psmouse,
3174
+
"ALPS CS19 trackpoint-only device detected, ignoring\n");
3175
+
return -EINVAL;
3176
+
}
3181
3177
3182
3178
/*
3183
3179
* Reset the device to make sure it is fully operational:
+2
-1
drivers/input/mouse/synaptics.c
+2
-1
drivers/input/mouse/synaptics.c
···
176
176
"LEN0093", /* T480 */
177
177
"LEN0096", /* X280 */
178
178
"LEN0097", /* X280 -> ALPS trackpoint */
179
+
"LEN009b", /* T580 */
179
180
"LEN200f", /* T450s */
180
181
"LEN2054", /* E480 */
181
182
"LEN2055", /* E580 */
···
706
705
707
706
serio->id.type = SERIO_PS_PSTHRU;
708
707
strlcpy(serio->name, "Synaptics pass-through", sizeof(serio->name));
709
-
strlcpy(serio->phys, "synaptics-pt/serio0", sizeof(serio->name));
708
+
strlcpy(serio->phys, "synaptics-pt/serio0", sizeof(serio->phys));
710
709
serio->write = synaptics_pt_write;
711
710
serio->start = synaptics_pt_start;
712
711
serio->stop = synaptics_pt_stop;
+2
-1
drivers/input/mouse/trackpoint.h
+2
-1
drivers/input/mouse/trackpoint.h
···
158
158
#ifdef CONFIG_MOUSE_PS2_TRACKPOINT
159
159
int trackpoint_detect(struct psmouse *psmouse, bool set_properties);
160
160
#else
161
-
inline int trackpoint_detect(struct psmouse *psmouse, bool set_properties)
161
+
static inline int trackpoint_detect(struct psmouse *psmouse,
162
+
bool set_properties)
162
163
{
163
164
return -ENOSYS;
164
165
}
+2
-2
drivers/input/serio/hyperv-keyboard.c
+2
-2
drivers/input/serio/hyperv-keyboard.c
···
75
75
76
76
#define HK_MAXIMUM_MESSAGE_SIZE 256
77
77
78
-
#define KBD_VSC_SEND_RING_BUFFER_SIZE (10 * PAGE_SIZE)
79
-
#define KBD_VSC_RECV_RING_BUFFER_SIZE (10 * PAGE_SIZE)
78
+
#define KBD_VSC_SEND_RING_BUFFER_SIZE (40 * 1024)
79
+
#define KBD_VSC_RECV_RING_BUFFER_SIZE (40 * 1024)
80
80
81
81
#define XTKBD_EMUL0 0xe0
82
82
#define XTKBD_EMUL1 0xe1
+17
-3
drivers/input/tablet/gtco.c
+17
-3
drivers/input/tablet/gtco.c
···
78
78
79
79
/* Max size of a single report */
80
80
#define REPORT_MAX_SIZE 10
81
+
#define MAX_COLLECTION_LEVELS 10
81
82
82
83
83
84
/* Bitmask whether pen is in range */
···
224
223
char maintype = 'x';
225
224
char globtype[12];
226
225
int indent = 0;
227
-
char indentstr[10] = "";
228
-
226
+
char indentstr[MAX_COLLECTION_LEVELS + 1] = { 0 };
229
227
230
228
dev_dbg(ddev, "======>>>>>>PARSE<<<<<<======\n");
231
229
···
350
350
case TAG_MAIN_COL_START:
351
351
maintype = 'S';
352
352
353
+
if (indent == MAX_COLLECTION_LEVELS) {
354
+
dev_err(ddev, "Collection level %d would exceed limit of %d\n",
355
+
indent + 1,
356
+
MAX_COLLECTION_LEVELS);
357
+
break;
358
+
}
359
+
353
360
if (data == 0) {
354
361
dev_dbg(ddev, "======>>>>>> Physical\n");
355
362
strcpy(globtype, "Physical");
···
376
369
break;
377
370
378
371
case TAG_MAIN_COL_END:
379
-
dev_dbg(ddev, "<<<<<<======\n");
380
372
maintype = 'E';
373
+
374
+
if (indent == 0) {
375
+
dev_err(ddev, "Collection level already at zero\n");
376
+
break;
377
+
}
378
+
379
+
dev_dbg(ddev, "<<<<<<======\n");
380
+
381
381
indent--;
382
382
for (x = 0; x < indent; x++)
383
383
indentstr[x] = '-';
+1
-2
drivers/input/touchscreen/auo-pixcir-ts.c
+1
-2
drivers/input/touchscreen/auo-pixcir-ts.c
···
602
602
return error;
603
603
}
604
604
605
-
error = devm_add_action(&client->dev, auo_pixcir_reset, ts);
605
+
error = devm_add_action_or_reset(&client->dev, auo_pixcir_reset, ts);
606
606
if (error) {
607
-
auo_pixcir_reset(ts);
608
607
dev_err(&client->dev, "failed to register reset action, %d\n",
609
608
error);
610
609
return error;