drivers/amlogic/input/avin_detect/avin_detect.c

/*
 * drivers/amlogic/input/avin_detect/avin_detect.c
 *
 * Copyright (C) 2017 Amlogic, Inc. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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/interrupt.h>
#include <linux/input.h>
#include <linux/platform_device.h>
#include <linux/irq.h>
#include <linux/poll.h>
#include <linux/of_irq.h>
#include <linux/slab.h>
#include <uapi/linux/input.h>
#include <linux/of.h>
#include <linux/uaccess.h>
#include <linux/delay.h>
#include "avin_detect.h"
#include <linux/gpio.h>

#ifndef CONFIG_OF
#define CONFIG_OF
#endif

#undef pr_fmt
#define pr_fmt(fmt)    "avin-detect: " fmt

#define DEBUG_DEF  1
#define INPUT_REPORT_SWITCH 0
#define LOOP_DETECT_TIMES 3

#define MAX_AVIN_DEVICE_NUM  3
#define AVIN_NAME  "avin_detect"
#define AVIN_NAME_CH1  "avin_detect_ch1"
#define AVIN_NAME_CH2  "avin_detect_ch2"
#define AVIN_NAME_CH3  "avin_detect_ch3"
#define ABS_AVIN_1 0
#define ABS_AVIN_2 1
#define ABS_AVIN_3 2

static char *avin_name_ch[3] = {AVIN_NAME_CH1, AVIN_NAME_CH2, AVIN_NAME_CH3};
static char avin_ch[3] = {AVIN_CHANNEL1, AVIN_CHANNEL2, AVIN_CHANNEL3};

static DECLARE_WAIT_QUEUE_HEAD(avin_waitq);

static inline void avin_disable_irq(int irq)
{
	struct irq_desc *desc = irq_to_desc(irq);

	if (!desc->depth)
		disable_irq_nosync(irq);
}

static inline void avin_enable_irq(int irq)
{
	struct irq_desc *desc = irq_to_desc(irq);

	if (!desc->depth)
		return;

	enable_irq(irq);
}

static irqreturn_t avin_detect_handler(int irq, void *data)
{
	int i;
	struct avin_det_s *avdev = (struct avin_det_s *)data;

	for (i = 0; i <= avdev->dts_param.dts_device_num; i++) {
		if (irq == avdev->hw_res.irq_num[i])
			break;
		else if (i == avdev->dts_param.dts_device_num)
			return IRQ_HANDLED;
	}

	if (avdev->code_variable.loop_detect_times[i]++
		== LOOP_DETECT_TIMES) {
		avdev->code_variable.irq_falling_times[
			i * avdev->dts_param.dts_detect_times +
			avdev->code_variable.detect_channel_times[i]]++;
		avdev->code_variable.pin_mask_irq_flag[i] = 1;
		/*avdev->code_variable.loop_detect_times[i] = 0;*/
		schedule_work(&(avdev->work_struct_maskirq));
	}
	return IRQ_HANDLED;
}

/* must open irq >100ms later,then into timer handler */
static void avin_timer_sr(unsigned long data)
{
	int i;
	struct avin_det_s *avdev = (struct avin_det_s *)data;

	for (i = 0; i < avdev->dts_param.dts_device_num; i++) {
		if (avdev->code_variable.detect_channel_times[i] <
			(avdev->dts_param.dts_detect_times-1)) {
			avdev->code_variable.detect_channel_times[i]++;
			if (avdev->code_variable.irq_falling_times[
				i * avdev->dts_param.dts_detect_times +
				avdev->code_variable.detect_channel_times[
					i]-1] != 0) {
				avdev->code_variable.loop_detect_times[i] = 0;
				/* avin_enable_irq(avdev->hw_res.irq_num[i]); */
			}
			avin_enable_irq(avdev->hw_res.irq_num[i]);
			if (avdev->code_variable.detect_channel_times[
				i] == 1) {
				avdev->code_variable.irq_falling_times[
				(i+1) * avdev->dts_param.dts_detect_times
				- 1] = 0;
			} else if (avdev->code_variable.detect_channel_times[i]
			== (avdev->dts_param.dts_detect_times-1)) {
				schedule_work(&(avdev->work_struct_update));
			}
		} else {
			avdev->code_variable.detect_channel_times[i] = 0;
			avdev->code_variable.loop_detect_times[i] = 0;
			avin_enable_irq(avdev->hw_res.irq_num[i]);
		}
	}
	mod_timer(&avdev->timer,
	jiffies+msecs_to_jiffies(avdev->dts_param.dts_interval_length));
}

static void kp_work_channel1(struct avin_det_s *avdev)
{
	int i, j;

	mutex_lock(&avdev->lock);
	for (i = 0; i < avdev->dts_param.dts_device_num; i++) {
		for (j = 0; j < (avdev->dts_param.dts_detect_times-1); j++) {
			if (avdev->code_variable.irq_falling_times[
				i * avdev->dts_param.dts_detect_times + j] == 0)
				avdev->code_variable.actual_into_irq_times[i]++;

			avdev->code_variable.irq_falling_times[
				i * avdev->dts_param.dts_detect_times + j] = 0;
		}

		if (avdev->code_variable.actual_into_irq_times[i] >=
			((avdev->dts_param.dts_detect_times - 1)
			- avdev->dts_param.dts_fault_tolerance)) {
			if (avdev->code_variable.ch_current_status[i]
				!= AVIN_STATUS_OUT) {
				avdev->code_variable.ch_current_status[i]
					= AVIN_STATUS_OUT;
				#if INPUT_REPORT_SWITCH
				input_report_abs(avdev->input_dev,
				 ABS_AVIN_1, AVIN_STATUS_OUT);
				input_sync(avdev->input_dev);
				#endif
				avdev->code_variable.report_data_s[i].channel
				= avin_ch[i];
				avdev->code_variable.report_data_s[i].status
					= AVIN_STATUS_OUT;
				avdev->code_variable.report_data_flag = 1;
				wake_up_interruptible(&avin_waitq);
				#if DEBUG_DEF
				pr_info("avin ch%d current_status out!\n", i);
				#endif
			}
		} else if (avdev->code_variable.actual_into_irq_times[i] <=
			avdev->dts_param.dts_fault_tolerance) {
			if (avdev->code_variable.ch_current_status[i]
				!= AVIN_STATUS_IN) {
				avdev->code_variable.ch_current_status[i]
					= AVIN_STATUS_IN;
				#if INPUT_REPORT_SWITCH
				input_report_abs(avdev->input_dev,
				 ABS_AVIN_1, AVIN_STATUS_IN);
				input_sync(avdev->input_dev);
				#endif
				avdev->code_variable.report_data_s[i].channel
				= avin_ch[i];
				avdev->code_variable.report_data_s[i].status
					= AVIN_STATUS_IN;
				avdev->code_variable.report_data_flag = 1;
				wake_up_interruptible(&avin_waitq);
				#if DEBUG_DEF
				pr_info("avin ch%d current_status in!\n", i);
				#endif
			}
		} else {
			/*keep current status*/
		}
	}
	memset(avdev->code_variable.actual_into_irq_times, 0,
		sizeof(avdev->code_variable.actual_into_irq_times[0]) *
		avdev->dts_param.dts_device_num);

	mutex_unlock(&avdev->lock);
}

static void update_work_update_status(struct work_struct *work)
{
	struct avin_det_s *avin_data =
	container_of(work, struct avin_det_s, work_struct_update);

	kp_work_channel1(avin_data);
}

static void update_work_maskirq(struct work_struct *work)
{
	int i;
	struct avin_det_s *avdev =
	container_of(work, struct avin_det_s, work_struct_maskirq);

	for (i = 0; i < avdev->dts_param.dts_device_num; i++) {
		if (avdev->code_variable.pin_mask_irq_flag[i] == 1) {
			avin_disable_irq(avdev->hw_res.irq_num[i]);
			avdev->code_variable.pin_mask_irq_flag[i] = 0;
		}
	}
}

static int aml_sysavin_dts_parse(struct platform_device *pdev)
{
	int ret;
	int i;
	int state;
	int value;
	struct avin_det_s *avdev;

	avdev = platform_get_drvdata(pdev);

	ret = of_property_read_u32(pdev->dev.of_node,
	"avin_device_num", &value);
	avdev->dts_param.dts_device_num = value;
	if (ret) {
		pr_info("Failed to get dts_device_num.\n");
		goto get_avin_param_failed;
	} else {
		if (avdev->dts_param.dts_device_num == 0) {
			pr_info("avin device num is 0\n");
			goto get_avin_param_failed;
		} else if (avdev->dts_param.dts_device_num >
		MAX_AVIN_DEVICE_NUM) {
			pr_info("avin device num is > MAX NUM\n");
			goto get_avin_param_failed;
		}
	}

	ret = of_property_read_u32(pdev->dev.of_node,
	"detect_interval_length", &value);
	if (ret) {
		pr_info("Failed to get dts_interval_length.\n");
		goto get_avin_param_failed;
	}
	avdev->dts_param.dts_interval_length = value;

	ret = of_property_read_u32(pdev->dev.of_node,
	"set_detect_times", &value);
	if (ret) {
		pr_info("Failed to get dts_detect_times.\n");
		goto get_avin_param_failed;
	}
	avdev->dts_param.dts_detect_times = value + 1;

	ret = of_property_read_u32(pdev->dev.of_node,
	"set_fault_tolerance", &value);
	if (ret) {
		pr_info("Failed to get dts_fault_tolerance.\n");
		goto get_avin_param_failed;
	}
	avdev->dts_param.dts_fault_tolerance = value;

	/* request resource of pin */
	avdev->hw_res.pin =
		devm_kzalloc(&pdev->dev, (sizeof(struct gpio_desc *)
		* avdev->dts_param.dts_device_num), GFP_KERNEL);
	if (!avdev->hw_res.pin) {
		state = -ENOMEM;
		goto get_avin_param_failed;
	}
	for (i = 0; i < avdev->dts_param.dts_device_num; i++) {
		avdev->hw_res.pin[i] = devm_gpiod_get_index(&pdev->dev,
				NULL, i, GPIOD_IN);

		if (IS_ERR_OR_NULL(avdev->hw_res.pin[i])) {
			state = -EINVAL;
			goto get_avin_param_failed;
		}

		gpiod_set_pull(avdev->hw_res.pin[i], GPIOD_PULL_DIS);
	}

	/* request resource of irq num */
	avdev->hw_res.irq_num =
		devm_kzalloc(&pdev->dev, (sizeof(avdev->hw_res.irq_num[0])
		* avdev->dts_param.dts_device_num), GFP_KERNEL);
	if (!avdev->hw_res.irq_num) {
		state = -ENOMEM;
		goto get_avin_param_failed;
	}

	for (i = 0; i < avdev->dts_param.dts_device_num; i++)
		avdev->hw_res.irq_num[i] = gpiod_to_irq(avdev->hw_res.pin[i]);

	return 0;

get_avin_param_failed:
	return -EINVAL;
}

static int avin_open(struct inode *inode, struct file *file)
{
	int ret = 0;
	struct avin_det_s *avindev;

	avindev = container_of(inode->i_cdev, struct avin_det_s, avin_cdev);
	file->private_data = avindev;
	return ret;
}

static ssize_t avin_read(struct file *file, char __user *buf,
	size_t count, loff_t *ppos)
{
	unsigned long ret;
	struct avin_det_s *avin_data = (struct avin_det_s *)file->private_data;

	/*wait_event_interruptible(avin_waitq, avin_data->report_data_flag);*/
	ret = copy_to_user(buf,
		(void *)(avin_data->code_variable.report_data_s),
		sizeof(avin_data->code_variable.report_data_s[0])
		* avin_data->dts_param.dts_device_num);
	avin_data->code_variable.report_data_flag = 0;
	return 0;
}

static int avin_config_release(struct inode *inode, struct file *file)
{
	file->private_data = NULL;
	return 0;
}

static unsigned int avin_poll(struct file *file, poll_table *wait)
{
	unsigned int mask = 0;
	struct avin_det_s *avin_data = (struct avin_det_s *)file->private_data;

	poll_wait(file, &avin_waitq, wait);

	if (avin_data->code_variable.report_data_flag)
		mask |= POLLIN | POLLRDNORM;
	return mask;
}

static const struct file_operations avin_fops = {
	.owner      = THIS_MODULE,
	.open       = avin_open,
	.read       = avin_read,
	.poll       = avin_poll,
	.release    = avin_config_release,
};

static int register_avin_dev(struct avin_det_s *avin_data)
{
	int ret = 0;

	ret = alloc_chrdev_region(&avin_data->avin_devno,
		0, 1, "avin_detect_region");
	if (ret < 0) {
		pr_err("avin: failed to allocate major number\n");
		return -ENODEV;
	}

	/* connect the file operations with cdev */
	cdev_init(&avin_data->avin_cdev, &avin_fops);
	avin_data->avin_cdev.owner = THIS_MODULE;
	/* connect the major/minor number to the cdev */
	ret = cdev_add(&avin_data->avin_cdev, avin_data->avin_devno, 1);
	if (ret) {
		pr_err("avin: failed to add device\n");
		return -ENODEV;
	}

	strcpy(avin_data->config_name, "avin_detect");
	avin_data->config_class = class_create(THIS_MODULE,
		avin_data->config_name);
	avin_data->config_dev = device_create(avin_data->config_class, NULL,
		avin_data->avin_devno, NULL, avin_data->config_name);
	if (IS_ERR(avin_data->config_dev)) {
		pr_err("avin: failed to create device node\n");
		ret = PTR_ERR(avin_data->config_dev);
		return ret;
	}

	return ret;
}

static int init_resource(struct avin_det_s *avdev)
{
	int i, j;

	INIT_WORK(&(avdev->work_struct_update),  update_work_update_status);
	INIT_WORK(&(avdev->work_struct_maskirq), update_work_maskirq);
	for (i = 0; i < avdev->dts_param.dts_device_num; i++) {
		for (j = 0; j < avdev->dts_param.dts_detect_times; j++)
			avdev->code_variable.irq_falling_times[
			i * avdev->dts_param.dts_detect_times + j] = 0;

		avdev->code_variable.loop_detect_times[i] = 0;
	}

	/* set timer */
	setup_timer(&avdev->timer, avin_timer_sr, (unsigned long)avdev);
	mod_timer(&avdev->timer, jiffies+msecs_to_jiffies(2000));

	return 0;
}

static int request_mem_resource(struct platform_device *pdev)
{
	int i;
	struct avin_det_s *avdev;

	avdev = platform_get_drvdata(pdev);

	avdev->code_variable.pin_mask_irq_flag =
		devm_kzalloc(&pdev->dev,
		(sizeof(avdev->code_variable.pin_mask_irq_flag[0]) *
		avdev->dts_param.dts_device_num), GFP_KERNEL);
	if (!avdev->code_variable.pin_mask_irq_flag)
		return -ENOMEM;

	avdev->code_variable.loop_detect_times =
		devm_kzalloc(&pdev->dev,
		(sizeof(avdev->code_variable.loop_detect_times[0]) *
		avdev->dts_param.dts_device_num), GFP_KERNEL);
	if (!avdev->code_variable.loop_detect_times)
		return -ENOMEM;

	avdev->code_variable.detect_channel_times =
		devm_kzalloc(&pdev->dev,
		(sizeof(avdev->code_variable.detect_channel_times[0]) *
		avdev->dts_param.dts_device_num), GFP_KERNEL);
	if (!avdev->code_variable.detect_channel_times)
		return -ENOMEM;

	avdev->code_variable.report_data_s =
		devm_kzalloc(&pdev->dev,
		(sizeof(avdev->code_variable.report_data_s[0]) *
		avdev->dts_param.dts_device_num), GFP_KERNEL);
	if (!avdev->code_variable.report_data_s)
		return -ENOMEM;

	avdev->code_variable.irq_falling_times =
		devm_kzalloc(&pdev->dev,
		(sizeof(avdev->code_variable.irq_falling_times[0]) *
		avdev->dts_param.dts_device_num
		* (avdev->dts_param.dts_detect_times)), GFP_KERNEL);
	if (!avdev->code_variable.irq_falling_times)
		return -ENOMEM;

	avdev->code_variable.actual_into_irq_times =
		devm_kzalloc(&pdev->dev,
		(sizeof(avdev->code_variable.actual_into_irq_times[0]) *
		avdev->dts_param.dts_device_num), GFP_KERNEL);
	if (!avdev->code_variable.actual_into_irq_times)
		return -ENOMEM;

	avdev->code_variable.ch_current_status =
		devm_kzalloc(&pdev->dev,
		(sizeof(avdev->code_variable.ch_current_status[0]) *
		avdev->dts_param.dts_device_num), GFP_KERNEL);
	if (!avdev->code_variable.ch_current_status)
		return -ENOMEM;

	for (i = 0; i < avdev->dts_param.dts_device_num; i++)
		avdev->code_variable.ch_current_status[i] = AVIN_STATUS_UNKNOWN;

	return 0;
}

int avin_detect_probe(struct platform_device *pdev)
{
	int i;
	int ret;
	struct avin_det_s *avdev = NULL;

	avdev = devm_kzalloc(&pdev->dev,
			sizeof(struct avin_det_s), GFP_KERNEL);
	if (!avdev)
		return -ENOMEM;

	platform_set_drvdata(pdev, avdev);

	ret = aml_sysavin_dts_parse(pdev);
	if (ret)
		return ret;

	ret = request_mem_resource(pdev);
	if (ret)
		return ret;

	init_resource(avdev);

	/* request irq num*/
	for (i = 0; i < avdev->dts_param.dts_device_num; i++) {
		ret = devm_request_irq(&pdev->dev, avdev->hw_res.irq_num[i],
		avin_detect_handler, IRQF_TRIGGER_FALLING,
		avin_name_ch[i], (void *)avdev);
		if (ret) {
			pr_info("Unable to request irq resource.\n");
			return -EINVAL;
		}
	}

	mutex_init(&avdev->lock);

	/* register input device */
	avdev->input_dev = input_allocate_device();
	if (avdev->input_dev == 0)
		return -ENOMEM;

	set_bit(EV_ABS, avdev->input_dev->evbit);
	input_set_abs_params(avdev->input_dev,
	 ABS_AVIN_1, 0, 2, 0, 0);
	input_set_abs_params(avdev->input_dev,
	 ABS_AVIN_2, 0, 2, 0, 0);
	avdev->input_dev->name = AVIN_NAME;
    /*avdev->input_dev->phys = "gpio_keypad/input0";*/
	avdev->input_dev->dev.parent = &pdev->dev;
	avdev->input_dev->id.bustype = BUS_ISA;
	avdev->input_dev->id.vendor  = 0x5f5f;
	avdev->input_dev->id.product = 0x6f6f;
	avdev->input_dev->id.version = 0x7f7f;

	ret = input_register_device(avdev->input_dev);
	if (ret < 0) {
		pr_info("Unable to register avin input device.\n");
		input_free_device(avdev->input_dev);
		return -EINVAL;
	}

	/* register char device */
	ret = register_avin_dev(avdev);
	if (ret)
		return ret;

	return 0;
}

static int avin_detect_suspend(struct platform_device *pdev,
	pm_message_t state)
{
	int i;
	struct avin_det_s *avdev = platform_get_drvdata(pdev);

	del_timer_sync(&avdev->timer);
	cancel_work_sync(&avdev->work_struct_update);
	cancel_work_sync(&avdev->work_struct_maskirq);
	for (i = 0; i < avdev->dts_param.dts_device_num; i++) {
		avin_disable_irq(avdev->hw_res.irq_num[i]);
		avdev->code_variable.irq_falling_times[i] = 0;
		avdev->code_variable.detect_channel_times[i] = 0;
		avdev->code_variable.loop_detect_times[i] = 0;
	}
	pr_info("avin_detect_suspend ok.\n");
	return 0;
}

static int avin_detect_resume(struct platform_device *pdev)
{
	int i;
	struct avin_det_s *avdev = platform_get_drvdata(pdev);

	for (i = 0; i < avdev->dts_param.dts_device_num; i++)
		avin_enable_irq(avdev->hw_res.irq_num[i]);
	init_resource(avdev);
	pr_info("avin_detect_resume ok.\n");
	return 0;
}

int avin_detect_remove(struct platform_device *pdev)
{
	struct avin_det_s *avdev = platform_get_drvdata(pdev);

	input_unregister_device(avdev->input_dev);
	input_free_device(avdev->input_dev);
	cdev_del(&avdev->avin_cdev);
	del_timer_sync(&avdev->timer);
	cancel_work_sync(&avdev->work_struct_update);
	cancel_work_sync(&avdev->work_struct_maskirq);

	return 0;
}

#ifdef CONFIG_OF
static const struct of_device_id avin_dt_match[] = {
	{	.compatible = "amlogic, avin_detect",
	},
	{},
};
#else
#define avin_dt_match NULL
#endif

static struct platform_driver avin_driver = {
	.probe      = avin_detect_probe,
	.remove     = avin_detect_remove,
	.suspend    = avin_detect_suspend,
	.resume     = avin_detect_resume,
	.driver     = {
		.name   = "avin_detect",
		.of_match_table = avin_dt_match,
	},
};

module_platform_driver(avin_driver);

MODULE_DESCRIPTION("Meson AVIN Driver");
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Amlogic, Inc.");