mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-12 13:55:32 +00:00
![Eugen Hristev](/assets/img/avatar_default.png)
This adds a generic resistive touchscreen (GRTS) driver, which is based on an IIO device (an ADC). It must be connected to the channels of an ADC to receive touch data. Then it will feed the data into the input subsystem where it registers an input device. It uses an IIO callback buffer to register to the IIO device Some parts of this patch are based on initial original work by Mohamed Jamsheeth Hajanajubudeen and Bandaru Venkateswara Swamy Signed-off-by: Eugen Hristev <eugen.hristev@microchip.com> Acked-by: Dmitry Torokhov <dmitry.torokhov@gmail.com> Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
204 lines
5 KiB
C
204 lines
5 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
/*
|
|
* ADC generic resistive touchscreen (GRTS)
|
|
* This is a generic input driver that connects to an ADC
|
|
* given the channels in device tree, and reports events to the input
|
|
* subsystem.
|
|
*
|
|
* Copyright (C) 2017,2018 Microchip Technology,
|
|
* Author: Eugen Hristev <eugen.hristev@microchip.com>
|
|
*
|
|
*/
|
|
#include <linux/input.h>
|
|
#include <linux/input/touchscreen.h>
|
|
#include <linux/iio/consumer.h>
|
|
#include <linux/iio/iio.h>
|
|
#include <linux/module.h>
|
|
#include <linux/of.h>
|
|
#include <linux/of_device.h>
|
|
#include <linux/platform_device.h>
|
|
|
|
#define DRIVER_NAME "resistive-adc-touch"
|
|
#define GRTS_DEFAULT_PRESSURE_MIN 50000
|
|
#define GRTS_MAX_POS_MASK GENMASK(11, 0)
|
|
|
|
/**
|
|
* grts_state - generic resistive touch screen information struct
|
|
* @pressure_min: number representing the minimum for the pressure
|
|
* @pressure: are we getting pressure info or not
|
|
* @iio_chans: list of channels acquired
|
|
* @iio_cb: iio_callback buffer for the data
|
|
* @input: the input device structure that we register
|
|
* @prop: touchscreen properties struct
|
|
*/
|
|
struct grts_state {
|
|
u32 pressure_min;
|
|
bool pressure;
|
|
struct iio_channel *iio_chans;
|
|
struct iio_cb_buffer *iio_cb;
|
|
struct input_dev *input;
|
|
struct touchscreen_properties prop;
|
|
};
|
|
|
|
static int grts_cb(const void *data, void *private)
|
|
{
|
|
const u16 *touch_info = data;
|
|
struct grts_state *st = private;
|
|
unsigned int x, y, press = 0x0;
|
|
|
|
/* channel data coming in buffer in the order below */
|
|
x = touch_info[0];
|
|
y = touch_info[1];
|
|
if (st->pressure)
|
|
press = touch_info[2];
|
|
|
|
if ((!x && !y) || (st->pressure && (press < st->pressure_min))) {
|
|
/* report end of touch */
|
|
input_report_key(st->input, BTN_TOUCH, 0);
|
|
input_sync(st->input);
|
|
return 0;
|
|
}
|
|
|
|
/* report proper touch to subsystem*/
|
|
touchscreen_report_pos(st->input, &st->prop, x, y, false);
|
|
if (st->pressure)
|
|
input_report_abs(st->input, ABS_PRESSURE, press);
|
|
input_report_key(st->input, BTN_TOUCH, 1);
|
|
input_sync(st->input);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int grts_open(struct input_dev *dev)
|
|
{
|
|
int error;
|
|
struct grts_state *st = input_get_drvdata(dev);
|
|
|
|
error = iio_channel_start_all_cb(st->iio_cb);
|
|
if (error) {
|
|
dev_err(dev->dev.parent, "failed to start callback buffer.\n");
|
|
return error;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void grts_close(struct input_dev *dev)
|
|
{
|
|
struct grts_state *st = input_get_drvdata(dev);
|
|
|
|
iio_channel_stop_all_cb(st->iio_cb);
|
|
}
|
|
|
|
static void grts_disable(void *data)
|
|
{
|
|
iio_channel_release_all_cb(data);
|
|
}
|
|
|
|
static int grts_probe(struct platform_device *pdev)
|
|
{
|
|
struct grts_state *st;
|
|
struct input_dev *input;
|
|
struct device *dev = &pdev->dev;
|
|
struct iio_channel *chan;
|
|
int error;
|
|
|
|
st = devm_kzalloc(dev, sizeof(struct grts_state), GFP_KERNEL);
|
|
if (!st)
|
|
return -ENOMEM;
|
|
|
|
/* get the channels from IIO device */
|
|
st->iio_chans = devm_iio_channel_get_all(dev);
|
|
if (IS_ERR(st->iio_chans)) {
|
|
error = PTR_ERR(st->iio_chans);
|
|
if (error != -EPROBE_DEFER)
|
|
dev_err(dev, "can't get iio channels.\n");
|
|
return error;
|
|
}
|
|
|
|
chan = &st->iio_chans[0];
|
|
st->pressure = false;
|
|
while (chan && chan->indio_dev) {
|
|
if (!strcmp(chan->channel->datasheet_name, "pressure"))
|
|
st->pressure = true;
|
|
chan++;
|
|
}
|
|
|
|
if (st->pressure) {
|
|
error = device_property_read_u32(dev,
|
|
"touchscreen-min-pressure",
|
|
&st->pressure_min);
|
|
if (error) {
|
|
dev_dbg(dev, "can't get touchscreen-min-pressure property.\n");
|
|
st->pressure_min = GRTS_DEFAULT_PRESSURE_MIN;
|
|
}
|
|
}
|
|
|
|
input = devm_input_allocate_device(dev);
|
|
if (!input) {
|
|
dev_err(dev, "failed to allocate input device.\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
input->name = DRIVER_NAME;
|
|
input->id.bustype = BUS_HOST;
|
|
input->open = grts_open;
|
|
input->close = grts_close;
|
|
|
|
input_set_abs_params(input, ABS_X, 0, GRTS_MAX_POS_MASK - 1, 0, 0);
|
|
input_set_abs_params(input, ABS_Y, 0, GRTS_MAX_POS_MASK - 1, 0, 0);
|
|
if (st->pressure)
|
|
input_set_abs_params(input, ABS_PRESSURE, st->pressure_min,
|
|
0xffff, 0, 0);
|
|
|
|
input_set_capability(input, EV_KEY, BTN_TOUCH);
|
|
|
|
/* parse optional device tree properties */
|
|
touchscreen_parse_properties(input, false, &st->prop);
|
|
|
|
st->input = input;
|
|
input_set_drvdata(input, st);
|
|
|
|
error = input_register_device(input);
|
|
if (error) {
|
|
dev_err(dev, "failed to register input device.");
|
|
return error;
|
|
}
|
|
|
|
st->iio_cb = iio_channel_get_all_cb(dev, grts_cb, st);
|
|
if (IS_ERR(st->iio_cb)) {
|
|
dev_err(dev, "failed to allocate callback buffer.\n");
|
|
return PTR_ERR(st->iio_cb);
|
|
}
|
|
|
|
error = devm_add_action_or_reset(dev, grts_disable, st->iio_cb);
|
|
if (error) {
|
|
dev_err(dev, "failed to add disable action.\n");
|
|
return error;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static const struct of_device_id grts_of_match[] = {
|
|
{
|
|
.compatible = "resistive-adc-touch",
|
|
}, {
|
|
/* sentinel */
|
|
},
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, grts_of_match);
|
|
|
|
static struct platform_driver grts_driver = {
|
|
.probe = grts_probe,
|
|
.driver = {
|
|
.name = DRIVER_NAME,
|
|
.of_match_table = of_match_ptr(grts_of_match),
|
|
},
|
|
};
|
|
|
|
module_platform_driver(grts_driver);
|
|
|
|
MODULE_AUTHOR("Eugen Hristev <eugen.hristev@microchip.com>");
|
|
MODULE_DESCRIPTION("Generic ADC Resistive Touch Driver");
|
|
MODULE_LICENSE("GPL v2");
|