/*
 * drivers/input/sensor/sunxi_tpadc.c
 *
 * Copyright (C) 2017 Allwinner.
 * fuzhaoke <yangshounan@allwinnertech.com>
 *
 * SUNXI TPADC Controller Driver
 *
 * 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.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/delay.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/ioport.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <linux/timer.h>
#include <linux/clk.h>
#include <linux/irq.h>
#include <linux/of_platform.h>
#include <linux/of_irq.h>
#include <linux/of_address.h>
#include <linux/pm.h>
#include "sunxi_tpadc.h"

static void sunxi_tpadc_clk_division(void __iomem *reg_base, unsigned char divider)
{
	u32 reg;

	reg = readl(reg_base + TP_CTRL0_REG);
	reg |= (divider & 0x3) << ADC_CLK_DIVIDER;
	writel(reg, reg_base + TP_CTRL0_REG);
}

static void sunxi_tpadc_fs_set(void __iomem *reg_base, unsigned char divider)
{
	u32 reg;

	reg = readl(reg_base + TP_CTRL0_REG);
	reg |= (divider & 0xf) << FS_DIVIDER;
	writel(reg, reg_base + TP_CTRL0_REG);
}
static void sunxi_tpadc_ta_set(void __iomem *reg_base, int val)
{
	int reg;

	reg = readl(reg_base + TP_CTRL0_REG);
	reg |= val & 0xfff;
	writel(reg, reg_base + TP_CTRL0_REG);
}

static void sunxi_tpadc_clk_select(void __iomem *reg_base, bool on)
{
	u32 reg;

	reg = readl(reg_base + TP_CTRL0_REG);
	if (on)
		reg &= ~TP_CLOCK;
	else
		reg |= TP_CLOCK;
	writel(reg, reg_base + TP_CTRL0_REG);
}

static void sunxi_tpadc_select_adc(void __iomem *reg_base)
{
	int reg;

	reg = readl(reg_base + TP_CTRL1_REG);
	reg |= ADC_ENABLE;
	writel(reg, reg_base + TP_CTRL1_REG);
}

static void sunxi_tpadc_rtp_enable(void __iomem *reg_base)
{
	int reg;

	reg = readl(reg_base + TP_CTRL1_REG);
	reg |= RTP_MODE_ENABLE;
	writel(reg, reg_base + TP_CTRL1_REG);
}

static void sunxi_tpadc_filter_enable(void __iomem *reg_base)
{
	int reg;

	reg = readl(reg_base + TP_CTRL3_REG);
	reg |= RTP_FILTER_ENABLE;
	writel(reg, reg_base + TP_CTRL3_REG);
}
static void sunxi_tpadc_filter_type(void __iomem *reg_base)
{
	int reg;

	reg = readl(reg_base + TP_CTRL3_REG);
	reg |= RTP_FILTER_TYPE;
	writel(reg, reg_base + TP_CTRL3_REG);
}

static void sunxi_tpadc_trig_level(void __iomem *reg_base, int val)
{
	int reg;

	reg = readl(reg_base + TP_INT_FIFOC_REG);
	reg |= (val & 0xf)<<8;
	writel(reg, reg_base + TP_INT_FIFOC_REG);
}
static void sunxi_tpadc_downup_irq(void __iomem *reg_base)
{
	int reg;

	reg = readl(reg_base + TP_INT_FIFOC_REG);
	reg |= 0x03;
	writel(reg, reg_base + TP_INT_FIFOC_REG);
}

static u32 sunxi_tpadc_ch_select(void __iomem *reg_base, enum tp_channel_id id)
{
	u32 reg_val;

	reg_val = readl(reg_base + TP_CTRL1_REG);
	switch (id) {
	case TP_CH_0:
		reg_val |= TP_CH0_SELECT;
		break;
	case TP_CH_1:
		reg_val |= TP_CH1_SELECT;
		break;
	case TP_CH_2:
		reg_val |= TP_CH2_SELECT;
		break;
	case TP_CH_3:
		reg_val |= TP_CH3_SELECT;
		break;
	default:
		pr_err("%s, invalid channel id!", __func__);
		return -EINVAL;
	}
	writel(reg_val, reg_base + TP_CTRL1_REG);

	return 0;
}

static int sunxi_tpadc_ch_deselect(void __iomem *reg_base, enum tp_channel_id id)
{
	u32 reg_val;

	reg_val = readl(reg_base + TP_CTRL1_REG);
	switch (id) {
	case TP_CH_0:
		reg_val &= ~TP_CH0_SELECT;
		break;
	case TP_CH_1:
		reg_val &= ~TP_CH1_SELECT;
		break;
	case TP_CH_2:
		reg_val &= ~TP_CH2_SELECT;
		break;
	case TP_CH_3:
		reg_val &= ~TP_CH3_SELECT;
		break;
	default:
		pr_err("%s, invalid channel id!", __func__);
		return -EINVAL;
	}
	writel(reg_val, reg_base + TP_CTRL1_REG);

	return 0;
}

static void sunxi_tpadc_enable_irq(void __iomem *reg_base)
{
	u32 reg_val;

	reg_val = readl(reg_base + TP_INT_FIFOC_REG);
	reg_val |= TP_DATA_IRQ_EN;
	writel(reg_val, reg_base + TP_INT_FIFOC_REG);

}

static void sunxi_tpadc_disable_irq(void __iomem *reg_base)
{
	u32 reg_val;

	reg_val = readl(reg_base + TP_INT_FIFOC_REG);
	reg_val &= ~TP_DATA_IRQ_EN;
	writel(reg_val, reg_base + TP_INT_FIFOC_REG);
}

static u32 sunxi_tpadc_irq_status(void __iomem *reg_base)
{
	return readl(reg_base + TP_INT_FIFOS_REG);
}

static void sunxi_tpadc_clear_pending(void __iomem *reg_base, int reg_val)
{
	writel(reg_val, reg_base + TP_INT_FIFOS_REG);
}

static u32 sunxi_tpadc_data_read(void __iomem *reg_base)
{
	return readl(reg_base + TP_DATA_REG);
}

static u32 sunxi_tpadc_clk_config(void __iomem *reg_base, u32 clk_in, u32 sclk_freq)
{
	u32 freq, divider = sclk_freq / clk_in;
	u32 val;

	if (divider > 3 && divider < 6)
		divider = 3;
	if (divider > 6)
		divider = 6;

	switch (divider) {
	case 1:
		val = 0x03;
		break;
	case 2:
		val = 0x00;
		break;
	case 3:
		val = 0x01;
		break;
	case 6:
		val = 0x02;
		break;
	default:
		break;
	}
	sunxi_tpadc_clk_division(reg_base, val);
	freq = sclk_freq / divider;

	return freq;
}
static u32 sunxi_tpadc_fs_config(void __iomem *reg_base, u32 clk_in, u32 fs_div)
{
	u32 sample_freq;

	sunxi_tpadc_fs_set(reg_base, fs_div);
	sample_freq = clk_in / (1 << (20 - fs_div));

	return sample_freq;
}

static int sunxi_tpadc_hw_init(struct sunxi_tpadc *sunxi_tpadc)
{
	u32 clk_in;
	u32 sample_freq;

	sunxi_tpadc_clk_select(sunxi_tpadc->reg_base, HOSC);
	clk_in = sunxi_tpadc_clk_config(sunxi_tpadc->reg_base, CLK_IN, 24000000);
	sunxi_tpadc_fs_config(sunxi_tpadc->reg_base, clk_in, 0x06);
	sunxi_tpadc_ta_set(sunxi_tpadc->reg_base, 0xff);
	sunxi_tpadc_select_adc(sunxi_tpadc->reg_base);
	sunxi_tpadc_ch_select(sunxi_tpadc->reg_base, 0);
	sunxi_tpadc_ch_select(sunxi_tpadc->reg_base, 2);
	sunxi_tpadc_enable_irq(sunxi_tpadc->reg_base);
	sunxi_tpadc_filter_enable(sunxi_tpadc->reg_base);
	sunxi_tpadc_filter_type(sunxi_tpadc->reg_base);
	sunxi_tpadc_trig_level(sunxi_tpadc->reg_base, 0x03);
	sunxi_tpadc_downup_irq(sunxi_tpadc->reg_base);
	sunxi_tpadc_rtp_enable(sunxi_tpadc->reg_base);

	return 0;
}

static irqreturn_t sunxi_tpadc_interrupt(int irqno, void *dev_id)
{
	struct sunxi_tpadc *sunxi_tpadc = (struct sunxi_tpadc *)dev_id;
	u32  reg_val;
	u32 data;

	reg_val = sunxi_tpadc_irq_status(sunxi_tpadc->reg_base);
	sunxi_tpadc_clear_pending(sunxi_tpadc->reg_base, reg_val);

	if (reg_val & SUNXI_FIFO_DATA) {
		data = sunxi_tpadc_data_read(sunxi_tpadc->reg_base);
		input_event(sunxi_tpadc->input_channel0, EV_MSC, MSC_SCAN, data);
		input_sync(sunxi_tpadc->input_channel0);

		data = sunxi_tpadc_data_read(sunxi_tpadc->reg_base);
		input_event(sunxi_tpadc->input_channel2, EV_MSC, MSC_SCAN, data);
		input_sync(sunxi_tpadc->input_channel2);
	}

	return IRQ_HANDLED;
}
static int sunxi_input_register_channel0(struct sunxi_tpadc *sunxi_tpadc)
{
	static struct input_dev *input_dev;
	int ret;

	input_dev = input_allocate_device();
	if (!input_dev) {
		pr_err("input_dev: not enough memory for input device\n");
		return -ENOMEM;
	}

	input_dev->name = "sunxitpadc_channel0";
	input_dev->phys = "sunxitpadc/input0";
	input_dev->id.bustype = BUS_HOST;
	input_dev->id.vendor = 0x0001;
	input_dev->id.product = 0x0001;
	input_dev->id.version = 0x0100;

	input_dev->evbit[0] = BIT_MASK(EV_MSC);
	set_bit(EV_MSC, input_dev->evbit);
	set_bit(MSC_SCAN, input_dev->mscbit);
	sunxi_tpadc->input_channel0 = input_dev;

	ret = input_register_device(sunxi_tpadc->input_channel0);
	if (ret) {
		pr_err("input register fail\n");
		goto fail;
	}

	return 0;

fail:
	input_unregister_device(sunxi_tpadc->input_channel0);
	input_free_device(sunxi_tpadc->input_channel0);

	return ret;
}

static int sunxi_input_register_channel2(struct sunxi_tpadc *sunxi_tpadc)
{
		static struct input_dev *input_dev;
		int ret;

		input_dev = input_allocate_device();
		if (!input_dev) {
			pr_err("input_dev: not enough memory for input device\n");
			return -ENOMEM;
		}

		input_dev->name = "sunxitpadc_channel2";
		input_dev->phys = "sunxitpadc/input0";
		input_dev->id.bustype = BUS_HOST;
		input_dev->id.vendor = 0x0001;
		input_dev->id.product = 0x0001;
		input_dev->id.version = 0x0100;

		input_dev->evbit[0] = BIT_MASK(EV_MSC);
		set_bit(EV_MSC, input_dev->evbit);
		set_bit(MSC_SCAN, input_dev->mscbit);
		sunxi_tpadc->input_channel2 = input_dev;

		ret = input_register_device(sunxi_tpadc->input_channel2);
		if (ret) {
			pr_err("input register fail\n");
			goto fail;
		}

		return 0;

	fail:
		input_unregister_device(sunxi_tpadc->input_channel2);
		input_free_device(sunxi_tpadc->input_channel2);

		return ret;

}

int sunxi_tpadc_probe(struct platform_device *pdev)
{
	struct device_node *np = pdev->dev.of_node;
	struct sunxi_tpadc *sunxi_tpadc;
	int ret = 0;

	if (!of_device_is_available(np)) {
		pr_err("%s: sunxi tpadc is disable\n", __func__);
		return -EPERM;
	}

	sunxi_tpadc = kzalloc(sizeof(struct sunxi_tpadc), GFP_KERNEL);
	if (IS_ERR_OR_NULL(sunxi_tpadc)) {
		pr_err("not enough memory for sunxi_tpadc\n");
		return -ENOMEM;
	}

	sunxi_tpadc->reg_base = of_iomap(np, 0);
	if (NULL == sunxi_tpadc->reg_base) {
		pr_err("sunxi_tpadc iomap fail\n");
		ret = -EBUSY;
		goto fail1;
	}

	sunxi_tpadc->irq_num = irq_of_parse_and_map(np, 0);
	if (0 == sunxi_tpadc->irq_num) {
		pr_err("sunxi_tpadc fail to map irq\n");
		ret = -EBUSY;
		goto fail2;
	}

	sunxi_tpadc_hw_init(sunxi_tpadc);

	sunxi_input_register_channel0(sunxi_tpadc);
	sunxi_input_register_channel2(sunxi_tpadc);

	if (request_irq(sunxi_tpadc->irq_num, sunxi_tpadc_interrupt,
				IRQF_TRIGGER_NONE, "sunxi-tpadc", sunxi_tpadc)) {
		pr_err("sunxi_tpadc request irq failure\n");
		return -1;
	}

	platform_set_drvdata(pdev, sunxi_tpadc);

	return 0;

fail2:
	iounmap(sunxi_tpadc->reg_base);
fail1:
	kfree(sunxi_tpadc);

	return ret;
}

int sunxi_tpadc_remove(struct platform_device *pdev)
{
	struct sunxi_tpadc *sunxi_tpadc = platform_get_drvdata(pdev);

	sunxi_tpadc_disable_irq(sunxi_tpadc->reg_base);
	sunxi_tpadc_ch_deselect(sunxi_tpadc->reg_base, 0);
	sunxi_tpadc_ch_deselect(sunxi_tpadc->reg_base, 2);
	free_irq(sunxi_tpadc->irq_num, sunxi_tpadc);
	iounmap(sunxi_tpadc->reg_base);
	input_unregister_device(sunxi_tpadc->input_channel0);
	input_free_device(sunxi_tpadc->input_channel0);
	input_unregister_device(sunxi_tpadc->input_channel2);
	input_free_device(sunxi_tpadc->input_channel2);
	kfree(sunxi_tpadc);

	return 0;
}

#ifdef CONFIG_PM
static int sunxi_tpadc_suspend(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct sunxi_tpadc *sunxi_tpadc = platform_get_drvdata(pdev);

	sunxi_tpadc_disable_irq(sunxi_tpadc->reg_base);
	sunxi_tpadc_ch_deselect(sunxi_tpadc->reg_base, 0);
	sunxi_tpadc_ch_deselect(sunxi_tpadc->reg_base, 2);
	disable_irq_nosync(sunxi_tpadc->irq_num);

	return 0;
}

static int sunxi_tpadc_resume(struct device *dev)
{
	struct platform_device *pdev = to_platform_device(dev);
	struct sunxi_tpadc *sunxi_tpadc = platform_get_drvdata(pdev);

	sunxi_tpadc_enable_irq(sunxi_tpadc->reg_base);
	sunxi_tpadc_ch_select(sunxi_tpadc->reg_base, 0);
	sunxi_tpadc_ch_select(sunxi_tpadc->reg_base, 2);
	enable_irq(sunxi_tpadc->irq_num);

	return 0;
}

static const struct dev_pm_ops sunxi_tpadc_dev_pm_ops = {
	.suspend = sunxi_tpadc_suspend,
	.resume = sunxi_tpadc_resume,
};

#define SUNXI_TPADC_DEV_PM_OPS (&sunxi_tpadc_dev_pm_ops)
#else
#define SUNXI_TPADC_DEV_PM_OPS NULL
#endif

static struct of_device_id sunxi_tpadc_of_match[] = {
	{ .compatible = "allwinner,sunxi-tpadc"},
	{},
};
MODULE_DEVICE_TABLE(of, sunxi_tpadc_of_match);

static struct platform_driver sunxi_tpadc_driver = {
	.probe  = sunxi_tpadc_probe,
	.remove = sunxi_tpadc_remove,
	.driver = {
		.name   = "sunxi-tpadc",
		.owner  = THIS_MODULE,
		.pm = SUNXI_TPADC_DEV_PM_OPS,
		.of_match_table = of_match_ptr(sunxi_tpadc_of_match),
	},
};
module_platform_driver(sunxi_tpadc_driver);

MODULE_AUTHOR("yangshounan");
MODULE_DESCRIPTION("sunxi-tpadc driver");
MODULE_LICENSE("GPL");