android: remove timed output/gpio driver
timed_output was only used by the Android vibrator HAL which has now learned how to use LED triggers instead[1]. Any users of it in AOSP are on ancient kernels. Adding support for LED triggers is purely DT changes and proper kernel config. [1] https://android.googlesource.com/platform%2Fhardware%2Flibhardware/+/61701df363310a5cbd95e3e1638baa9526e42c9b Cc: John Stultz <john.stultz@linaro.org> Cc: "Arve Hjønnevåg" <arve@android.com> Cc: Riley Andrews <riandrews@android.com> Signed-off-by: Rob Herring <robh@kernel.org> Acked-by: John Stultz <john.stultz@linaro.org> Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>hifive-unleashed-5.1
Rob Herring
Greg Kroah-Hartman
parent
64938182e7
commit
9f6b68774f
|
|
@ -14,20 +14,6 @@ config ASHMEM
|
|||
It is, in theory, a good memory allocator for low-memory devices,
|
||||
because it can discard shared memory units when under memory pressure.
|
||||
|
||||
config ANDROID_TIMED_OUTPUT
|
||||
bool "Timed output class driver"
|
||||
default y
|
||||
|
||||
config ANDROID_TIMED_GPIO
|
||||
tristate "Android timed gpio driver"
|
||||
depends on GPIOLIB || COMPILE_TEST
|
||||
depends on ANDROID_TIMED_OUTPUT
|
||||
default n
|
||||
---help---
|
||||
Unlike generic gpio is to allow programs to access and manipulate gpio
|
||||
registers from user space, timed output/gpio is a system to allow changing
|
||||
a gpio pin and restore it automatically after a specified timeout.
|
||||
|
||||
config ANDROID_LOW_MEMORY_KILLER
|
||||
bool "Android Low Memory Killer"
|
||||
---help---
|
||||
|
|
|
|||
|
|
@ -3,8 +3,6 @@ ccflags-y += -I$(src) # needed for trace events
|
|||
obj-y += ion/
|
||||
|
||||
obj-$(CONFIG_ASHMEM) += ashmem.o
|
||||
obj-$(CONFIG_ANDROID_TIMED_OUTPUT) += timed_output.o
|
||||
obj-$(CONFIG_ANDROID_TIMED_GPIO) += timed_gpio.o
|
||||
obj-$(CONFIG_ANDROID_LOW_MEMORY_KILLER) += lowmemorykiller.o
|
||||
obj-$(CONFIG_SYNC) += sync.o sync_debug.o
|
||||
obj-$(CONFIG_SW_SYNC) += sw_sync.o
|
||||
|
|
|
|||
|
|
@ -1,166 +0,0 @@
|
|||
/* drivers/misc/timed_gpio.c
|
||||
*
|
||||
* Copyright (C) 2008 Google, Inc.
|
||||
* Author: Mike Lockwood <lockwood@android.com>
|
||||
*
|
||||
* This software is licensed under the terms of the GNU General Public
|
||||
* License version 2, as published by the Free Software Foundation, and
|
||||
* may be copied, distributed, and modified under those terms.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <linux/module.h>
|
||||
#include <linux/platform_device.h>
|
||||
#include <linux/slab.h>
|
||||
#include <linux/hrtimer.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/gpio.h>
|
||||
#include <linux/ktime.h>
|
||||
|
||||
#include "timed_output.h"
|
||||
#include "timed_gpio.h"
|
||||
|
||||
struct timed_gpio_data {
|
||||
struct timed_output_dev dev;
|
||||
struct hrtimer timer;
|
||||
spinlock_t lock;
|
||||
unsigned gpio;
|
||||
int max_timeout;
|
||||
u8 active_low;
|
||||
};
|
||||
|
||||
static enum hrtimer_restart gpio_timer_func(struct hrtimer *timer)
|
||||
{
|
||||
struct timed_gpio_data *data =
|
||||
container_of(timer, struct timed_gpio_data, timer);
|
||||
|
||||
gpio_direction_output(data->gpio, data->active_low ? 1 : 0);
|
||||
return HRTIMER_NORESTART;
|
||||
}
|
||||
|
||||
static int gpio_get_time(struct timed_output_dev *dev)
|
||||
{
|
||||
struct timed_gpio_data *data;
|
||||
ktime_t t;
|
||||
|
||||
data = container_of(dev, struct timed_gpio_data, dev);
|
||||
|
||||
if (!hrtimer_active(&data->timer))
|
||||
return 0;
|
||||
|
||||
t = hrtimer_get_remaining(&data->timer);
|
||||
|
||||
return ktime_to_ms(t);
|
||||
}
|
||||
|
||||
static void gpio_enable(struct timed_output_dev *dev, int value)
|
||||
{
|
||||
struct timed_gpio_data *data =
|
||||
container_of(dev, struct timed_gpio_data, dev);
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&data->lock, flags);
|
||||
|
||||
/* cancel previous timer and set GPIO according to value */
|
||||
hrtimer_cancel(&data->timer);
|
||||
gpio_direction_output(data->gpio, data->active_low ? !value : !!value);
|
||||
|
||||
if (value > 0) {
|
||||
if (value > data->max_timeout)
|
||||
value = data->max_timeout;
|
||||
|
||||
hrtimer_start(&data->timer,
|
||||
ktime_set(value / 1000, (value % 1000) * 1000000),
|
||||
HRTIMER_MODE_REL);
|
||||
}
|
||||
|
||||
spin_unlock_irqrestore(&data->lock, flags);
|
||||
}
|
||||
|
||||
static int timed_gpio_probe(struct platform_device *pdev)
|
||||
{
|
||||
struct timed_gpio_platform_data *pdata = pdev->dev.platform_data;
|
||||
struct timed_gpio *cur_gpio;
|
||||
struct timed_gpio_data *gpio_data, *gpio_dat;
|
||||
int i, ret;
|
||||
|
||||
if (!pdata)
|
||||
return -EBUSY;
|
||||
|
||||
gpio_data = devm_kcalloc(&pdev->dev, pdata->num_gpios,
|
||||
sizeof(*gpio_data), GFP_KERNEL);
|
||||
if (!gpio_data)
|
||||
return -ENOMEM;
|
||||
|
||||
for (i = 0; i < pdata->num_gpios; i++) {
|
||||
cur_gpio = &pdata->gpios[i];
|
||||
gpio_dat = &gpio_data[i];
|
||||
|
||||
hrtimer_init(&gpio_dat->timer, CLOCK_MONOTONIC,
|
||||
HRTIMER_MODE_REL);
|
||||
gpio_dat->timer.function = gpio_timer_func;
|
||||
spin_lock_init(&gpio_dat->lock);
|
||||
|
||||
gpio_dat->dev.name = cur_gpio->name;
|
||||
gpio_dat->dev.get_time = gpio_get_time;
|
||||
gpio_dat->dev.enable = gpio_enable;
|
||||
ret = gpio_request(cur_gpio->gpio, cur_gpio->name);
|
||||
if (ret < 0)
|
||||
goto err_out;
|
||||
ret = timed_output_dev_register(&gpio_dat->dev);
|
||||
if (ret < 0) {
|
||||
gpio_free(cur_gpio->gpio);
|
||||
goto err_out;
|
||||
}
|
||||
|
||||
gpio_dat->gpio = cur_gpio->gpio;
|
||||
gpio_dat->max_timeout = cur_gpio->max_timeout;
|
||||
gpio_dat->active_low = cur_gpio->active_low;
|
||||
gpio_direction_output(gpio_dat->gpio, gpio_dat->active_low);
|
||||
}
|
||||
|
||||
platform_set_drvdata(pdev, gpio_data);
|
||||
|
||||
return 0;
|
||||
|
||||
err_out:
|
||||
while (--i >= 0) {
|
||||
timed_output_dev_unregister(&gpio_data[i].dev);
|
||||
gpio_free(gpio_data[i].gpio);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int timed_gpio_remove(struct platform_device *pdev)
|
||||
{
|
||||
struct timed_gpio_platform_data *pdata = pdev->dev.platform_data;
|
||||
struct timed_gpio_data *gpio_data = platform_get_drvdata(pdev);
|
||||
int i;
|
||||
|
||||
for (i = 0; i < pdata->num_gpios; i++) {
|
||||
timed_output_dev_unregister(&gpio_data[i].dev);
|
||||
gpio_free(gpio_data[i].gpio);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static struct platform_driver timed_gpio_driver = {
|
||||
.probe = timed_gpio_probe,
|
||||
.remove = timed_gpio_remove,
|
||||
.driver = {
|
||||
.name = TIMED_GPIO_NAME,
|
||||
},
|
||||
};
|
||||
|
||||
module_platform_driver(timed_gpio_driver);
|
||||
|
||||
MODULE_AUTHOR("Mike Lockwood <lockwood@android.com>");
|
||||
MODULE_DESCRIPTION("timed gpio driver");
|
||||
MODULE_LICENSE("GPL");
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
/* include/linux/timed_gpio.h
|
||||
*
|
||||
* Copyright (C) 2008 Google, Inc.
|
||||
*
|
||||
* This software is licensed under the terms of the GNU General Public
|
||||
* License version 2, as published by the Free Software Foundation, and
|
||||
* may be copied, distributed, and modified under those terms.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _LINUX_TIMED_GPIO_H
|
||||
#define _LINUX_TIMED_GPIO_H
|
||||
|
||||
#define TIMED_GPIO_NAME "timed-gpio"
|
||||
|
||||
struct timed_gpio {
|
||||
const char *name;
|
||||
unsigned gpio;
|
||||
int max_timeout;
|
||||
u8 active_low;
|
||||
};
|
||||
|
||||
struct timed_gpio_platform_data {
|
||||
int num_gpios;
|
||||
struct timed_gpio *gpios;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -1,110 +0,0 @@
|
|||
/* drivers/misc/timed_output.c
|
||||
*
|
||||
* Copyright (C) 2009 Google, Inc.
|
||||
* Author: Mike Lockwood <lockwood@android.com>
|
||||
*
|
||||
* This software is licensed under the terms of the GNU General Public
|
||||
* License version 2, as published by the Free Software Foundation, and
|
||||
* may be copied, distributed, and modified under those terms.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
*/
|
||||
|
||||
#define pr_fmt(fmt) "timed_output: " fmt
|
||||
|
||||
#include <linux/init.h>
|
||||
#include <linux/export.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/err.h>
|
||||
|
||||
#include "timed_output.h"
|
||||
|
||||
static struct class *timed_output_class;
|
||||
static atomic_t device_count;
|
||||
|
||||
static ssize_t enable_show(struct device *dev, struct device_attribute *attr,
|
||||
char *buf)
|
||||
{
|
||||
struct timed_output_dev *tdev = dev_get_drvdata(dev);
|
||||
int remaining = tdev->get_time(tdev);
|
||||
|
||||
return sprintf(buf, "%d\n", remaining);
|
||||
}
|
||||
|
||||
static ssize_t enable_store(struct device *dev, struct device_attribute *attr,
|
||||
const char *buf, size_t size)
|
||||
{
|
||||
struct timed_output_dev *tdev = dev_get_drvdata(dev);
|
||||
int value;
|
||||
int rc;
|
||||
|
||||
rc = kstrtoint(buf, 0, &value);
|
||||
if (rc != 0)
|
||||
return -EINVAL;
|
||||
|
||||
tdev->enable(tdev, value);
|
||||
|
||||
return size;
|
||||
}
|
||||
static DEVICE_ATTR_RW(enable);
|
||||
|
||||
static struct attribute *timed_output_attrs[] = {
|
||||
&dev_attr_enable.attr,
|
||||
NULL,
|
||||
};
|
||||
ATTRIBUTE_GROUPS(timed_output);
|
||||
|
||||
static int create_timed_output_class(void)
|
||||
{
|
||||
if (!timed_output_class) {
|
||||
timed_output_class = class_create(THIS_MODULE, "timed_output");
|
||||
if (IS_ERR(timed_output_class))
|
||||
return PTR_ERR(timed_output_class);
|
||||
atomic_set(&device_count, 0);
|
||||
timed_output_class->dev_groups = timed_output_groups;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int timed_output_dev_register(struct timed_output_dev *tdev)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (!tdev || !tdev->name || !tdev->enable || !tdev->get_time)
|
||||
return -EINVAL;
|
||||
|
||||
ret = create_timed_output_class();
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
tdev->index = atomic_inc_return(&device_count);
|
||||
tdev->dev = device_create(timed_output_class, NULL,
|
||||
MKDEV(0, tdev->index), NULL, "%s", tdev->name);
|
||||
if (IS_ERR(tdev->dev))
|
||||
return PTR_ERR(tdev->dev);
|
||||
|
||||
dev_set_drvdata(tdev->dev, tdev);
|
||||
tdev->state = 0;
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(timed_output_dev_register);
|
||||
|
||||
void timed_output_dev_unregister(struct timed_output_dev *tdev)
|
||||
{
|
||||
tdev->enable(tdev, 0);
|
||||
device_destroy(timed_output_class, MKDEV(0, tdev->index));
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(timed_output_dev_unregister);
|
||||
|
||||
static int __init timed_output_init(void)
|
||||
{
|
||||
return create_timed_output_class();
|
||||
}
|
||||
device_initcall(timed_output_init);
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
/* include/linux/timed_output.h
|
||||
*
|
||||
* Copyright (C) 2008 Google, Inc.
|
||||
*
|
||||
* This software is licensed under the terms of the GNU General Public
|
||||
* License version 2, as published by the Free Software Foundation, and
|
||||
* may be copied, distributed, and modified under those terms.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef _LINUX_TIMED_OUTPUT_H
|
||||
#define _LINUX_TIMED_OUTPUT_H
|
||||
|
||||
struct timed_output_dev {
|
||||
const char *name;
|
||||
|
||||
/* enable the output and set the timer */
|
||||
void (*enable)(struct timed_output_dev *sdev, int timeout);
|
||||
|
||||
/* returns the current number of milliseconds remaining on the timer */
|
||||
int (*get_time)(struct timed_output_dev *sdev);
|
||||
|
||||
/* private data */
|
||||
struct device *dev;
|
||||
int index;
|
||||
int state;
|
||||
};
|
||||
|
||||
int timed_output_dev_register(struct timed_output_dev *dev);
|
||||
void timed_output_dev_unregister(struct timed_output_dev *dev);
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue