/*
 * Copyright (C) 2014 Rockchip Corporation.
 *
 * 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/moduleparam.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/pm.h>
#include <linux/i2c.h>
#include <linux/spi/spi.h>
#include <linux/platform_device.h>
#include <linux/errno.h>
#include <linux/err.h>
#include <linux/debugfs.h>
#include "rk_headset.h"
#include <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/iio/consumer.h>

/* Debug */
#if 0
#define DBG(x...) printk(x)
#else
#define DBG(x...) do { } while (0)
#endif

static struct rk_headset_pdata *pdata_info;

static int rockchip_headset_probe(struct platform_device *pdev)
{
	struct device_node *node = pdev->dev.of_node;
	struct rk_headset_pdata *pdata;
	int ret;
	enum of_gpio_flags flags;

	pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
	if (!pdata) {
		printk("%s failed to allocate driver data\n", __func__);
		return -ENOMEM;
	}
	pdata_info = pdata;

	/* headset */
	ret = of_get_named_gpio_flags(node, "headset_gpio", 0, &flags);
	if (ret < 0) {
		dev_err(&pdev->dev, "Can not read property headset_gpio\n");
		goto err;
	} else {
		pdata->headset_gpio = ret;
		ret = devm_gpio_request(&pdev->dev, pdata->headset_gpio,
					"headset_gpio");
		if (ret < 0) {
			dev_err(&pdev->dev, "headset_gpio request fail\n");
			goto err;
		}
		ret = gpio_direction_input(pdata->headset_gpio);
		if (ret < 0) {
			dev_err(&pdev->dev,
				"headset_gpio set direction fail\n");
			goto err;
		}
		pdata->headset_insert_type = (flags & OF_GPIO_ACTIVE_LOW) ?
						     HEADSET_IN_LOW :
						     HEADSET_IN_HIGH;
	}

        /* spk-ctl */
        ret = of_get_named_gpio_flags(node, "spk_ctl_gpio", 0, &flags);
        if (ret < 0) {
                dev_err(&pdev->dev, "Can not read property headset_gpio\n");
                goto err;
        } else {
                pdata->spk_ctl_gpio = ret;
                ret = devm_gpio_request(&pdev->dev, pdata->spk_ctl_gpio,
                                        "spk_ctl_gpio");
                if (ret < 0) {
                        dev_err(&pdev->dev, "spk_ctl_gpio request fail\n");
                        goto err;
                }
		
		ret = gpio_get_value(pdata->headset_gpio);
		printk(" headset_gpio value : %d\n",ret);
		if (ret == 0)
                	ret = gpio_direction_output(pdata->spk_ctl_gpio,0);
		else 
			ret = gpio_direction_output(pdata->spk_ctl_gpio,1);
                if (ret < 0) {
                        dev_err(&pdev->dev,
                                "spk_ctl_gpio set direction fail\n");
                        goto err;
                }
        }

	/* hook */
	ret = of_get_named_gpio_flags(node, "hook_gpio", 0, &pdata->hook_gpio);
	if (ret < 0) {
		dev_warn(&pdev->dev, "Can not read property hook_gpio\n");
		pdata->hook_gpio = 0;
		/* adc mode */
		pdata->chan = iio_channel_get(&pdev->dev, NULL);
		if (IS_ERR(pdata->chan)) {
			pdata->chan = NULL;
			dev_warn(&pdev->dev, "have not set adc chan\n");
		}
	} else {
		ret = of_property_read_u32(node, "hook_down_type",
					   &pdata->hook_down_type);
		if (ret < 0) {
			dev_warn(&pdev->dev,
				 "have not set hook_down_type,set >hook< insert type low level default\n");
			pdata->hook_down_type = 0;
		}
		ret = devm_gpio_request(&pdev->dev, pdata->hook_gpio,
					"hook_gpio");
		if (ret < 0) {
			dev_warn(&pdev->dev,
				 "devm_gpio_request hook_gpio request ERROR\n");
			goto err;
		}
		ret = gpio_direction_input(pdata->hook_gpio);
		if (ret < 0) {
			dev_warn(&pdev->dev,
				 "gpio_direction_input hook_gpio set ERROR\n");
			goto err;
		}
	}

#ifdef CONFIG_MODEM_MIC_SWITCH
	/* mic */
	ret = of_get_named_gpio_flags(node, "mic_switch_gpio", 0, &flags);
	if (ret < 0) {
		DBG("%s() Can not read property mic_switch_gpio\n",
		    __func__);
	} else {
		pdata->headset_gpio = ret;
		ret = of_property_read_u32(node, "hp_mic_io_value",
					   &pdata->hp_mic_io_value);
		if (ret < 0) {
			DBG("%s() have not set hp_mic_io_value ,so default set pull down low level\n",
			    __func__);
			pdata->hp_mic_io_value = 0;
		}
		ret = of_property_read_u32(node, "main_mic_io_value",
					   &pdata->main_mic_io_value);
		if (ret < 0) {
			DBG("%s() have not set main_mic_io_value ,so default set pull down low level\n",
			    __func__);
			pdata->main_mic_io_value = 1;
		}
	}
#endif
	ret = of_property_read_u32(node, "rockchip,headset_wakeup",
				   &pdata->headset_wakeup);
	if (ret < 0)
		pdata->headset_wakeup = 1;
	if (pdata->chan) { /* hook adc mode */
		dev_info(&pdev->dev, "headset have hook adc mode\n");
		ret = rk_headset_adc_probe(pdev, pdata);
		if (ret < 0) {
			goto err;
		}
	} else { /* hook interrupt mode and not hook */
		dev_info(&pdev->dev, "headset have %s mode\n",
			 pdata->hook_gpio ? "interrupt hook" : "no hook");
		ret = rk_headset_probe(pdev, pdata);
		if (ret < 0) {
			goto err;
		}
	}
	return 0;
err:
	return ret;
}

static int rockchip_headset_remove(struct platform_device *pdev)
{
	return 0;
}

static int rockchip_headset_suspend(struct platform_device *pdev,
				    pm_message_t state)
{
	if (pdata_info->chan != 0) {
		return rk_headset_adc_suspend(pdev, state);
	}
	return 0;
}

static int rockchip_headset_resume(struct platform_device *pdev)
{
	if (pdata_info->chan != 0) {
		return rk_headset_adc_resume(pdev);
	}
	return 0;
}

static const struct of_device_id rockchip_headset_of_match[] = {
	{ .compatible = "rockchip_headset", },
	{},
};
MODULE_DEVICE_TABLE(of, rockchip_headset_of_match);

static struct platform_driver rockchip_headset_driver = {
	.probe	= rockchip_headset_probe,
	.remove = rockchip_headset_remove,
	.resume =	rockchip_headset_resume,
	.suspend =	rockchip_headset_suspend,
	.driver	= {
		.name	= "rockchip_headset",
		.owner	= THIS_MODULE,
		.of_match_table = of_match_ptr(rockchip_headset_of_match),
	},
};

static int __init rockchip_headset_init(void)
{
	platform_driver_register(&rockchip_headset_driver);
	return 0;
}

static void __exit rockchip_headset_exit(void)
{
	platform_driver_unregister(&rockchip_headset_driver);
}
late_initcall(rockchip_headset_init);
module_exit(rockchip_headset_exit);

MODULE_DESCRIPTION("Rockchip Headset Core Driver");
MODULE_LICENSE("GPL");