History

Input: gpio_tilt - delete driver

This driver was merged in 2011 as a tool for detecting the orientation of a screen. The device driver assumes board file setup using the platform data from <linux/input/gpio_tilt.h>. But no boards in the kernel tree defines this platform data. As I am faced with refactoring drivers to use GPIO descriptors and pass decriptor tables from boards, or use the device tree device drivers like these creates a serious problem: I cannot fix them and cannot test them, not even compile-test them with a system actually using it (no in-tree boardfile). I suggest to delete this driver and rewrite it using device tree if it is still in use on actively maintained systems. I can also offer to rewrite it out of the blue using device tree if someone promise to test it and help me iterate it.

Linus Walleij committed 8 years ago

Commit 3c8a23c1 parent b3495ce6 files · +0 −407Browse files

Unified · Split

6 files
  1. Documentation/gpio/drivers-on-gpio.txt +0 −5
  2. Documentation/input/devices/gpio-tilt.rst +0 −103
  3. drivers/input/misc/Kconfig +0 −14
  4. drivers/input/misc/Makefile +0 −1
  5. drivers/input/misc/gpio_tilt_polled.c +0 −210
  6. include/linux/input/gpio_tilt.h +0 −74
Documentation/gpio/drivers-on-gpio.txt+0−5
@@ -28,11 +28,6 @@ hardware descriptions such as device tree or ACPI: · 27 unmodified lines
2828 - gpio-beeper: drivers/input/misc/gpio-beeper.c is used to provide a beep from
2929 an external speaker connected to a GPIO line.
3030
31−- gpio-tilt-polled: drivers/input/misc/gpio_tilt_polled.c provides tilt
32− detection switches using GPIO, which is useful for your homebrewn pinball
33− machine if for nothing else. It can detect different tilt angles of the
34− monitored object.
35−
3631 - extcon-gpio: drivers/extcon/extcon-gpio.c is used when you need to read an
3732 external connector status, such as a headset line for an audio driver or an
3833 HDMI connector. It will provide a better userspace sysfs interface than GPIO.
Documentation/input/devices/gpio-tilt.rst+0−103
@@ -1,103 +0,0 @@
1−Driver for tilt-switches connected via GPIOs
2−============================================
3−
4−Generic driver to read data from tilt switches connected via gpios.
5−Orientation can be provided by one or more than one tilt switches,
6−i.e. each tilt switch providing one axis, and the number of axes
7−is also not limited.
8−
9−
10−Data structures
11−---------------
12−
13−The array of struct gpio in the gpios field is used to list the gpios
14−that represent the current tilt state.
15−
16−The array of struct gpio_tilt_axis describes the axes that are reported
17−to the input system. The values set therein are used for the
18−input_set_abs_params calls needed to init the axes.
19−
20−The array of struct gpio_tilt_state maps gpio states to the corresponding
21−values to report. The gpio state is represented as a bitfield where the
22−bit-index corresponds to the index of the gpio in the struct gpio array.
23−In the same manner the values stored in the axes array correspond to
24−the elements of the gpio_tilt_axis-array.
25−
26−
27−Example
28−-------
29−
30−Example configuration for a single TS1003 tilt switch that rotates around
31−one axis in 4 steps and emits the current tilt via two GPIOs::
32−
33− static int sg060_tilt_enable(struct device *dev) {
34− /* code to enable the sensors */
35− };
36−
37− static void sg060_tilt_disable(struct device *dev) {
38− /* code to disable the sensors */
39− };
40−
41− static struct gpio sg060_tilt_gpios[] = {
42− { SG060_TILT_GPIO_SENSOR1, GPIOF_IN, "tilt_sensor1" },
43− { SG060_TILT_GPIO_SENSOR2, GPIOF_IN, "tilt_sensor2" },
44− };
45−
46− static struct gpio_tilt_state sg060_tilt_states[] = {
47− {
48− .gpios = (0 << 1) | (0 << 0),
49− .axes = (int[]) {
50− 0,
51− },
52− }, {
53− .gpios = (0 << 1) | (1 << 0),
54− .axes = (int[]) {
55− 1, /* 90 degrees */
56− },
57− }, {
58− .gpios = (1 << 1) | (1 << 0),
59− .axes = (int[]) {
60− 2, /* 180 degrees */
61− },
62− }, {
63− .gpios = (1 << 1) | (0 << 0),
64− .axes = (int[]) {
65− 3, /* 270 degrees */
66− },
67− },
68− };
69−
70− static struct gpio_tilt_axis sg060_tilt_axes[] = {
71− {
72− .axis = ABS_RY,
73− .min = 0,
74− .max = 3,
75− .fuzz = 0,
76− .flat = 0,
77− },
78− };
79−
80− static struct gpio_tilt_platform_data sg060_tilt_pdata= {
81− .gpios = sg060_tilt_gpios,
82− .nr_gpios = ARRAY_SIZE(sg060_tilt_gpios),
83−
84− .axes = sg060_tilt_axes,
85− .nr_axes = ARRAY_SIZE(sg060_tilt_axes),
86−
87− .states = sg060_tilt_states,
88− .nr_states = ARRAY_SIZE(sg060_tilt_states),
89−
90− .debounce_interval = 100,
91−
92− .poll_interval = 1000,
93− .enable = sg060_tilt_enable,
94− .disable = sg060_tilt_disable,
95− };
96−
97− static struct platform_device sg060_device_tilt = {
98− .name = "gpio-tilt-polled",
99− .id = -1,
100− .dev = {
101− .platform_data = &sg060_tilt_pdata,
102− },
103− };
drivers/input/misc/Kconfig+0−14
@@ -268,20 +268,6 @@ config INPUT_GPIO_BEEPER · 267 unmodified lines
268268 To compile this driver as a module, choose M here: the
269269 module will be called gpio-beeper.
270270
271−config INPUT_GPIO_TILT_POLLED
272− tristate "Polled GPIO tilt switch"
273− depends on GPIOLIB || COMPILE_TEST
274− select INPUT_POLLDEV
275− help
276− This driver implements support for tilt switches connected
277− to GPIO pins that are not capable of generating interrupts.
278−
279− The list of gpios to use and the mapping of their states
280− to specific angles is done via platform data.
281−
282− To compile this driver as a module, choose M here: the
283− module will be called gpio_tilt_polled.
284−
285271 config INPUT_GPIO_DECODER
286272 tristate "Polled GPIO Decoder Input driver"
287273 depends on GPIOLIB || COMPILE_TEST
drivers/input/misc/Makefile+0−1
@@ -36,7 +36,6 @@ obj-$(CONFIG_INPUT_DRV2665_HAPTICS) += drv2665.o · 35 unmodified lines
3636 obj-$(CONFIG_INPUT_DRV2667_HAPTICS) += drv2667.o
3737 obj-$(CONFIG_INPUT_GP2A) += gp2ap002a00f.o
3838 obj-$(CONFIG_INPUT_GPIO_BEEPER) += gpio-beeper.o
39−obj-$(CONFIG_INPUT_GPIO_TILT_POLLED) += gpio_tilt_polled.o
4039 obj-$(CONFIG_INPUT_GPIO_DECODER) += gpio_decoder.o
4140 obj-$(CONFIG_INPUT_HISI_POWERKEY) += hisi_powerkey.o
4241 obj-$(CONFIG_HP_SDC_RTC) += hp_sdc_rtc.o
drivers/input/misc/gpio_tilt_polled.c+0−210
@@ -1,210 +0,0 @@
1−/*
2− * Driver for tilt switches connected via GPIO lines
3− * not capable of generating interrupts
4− *
5− * Copyright (C) 2011 Heiko Stuebner <heiko@sntech.de>
6− *
7− * based on: drivers/input/keyboard/gpio_keys_polled.c
8− *
9− * Copyright (C) 2007-2010 Gabor Juhos <juhosg@openwrt.org>
10− * Copyright (C) 2010 Nuno Goncalves <nunojpg@gmail.com>
11− *
12− * This program is free software; you can redistribute it and/or modify
13− * it under the terms of the GNU General Public License version 2 as
14− * published by the Free Software Foundation.
15− */
16−
17−#include <linux/kernel.h>
18−#include <linux/module.h>
19−#include <linux/slab.h>
20−#include <linux/input.h>
21−#include <linux/input-polldev.h>
22−#include <linux/ioport.h>
23−#include <linux/platform_device.h>
24−#include <linux/gpio.h>
25−#include <linux/input/gpio_tilt.h>
26−
27−#define DRV_NAME "gpio-tilt-polled"
28−
29−struct gpio_tilt_polled_dev {
30− struct input_polled_dev *poll_dev;
31− struct device *dev;
32− const struct gpio_tilt_platform_data *pdata;
33−
34− int last_state;
35−
36− int threshold;
37− int count;
38−};
39−
40−static void gpio_tilt_polled_poll(struct input_polled_dev *dev)
41−{
42− struct gpio_tilt_polled_dev *tdev = dev->private;
43− const struct gpio_tilt_platform_data *pdata = tdev->pdata;
44− struct input_dev *input = dev->input;
45− struct gpio_tilt_state *tilt_state = NULL;
46− int state, i;
47−
48− if (tdev->count < tdev->threshold) {
49− tdev->count++;
50− } else {
51− state = 0;
52− for (i = 0; i < pdata->nr_gpios; i++)
53− state |= (!!gpio_get_value(pdata->gpios[i].gpio) << i);
54−
55− if (state != tdev->last_state) {
56− for (i = 0; i < pdata->nr_states; i++)
57− if (pdata->states[i].gpios == state)
58− tilt_state = &pdata->states[i];
59−
60− if (tilt_state) {
61− for (i = 0; i < pdata->nr_axes; i++)
62− input_report_abs(input,
63− pdata->axes[i].axis,
64− tilt_state->axes[i]);
65−
66− input_sync(input);
67− }
68−
69− tdev->count = 0;
70− tdev->last_state = state;
71− }
72− }
73−}
74−
75−static void gpio_tilt_polled_open(struct input_polled_dev *dev)
76−{
77− struct gpio_tilt_polled_dev *tdev = dev->private;
78− const struct gpio_tilt_platform_data *pdata = tdev->pdata;
79−
80− if (pdata->enable)
81− pdata->enable(tdev->dev);
82−
83− /* report initial state of the axes */
84− tdev->last_state = -1;
85− tdev->count = tdev->threshold;
86− gpio_tilt_polled_poll(tdev->poll_dev);
87−}
88−
89−static void gpio_tilt_polled_close(struct input_polled_dev *dev)
90−{
91− struct gpio_tilt_polled_dev *tdev = dev->private;
92− const struct gpio_tilt_platform_data *pdata = tdev->pdata;
93−
94− if (pdata->disable)
95− pdata->disable(tdev->dev);
96−}
97−
98−static int gpio_tilt_polled_probe(struct platform_device *pdev)
99−{
100− const struct gpio_tilt_platform_data *pdata =
101− dev_get_platdata(&pdev->dev);
102− struct device *dev = &pdev->dev;
103− struct gpio_tilt_polled_dev *tdev;
104− struct input_polled_dev *poll_dev;
105− struct input_dev *input;
106− int error, i;
107−
108− if (!pdata || !pdata->poll_interval)
109− return -EINVAL;
110−
111− tdev = kzalloc(sizeof(struct gpio_tilt_polled_dev), GFP_KERNEL);
112− if (!tdev) {
113− dev_err(dev, "no memory for private data\n");
114− return -ENOMEM;
115− }
116−
117− error = gpio_request_array(pdata->gpios, pdata->nr_gpios);
118− if (error) {
119− dev_err(dev,
120− "Could not request tilt GPIOs: %d\n", error);
121− goto err_free_tdev;
122− }
123−
124− poll_dev = input_allocate_polled_device();
125− if (!poll_dev) {
126− dev_err(dev, "no memory for polled device\n");
127− error = -ENOMEM;
128− goto err_free_gpios;
129− }
130−
131− poll_dev->private = tdev;
132− poll_dev->poll = gpio_tilt_polled_poll;
133− poll_dev->poll_interval = pdata->poll_interval;
134− poll_dev->open = gpio_tilt_polled_open;
135− poll_dev->close = gpio_tilt_polled_close;
136−
137− input = poll_dev->input;
138−
139− input->name = pdev->name;
140− input->phys = DRV_NAME"/input0";
141− input->dev.parent = dev;
142−
143− input->id.bustype = BUS_HOST;
144− input->id.vendor = 0x0001;
145− input->id.product = 0x0001;
146− input->id.version = 0x0100;
147−
148− __set_bit(EV_ABS, input->evbit);
149− for (i = 0; i < pdata->nr_axes; i++)
150− input_set_abs_params(input, pdata->axes[i].axis,
151− pdata->axes[i].min, pdata->axes[i].max,
152− pdata->axes[i].fuzz, pdata->axes[i].flat);
153−
154− tdev->threshold = DIV_ROUND_UP(pdata->debounce_interval,
155− pdata->poll_interval);
156−
157− tdev->poll_dev = poll_dev;
158− tdev->dev = dev;
159− tdev->pdata = pdata;
160−
161− error = input_register_polled_device(poll_dev);
162− if (error) {
163− dev_err(dev, "unable to register polled device, err=%d\n",
164− error);
165− goto err_free_polldev;
166− }
167−
168− platform_set_drvdata(pdev, tdev);
169−
170− return 0;
171−
172−err_free_polldev:
173− input_free_polled_device(poll_dev);
174−err_free_gpios:
175− gpio_free_array(pdata->gpios, pdata->nr_gpios);
176−err_free_tdev:
177− kfree(tdev);
178−
179− return error;
180−}
181−
182−static int gpio_tilt_polled_remove(struct platform_device *pdev)
183−{
184− struct gpio_tilt_polled_dev *tdev = platform_get_drvdata(pdev);
185− const struct gpio_tilt_platform_data *pdata = tdev->pdata;
186−
187− input_unregister_polled_device(tdev->poll_dev);
188− input_free_polled_device(tdev->poll_dev);
189−
190− gpio_free_array(pdata->gpios, pdata->nr_gpios);
191−
192− kfree(tdev);
193−
194− return 0;
195−}
196−
197−static struct platform_driver gpio_tilt_polled_driver = {
198− .probe = gpio_tilt_polled_probe,
199− .remove = gpio_tilt_polled_remove,
200− .driver = {
201− .name = DRV_NAME,
202− },
203−};
204−
205−module_platform_driver(gpio_tilt_polled_driver);
206−
207−MODULE_LICENSE("GPL v2");
208−MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
209−MODULE_DESCRIPTION("Polled GPIO tilt driver");
210−MODULE_ALIAS("platform:" DRV_NAME);
include/linux/input/gpio_tilt.h+0−74
@@ -1,74 +0,0 @@
1−/* SPDX-License-Identifier: GPL-2.0 */
2−#ifndef _INPUT_GPIO_TILT_H
3−#define _INPUT_GPIO_TILT_H
4−
5−/**
6− * struct gpio_tilt_axis - Axis used by the tilt switch
7− * @axis: Constant describing the axis, e.g. ABS_X
8− * @min: minimum value for abs_param
9− * @max: maximum value for abs_param
10− * @fuzz: fuzz value for abs_param
11− * @flat: flat value for abs_param
12− */
13−struct gpio_tilt_axis {
14− int axis;
15− int min;
16− int max;
17− int fuzz;
18− int flat;
19−};
20−
21−/**
22− * struct gpio_tilt_state - state description
23− * @gpios: bitfield of gpio target-states for the value
24− * @axes: array containing the axes settings for the gpio state
25− * The array indizes must correspond to the axes defined
26− * in platform_data
27− *
28− * This structure describes a supported axis settings
29− * and the necessary gpio-state which represent it.
30− *
31− * The n-th bit in the bitfield describes the state of the n-th GPIO
32− * from the gpios-array defined in gpio_regulator_config below.
33− */
34−struct gpio_tilt_state {
35− int gpios;
36− int *axes;
37−};
38−
39−/**
40− * struct gpio_tilt_platform_data
41− * @gpios: Array containing the gpios determining the tilt state
42− * @nr_gpios: Number of gpios
43− * @axes: Array of gpio_tilt_axis descriptions
44− * @nr_axes: Number of axes
45− * @states: Array of gpio_tilt_state entries describing
46− * the gpio state for specific tilts
47− * @nr_states: Number of states available
48− * @debounce_interval: debounce ticks interval in msecs
49− * @poll_interval: polling interval in msecs - for polling driver only
50− * @enable: callback to enable the tilt switch
51− * @disable: callback to disable the tilt switch
52− *
53− * This structure contains gpio-tilt-switch configuration
54− * information that must be passed by platform code to the
55− * gpio-tilt input driver.
56− */
57−struct gpio_tilt_platform_data {
58− struct gpio *gpios;
59− int nr_gpios;
60−
61− struct gpio_tilt_axis *axes;
62− int nr_axes;
63−
64− struct gpio_tilt_state *states;
65− int nr_states;
66−
67− int debounce_interval;
68−
69− unsigned int poll_interval;
70− int (*enable)(struct device *dev);
71− void (*disable)(struct device *dev);
72−};
73−
74−#endif

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t