projects/linux·blob master · refs

481 lines · 12.8 KiB

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