Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Input: apple_z2 - add a driver for Apple Z2 touchscreens
Adds a driver for Apple touchscreens using the Z2 protocol.
Signed-off-by: Janne Grunau <j@jannau.net>
Reviewed-by: Neal Gompa <neal@gompa.dev>
Signed-off-by: Sasha Finkelstein <fnkl.kernel@gmail.com>
Link: https://lore.kernel.org/r/20250217-z2-v6-2-c2115d6e5a8f@gmail.com
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
authored by
Sasha Finkelstein
and committed by
Dmitry Torokhov
471a92f8
ed872cea
+491
+13
drivers/input/touchscreen/Kconfig
+13
drivers/input/touchscreen/Kconfig
···
103
103
To compile this driver as a module, choose M here: the
104
104
module will be called resistive-adc-touch.ko.
105
105
106
+
config TOUCHSCREEN_APPLE_Z2
107
+
tristate "Apple Z2 touchscreens"
108
+
default ARCH_APPLE
109
+
depends on SPI
110
+
help
111
+
Say Y here if you have an Apple device with
112
+
a touchscreen or a touchbar.
113
+
114
+
If unsure, say N.
115
+
116
+
To compile this driver as a module, choose M here: the
117
+
module will be called apple_z2.
118
+
106
119
config TOUCHSCREEN_AR1021_I2C
107
120
tristate "Microchip AR1020/1021 i2c touchscreen"
108
121
depends on I2C && OF
+1
drivers/input/touchscreen/Makefile
+1
drivers/input/touchscreen/Makefile
···
15
15
obj-$(CONFIG_TOUCHSCREEN_AD7879_SPI) += ad7879-spi.o
16
16
obj-$(CONFIG_TOUCHSCREEN_ADC) += resistive-adc-touch.o
17
17
obj-$(CONFIG_TOUCHSCREEN_ADS7846) += ads7846.o
18
+
obj-$(CONFIG_TOUCHSCREEN_APPLE_Z2) += apple_z2.o
18
19
obj-$(CONFIG_TOUCHSCREEN_AR1021_I2C) += ar1021_i2c.o
19
20
obj-$(CONFIG_TOUCHSCREEN_ATMEL_MXT) += atmel_mxt_ts.o
20
21
obj-$(CONFIG_TOUCHSCREEN_AUO_PIXCIR) += auo-pixcir-ts.o
+477
drivers/input/touchscreen/apple_z2.c
+477
drivers/input/touchscreen/apple_z2.c
···
1
+
// SPDX-License-Identifier: GPL-2.0
2
+
/*
3
+
* Apple Z2 touchscreen driver
4
+
*
5
+
* Copyright (C) The Asahi Linux Contributors
6
+
*/
7
+
8
+
#include <linux/delay.h>
9
+
#include <linux/firmware.h>
10
+
#include <linux/input.h>
11
+
#include <linux/input/mt.h>
12
+
#include <linux/input/touchscreen.h>
13
+
#include <linux/interrupt.h>
14
+
#include <linux/module.h>
15
+
#include <linux/of.h>
16
+
#include <linux/spi/spi.h>
17
+
#include <linux/unaligned.h>
18
+
19
+
#define APPLE_Z2_NUM_FINGERS_OFFSET 16
20
+
#define APPLE_Z2_FINGERS_OFFSET 24
21
+
#define APPLE_Z2_TOUCH_STARTED 3
22
+
#define APPLE_Z2_TOUCH_MOVED 4
23
+
#define APPLE_Z2_CMD_READ_INTERRUPT_DATA 0xEB
24
+
#define APPLE_Z2_HBPP_CMD_BLOB 0x3001
25
+
#define APPLE_Z2_FW_MAGIC 0x5746325A
26
+
#define LOAD_COMMAND_INIT_PAYLOAD 0
27
+
#define LOAD_COMMAND_SEND_BLOB 1
28
+
#define LOAD_COMMAND_SEND_CALIBRATION 2
29
+
#define CAL_PROP_NAME "apple,z2-cal-blob"
30
+
31
+
struct apple_z2 {
32
+
struct spi_device *spidev;
33
+
struct gpio_desc *reset_gpio;
34
+
struct input_dev *input_dev;
35
+
struct completion boot_irq;
36
+
bool booted;
37
+
int index_parity;
38
+
struct touchscreen_properties props;
39
+
const char *fw_name;
40
+
u8 *tx_buf;
41
+
u8 *rx_buf;
42
+
};
43
+
44
+
struct apple_z2_finger {
45
+
u8 finger;
46
+
u8 state;
47
+
__le16 unknown2;
48
+
__le16 abs_x;
49
+
__le16 abs_y;
50
+
__le16 rel_x;
51
+
__le16 rel_y;
52
+
__le16 tool_major;
53
+
__le16 tool_minor;
54
+
__le16 orientation;
55
+
__le16 touch_major;
56
+
__le16 touch_minor;
57
+
__le16 unused[2];
58
+
__le16 pressure;
59
+
__le16 multi;
60
+
} __packed;
61
+
62
+
struct apple_z2_hbpp_blob_hdr {
63
+
__le16 cmd;
64
+
__le16 len;
65
+
__le32 addr;
66
+
__le16 checksum;
67
+
};
68
+
69
+
struct apple_z2_fw_hdr {
70
+
__le32 magic;
71
+
__le32 version;
72
+
};
73
+
74
+
struct apple_z2_read_interrupt_cmd {
75
+
u8 cmd;
76
+
u8 counter;
77
+
u8 unused[12];
78
+
__le16 checksum;
79
+
};
80
+
81
+
static void apple_z2_parse_touches(struct apple_z2 *z2,
82
+
const u8 *msg, size_t msg_len)
83
+
{
84
+
int i;
85
+
int nfingers;
86
+
int slot;
87
+
int slot_valid;
88
+
struct apple_z2_finger *fingers;
89
+
90
+
if (msg_len <= APPLE_Z2_NUM_FINGERS_OFFSET)
91
+
return;
92
+
nfingers = msg[APPLE_Z2_NUM_FINGERS_OFFSET];
93
+
fingers = (struct apple_z2_finger *)(msg + APPLE_Z2_FINGERS_OFFSET);
94
+
for (i = 0; i < nfingers; i++) {
95
+
slot = input_mt_get_slot_by_key(z2->input_dev, fingers[i].finger);
96
+
if (slot < 0) {
97
+
dev_warn(&z2->spidev->dev, "unable to get slot for finger\n");
98
+
continue;
99
+
}
100
+
slot_valid = fingers[i].state == APPLE_Z2_TOUCH_STARTED ||
101
+
fingers[i].state == APPLE_Z2_TOUCH_MOVED;
102
+
input_mt_slot(z2->input_dev, slot);
103
+
if (!input_mt_report_slot_state(z2->input_dev, MT_TOOL_FINGER, slot_valid))
104
+
continue;
105
+
touchscreen_report_pos(z2->input_dev, &z2->props,
106
+
le16_to_cpu(fingers[i].abs_x),
107
+
le16_to_cpu(fingers[i].abs_y),
108
+
true);
109
+
input_report_abs(z2->input_dev, ABS_MT_WIDTH_MAJOR,
110
+
le16_to_cpu(fingers[i].tool_major));
111
+
input_report_abs(z2->input_dev, ABS_MT_WIDTH_MINOR,
112
+
le16_to_cpu(fingers[i].tool_minor));
113
+
input_report_abs(z2->input_dev, ABS_MT_ORIENTATION,
114
+
le16_to_cpu(fingers[i].orientation));
115
+
input_report_abs(z2->input_dev, ABS_MT_TOUCH_MAJOR,
116
+
le16_to_cpu(fingers[i].touch_major));
117
+
input_report_abs(z2->input_dev, ABS_MT_TOUCH_MINOR,
118
+
le16_to_cpu(fingers[i].touch_minor));
119
+
}
120
+
input_mt_sync_frame(z2->input_dev);
121
+
input_sync(z2->input_dev);
122
+
}
123
+
124
+
static int apple_z2_read_packet(struct apple_z2 *z2)
125
+
{
126
+
struct apple_z2_read_interrupt_cmd *len_cmd = (void *)z2->tx_buf;
127
+
struct spi_transfer xfer;
128
+
int error;
129
+
size_t pkt_len;
130
+
131
+
memset(&xfer, 0, sizeof(xfer));
132
+
len_cmd->cmd = APPLE_Z2_CMD_READ_INTERRUPT_DATA;
133
+
len_cmd->counter = z2->index_parity + 1;
134
+
len_cmd->checksum =
135
+
cpu_to_le16(APPLE_Z2_CMD_READ_INTERRUPT_DATA + len_cmd->counter);
136
+
z2->index_parity = !z2->index_parity;
137
+
xfer.tx_buf = z2->tx_buf;
138
+
xfer.rx_buf = z2->rx_buf;
139
+
xfer.len = sizeof(*len_cmd);
140
+
141
+
error = spi_sync_transfer(z2->spidev, &xfer, 1);
142
+
if (error)
143
+
return error;
144
+
145
+
pkt_len = (get_unaligned_le16(z2->rx_buf + 1) + 8) & 0xfffffffc;
146
+
147
+
error = spi_read(z2->spidev, z2->rx_buf, pkt_len);
148
+
if (error)
149
+
return error;
150
+
151
+
apple_z2_parse_touches(z2, z2->rx_buf + 5, pkt_len - 5);
152
+
153
+
return 0;
154
+
}
155
+
156
+
static irqreturn_t apple_z2_irq(int irq, void *data)
157
+
{
158
+
struct apple_z2 *z2 = data;
159
+
160
+
if (unlikely(!z2->booted))
161
+
complete(&z2->boot_irq);
162
+
else
163
+
apple_z2_read_packet(z2);
164
+
165
+
return IRQ_HANDLED;
166
+
}
167
+
168
+
/* Build calibration blob, caller is responsible for freeing the blob data. */
169
+
static const u8 *apple_z2_build_cal_blob(struct apple_z2 *z2,
170
+
u32 address, size_t *size)
171
+
{
172
+
u8 *cal_data;
173
+
int cal_size;
174
+
size_t blob_size;
175
+
u32 checksum;
176
+
u16 checksum_hdr;
177
+
int i;
178
+
struct apple_z2_hbpp_blob_hdr *hdr;
179
+
int error;
180
+
181
+
if (!device_property_present(&z2->spidev->dev, CAL_PROP_NAME))
182
+
return NULL;
183
+
184
+
cal_size = device_property_count_u8(&z2->spidev->dev, CAL_PROP_NAME);
185
+
if (cal_size < 0)
186
+
return ERR_PTR(cal_size);
187
+
188
+
blob_size = sizeof(struct apple_z2_hbpp_blob_hdr) + cal_size + sizeof(__le32);
189
+
u8 *blob_data __free(kfree) = kzalloc(blob_size, GFP_KERNEL);
190
+
if (!blob_data)
191
+
return ERR_PTR(-ENOMEM);
192
+
193
+
hdr = (struct apple_z2_hbpp_blob_hdr *)blob_data;
194
+
hdr->cmd = cpu_to_le16(APPLE_Z2_HBPP_CMD_BLOB);
195
+
hdr->len = cpu_to_le16(round_up(cal_size, 4) / 4);
196
+
hdr->addr = cpu_to_le32(address);
197
+
198
+
checksum_hdr = 0;
199
+
for (i = 2; i < 8; i++)
200
+
checksum_hdr += blob_data[i];
201
+
hdr->checksum = cpu_to_le16(checksum_hdr);
202
+
203
+
cal_data = blob_data + sizeof(struct apple_z2_hbpp_blob_hdr);
204
+
error = device_property_read_u8_array(&z2->spidev->dev, CAL_PROP_NAME,
205
+
cal_data, cal_size);
206
+
if (error)
207
+
return ERR_PTR(error);
208
+
209
+
checksum = 0;
210
+
for (i = 0; i < cal_size; i++)
211
+
checksum += cal_data[i];
212
+
put_unaligned_le32(checksum, cal_data + cal_size);
213
+
214
+
*size = blob_size;
215
+
return no_free_ptr(blob_data);
216
+
}
217
+
218
+
static int apple_z2_send_firmware_blob(struct apple_z2 *z2, const u8 *data,
219
+
u32 size, bool init)
220
+
{
221
+
struct spi_message msg;
222
+
struct spi_transfer blob_xfer, ack_xfer;
223
+
int error;
224
+
225
+
z2->tx_buf[0] = 0x1a;
226
+
z2->tx_buf[1] = 0xa1;
227
+
228
+
spi_message_init(&msg);
229
+
memset(&blob_xfer, 0, sizeof(blob_xfer));
230
+
memset(&ack_xfer, 0, sizeof(ack_xfer));
231
+
232
+
blob_xfer.tx_buf = data;
233
+
blob_xfer.len = size;
234
+
blob_xfer.bits_per_word = init ? 8 : 16;
235
+
spi_message_add_tail(&blob_xfer, &msg);
236
+
237
+
ack_xfer.tx_buf = z2->tx_buf;
238
+
ack_xfer.len = 2;
239
+
spi_message_add_tail(&ack_xfer, &msg);
240
+
241
+
reinit_completion(&z2->boot_irq);
242
+
error = spi_sync(z2->spidev, &msg);
243
+
if (error)
244
+
return error;
245
+
246
+
/* Irq only happens sometimes, but the thing boots reliably nonetheless */
247
+
wait_for_completion_timeout(&z2->boot_irq, msecs_to_jiffies(20));
248
+
249
+
return 0;
250
+
}
251
+
252
+
static int apple_z2_upload_firmware(struct apple_z2 *z2)
253
+
{
254
+
const struct apple_z2_fw_hdr *fw_hdr;
255
+
size_t fw_idx = sizeof(struct apple_z2_fw_hdr);
256
+
int error;
257
+
u32 load_cmd;
258
+
u32 address;
259
+
bool init;
260
+
size_t size;
261
+
262
+
const struct firmware *fw __free(firmware) = NULL;
263
+
error = request_firmware(&fw, z2->fw_name, &z2->spidev->dev);
264
+
if (error) {
265
+
dev_err(&z2->spidev->dev, "unable to load firmware\n");
266
+
return error;
267
+
}
268
+
269
+
fw_hdr = (const struct apple_z2_fw_hdr *)fw->data;
270
+
if (le32_to_cpu(fw_hdr->magic) != APPLE_Z2_FW_MAGIC || le32_to_cpu(fw_hdr->version) != 1) {
271
+
dev_err(&z2->spidev->dev, "invalid firmware header\n");
272
+
return -EINVAL;
273
+
}
274
+
275
+
/*
276
+
* This will interrupt the upload half-way if the file is malformed
277
+
* As the device has no non-volatile storage to corrupt, and gets reset
278
+
* on boot anyway, this is fine.
279
+
*/
280
+
while (fw_idx < fw->size) {
281
+
if (fw->size - fw_idx < 8) {
282
+
dev_err(&z2->spidev->dev, "firmware malformed\n");
283
+
return -EINVAL;
284
+
}
285
+
286
+
load_cmd = le32_to_cpup((__force __le32 *)(fw->data + fw_idx));
287
+
fw_idx += sizeof(u32);
288
+
if (load_cmd == LOAD_COMMAND_INIT_PAYLOAD || load_cmd == LOAD_COMMAND_SEND_BLOB) {
289
+
size = le32_to_cpup((__force __le32 *)(fw->data + fw_idx));
290
+
fw_idx += sizeof(u32);
291
+
if (fw->size - fw_idx < size) {
292
+
dev_err(&z2->spidev->dev, "firmware malformed\n");
293
+
return -EINVAL;
294
+
}
295
+
init = load_cmd == LOAD_COMMAND_INIT_PAYLOAD;
296
+
error = apple_z2_send_firmware_blob(z2, fw->data + fw_idx,
297
+
size, init);
298
+
if (error)
299
+
return error;
300
+
fw_idx += size;
301
+
} else if (load_cmd == LOAD_COMMAND_SEND_CALIBRATION) {
302
+
address = le32_to_cpup((__force __le32 *)(fw->data + fw_idx));
303
+
fw_idx += sizeof(u32);
304
+
305
+
const u8 *data __free(kfree) =
306
+
apple_z2_build_cal_blob(z2, address, &size);
307
+
if (IS_ERR(data))
308
+
return PTR_ERR(data);
309
+
310
+
if (data) {
311
+
error = apple_z2_send_firmware_blob(z2, data, size, false);
312
+
if (error)
313
+
return error;
314
+
}
315
+
} else {
316
+
dev_err(&z2->spidev->dev, "firmware malformed\n");
317
+
return -EINVAL;
318
+
}
319
+
fw_idx = round_up(fw_idx, 4);
320
+
}
321
+
322
+
323
+
z2->booted = true;
324
+
apple_z2_read_packet(z2);
325
+
return 0;
326
+
}
327
+
328
+
static int apple_z2_boot(struct apple_z2 *z2)
329
+
{
330
+
int error;
331
+
332
+
reinit_completion(&z2->boot_irq);
333
+
enable_irq(z2->spidev->irq);
334
+
gpiod_set_value(z2->reset_gpio, 0);
335
+
if (!wait_for_completion_timeout(&z2->boot_irq, msecs_to_jiffies(20)))
336
+
return -ETIMEDOUT;
337
+
338
+
error = apple_z2_upload_firmware(z2);
339
+
if (error) {
340
+
gpiod_set_value(z2->reset_gpio, 1);
341
+
disable_irq(z2->spidev->irq);
342
+
return error;
343
+
}
344
+
345
+
return 0;
346
+
}
347
+
348
+
static int apple_z2_probe(struct spi_device *spi)
349
+
{
350
+
struct device *dev = &spi->dev;
351
+
struct apple_z2 *z2;
352
+
int error;
353
+
354
+
z2 = devm_kzalloc(dev, sizeof(*z2), GFP_KERNEL);
355
+
if (!z2)
356
+
return -ENOMEM;
357
+
358
+
z2->tx_buf = devm_kzalloc(dev, sizeof(struct apple_z2_read_interrupt_cmd), GFP_KERNEL);
359
+
if (!z2->tx_buf)
360
+
return -ENOMEM;
361
+
/* 4096 will end up being rounded up to 8192 due to devres header */
362
+
z2->rx_buf = devm_kzalloc(dev, 4000, GFP_KERNEL);
363
+
if (!z2->rx_buf)
364
+
return -ENOMEM;
365
+
366
+
z2->spidev = spi;
367
+
init_completion(&z2->boot_irq);
368
+
spi_set_drvdata(spi, z2);
369
+
370
+
/* Reset the device on boot */
371
+
z2->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH);
372
+
if (IS_ERR(z2->reset_gpio))
373
+
return dev_err_probe(dev, PTR_ERR(z2->reset_gpio), "unable to get reset\n");
374
+
375
+
error = devm_request_threaded_irq(dev, z2->spidev->irq, NULL, apple_z2_irq,
376
+
IRQF_ONESHOT | IRQF_NO_AUTOEN,
377
+
"apple-z2-irq", z2);
378
+
if (error)
379
+
return dev_err_probe(dev, error, "unable to request irq\n");
380
+
381
+
error = device_property_read_string(dev, "firmware-name", &z2->fw_name);
382
+
if (error)
383
+
return dev_err_probe(dev, error, "unable to get firmware name\n");
384
+
385
+
z2->input_dev = devm_input_allocate_device(dev);
386
+
if (!z2->input_dev)
387
+
return -ENOMEM;
388
+
389
+
z2->input_dev->name = (char *)spi_get_device_id(spi)->driver_data;
390
+
z2->input_dev->phys = "apple_z2";
391
+
z2->input_dev->id.bustype = BUS_SPI;
392
+
393
+
/* Allocate the axes before setting from DT */
394
+
input_set_abs_params(z2->input_dev, ABS_MT_POSITION_X, 0, 0, 0, 0);
395
+
input_set_abs_params(z2->input_dev, ABS_MT_POSITION_Y, 0, 0, 0, 0);
396
+
touchscreen_parse_properties(z2->input_dev, true, &z2->props);
397
+
input_abs_set_res(z2->input_dev, ABS_MT_POSITION_X, 100);
398
+
input_abs_set_res(z2->input_dev, ABS_MT_POSITION_Y, 100);
399
+
input_set_abs_params(z2->input_dev, ABS_MT_WIDTH_MAJOR, 0, 65535, 0, 0);
400
+
input_set_abs_params(z2->input_dev, ABS_MT_WIDTH_MINOR, 0, 65535, 0, 0);
401
+
input_set_abs_params(z2->input_dev, ABS_MT_TOUCH_MAJOR, 0, 65535, 0, 0);
402
+
input_set_abs_params(z2->input_dev, ABS_MT_TOUCH_MINOR, 0, 65535, 0, 0);
403
+
input_set_abs_params(z2->input_dev, ABS_MT_ORIENTATION, -32768, 32767, 0, 0);
404
+
405
+
error = input_mt_init_slots(z2->input_dev, 256, INPUT_MT_DIRECT);
406
+
if (error)
407
+
return dev_err_probe(dev, error, "unable to initialize multitouch slots\n");
408
+
409
+
error = input_register_device(z2->input_dev);
410
+
if (error)
411
+
return dev_err_probe(dev, error, "unable to register input device\n");
412
+
413
+
/* Wait for device reset to finish */
414
+
usleep_range(5000, 10000);
415
+
error = apple_z2_boot(z2);
416
+
if (error)
417
+
return error;
418
+
419
+
return 0;
420
+
}
421
+
422
+
static void apple_z2_shutdown(struct spi_device *spi)
423
+
{
424
+
struct apple_z2 *z2 = spi_get_drvdata(spi);
425
+
426
+
disable_irq(z2->spidev->irq);
427
+
gpiod_direction_output(z2->reset_gpio, 1);
428
+
z2->booted = false;
429
+
}
430
+
431
+
static int apple_z2_suspend(struct device *dev)
432
+
{
433
+
apple_z2_shutdown(to_spi_device(dev));
434
+
435
+
return 0;
436
+
}
437
+
438
+
static int apple_z2_resume(struct device *dev)
439
+
{
440
+
struct apple_z2 *z2 = spi_get_drvdata(to_spi_device(dev));
441
+
442
+
return apple_z2_boot(z2);
443
+
}
444
+
445
+
static DEFINE_SIMPLE_DEV_PM_OPS(apple_z2_pm, apple_z2_suspend, apple_z2_resume);
446
+
447
+
static const struct of_device_id apple_z2_of_match[] = {
448
+
{ .compatible = "apple,j293-touchbar" },
449
+
{ .compatible = "apple,j493-touchbar" },
450
+
{}
451
+
};
452
+
MODULE_DEVICE_TABLE(of, apple_z2_of_match);
453
+
454
+
static struct spi_device_id apple_z2_of_id[] = {
455
+
{ .name = "j293-touchbar", .driver_data = (kernel_ulong_t)"MacBookPro17,1 Touch Bar" },
456
+
{ .name = "j493-touchbar", .driver_data = (kernel_ulong_t)"Mac14,7 Touch Bar" },
457
+
{}
458
+
};
459
+
MODULE_DEVICE_TABLE(spi, apple_z2_of_id);
460
+
461
+
static struct spi_driver apple_z2_driver = {
462
+
.driver = {
463
+
.name = "apple-z2",
464
+
.pm = pm_sleep_ptr(&apple_z2_pm),
465
+
.of_match_table = apple_z2_of_match,
466
+
.probe_type = PROBE_PREFER_ASYNCHRONOUS,
467
+
},
468
+
.id_table = apple_z2_of_id,
469
+
.probe = apple_z2_probe,
470
+
.remove = apple_z2_shutdown,
471
+
};
472
+
473
+
module_spi_driver(apple_z2_driver);
474
+
475
+
MODULE_LICENSE("GPL");
476
+
MODULE_FIRMWARE("apple/dfrmtfw-*.bin");
477
+
MODULE_DESCRIPTION("Apple Z2 touchscreens driver");