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.
Unified · Split
| @@ -28,11 +28,6 @@ hardware descriptions such as device tree or ACPI: · 27 unmodified lines | ||
| 28 | 28 | - gpio-beeper: drivers/input/misc/gpio-beeper.c is used to provide a beep from |
| 29 | 29 | an external speaker connected to a GPIO line. |
| 30 | 30 | |
| 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 | − | |
| 36 | 31 | - extcon-gpio: drivers/extcon/extcon-gpio.c is used when you need to read an |
| 37 | 32 | external connector status, such as a headset line for an audio driver or an |
| 38 | 33 | HDMI connector. It will provide a better userspace sysfs interface than GPIO. |
| @@ -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 | − }; | |
| @@ -268,20 +268,6 @@ config INPUT_GPIO_BEEPER · 267 unmodified lines | ||
| 268 | 268 | To compile this driver as a module, choose M here: the |
| 269 | 269 | module will be called gpio-beeper. |
| 270 | 270 | |
| 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 | − | |
| 285 | 271 | config INPUT_GPIO_DECODER |
| 286 | 272 | tristate "Polled GPIO Decoder Input driver" |
| 287 | 273 | depends on GPIOLIB || COMPILE_TEST |
| @@ -36,7 +36,6 @@ obj-$(CONFIG_INPUT_DRV2665_HAPTICS) += drv2665.o · 35 unmodified lines | ||
| 36 | 36 | obj-$(CONFIG_INPUT_DRV2667_HAPTICS) += drv2667.o |
| 37 | 37 | obj-$(CONFIG_INPUT_GP2A) += gp2ap002a00f.o |
| 38 | 38 | obj-$(CONFIG_INPUT_GPIO_BEEPER) += gpio-beeper.o |
| 39 | −obj-$(CONFIG_INPUT_GPIO_TILT_POLLED) += gpio_tilt_polled.o | |
| 40 | 39 | obj-$(CONFIG_INPUT_GPIO_DECODER) += gpio_decoder.o |
| 41 | 40 | obj-$(CONFIG_INPUT_HISI_POWERKEY) += hisi_powerkey.o |
| 42 | 41 | obj-$(CONFIG_HP_SDC_RTC) += hp_sdc_rtc.o |
| @@ -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); | |
| @@ -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 | |