forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
204 lines
5.0 KiB
204 lines
5.0 KiB
// 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 <[email protected]> |
|
* |
|
*/ |
|
#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) |
|
|
|
/** |
|
* struct 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 <[email protected]>"); |
|
MODULE_DESCRIPTION("Generic ADC Resistive Touch Driver"); |
|
MODULE_LICENSE("GPL v2");
|
|
|