| // SPDX-License-Identifier: GPL-2.0-or-later | |
| /* | |
| * Driver for Novatek NT11205 i2c touchscreen controller as found | |
| * on the Acer Iconia One 7 B1-750 tablet. | |
| * | |
| * Copyright (c) 2023 Hans de Goede <hdegoede@redhat.com> | |
| */ | |
| #include <linux/delay.h> | |
| #include <linux/gpio/consumer.h> | |
| #include <linux/interrupt.h> | |
| #include <linux/i2c.h> | |
| #include <linux/input.h> | |
| #include <linux/input/mt.h> | |
| #include <linux/input/touchscreen.h> | |
| #include <linux/module.h> | |
| #include <linux/unaligned.h> | |
| #define NVT_TS_TOUCH_START 0x00 | |
| #define NVT_TS_TOUCH_SIZE 6 | |
| #define NVT_TS_PARAMETERS_START 0x78 | |
| /* These are offsets from NVT_TS_PARAMETERS_START */ | |
| #define NVT_TS_PARAMS_WIDTH 0x04 | |
| #define NVT_TS_PARAMS_HEIGHT 0x06 | |
| #define NVT_TS_PARAMS_MAX_TOUCH 0x09 | |
| #define NVT_TS_PARAMS_MAX_BUTTONS 0x0a | |
| #define NVT_TS_PARAMS_IRQ_TYPE 0x0b | |
| #define NVT_TS_PARAMS_CHIP_ID 0x0e | |
| #define NVT_TS_PARAMS_SIZE 0x0f | |
| #define NVT_TS_MAX_TOUCHES 10 | |
| #define NVT_TS_MAX_SIZE 4096 | |
| #define NVT_TS_TOUCH_INVALID 0xff | |
| #define NVT_TS_TOUCH_SLOT_SHIFT 3 | |
| #define NVT_TS_TOUCH_TYPE_MASK GENMASK(2, 0) | |
| #define NVT_TS_TOUCH_NEW 1 | |
| #define NVT_TS_TOUCH_UPDATE 2 | |
| #define NVT_TS_TOUCH_RELEASE 3 | |
| static const int nvt_ts_irq_type[4] = { | |
| IRQF_TRIGGER_RISING, | |
| IRQF_TRIGGER_FALLING, | |
| IRQF_TRIGGER_LOW, | |
| IRQF_TRIGGER_HIGH | |
| }; | |
| struct nvt_ts_i2c_chip_data { | |
| u8 chip_id; | |
| }; | |
| struct nvt_ts_data { | |
| struct i2c_client *client; | |
| struct input_dev *input; | |
| struct gpio_desc *reset_gpio; | |
| struct regulator_bulk_data regulators[2]; | |
| struct touchscreen_properties prop; | |
| int max_touches; | |
| u8 buf[NVT_TS_TOUCH_SIZE * NVT_TS_MAX_TOUCHES]; | |
| }; | |
| static int nvt_ts_read_data(struct i2c_client *client, u8 reg, u8 *data, int count) | |
| { | |
| struct i2c_msg msg[2] = { | |
| { | |
| .addr = client->addr, | |
| .len = 1, | |
| .buf = ®, | |
| }, | |
| { | |
| .addr = client->addr, | |
| .flags = I2C_M_RD, | |
| .len = count, | |
| .buf = data, | |
| } | |
| }; | |
| int ret; | |
| ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg)); | |
| if (ret != ARRAY_SIZE(msg)) { | |
| dev_err(&client->dev, "Error reading from 0x%02x: %d\n", reg, ret); | |
| return (ret < 0) ? ret : -EIO; | |
| } | |
| return 0; | |
| } | |
| static irqreturn_t nvt_ts_irq(int irq, void *dev_id) | |
| { | |
| struct nvt_ts_data *data = dev_id; | |
| struct device *dev = &data->client->dev; | |
| int i, error, slot, x, y; | |
| bool active; | |
| u8 *touch; | |
| error = nvt_ts_read_data(data->client, NVT_TS_TOUCH_START, data->buf, | |
| data->max_touches * NVT_TS_TOUCH_SIZE); | |
| if (error) | |
| return IRQ_HANDLED; | |
| for (i = 0; i < data->max_touches; i++) { | |
| touch = &data->buf[i * NVT_TS_TOUCH_SIZE]; | |
| if (touch[0] == NVT_TS_TOUCH_INVALID) | |
| continue; | |
| slot = touch[0] >> NVT_TS_TOUCH_SLOT_SHIFT; | |
| if (slot < 1 || slot > data->max_touches) { | |
| dev_warn(dev, "slot %d out of range, ignoring\n", slot); | |
| continue; | |
| } | |
| switch (touch[0] & NVT_TS_TOUCH_TYPE_MASK) { | |
| case NVT_TS_TOUCH_NEW: | |
| case NVT_TS_TOUCH_UPDATE: | |
| active = true; | |
| break; | |
| case NVT_TS_TOUCH_RELEASE: | |
| active = false; | |
| break; | |
| default: | |
| dev_warn(dev, "slot %d unknown state %d\n", slot, touch[0] & 7); | |
| continue; | |
| } | |
| slot--; | |
| x = (touch[1] << 4) | (touch[3] >> 4); | |
| y = (touch[2] << 4) | (touch[3] & 0x0f); | |
| input_mt_slot(data->input, slot); | |
| input_mt_report_slot_state(data->input, MT_TOOL_FINGER, active); | |
| touchscreen_report_pos(data->input, &data->prop, x, y, true); | |
| } | |
| input_mt_sync_frame(data->input); | |
| input_sync(data->input); | |
| return IRQ_HANDLED; | |
| } | |
| static int nvt_ts_start(struct input_dev *dev) | |
| { | |
| struct nvt_ts_data *data = input_get_drvdata(dev); | |
| int error; | |
| error = regulator_bulk_enable(ARRAY_SIZE(data->regulators), data->regulators); | |
| if (error) { | |
| dev_err(&data->client->dev, "failed to enable regulators\n"); | |
| return error; | |
| } | |
| enable_irq(data->client->irq); | |
| gpiod_set_value_cansleep(data->reset_gpio, 0); | |
| return 0; | |
| } | |
| static void nvt_ts_stop(struct input_dev *dev) | |
| { | |
| struct nvt_ts_data *data = input_get_drvdata(dev); | |
| disable_irq(data->client->irq); | |
| gpiod_set_value_cansleep(data->reset_gpio, 1); | |
| regulator_bulk_disable(ARRAY_SIZE(data->regulators), data->regulators); | |
| } | |
| static int nvt_ts_suspend(struct device *dev) | |
| { | |
| struct nvt_ts_data *data = i2c_get_clientdata(to_i2c_client(dev)); | |
| guard(mutex)(&data->input->mutex); | |
| if (input_device_enabled(data->input)) | |
| nvt_ts_stop(data->input); | |
| return 0; | |
| } | |
| static int nvt_ts_resume(struct device *dev) | |
| { | |
| struct nvt_ts_data *data = i2c_get_clientdata(to_i2c_client(dev)); | |
| guard(mutex)(&data->input->mutex); | |
| if (input_device_enabled(data->input)) | |
| nvt_ts_start(data->input); | |
| return 0; | |
| } | |
| static DEFINE_SIMPLE_DEV_PM_OPS(nvt_ts_pm_ops, nvt_ts_suspend, nvt_ts_resume); | |
| static int nvt_ts_probe(struct i2c_client *client) | |
| { | |
| struct device *dev = &client->dev; | |
| int error, width, height, irq_type; | |
| struct nvt_ts_data *data; | |
| const struct nvt_ts_i2c_chip_data *chip; | |
| struct input_dev *input; | |
| if (!client->irq) { | |
| dev_err(dev, "Error no irq specified\n"); | |
| return -EINVAL; | |
| } | |
| data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); | |
| if (!data) | |
| return -ENOMEM; | |
| chip = device_get_match_data(&client->dev); | |
| if (!chip) | |
| return -EINVAL; | |
| data->client = client; | |
| i2c_set_clientdata(client, data); | |
| /* | |
| * VCC is the analog voltage supply | |
| * IOVCC is the digital voltage supply | |
| */ | |
| data->regulators[0].supply = "vcc"; | |
| data->regulators[1].supply = "iovcc"; | |
| error = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->regulators), data->regulators); | |
| if (error) { | |
| dev_err(dev, "cannot get regulators: %d\n", error); | |
| return error; | |
| } | |
| error = regulator_bulk_enable(ARRAY_SIZE(data->regulators), data->regulators); | |
| if (error) { | |
| dev_err(dev, "failed to enable regulators: %d\n", error); | |
| return error; | |
| } | |
| data->reset_gpio = devm_gpiod_get(dev, "reset", GPIOD_OUT_LOW); | |
| error = PTR_ERR_OR_ZERO(data->reset_gpio); | |
| if (error) { | |
| regulator_bulk_disable(ARRAY_SIZE(data->regulators), data->regulators); | |
| dev_err(dev, "failed to request reset GPIO: %d\n", error); | |
| return error; | |
| } | |
| /* Wait for controller to come out of reset before params read */ | |
| msleep(100); | |
| error = nvt_ts_read_data(data->client, NVT_TS_PARAMETERS_START, | |
| data->buf, NVT_TS_PARAMS_SIZE); | |
| gpiod_set_value_cansleep(data->reset_gpio, 1); /* Put back in reset */ | |
| regulator_bulk_disable(ARRAY_SIZE(data->regulators), data->regulators); | |
| if (error) | |
| return error; | |
| width = get_unaligned_be16(&data->buf[NVT_TS_PARAMS_WIDTH]); | |
| height = get_unaligned_be16(&data->buf[NVT_TS_PARAMS_HEIGHT]); | |
| data->max_touches = data->buf[NVT_TS_PARAMS_MAX_TOUCH]; | |
| irq_type = data->buf[NVT_TS_PARAMS_IRQ_TYPE]; | |
| if (width > NVT_TS_MAX_SIZE || height >= NVT_TS_MAX_SIZE || | |
| data->max_touches > NVT_TS_MAX_TOUCHES || | |
| irq_type >= ARRAY_SIZE(nvt_ts_irq_type) || | |
| data->buf[NVT_TS_PARAMS_CHIP_ID] != chip->chip_id) { | |
| dev_err(dev, "Unsupported touchscreen parameters: %*ph\n", | |
| NVT_TS_PARAMS_SIZE, data->buf); | |
| return -EIO; | |
| } | |
| dev_dbg(dev, "Detected %dx%d touchscreen with %d max touches\n", | |
| width, height, data->max_touches); | |
| if (data->buf[NVT_TS_PARAMS_MAX_BUTTONS]) | |
| dev_warn(dev, "Touchscreen buttons are not supported\n"); | |
| input = devm_input_allocate_device(dev); | |
| if (!input) | |
| return -ENOMEM; | |
| input->name = client->name; | |
| input->id.bustype = BUS_I2C; | |
| input->open = nvt_ts_start; | |
| input->close = nvt_ts_stop; | |
| input_set_abs_params(input, ABS_MT_POSITION_X, 0, width - 1, 0, 0); | |
| input_set_abs_params(input, ABS_MT_POSITION_Y, 0, height - 1, 0, 0); | |
| touchscreen_parse_properties(input, true, &data->prop); | |
| error = input_mt_init_slots(input, data->max_touches, | |
| INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); | |
| if (error) | |
| return error; | |
| data->input = input; | |
| input_set_drvdata(input, data); | |
| error = devm_request_threaded_irq(dev, client->irq, NULL, nvt_ts_irq, | |
| IRQF_ONESHOT | IRQF_NO_AUTOEN | | |
| nvt_ts_irq_type[irq_type], | |
| client->name, data); | |
| if (error) { | |
| dev_err(dev, "failed to request irq: %d\n", error); | |
| return error; | |
| } | |
| error = input_register_device(input); | |
| if (error) { | |
| dev_err(dev, "failed to register input device: %d\n", error); | |
| return error; | |
| } | |
| return 0; | |
| } | |
| static const struct nvt_ts_i2c_chip_data nvt_nt11205_ts_data = { | |
| .chip_id = 0x05, | |
| }; | |
| static const struct nvt_ts_i2c_chip_data nvt_nt36672a_ts_data = { | |
| .chip_id = 0x08, | |
| }; | |
| static const struct of_device_id nvt_ts_of_match[] = { | |
| { .compatible = "novatek,nt11205-ts", .data = &nvt_nt11205_ts_data }, | |
| { .compatible = "novatek,nt36672a-ts", .data = &nvt_nt36672a_ts_data }, | |
| { } | |
| }; | |
| MODULE_DEVICE_TABLE(of, nvt_ts_of_match); | |
| static const struct i2c_device_id nvt_ts_i2c_id[] = { | |
| { .name = "nt11205-ts", .driver_data = (unsigned long)&nvt_nt11205_ts_data }, | |
| { .name = "nt36672a-ts", .driver_data = (unsigned long)&nvt_nt36672a_ts_data }, | |
| { } | |
| }; | |
| MODULE_DEVICE_TABLE(i2c, nvt_ts_i2c_id); | |
| static struct i2c_driver nvt_ts_driver = { | |
| .driver = { | |
| .name = "novatek-nvt-ts", | |
| .pm = pm_sleep_ptr(&nvt_ts_pm_ops), | |
| .of_match_table = nvt_ts_of_match, | |
| }, | |
| .probe = nvt_ts_probe, | |
| .id_table = nvt_ts_i2c_id, | |
| }; | |
| module_i2c_driver(nvt_ts_driver); | |
| MODULE_DESCRIPTION("Novatek NT11205 touchscreen driver"); | |
| MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>"); | |
| MODULE_LICENSE("GPL"); |