Something went wrong. Try again.
(I'm so sorry!) Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
Something went wrong. Try again.
13 kB · 481 lines
C
at master
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482// SPDX-License-Identifier: GPL-2.0/* * Apple Z2 touchscreen driver * * Copyright (C) The Asahi Linux Contributors */
#include <linux/delay.h>#include <linux/firmware.h>#include <linux/input.h>#include <linux/input/mt.h>#include <linux/input/touchscreen.h>#include <linux/interrupt.h>#include <linux/module.h>#include <linux/of.h>#include <linux/spi/spi.h>#include <linux/unaligned.h>
#define APPLE_Z2_NUM_FINGERS_OFFSET 16#define APPLE_Z2_FINGERS_OFFSET 24#define APPLE_Z2_TOUCH_STARTED 3#define APPLE_Z2_TOUCH_MOVED 4#define APPLE_Z2_CMD_READ_INTERRUPT_DATA 0xEB#define APPLE_Z2_REPLY_INTERRUPT_DATA 0xE1#define APPLE_Z2_HBPP_CMD_BLOB 0x3001#define APPLE_Z2_FW_MAGIC 0x5746325A#define LOAD_COMMAND_INIT_PAYLOAD 0#define LOAD_COMMAND_SEND_BLOB 1#define LOAD_COMMAND_SEND_CALIBRATION 2#define CAL_PROP_NAME "apple,z2-cal-blob"
struct apple_z2 { struct spi_device *spidev; struct gpio_desc *reset_gpio; struct input_dev *input_dev; struct completion boot_irq; bool booted; int index_parity; struct touchscreen_properties props; const char *fw_name; u8 *tx_buf; u8 *rx_buf;};
struct apple_z2_finger { u8 finger; u8 state; __le16 unknown2; __le16 abs_x; __le16 abs_y; __le16 rel_x; __le16 rel_y; __le16 tool_major; __le16 tool_minor; __le16 orientation; __le16 touch_major; __le16 touch_minor; __le16 unused[2]; __le16 pressure; __le16 multi;} __packed;
struct apple_z2_hbpp_blob_hdr { __le16 cmd; __le16 len; __le32 addr; __le16 checksum;};
struct apple_z2_fw_hdr { __le32 magic; __le32 version;};
struct apple_z2_read_interrupt_cmd { u8 cmd; u8 counter; u8 unused[12]; __le16 checksum;};
static void apple_z2_parse_touches(struct apple_z2 *z2, const u8 *msg, size_t msg_len){ int i; int nfingers; int slot; int slot_valid; struct apple_z2_finger *fingers;
if (msg_len <= APPLE_Z2_NUM_FINGERS_OFFSET) return; nfingers = msg[APPLE_Z2_NUM_FINGERS_OFFSET]; fingers = (struct apple_z2_finger *)(msg + APPLE_Z2_FINGERS_OFFSET); for (i = 0; i < nfingers; i++) { slot = input_mt_get_slot_by_key(z2->input_dev, fingers[i].finger); if (slot < 0) { dev_warn(&z2->spidev->dev, "unable to get slot for finger\n"); continue; } slot_valid = fingers[i].state == APPLE_Z2_TOUCH_STARTED || fingers[i].state == APPLE_Z2_TOUCH_MOVED; input_mt_slot(z2->input_dev, slot); if (!input_mt_report_slot_state(z2->input_dev, MT_TOOL_FINGER, slot_valid)) continue; touchscreen_report_pos(z2->input_dev, &z2->props, le16_to_cpu(fingers[i].abs_x), le16_to_cpu(fingers[i].abs_y), true); input_report_abs(z2->input_dev, ABS_MT_WIDTH_MAJOR, le16_to_cpu(fingers[i].tool_major)); input_report_abs(z2->input_dev, ABS_MT_WIDTH_MINOR, le16_to_cpu(fingers[i].tool_minor)); input_report_abs(z2->input_dev, ABS_MT_ORIENTATION, le16_to_cpu(fingers[i].orientation)); input_report_abs(z2->input_dev, ABS_MT_TOUCH_MAJOR, le16_to_cpu(fingers[i].touch_major)); input_report_abs(z2->input_dev, ABS_MT_TOUCH_MINOR, le16_to_cpu(fingers[i].touch_minor)); } input_mt_sync_frame(z2->input_dev); input_sync(z2->input_dev);}
static int apple_z2_read_packet(struct apple_z2 *z2){ struct apple_z2_read_interrupt_cmd *len_cmd = (void *)z2->tx_buf; struct spi_transfer xfer; int error; size_t pkt_len;
memset(&xfer, 0, sizeof(xfer)); len_cmd->cmd = APPLE_Z2_CMD_READ_INTERRUPT_DATA; len_cmd->counter = z2->index_parity + 1; len_cmd->checksum = cpu_to_le16(APPLE_Z2_CMD_READ_INTERRUPT_DATA + len_cmd->counter); z2->index_parity = !z2->index_parity; xfer.tx_buf = z2->tx_buf; xfer.rx_buf = z2->rx_buf; xfer.len = sizeof(*len_cmd);
error = spi_sync_transfer(z2->spidev, &xfer, 1); if (error) return error;
if (z2->rx_buf[0] != APPLE_Z2_REPLY_INTERRUPT_DATA) return 0;
pkt_len = (get_unaligned_le16(z2->rx_buf + 1) + 8) & 0xfffffffc;
error = spi_read(z2->spidev, z2->rx_buf, pkt_len); if (error) return error;
apple_z2_parse_touches(z2, z2->rx_buf + 5, pkt_len - 5);
return 0;}
static irqreturn_t apple_z2_irq(int irq, void *data){ struct apple_z2 *z2 = data;
if (unlikely(!z2->booted)) complete(&z2->boot_irq); else apple_z2_read_packet(z2);
return IRQ_HANDLED;}
/* Build calibration blob, caller is responsible for freeing the blob data. */static const u8 *apple_z2_build_cal_blob(struct apple_z2 *z2, u32 address, size_t *size){ u8 *cal_data; int cal_size; size_t blob_size; u32 checksum; u16 checksum_hdr; int i; struct apple_z2_hbpp_blob_hdr *hdr; int error;
if (!device_property_present(&z2->spidev->dev, CAL_PROP_NAME)) return NULL;
cal_size = device_property_count_u8(&z2->spidev->dev, CAL_PROP_NAME); if (cal_size < 0) return ERR_PTR(cal_size);
blob_size = sizeof(struct apple_z2_hbpp_blob_hdr) + cal_size + sizeof(__le32); u8 *blob_data __free(kfree) = kzalloc(blob_size, GFP_KERNEL); if (!blob_data) return ERR_PTR(-ENOMEM);
hdr = (struct apple_z2_hbpp_blob_hdr *)blob_data; hdr->cmd = cpu_to_le16(APPLE_Z2_HBPP_CMD_BLOB); hdr->len = cpu_to_le16(round_up(cal_size, 4) / 4); hdr->addr = cpu_to_le32(address);
checksum_hdr = 0; for (i = 2; i < 8; i++) checksum_hdr += blob_data[i]; hdr->checksum = cpu_to_le16(checksum_hdr);
cal_data = blob_data + sizeof(struct apple_z2_hbpp_blob_hdr); error = device_property_read_u8_array(&z2->spidev->dev, CAL_PROP_NAME, cal_data, cal_size); if (error) return ERR_PTR(error);
checksum = 0; for (i = 0; i < cal_size; i++) checksum += cal_data[i]; put_unaligned_le32(checksum, cal_data + cal_size);
*size = blob_size; return no_free_ptr(blob_data);}
static int apple_z2_send_firmware_blob(struct apple_z2 *z2, const u8 *data, u32 size, bool init){ struct spi_message msg; struct spi_transfer blob_xfer, ack_xfer; int error;
z2->tx_buf[0] = 0x1a; z2->tx_buf[1] = 0xa1;
spi_message_init(&msg); memset(&blob_xfer, 0, sizeof(blob_xfer)); memset(&ack_xfer, 0, sizeof(ack_xfer));
blob_xfer.tx_buf = data; blob_xfer.len = size; blob_xfer.bits_per_word = init ? 8 : 16; spi_message_add_tail(&blob_xfer, &msg);
ack_xfer.tx_buf = z2->tx_buf; ack_xfer.len = 2; spi_message_add_tail(&ack_xfer, &msg);
reinit_completion(&z2->boot_irq); error = spi_sync(z2->spidev, &msg); if (error) return error;
/* Irq only happens sometimes, but the thing boots reliably nonetheless */ wait_for_completion_timeout(&z2->boot_irq, msecs_to_jiffies(20));
return 0;}
static int apple_z2_upload_firmware(struct apple_z2 *z2){ const struct apple_z2_fw_hdr *fw_hdr; size_t fw_idx = sizeof(struct apple_z2_fw_hdr); int error; u32 load_cmd; u32 address; bool init; size_t size;
const struct firmware *fw __free(firmware) = NULL; error = request_firmware(&fw, z2->fw_name, &z2->spidev->dev); if (error) { dev_err(&z2->spidev->dev, "unable to load firmware\n"); return error; }
fw_hdr = (const struct apple_z2_fw_hdr *)fw->data; if (le32_to_cpu(fw_hdr->magic) != APPLE_Z2_FW_MAGIC || le32_to_cpu(fw_hdr->version) != 1) { dev_err(&z2->spidev->dev, "invalid firmware header\n"); return -EINVAL; }
/* * This will interrupt the upload half-way if the file is malformed * As the device has no non-volatile storage to corrupt, and gets reset * on boot anyway, this is fine. */ while (fw_idx < fw->size) { if (fw->size - fw_idx < 8) { dev_err(&z2->spidev->dev, "firmware malformed\n"); return -EINVAL; }
load_cmd = le32_to_cpup((__force __le32 *)(fw->data + fw_idx)); fw_idx += sizeof(u32); if (load_cmd == LOAD_COMMAND_INIT_PAYLOAD || load_cmd == LOAD_COMMAND_SEND_BLOB) { size = le32_to_cpup((__force __le32 *)(fw->data + fw_idx)); fw_idx += sizeof(u32); if (fw->size - fw_idx < size) { dev_err(&z2->spidev->dev, "firmware malformed\n"); return -EINVAL; } init = load_cmd == LOAD_COMMAND_INIT_PAYLOAD; error = apple_z2_send_firmware_blob(z2, fw->data + fw_idx, size, init); if (error) return error; fw_idx += size; } else if (load_cmd == LOAD_COMMAND_SEND_CALIBRATION) { address = le32_to_cpup((__force __le32 *)(fw->data + fw_idx)); fw_idx += sizeof(u32);
const u8 *data __free(kfree) = apple_z2_build_cal_blob(z2, address, &size); if (IS_ERR(data)) return PTR_ERR(data);
if (data) { error = apple_z2_send_firmware_blob(z2, data, size, false); if (error) return error; } } else { dev_err(&z2->spidev->dev, "firmware malformed\n"); return -EINVAL; } fw_idx = round_up(fw_idx, 4); }
z2->booted = true; apple_z2_read_packet(z2); return 0;}
static int apple_z2_boot(struct apple_z2 *z2){ int error;
reinit_completion(&z2->boot_irq); enable_irq(z2->spidev->irq); gpiod_set_value(z2->reset_gpio, 0); if (!wait_for_completion_timeout(&z2->boot_irq, msecs_to_jiffies(20))) return -ETIMEDOUT;
error = apple_z2_upload_firmware(z2); if (error) { gpiod_set_value(z2->reset_gpio, 1); disable_irq(z2->spidev->irq); return error; }
return 0;}
static int apple_z2_probe(struct spi_device *spi){ struct device *dev = &spi->dev; struct apple_z2 *z2; int error;
z2 = devm_kzalloc(dev, sizeof(*z2), GFP_KERNEL); if (!z2) return -ENOMEM;
z2->tx_buf = devm_kzalloc(dev, sizeof(struct apple_z2_read_interrupt_cmd), GFP_KERNEL); if (!z2->tx_buf) return -ENOMEM; /* 4096 will end up being rounded up to 8192 due to devres header */ z2->rx_buf = devm_kzalloc(dev, 4000, GFP_KERNEL); if (!z2->rx_buf) return -ENOMEM;
z2->spidev = spi; init_completion(&z2->boot_irq); spi_set_drvdata(spi, z2);
/* Reset the device on boot */ z2->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_HIGH); if (IS_ERR(z2->reset_gpio)) return dev_err_probe(dev, PTR_ERR(z2->reset_gpio), "unable to get reset\n");
error = devm_request_threaded_irq(dev, z2->spidev->irq, NULL, apple_z2_irq, IRQF_ONESHOT | IRQF_NO_AUTOEN, "apple-z2-irq", z2); if (error) return dev_err_probe(dev, error, "unable to request irq\n");
error = device_property_read_string(dev, "firmware-name", &z2->fw_name); if (error) return dev_err_probe(dev, error, "unable to get firmware name\n");
z2->input_dev = devm_input_allocate_device(dev); if (!z2->input_dev) return -ENOMEM;
z2->input_dev->name = (char *)spi_get_device_id(spi)->driver_data; z2->input_dev->phys = "apple_z2"; z2->input_dev->id.bustype = BUS_SPI;
/* Allocate the axes before setting from DT */ input_set_abs_params(z2->input_dev, ABS_MT_POSITION_X, 0, 0, 0, 0); input_set_abs_params(z2->input_dev, ABS_MT_POSITION_Y, 0, 0, 0, 0); touchscreen_parse_properties(z2->input_dev, true, &z2->props); input_abs_set_res(z2->input_dev, ABS_MT_POSITION_X, 100); input_abs_set_res(z2->input_dev, ABS_MT_POSITION_Y, 100); input_set_abs_params(z2->input_dev, ABS_MT_WIDTH_MAJOR, 0, 65535, 0, 0); input_set_abs_params(z2->input_dev, ABS_MT_WIDTH_MINOR, 0, 65535, 0, 0); input_set_abs_params(z2->input_dev, ABS_MT_TOUCH_MAJOR, 0, 65535, 0, 0); input_set_abs_params(z2->input_dev, ABS_MT_TOUCH_MINOR, 0, 65535, 0, 0); input_set_abs_params(z2->input_dev, ABS_MT_ORIENTATION, -32768, 32767, 0, 0);
error = input_mt_init_slots(z2->input_dev, 256, INPUT_MT_DIRECT); if (error) return dev_err_probe(dev, error, "unable to initialize multitouch slots\n");
error = input_register_device(z2->input_dev); if (error) return dev_err_probe(dev, error, "unable to register input device\n");
/* Wait for device reset to finish */ usleep_range(5000, 10000); error = apple_z2_boot(z2); if (error) return error;
return 0;}
static void apple_z2_shutdown(struct spi_device *spi){ struct apple_z2 *z2 = spi_get_drvdata(spi);
disable_irq(z2->spidev->irq); gpiod_direction_output(z2->reset_gpio, 1); z2->booted = false;}
static int apple_z2_suspend(struct device *dev){ apple_z2_shutdown(to_spi_device(dev));
return 0;}
static int apple_z2_resume(struct device *dev){ struct apple_z2 *z2 = spi_get_drvdata(to_spi_device(dev));
return apple_z2_boot(z2);}
static DEFINE_SIMPLE_DEV_PM_OPS(apple_z2_pm, apple_z2_suspend, apple_z2_resume);
static const struct of_device_id apple_z2_of_match[] = { { .compatible = "apple,j293-touchbar" }, { .compatible = "apple,j493-touchbar" }, {}};MODULE_DEVICE_TABLE(of, apple_z2_of_match);
static struct spi_device_id apple_z2_of_id[] = { { .name = "j293-touchbar", .driver_data = (kernel_ulong_t)"MacBookPro17,1 Touch Bar" }, { .name = "j493-touchbar", .driver_data = (kernel_ulong_t)"Mac14,7 Touch Bar" }, {}};MODULE_DEVICE_TABLE(spi, apple_z2_of_id);
static struct spi_driver apple_z2_driver = { .driver = { .name = "apple-z2", .pm = pm_sleep_ptr(&apple_z2_pm), .of_match_table = apple_z2_of_match, .probe_type = PROBE_PREFER_ASYNCHRONOUS, }, .id_table = apple_z2_of_id, .probe = apple_z2_probe, .remove = apple_z2_shutdown,};
module_spi_driver(apple_z2_driver);
MODULE_LICENSE("GPL");MODULE_FIRMWARE("apple/dfrmtfw-*.bin");MODULE_DESCRIPTION("Apple Z2 touchscreens driver");