/* * Driver for Pixcir I2C touchscreen controllers. * * Copyright (C) 2010-2011 Pixcir, Inc. * * This software is licensed under the terms of the GNU General Public * License version 2, as published by the Free Software Foundation, and * may be copied, distributed, and modified under those terms. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. */ #include <linux/delay.h> #include <linux/module.h> #include <linux/interrupt.h> #include <linux/slab.h> #include <linux/i2c.h> #include <linux/input.h> #include <linux/input/mt.h> #include <linux/input/touchscreen.h> #include <linux/gpio.h> #include <linux/gpio/consumer.h> #include <linux/of_device.h> #include <linux/platform_data/pixcir_i2c_ts.h> #include <asm/unaligned.h> #define PIXCIR_MAX_SLOTS 5 /* Max fingers supported by driver */ struct pixcir_i2c_ts_data { struct i2c_client *client; struct input_dev *input; struct gpio_desc *gpio_attb; struct gpio_desc *gpio_reset; struct gpio_desc *gpio_enable; struct gpio_desc *gpio_wake; const struct pixcir_i2c_chip_data *chip; struct touchscreen_properties prop; int max_fingers; /* Max fingers supported in this instance */ bool running; }; struct pixcir_report_data { int num_touches; struct input_mt_pos pos[PIXCIR_MAX_SLOTS]; int ids[PIXCIR_MAX_SLOTS]; }; static void pixcir_ts_parse(struct pixcir_i2c_ts_data *tsdata, struct pixcir_report_data *report) { u8 rdbuf[2 + PIXCIR_MAX_SLOTS * 5]; u8 wrbuf[1] = { 0 }; u8 *bufptr; u8 touch; int ret, i; int readsize; const struct pixcir_i2c_chip_data *chip = tsdata->chip; memset(report, 0, sizeof(struct pixcir_report_data)); i = chip->has_hw_ids ? 1 : 0; readsize = 2 + tsdata->max_fingers * (4 + i); if (readsize > sizeof(rdbuf)) readsize = sizeof(rdbuf); ret = i2c_master_send(tsdata->client, wrbuf, sizeof(wrbuf)); if (ret != sizeof(wrbuf)) { dev_err(&tsdata->client->dev, "%s: i2c_master_send failed(), ret=%d\n", __func__, ret); return; } ret = i2c_master_recv(tsdata->client, rdbuf, readsize); if (ret != readsize) { dev_err(&tsdata->client->dev, "%s: i2c_master_recv failed(), ret=%d\n", __func__, ret); return; } touch = rdbuf[0] & 0x7; if (touch > tsdata->max_fingers) touch = tsdata->max_fingers; report->num_touches = touch; bufptr = &rdbuf[2]; for (i = 0; i < touch; i++) { touchscreen_set_mt_pos(&report->pos[i], &tsdata->prop, get_unaligned_le16(bufptr), get_unaligned_le16(bufptr + 2)); if (chip->has_hw_ids) { report->ids[i] = bufptr[4]; bufptr = bufptr + 5; } else { bufptr = bufptr + 4; } } } static void pixcir_ts_report(struct pixcir_i2c_ts_data *ts, struct pixcir_report_data *report) { int slots[PIXCIR_MAX_SLOTS]; int n, i, slot; struct device *dev = &ts->client->dev; const struct pixcir_i2c_chip_data *chip = ts->chip; n = report->num_touches; if (n > PIXCIR_MAX_SLOTS) n = PIXCIR_MAX_SLOTS; if (!ts->chip->has_hw_ids) input_mt_assign_slots(ts->input, slots, report->pos, n, 0); for (i = 0; i < n; i++) { if (chip->has_hw_ids) { slot = input_mt_get_slot_by_key(ts->input, report->ids[i]); if (slot < 0) { dev_dbg(dev, "no free slot for id 0x%x\n", report->ids[i]); continue; } } else { slot = slots[i]; } input_mt_slot(ts->input, slot); input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true); input_report_abs(ts->input, ABS_MT_POSITION_X, report->pos[i].x); input_report_abs(ts->input, ABS_MT_POSITION_Y, report->pos[i].y); dev_dbg(dev, "%d: slot %d, x %d, y %d\n", i, slot, report->pos[i].x, report->pos[i].y); } input_mt_sync_frame(ts->input); input_sync(ts->input); } static irqreturn_t pixcir_ts_isr(int irq, void *dev_id) { struct pixcir_i2c_ts_data *tsdata = dev_id; struct pixcir_report_data report; while (tsdata->running) { /* parse packet */ pixcir_ts_parse(tsdata, &report); /* report it */ pixcir_ts_report(tsdata, &report); if (gpiod_get_value_cansleep(tsdata->gpio_attb)) { if (report.num_touches) { /* * Last report with no finger up? * Do it now then. */ input_mt_sync_frame(tsdata->input); input_sync(tsdata->input); } break; } msleep(20); } return IRQ_HANDLED; } static void pixcir_reset(struct pixcir_i2c_ts_data *tsdata) { if (!IS_ERR_OR_NULL(tsdata->gpio_reset)) { gpiod_set_value_cansleep(tsdata->gpio_reset, 1); ndelay(100); /* datasheet section 1.2.3 says 80ns min. */ gpiod_set_value_cansleep(tsdata->gpio_reset, 0); /* wait for controller ready. 100ms guess. */ msleep(100); } } static int pixcir_set_power_mode(struct pixcir_i2c_ts_data *ts, enum pixcir_power_mode mode) { struct device *dev = &ts->client->dev; int ret; if (mode == PIXCIR_POWER_ACTIVE || mode == PIXCIR_POWER_IDLE) { if (ts->gpio_wake) gpiod_set_value_cansleep(ts->gpio_wake, 1); } ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_POWER_MODE); if (ret < 0) { dev_err(dev, "%s: can't read reg 0x%x : %d\n", __func__, PIXCIR_REG_POWER_MODE, ret); return ret; } ret &= ~PIXCIR_POWER_MODE_MASK; ret |= mode; /* Always AUTO_IDLE */ ret |= PIXCIR_POWER_ALLOW_IDLE; ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_POWER_MODE, ret); if (ret < 0) { dev_err(dev, "%s: can't write reg 0x%x : %d\n", __func__, PIXCIR_REG_POWER_MODE, ret); return ret; } if (mode == PIXCIR_POWER_HALT) { if (ts->gpio_wake) gpiod_set_value_cansleep(ts->gpio_wake, 0); } return 0; } /* * Set the interrupt mode for the device i.e. ATTB line behaviour * * @polarity : 1 for active high, 0 for active low. */ static int pixcir_set_int_mode(struct pixcir_i2c_ts_data *ts, enum pixcir_int_mode mode, bool polarity) { struct device *dev = &ts->client->dev; int ret; ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_INT_MODE); if (ret < 0) { dev_err(dev, "%s: can't read reg 0x%x : %d\n", __func__, PIXCIR_REG_INT_MODE, ret); return ret; } ret &= ~PIXCIR_INT_MODE_MASK; ret |= mode; if (polarity) ret |= PIXCIR_INT_POL_HIGH; else ret &= ~PIXCIR_INT_POL_HIGH; ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_INT_MODE, ret); if (ret < 0) { dev_err(dev, "%s: can't write reg 0x%x : %d\n", __func__, PIXCIR_REG_INT_MODE, ret); return ret; } return 0; } /* * Enable/disable interrupt generation */ static int pixcir_int_enable(struct pixcir_i2c_ts_data *ts, bool enable) { struct device *dev = &ts->client->dev; int ret; ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_INT_MODE); if (ret < 0) { dev_err(dev, "%s: can't read reg 0x%x : %d\n", __func__, PIXCIR_REG_INT_MODE, ret); return ret; } if (enable) ret |= PIXCIR_INT_ENABLE; else ret &= ~PIXCIR_INT_ENABLE; ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_INT_MODE, ret); if (ret < 0) { dev_err(dev, "%s: can't write reg 0x%x : %d\n", __func__, PIXCIR_REG_INT_MODE, ret); return ret; } return 0; } static int pixcir_start(struct pixcir_i2c_ts_data *ts) { struct device *dev = &ts->client->dev; int error; if (ts->gpio_enable) { gpiod_set_value_cansleep(ts->gpio_enable, 1); msleep(100); } /* LEVEL_TOUCH interrupt with active low polarity */ error = pixcir_set_int_mode(ts, PIXCIR_INT_LEVEL_TOUCH, 0); if (error) { dev_err(dev, "Failed to set interrupt mode: %d\n", error); return error; } ts->running = true; mb(); /* Update status before IRQ can fire */ /* enable interrupt generation */ error = pixcir_int_enable(ts, true); if (error) { dev_err(dev, "Failed to enable interrupt generation: %d\n", error); return error; } return 0; } static int pixcir_stop(struct pixcir_i2c_ts_data *ts) { int error; /* Disable interrupt generation */ error = pixcir_int_enable(ts, false); if (error) { dev_err(&ts->client->dev, "Failed to disable interrupt generation: %d\n", error); return error; } /* Exit ISR if running, no more report parsing */ ts->running = false; mb(); /* update status before we synchronize irq */ /* Wait till running ISR is complete */ synchronize_irq(ts->client->irq); if (ts->gpio_enable) gpiod_set_value_cansleep(ts->gpio_enable, 0); return 0; } static int pixcir_input_open(struct input_dev *dev) { struct pixcir_i2c_ts_data *ts = input_get_drvdata(dev); return pixcir_start(ts); } static void pixcir_input_close(struct input_dev *dev) { struct pixcir_i2c_ts_data *ts = input_get_drvdata(dev); pixcir_stop(ts); } static int __maybe_unused pixcir_i2c_ts_suspend(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct pixcir_i2c_ts_data *ts = i2c_get_clientdata(client); struct input_dev *input = ts->input; int ret = 0; mutex_lock(&input->mutex); if (device_may_wakeup(&client->dev)) { if (!input->users) { ret = pixcir_start(ts); if (ret) { dev_err(dev, "Failed to start\n"); goto unlock; } } } else if (input->users) { ret = pixcir_stop(ts); } unlock: mutex_unlock(&input->mutex); return ret; } static int __maybe_unused pixcir_i2c_ts_resume(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct pixcir_i2c_ts_data *ts = i2c_get_clientdata(client); struct input_dev *input = ts->input; int ret = 0; mutex_lock(&input->mutex); if (device_may_wakeup(&client->dev)) { if (!input->users) { ret = pixcir_stop(ts); if (ret) { dev_err(dev, "Failed to stop\n"); goto unlock; } } } else if (input->users) { ret = pixcir_start(ts); } unlock: mutex_unlock(&input->mutex); return ret; } static SIMPLE_DEV_PM_OPS(pixcir_dev_pm_ops, pixcir_i2c_ts_suspend, pixcir_i2c_ts_resume); #ifdef CONFIG_OF static const struct of_device_id pixcir_of_match[]; static int pixcir_parse_dt(struct device *dev, struct pixcir_i2c_ts_data *tsdata) { tsdata->chip = of_device_get_match_data(dev); if (!tsdata->chip) return -EINVAL; return 0; } #else static int pixcir_parse_dt(struct device *dev, struct pixcir_i2c_ts_data *tsdata) { return -EINVAL; } #endif static int pixcir_i2c_ts_probe(struct i2c_client *client, const struct i2c_device_id *id) { const struct pixcir_ts_platform_data *pdata = dev_get_platdata(&client->dev); struct device *dev = &client->dev; struct pixcir_i2c_ts_data *tsdata; struct input_dev *input; int error; tsdata = devm_kzalloc(dev, sizeof(*tsdata), GFP_KERNEL); if (!tsdata) return -ENOMEM; if (pdata) { tsdata->chip = &pdata->chip; } else if (dev->of_node) { error = pixcir_parse_dt(dev, tsdata); if (error) return error; } else { dev_err(dev, "platform data not defined\n"); return -EINVAL; } if (!tsdata->chip->max_fingers) { dev_err(dev, "Invalid max_fingers in chip data\n"); return -EINVAL; } input = devm_input_allocate_device(dev); if (!input) { dev_err(dev, "Failed to allocate input device\n"); return -ENOMEM; } tsdata->client = client; tsdata->input = input; input->name = client->name; input->id.bustype = BUS_I2C; input->open = pixcir_input_open; input->close = pixcir_input_close; input->dev.parent = dev; if (pdata) { input_set_abs_params(input, ABS_MT_POSITION_X, 0, pdata->x_max, 0, 0); input_set_abs_params(input, ABS_MT_POSITION_Y, 0, pdata->y_max, 0, 0); } else { input_set_capability(input, EV_ABS, ABS_MT_POSITION_X); input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y); touchscreen_parse_properties(input, true, &tsdata->prop); if (!input_abs_get_max(input, ABS_MT_POSITION_X) || !input_abs_get_max(input, ABS_MT_POSITION_Y)) { dev_err(dev, "Touchscreen size is not specified\n"); return -EINVAL; } } tsdata->max_fingers = tsdata->chip->max_fingers; if (tsdata->max_fingers > PIXCIR_MAX_SLOTS) { tsdata->max_fingers = PIXCIR_MAX_SLOTS; dev_info(dev, "Limiting maximum fingers to %d\n", tsdata->max_fingers); } error = input_mt_init_slots(input, tsdata->max_fingers, INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); if (error) { dev_err(dev, "Error initializing Multi-Touch slots\n"); return error; } input_set_drvdata(input, tsdata); tsdata->gpio_attb = devm_gpiod_get(dev, "attb", GPIOD_IN); if (IS_ERR(tsdata->gpio_attb)) { error = PTR_ERR(tsdata->gpio_attb); dev_err(dev, "Failed to request ATTB gpio: %d\n", error); return error; } tsdata->gpio_reset = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW); if (IS_ERR(tsdata->gpio_reset)) { error = PTR_ERR(tsdata->gpio_reset); dev_err(dev, "Failed to request RESET gpio: %d\n", error); return error; } tsdata->gpio_wake = devm_gpiod_get_optional(dev, "wake", GPIOD_OUT_HIGH); if (IS_ERR(tsdata->gpio_wake)) { error = PTR_ERR(tsdata->gpio_wake); if (error != -EPROBE_DEFER) dev_err(dev, "Failed to get wake gpio: %d\n", error); return error; } tsdata->gpio_enable = devm_gpiod_get_optional(dev, "enable", GPIOD_OUT_HIGH); if (IS_ERR(tsdata->gpio_enable)) { error = PTR_ERR(tsdata->gpio_enable); if (error != -EPROBE_DEFER) dev_err(dev, "Failed to get enable gpio: %d\n", error); return error; } if (tsdata->gpio_enable) msleep(100); error = devm_request_threaded_irq(dev, client->irq, NULL, pixcir_ts_isr, IRQF_TRIGGER_FALLING | IRQF_ONESHOT, client->name, tsdata); if (error) { dev_err(dev, "failed to request irq %d\n", client->irq); return error; } pixcir_reset(tsdata); /* Always be in IDLE mode to save power, device supports auto wake */ error = pixcir_set_power_mode(tsdata, PIXCIR_POWER_IDLE); if (error) { dev_err(dev, "Failed to set IDLE mode\n"); return error; } /* Stop device till opened */ error = pixcir_stop(tsdata); if (error) return error; error = input_register_device(input); if (error) return error; i2c_set_clientdata(client, tsdata); return 0; } static const struct i2c_device_id pixcir_i2c_ts_id[] = { { "pixcir_ts", 0 }, { "pixcir_tangoc", 0 }, { } }; MODULE_DEVICE_TABLE(i2c, pixcir_i2c_ts_id); #ifdef CONFIG_OF static const struct pixcir_i2c_chip_data pixcir_ts_data = { .max_fingers = 2, /* no hw id support */ }; static const struct pixcir_i2c_chip_data pixcir_tangoc_data = { .max_fingers = 5, .has_hw_ids = true, }; static const struct of_device_id pixcir_of_match[] = { { .compatible = "pixcir,pixcir_ts", .data = &pixcir_ts_data }, { .compatible = "pixcir,pixcir_tangoc", .data = &pixcir_tangoc_data }, { } }; MODULE_DEVICE_TABLE(of, pixcir_of_match); #endif static struct i2c_driver pixcir_i2c_ts_driver = { .driver = { .name = "pixcir_ts", .pm = &pixcir_dev_pm_ops, .of_match_table = of_match_ptr(pixcir_of_match), }, .probe = pixcir_i2c_ts_probe, .id_table = pixcir_i2c_ts_id, }; module_i2c_driver(pixcir_i2c_ts_driver); MODULE_AUTHOR("Jianchun Bian <jcbian@pixcir.com.cn>, Dequan Meng <dqmeng@pixcir.com.cn>"); MODULE_DESCRIPTION("Pixcir I2C Touchscreen Driver"); MODULE_LICENSE("GPL");