path: root/drivers/misc/gpio-detection.c

/*
 * gpio detection  driver
 *
 * Copyright (C) 2015 Rockchip Electronics Co., Ltd.
 *
 * 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/init.h>
#include <linux/device.h>
#include <linux/fb.h>
#include <linux/gpio_detection.h>
#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/of_gpio.h>
#include <linux/of_irq.h>
#include <linux/platform_device.h>
#include <linux/wakelock.h>
#include <linux/rk_keys.h>
#include <linux/gpio/consumer.h>

#define WAKE_LOCK_TIMEOUT_MS (5000)

struct gpio_data {
	struct gpio_detection *parent;
	const char *name;
	struct device dev;
	int notify;
	struct gpio_desc *gpio;
	int val;
	int irq;
	struct delayed_work work;
	unsigned int debounce_ms;
	int wakeup;
};

struct gpio_detection {
	struct class_attribute cls_attr;
	struct device *dev;
	int num;
	struct gpio_data *data;
	struct pinctrl *pinctrl;
	struct pinctrl_state *pins_default;
	struct notifier_block fb_notifier;
	struct wake_lock wake_lock;
	int mirror;
	int type;
	int info;
};

static struct class *gpio_detection_class;
static BLOCKING_NOTIFIER_HEAD(gpio_det_notifier_list);
static int system_suspend;

#if IS_ENABLED(CONFIG_GPIO_DET)

/*
 * gpio_det_notifier_call_chain - notify clients of gpio_det_events
 *
 */
int gpio_det_notifier_call_chain(unsigned long val, void *v)
{
	return blocking_notifier_call_chain(&gpio_det_notifier_list, val, v);
}
EXPORT_SYMBOL_GPL(gpio_det_notifier_call_chain);

/*
 * gpio_det_register_notifier - register a client notifier
 * @nb: notifier block to callback on events
 */
int gpio_det_register_notifier(struct notifier_block *nb)
{
	int ret = blocking_notifier_chain_register(&gpio_det_notifier_list, nb);

	return ret;
}
EXPORT_SYMBOL(gpio_det_register_notifier);

/*
 * gpio_det_unregister_client - unregister a client notifier
 * @nb: notifier block to callback on events
 */
int gpio_det_unregister_notifier(struct notifier_block *nb)
{
	return blocking_notifier_chain_unregister(&gpio_det_notifier_list, nb);
}
EXPORT_SYMBOL(gpio_det_unregister_notifier);

#endif

static void gpio_det_report_event(struct gpio_data *gpiod)
{
	struct gpio_event event;
	struct gpio_detection *gpio_det = gpiod->parent;
	char *status = NULL;
	char *envp[2];

	event.val = gpiod->val;
	event.name = gpiod->name;
	status = kasprintf(GFP_KERNEL, "GPIO_NAME=%s GPIO_STATE=%s",
			   gpiod->name, event.val ? "over" : "on");
	envp[0] = status;
	envp[1] = NULL;
	wake_lock_timeout(&gpio_det->wake_lock,
			  msecs_to_jiffies(WAKE_LOCK_TIMEOUT_MS));
	kobject_uevent_env(&gpiod->dev.kobj, KOBJ_CHANGE, envp);
	if (gpiod->notify)
		gpio_det_notifier_call_chain(GPIO_EVENT, &event);
	kfree(status);
}

static void gpio_det_work_func(struct work_struct *work)
{
	struct gpio_data *gpiod = container_of(work, struct gpio_data,
					       work.work);
	int val = gpiod_get_value(gpiod->gpio);

	if (gpiod->val != val) {
		gpiod->val = val;
		gpio_det_report_event(gpiod);
		if (system_suspend && gpiod->wakeup) {
			rk_send_power_key(1);
			rk_send_power_key(0);
		}
	}
}

static irqreturn_t gpio_det_interrupt(int irq, void *dev_id)
{
	struct gpio_data *gpiod = dev_id;
	int val = gpiod_get_raw_value(gpiod->gpio);
	unsigned int irqflags = IRQF_ONESHOT;

	if (val)
		irqflags |= IRQ_TYPE_EDGE_FALLING;
	else
		irqflags |= IRQ_TYPE_EDGE_RISING;
	irq_set_irq_type(gpiod->irq, irqflags);

	mod_delayed_work(system_wq, &gpiod->work,
			 msecs_to_jiffies(gpiod->debounce_ms));

	return IRQ_HANDLED;
}

static int gpio_det_init_status_check(struct gpio_detection *gpio_det)
{
	struct gpio_data *gpiod;
	int i;

	for (i = 0; i < gpio_det->num; i++) {
		gpiod = &gpio_det->data[i];
		gpiod->val = gpiod_get_value(gpiod->gpio);
		if (gpiod->val)
			gpio_det_report_event(gpiod);
	}

	return 0;
}

static int gpio_det_fb_notifier_callback(struct notifier_block *self,
					 unsigned long event,
					 void *data)
{
	struct gpio_detection *gpio_det;
	struct fb_event *evdata = data;
	int fb_blank;

	if (event != FB_EVENT_BLANK && event != FB_EVENT_CONBLANK)
		return 0;

	gpio_det = container_of(self, struct gpio_detection, fb_notifier);
	fb_blank = *(int *)evdata->data;
	if (fb_blank == FB_BLANK_UNBLANK)
		system_suspend = 0;
	else
		system_suspend = 1;

	return 0;
}

static int gpio_det_fb_notifier_register(struct gpio_detection *gpio)
{
	gpio->fb_notifier.notifier_call = gpio_det_fb_notifier_callback;

	return fb_register_client(&gpio->fb_notifier);
}

static ssize_t gpio_detection_info_show(struct class *class,
					struct class_attribute *attr,
					char *buf)
{
	struct gpio_detection *gpio_det;

	gpio_det = container_of(attr, struct gpio_detection, cls_attr);

	return sprintf(buf, "%d\n", gpio_det->info);
}

static ssize_t status_show(struct device *dev, struct device_attribute *attr,
			   char *buf)
{
	struct gpio_data *gpiod = container_of(dev, struct gpio_data, dev);
	unsigned int val = gpiod_get_value(gpiod->gpio);

	return sprintf(buf, "%d\n", val);
}

static ssize_t status_store(struct device *dev, struct device_attribute *attr,
			    const char *buf, size_t count)
{
	struct gpio_data *gpiod;
	int val;
	int ret;
	struct gpio_event event;

	gpiod = container_of(dev, struct gpio_data, dev);
	ret = kstrtoint(buf, 0, &val);
	if (ret < 0)
		return ret;
	if (val >= 0) {
		event.val = val;
		event.name = gpiod->name;
		gpio_det_notifier_call_chain(GPIO_EVENT, &event);
	} else {
		gpiod->notify = 0;
	}

	return count;
}

static DEVICE_ATTR_RW(status);

static struct attribute *gpio_detection_attrs[] = {
	&dev_attr_status.attr,
	NULL,
};
ATTRIBUTE_GROUPS(gpio_detection);

static int __init gpio_deteciton_class_init(void)
{
	gpio_detection_class = class_create(THIS_MODULE, "gpio-detection");
	if (IS_ERR(gpio_detection_class)) {
		pr_err("create gpio_detection class failed (%ld)\n",
		       PTR_ERR(gpio_detection_class));
		return PTR_ERR(gpio_detection_class);
	}

	return 0;
}

static int gpio_detection_class_register(struct gpio_detection *gpio_det,
					 struct gpio_data *gpiod)
{
	int ret;

	gpiod->dev.class = gpio_detection_class;
	dev_set_name(&gpiod->dev, "%s", gpiod->name);
	dev_set_drvdata(&gpiod->dev, gpio_det);
	ret = device_register(&gpiod->dev);
	ret = sysfs_create_groups(&gpiod->dev.kobj, gpio_detection_groups);

	return ret;
}

static int gpio_det_parse_dt(struct gpio_detection *gpio_det,
			     struct platform_device *pdev)
{
	struct gpio_data *data;
	struct device *dev = &pdev->dev;
	struct device_node *node;
	struct gpio_data *gpiod;
	struct fwnode_handle *child;
	int count = 0;
	int i = 0;
	int num = 0;

	num = of_get_child_count(gpio_det->dev->of_node);
	count = device_get_child_node_count(dev);
	if (!count || !num)
		return -ENODEV;
	data = devm_kzalloc(gpio_det->dev, num * sizeof(*data), GFP_KERNEL);
	if (!data)
		return -ENOMEM;
	of_property_read_u32(gpio_det->dev->of_node, "rockchip,camcap-type",
			     &gpio_det->type);
	of_property_read_u32(gpio_det->dev->of_node, "rockchip,camcap-mirror",
			     &gpio_det->mirror);
	gpio_det->info = (gpio_det->mirror << 4) | gpio_det->type;
	device_for_each_child_node(dev, child) {
		node = to_of_node(child);
		gpiod = &data[i++];
		gpiod->parent = gpio_det;
		gpiod->notify = 1;
		gpiod->name = of_get_property(node, "label", NULL);
		gpiod->wakeup = !!of_get_property(node, "gpio,wakeup", NULL);
		of_property_read_u32(node, "linux,debounce-ms",
				     &gpiod->debounce_ms);
		if (!strcmp(gpiod->name, "car-reverse"))
			gpiod->gpio = devm_get_gpiod_from_child(dev,
							"car-reverse", child);
		else
			gpiod->gpio = devm_get_gpiod_from_child(dev,
							"car-acc", child);
	}
	gpio_det->num = num;
	gpio_det->data = data;

	return 0;
}

static int gpio_det_probe(struct platform_device *pdev)
{
	struct gpio_detection *gpio_det;
	struct gpio_data *gpiod;
	unsigned long irqflags = IRQF_ONESHOT;
	int i;
	int ret;

	gpio_det = devm_kzalloc(&pdev->dev, sizeof(*gpio_det), GFP_KERNEL);
	if (!gpio_det)
		return -ENOMEM;
	gpio_det->dev = &pdev->dev;
	gpio_det->cls_attr.attr.name = "info";
	gpio_det->cls_attr.attr.mode = S_IRUGO;
	gpio_det->cls_attr.show = gpio_detection_info_show;
	dev_set_name(gpio_det->dev, "gpio_detection");
	if (!pdev->dev.of_node)
		return -EINVAL;
	gpio_det->pinctrl = devm_pinctrl_get(&pdev->dev);
	if (IS_ERR(gpio_det->pinctrl)) {
		dev_err(&pdev->dev, "pinctrl get failed\n");
		return PTR_ERR(gpio_det->pinctrl);
	}
	gpio_det->pins_default = pinctrl_lookup_state(gpio_det->pinctrl,
						      PINCTRL_STATE_DEFAULT);
	if (IS_ERR(gpio_det->pins_default))
		dev_err(gpio_det->dev, "get default pinstate failed\n");
	else
		pinctrl_select_state(gpio_det->pinctrl, gpio_det->pins_default);
	if (gpio_det_parse_dt(gpio_det, pdev))
		return -ENODEV;
	wake_lock_init(&gpio_det->wake_lock, WAKE_LOCK_SUSPEND,
		       "gpio_detection");
	for (i = 0; i < gpio_det->num; i++) {
		gpiod = &gpio_det->data[i];
		gpiod_direction_input(gpiod->gpio);

		gpiod->irq = gpiod_to_irq(gpiod->gpio);
		if (gpiod->irq < 0) {
			dev_err(gpio_det->dev, "failed to get irq number for GPIO %s\n",
				gpiod->name);
			continue;
		}

		ret = gpio_detection_class_register(gpio_det, gpiod);
		if (ret < 0)
			return ret;
		INIT_DELAYED_WORK(&gpiod->work, gpio_det_work_func);
		gpiod->val = gpiod_get_raw_value(gpiod->gpio);
		if  (gpiod->val)
			irqflags |= IRQ_TYPE_EDGE_FALLING;
		else
			irqflags |= IRQ_TYPE_EDGE_RISING;
		ret = devm_request_threaded_irq(gpio_det->dev, gpiod->irq,
						NULL, gpio_det_interrupt,
						irqflags | IRQF_ONESHOT,
						gpiod->name, gpiod);
		if (ret < 0)
			dev_err(gpio_det->dev, "request irq(%s) failed:%d\n",
				gpiod->name, ret);
		else
			if (gpiod->wakeup)
				enable_irq_wake(gpiod->irq);
	}

	if (gpio_det->info) {
		ret = class_create_file(gpio_detection_class,
					&gpio_det->cls_attr);
		if (ret)
			dev_warn(gpio_det->dev, "create class file failed:%d\n",
				 ret);
	}

	gpio_det_fb_notifier_register(gpio_det);
	gpio_det_init_status_check(gpio_det);

	dev_info(gpio_det->dev, "gpio detection driver probe success\n");

	return 0;
}

#if defined(CONFIG_OF)
static const struct of_device_id gpio_det_of_match[] = {
	{
		 .compatible = "gpio-detection"
	},
	{},
};
#endif

static struct platform_driver gpio_det_driver = {
	.driver	= {
		.name = "gpio-detection",
		.of_match_table = of_match_ptr(gpio_det_of_match),
	},
	.probe = gpio_det_probe,
};

#ifdef CONFIG_VIDEO_REVERSE_IMAGE
int gpio_det_init(void)
#else
static int __init gpio_det_init(void)
#endif
{
	if (!gpio_deteciton_class_init())
		return platform_driver_register(&gpio_det_driver);
	else
		return -1;
}

#ifndef CONFIG_VIDEO_REVERSE_IMAGE
fs_initcall_sync(gpio_det_init);
#endif
static void __exit gpio_det_exit(void)
{
	platform_driver_unregister(&gpio_det_driver);
}

module_exit(gpio_det_exit);

MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:gpio-detection");
MODULE_AUTHOR("ROCKCHIP");