Re: [PATCH v1 3/4] touchscreen: colibri-vf50-ts: Add touchscreen support for Colibri VF50

[Stefan Agner]

Hi Sanchayan,

I wrote the driver some while ago, so reading it today again feels like
reading someone else's code again :-)

Some minor nits below:

On 2015-06-30 08:54, Sanchayan Maity wrote:
> The Colibri Vybrid VF50 module supports 4-wire touchscreens using
> FETs and ADC inputs. This driver uses the IIO consumer interface
> and relies on the vf610_adc driver based on the IIO framework.
> 
> Signed-off-by: Sanchayan Maity <maitysanchayan@xxxxxxxxx>
> ---
>  drivers/input/touchscreen/Kconfig           |  12 +
>  drivers/input/touchscreen/Makefile          |   1 +
>  drivers/input/touchscreen/colibri-vf50-ts.c | 466 ++++++++++++++++++++++++++++
>  3 files changed, 479 insertions(+)
>  create mode 100644 drivers/input/touchscreen/colibri-vf50-ts.c
> 
> diff --git a/drivers/input/touchscreen/Kconfig
> b/drivers/input/touchscreen/Kconfig
> index 80f6386..c243914 100644
> --- a/drivers/input/touchscreen/Kconfig
> +++ b/drivers/input/touchscreen/Kconfig
> @@ -1027,4 +1027,16 @@ config TOUCHSCREEN_ZFORCE
>  	  To compile this driver as a module, choose M here: the
>  	  module will be called zforce_ts.
>  
> +config TOUCHSCREEN_COLIBRI_VF50
> +	tristate "Toradex Colibri on board touchscreen driver"
> +	depends on IIO && VF610_ADC

Since we use GPIO's this also depends on GPIOLIB

> +	help
> +	  Say Y here if you have a Colibri VF50 and plan to use
> +	  the on-board provided 4-wire touchscreen driver.
> +
> +	  If unsure, say N.
> +
> +	  To compile this driver as a module, choose M here: the
> +	  module will be called colibri_vf50_ts.
> +
<snip>
> +
> +	/* Use hrtimer sleep since msleep sleeps 10ms+ */

This comment is probably somewhat outdated. Depending on kernel
configuration probably wrong too. Just drop it.

> +	usleep_range(COLI_TOUCH_MIN_DELAY_US, COLI_TOUCH_MAX_DELAY_US);
> +
> +	for (i = 0; i < 5; i++) {
> +		ret = iio_read_channel_raw(channel, &val);
> +		if (ret < 0)
> +			return -EINVAL;
> +
> +		value += val;
> +	}
> +
> +	value /= 5;
> +
> +	gpiod_set_value(plate_p, 0);
> +	gpiod_set_value(plate_m, 0);
> +
> +	return value;
> +}
> +
> +/*
> + * Enable touch detection using falling edge detection on XM
> + */
> +static void vf50_ts_enable_touch_detection(struct vf50_touch_device *vf50_ts)
> +{
> +	/* Enable plate YM (needs to be strong GND, high active) */
> +	gpiod_set_value(vf50_ts->gpio_ym, 1);
> +
> +	/* Let the platform mux to GPIO in order to enable Pull-Up on GPIO */

The comment is somewhat configuing, since you use the pinctrl framework
to mux to the state "idle" I would write "Let the platform mux to
idle..."

> +	pinctrl_pm_select_idle_state(&vf50_ts->pdev->dev);
> +}
> +
> +/*
> + * ADC touch screen sampling worker function
> + */
> +static void vf50_ts_work(struct work_struct *ts_work)
> +{
> +	struct vf50_touch_device *vf50_ts = container_of(ts_work,
> +				struct vf50_touch_device, ts_work);
> +	struct device *dev = &vf50_ts->pdev->dev;
> +	int val_x, val_y, val_z1, val_z2, val_p = 0;
> +	bool discard_val_on_start = true;
> +
> +	while (!vf50_ts->stop_touchscreen) {
> +		/* X-Direction */
> +		val_x = adc_ts_measure(&vf50_ts->channels[0],
> +				vf50_ts->gpio_xp, vf50_ts->gpio_xm);
> +		if (val_x < 0)
> +			continue;
> +
> +		/* Y-Direction */
> +		val_y = adc_ts_measure(&vf50_ts->channels[1],
> +				vf50_ts->gpio_yp, vf50_ts->gpio_ym);
> +		if (val_y < 0)
> +			continue;
> +
> +		/*
> +		 * Touch pressure
> +		 * Measure on XP/YM
> +		 */
> +		val_z1 = adc_ts_measure(&vf50_ts->channels[2],
> +				vf50_ts->gpio_yp, vf50_ts->gpio_xm);
> +		if (val_z1 < 0)
> +			continue;
> +		val_z2 = adc_ts_measure(&vf50_ts->channels[3],
> +				vf50_ts->gpio_yp, vf50_ts->gpio_xm);
> +		if (val_z2 < 0)
> +			continue;
> +
> +		/*
> +		 * According to datasheet of our touchscreen,
> +		 * resistance on X axis is 400~1200..
> +		 */

This is somewhat vague and not really helpful, either mention the type
(I think it was an EDT) or drop that...

> +
> +		/* Validate signal (avoid calculation using noise) */
> +		if (val_z1 > 64 && val_x > 64) {
> +			/*
> +			 * Calculate resistance between the plates
> +			 * lower resistance means higher pressure
> +			 */
> +			int r_x = (1000 * val_x) / VF_ADC_MAX;
> +
> +			val_p = (r_x * val_z2) / val_z1 - r_x;
> +
> +		} else {
> +			val_p = 2000;
> +		}
> +
> +		val_p = 2000 - val_p;
> +		dev_dbg(dev, "Measured values: x: %d, y: %d, z1: %d, z2: %d, "
> +			"p: %d\n", val_x, val_y, val_z1, val_z2, val_p);
> +
> +		/*
> +		 * If touch pressure is too low, stop measuring and reenable
> +		 * touch detection
> +		 */
> +		if (val_p < min_pressure || val_p > 2000)
> +			break;
> +
> +		/*
> +		 * The pressure may not be enough for the first x and the
> +		 * second y measurement, but, the pressure is ok when the
> +		 * driver is doing the third and fourth measurement. To
> +		 * take care of this, we drop the first measurement always.
> +		 */
> +		if (discard_val_on_start) {
> +			discard_val_on_start = false;
> +		} else {
> +			/*
> +			 * Report touch position and sleep for
> +			 * next measurement
> +			 */
> +			input_report_abs(vf50_ts->ts_input,
> +					ABS_X, VF_ADC_MAX - val_x);
> +			input_report_abs(vf50_ts->ts_input,
> +					ABS_Y, VF_ADC_MAX - val_y);
> +			input_report_abs(vf50_ts->ts_input,
> +					ABS_PRESSURE, val_p);
> +			input_report_key(vf50_ts->ts_input, BTN_TOUCH, 1);
> +			input_sync(vf50_ts->ts_input);
> +		}
> +
> +		msleep(10);
> +	}
> +
> +	/* Report no more touch, reenable touch detection */
> +	input_report_abs(vf50_ts->ts_input, ABS_PRESSURE, 0);
> +	input_report_key(vf50_ts->ts_input, BTN_TOUCH, 0);
> +	input_sync(vf50_ts->ts_input);
> +
> +	/* Wait the pull-up to be stable on high */
> +	vf50_ts_enable_touch_detection(vf50_ts);

I would move that comment one line lower, since that is the place we
wait until the pin is high.

> +	msleep(10);
> +
> +	/* Reenable IRQ to detect touch */
> +	enable_irq(vf50_ts->pen_irq);
> +
> +	dev_dbg(dev, "Reenabled touch detection interrupt\n");
> +}
> +
> +static irqreturn_t vf50_tc_touched(int irq, void *dev_id)

tc?

> +{
> +	struct vf50_touch_device *vf50_ts = (struct vf50_touch_device *)dev_id;
> +	struct device *dev = &vf50_ts->pdev->dev;
> +
> +	dev_dbg(dev, "Touch detected, start worker thread\n");
> +
> +	/* Stop IRQ */

Some comments like this...

> +	disable_irq_nosync(irq);
> +
> +	/* Disable the touch detection plates */
> +	gpiod_set_value(vf50_ts->gpio_ym, 0);
> +
> +	/* Let the platform mux to GPIO in order to enable Pull-Up on GPIO */
> +	pinctrl_pm_select_default_state(dev);
> +
> +	/* Start worker thread */

or this are not really required since the function name called is
actually verbose enough.

> +	queue_work(vf50_ts->ts_workqueue, &vf50_ts->ts_work);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int vf50_ts_open(struct input_dev *dev_input)
> +{
> +	int ret;
> +	struct vf50_touch_device *touchdev = input_get_drvdata(dev_input);
> +	struct device *dev = &touchdev->pdev->dev;
> +
> +	dev_dbg(dev, "Input device %s opened, starting touch detection\n",
> +			dev_input->name);
> +
> +	touchdev->stop_touchscreen = false;
> +
> +	ret = gpiod_direction_output(touchdev->gpio_xp, 0);
> +	if (ret) {
> +		dev_err(dev, "Could not set gpio xp as output %d\n", ret);
> +		return ret;
> +	}
> +
> +	ret = gpiod_direction_output(touchdev->gpio_xm, 0);
> +	if (ret) {
> +		dev_err(dev, "Could not set gpio xm as output %d\n", ret);
> +		return ret;
> +	}
> +
> +	ret = gpiod_direction_output(touchdev->gpio_yp, 0);
> +	if (ret) {
> +		dev_err(dev, "Could not set gpio yp as output %d\n", ret);
> +		return ret;
> +	}
> +
> +	ret = gpiod_direction_output(touchdev->gpio_ym, 0);
> +	if (ret) {
> +		dev_err(dev, "Could not set gpio ym as output %d\n", ret);
> +		return ret;
> +	}
> +
> +	ret = gpiod_direction_input(touchdev->gpio_pen_detect);
> +	if (ret) {
> +		dev_err(dev,
> +			"Could not set gpio pen detect as input %d\n", ret);
> +		return ret;
> +	}
> +
> +	ret = gpiod_direction_input(touchdev->gpio_pen_detect_pullup);
> +	if (ret) {
> +		dev_err(dev,
> +			"Could not set pen detect pullup as input %d\n", ret);
> +		return ret;
> +	}
> +
> +	/* Mux detection before request IRQ, wait for pull-up to settle */
> +	vf50_ts_enable_touch_detection(touchdev);
> +	msleep(10);
> +
> +	touchdev->pen_irq = gpiod_to_irq(touchdev->gpio_pen_detect);
> +	if (touchdev->pen_irq < 0) {
> +		dev_err(dev, "Unable to get IRQ for GPIO\n");
> +		return touchdev->pen_irq;
> +	}
> +
> +	ret = request_irq(touchdev->pen_irq, vf50_tc_touched,
> +			IRQF_TRIGGER_FALLING, "touch detected", touchdev);
> +	if (ret < 0) {
> +		dev_err(dev, "Unable to request IRQ %d\n", touchdev->pen_irq);
> +		return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +static void vf50_ts_close(struct input_dev *dev_input)
> +{
> +	struct vf50_touch_device *touchdev = input_get_drvdata(dev_input);
> +	struct device *dev = &touchdev->pdev->dev;
> +
> +	free_irq(touchdev->pen_irq, touchdev);
> +
> +	touchdev->stop_touchscreen = true;
> +
> +	/* Wait until touchscreen thread finishes any possible remnants. */
> +	cancel_work_sync(&touchdev->ts_work);
> +
> +	dev_dbg(dev, "Input device %s closed, disable touch detection\n",
> +		dev_input->name);
> +}
> +
> +static int vf50_ts_probe(struct platform_device *pdev)
> +{
> +	int ret = 0;
> +	struct device *dev = &pdev->dev;
> +	struct device_node *node = dev->of_node;
> +	struct vf50_touch_device *touchdev;
> +	struct input_dev *input;
> +	struct iio_channel *channels;
> +
> +	if (!node) {
> +		dev_err(dev, "Device does not have associated DT data\n");
> +		return -EINVAL;
> +	}
> +
> +	channels = iio_channel_get_all(dev);
> +	if (IS_ERR(channels))
> +		return PTR_ERR(channels);
> +
> +	touchdev = devm_kzalloc(dev, sizeof(*touchdev), GFP_KERNEL);
> +	if (touchdev == NULL) {
> +		ret = -ENOMEM;
> +		goto error_release_channels;
> +	}
> +
> +	input = devm_input_allocate_device(dev);
> +	if (!input) {
> +		dev_err(dev, "Failed to allocate TS input device\n");
> +		ret = -ENOMEM;
> +		goto error_release_channels;
> +	}
> +
> +	platform_set_drvdata(pdev, touchdev);
> +
> +	touchdev->pdev = pdev;
> +	touchdev->channels = channels;
> +
> +	input->name = DRIVER_NAME;
> +	input->id.bustype = BUS_HOST;
> +	input->dev.parent = dev;
> +	input->open = vf50_ts_open;
> +	input->close = vf50_ts_close;
> +
> +	_set_bit(EV_ABS, input->evbit);
> +	_set_bit(EV_KEY, input->evbit);
> +	_set_bit(BTN_TOUCH, input->keybit);
> +	input_set_abs_params(input, ABS_X, 0, VF_ADC_MAX, 0, 0);
> +	input_set_abs_params(input, ABS_Y, 0, VF_ADC_MAX, 0, 0);
> +	input_set_abs_params(input, ABS_PRESSURE, 0, VF_ADC_MAX, 0, 0);
> +
> +	touchdev->ts_input = input;
> +	input_set_drvdata(input, touchdev);
> +	ret = input_register_device(input);
> +	if (ret) {
> +		dev_err(dev, "Failed to register input device\n");
> +		goto error_release_channels;
> +	}
> +
> +	touchdev->gpio_xp = devm_gpiod_get(dev, "xp");
> +	if (IS_ERR(touchdev->gpio_xp)) {
> +		ret = PTR_ERR(touchdev->gpio_xp);
> +		dev_err(dev, "Could not get gpio_xp %d\n", ret);
> +		goto error_release_channels;
> +	}
> +
> +	touchdev->gpio_xm = devm_gpiod_get(dev, "xm");
> +	if (IS_ERR(touchdev->gpio_xm)) {
> +		ret = PTR_ERR(touchdev->gpio_xm);
> +		dev_err(dev, "Could not get gpio_xm %d\n", ret);
> +		goto error_release_channels;
> +	}
> +
> +	touchdev->gpio_yp = devm_gpiod_get(dev, "yp");
> +	if (IS_ERR(touchdev->gpio_yp)) {
> +		ret = PTR_ERR(touchdev->gpio_yp);
> +		dev_err(dev, "Could not get gpio_yp %d\n", ret);
> +		goto error_release_channels;
> +	}
> +
> +	touchdev->gpio_ym = devm_gpiod_get(dev, "ym");
> +	if (IS_ERR(touchdev->gpio_ym)) {
> +		ret = PTR_ERR(touchdev->gpio_ym);
> +		dev_err(dev, "Could not get gpio_ym %d\n", ret);
> +		goto error_release_channels;
> +	}
> +
> +	touchdev->gpio_pen_detect = devm_gpiod_get(dev, "pen-detect");
> +	if (IS_ERR(touchdev->gpio_pen_detect)) {
> +		ret = PTR_ERR(touchdev->gpio_pen_detect);
> +		dev_err(dev, "Could not get gpio_pen_detect %d\n", ret);
> +		goto error_release_channels;
> +	}
> +
> +	touchdev->gpio_pen_detect_pullup = devm_gpiod_get(dev, "pen-pullup");
> +	if (IS_ERR(touchdev->gpio_pen_detect_pullup)) {
> +		ret = PTR_ERR(touchdev->gpio_pen_detect_pullup);
> +		dev_err(dev, "Could not get gpio_pen_detect_pullup %d\n", ret);
> +		goto error_release_channels;
> +	}

Quite some repetition here. Maybe a inline function vf50_ts_get_gpio?

static inline int vf50_ts_get_gpio(...)
{
...
		dev_err(dev, "Could not get gpio-%s: %d\n", gpio, ret);
...
}


if (ret = vf50_ts_get_gpio(&touchdev->gpio_pen_detect_pullup,
"pen-pullup")
	goto error_release_channels;

This would also save some message strings and we can reuse the GPIO name
string.

I think it should also be possible to move the channel initialization
below the GPIO's, hence saving the goto...

We could do something similar above in the open function, although its
not that huge of a deal there. But when we do here, I would probably do
it above to, just for the sake of consistency.

> +
> +	/* Create workqueue for ADC sampling and calculation */
> +	INIT_WORK(&touchdev->ts_work, vf50_ts_work);
> +	touchdev->ts_workqueue = create_singlethread_workqueue("vf50-ts-touch");
> +
> +	if (!touchdev->ts_workqueue) {
> +		ret = PTR_ERR(touchdev->ts_workqueue);
> +		dev_err(dev,
> +			"Failed creating vf50-ts-touch workqueue %d\n", ret);
> +		goto error_release_channels;
> +	}
> +
> +	dev_info(dev, "Attached colibri-vf50-ts driver successfully\n");
> +
> +	return 0;
> +
> +error_release_channels:
> +	iio_channel_release_all(channels);
> +	return ret;
> +}
> +
> +static int vf50_ts_remove(struct platform_device *pdev)
> +{
> +	struct vf50_touch_device *touchdev = platform_get_drvdata(pdev);
> +
> +	destroy_workqueue(touchdev->ts_workqueue);
> +	iio_channel_release_all(touchdev->channels);
> +
> +	return 0;
> +}
> +
> +static const struct of_device_id vf50_touch_of_match[] = {
> +	{ .compatible = "toradex,vf50-touchctrl", },
> +	{ }
> +};
> +MODULE_DEVICE_TABLE(of, vf50_touch_of_match);
> +
> +static struct platform_driver __refdata vf50_touch_driver = {
> +	.driver = {
> +		.name = "toradex,vf50_touchctrl",
> +		.owner = THIS_MODULE,

I think the owner is not needed any more.

--
Stefan

> +		.of_match_table = vf50_touch_of_match,
> +	},
> +	.probe = vf50_ts_probe,
> +	.remove = vf50_ts_remove,
> +	.prevent_deferred_probe = false,
> +};
> +
> +module_platform_driver(vf50_touch_driver);
> +
> +module_param(min_pressure, int, 0600);
> +MODULE_PARM_DESC(min_pressure, "Minimum pressure for touch detection");
> +MODULE_AUTHOR("Sanchayan Maity");
> +MODULE_DESCRIPTION("Colibri VF50 Touchscreen driver");
> +MODULE_LICENSE("GPL v2");
> +MODULE_VERSION(DRV_VERSION);

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/