/* 
 * 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 <linux/of_gpio.h>
#include <linux/gpio.h>
#include <linux/iio/consumer.h>
#include <linux/of.h>
#include "nkio.h"

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

struct ndj_io_pdata *NDJpdata_info;
u32 op0_enable,op1_enable,op2_enable,op3_enable,op4_enable,op5_enable,mic_enable;
u32 ip0_enable,ip1_enable,ip2_enable,ip3_enable,ip4_enable,ip5_enable;
u32 module_enable;
static struct class *ndj_class;

  
static int ndj_io_control_probe(struct platform_device *pdev)
{
	struct device_node *node = pdev->dev.of_node;
	struct ndj_io_pdata *pdata;
	int ret;
	int i=0;
	enum of_gpio_flags flags;
	int ch342_reset, ch342_reset_2;
	printk(" ####### NDJ_io_control_probe####### \n");
	
	pdata = kzalloc(sizeof(struct ndj_io_pdata), GFP_KERNEL);
	if (pdata == NULL) {
		printk("%s failed to allocate driver data\n",__FUNCTION__);
		return -ENOMEM;
	}
	memset(pdata,0,sizeof(struct ndj_io_pdata));

	
	//mic_switch_gpio
		ret = of_get_named_gpio_flags(node, "mic_switch_gpio", 0, &flags);
		if (ret < 0) {
				printk("%s() Can not read property mic_switch_gpio\n", __FUNCTION__);
				goto err;
		} else {
				pdata->mic_switch_gpio = ret;
				ret = devm_gpio_request(&pdev->dev, pdata->mic_switch_gpio, "mic_switch_gpio");
				if(ret < 0){
						printk("%s() devm_gpio_request mic_switch_gpio request ERROR\n", __FUNCTION__);
						goto err;
				}
				ret = gpio_direction_output(pdata->mic_switch_gpio,0); 
				mic_enable = 0;
				if(ret < 0){
				printk("%s() gpio_direction_input mic_switch_gpio set ERROR\n", __FUNCTION__);
				goto err;
		}
				}

	//vcc_5v_io
	ret = of_get_named_gpio_flags(node, "vcc_5v_io", 0, &flags);
	if (ret < 0) {
		printk("%s() Can not read property vcc_5v_io\n", __FUNCTION__);
		goto err;
	} else {
		pdata->vcc_5v_io = ret;
		ret = devm_gpio_request(&pdev->dev, pdata->vcc_5v_io, "vcc_5v_io");
		if(ret < 0){
			printk("%s() devm_gpio_request vcc_5v_io request ERROR\n", __FUNCTION__);
			goto err;
		}

		ret = gpio_direction_output(pdata->vcc_5v_io,1); 
		if(ret < 0){
			printk("%s() gpio_direction_output vcc_5v_io set ERROR\n", __FUNCTION__);
			goto err;
		}
	}

		//vcc_12v_io
	ret = of_get_named_gpio_flags(node, "vcc_12v_io", 0, &flags);
	if (ret < 0) {
		printk("%s() Can not read property vcc_12v_io\n", __FUNCTION__);
		goto err;
	} else {
		pdata->vcc_12v_io = ret;
		ret = devm_gpio_request(&pdev->dev, pdata->vcc_12v_io, "vcc_12v_io");
		if(ret < 0){
			printk("%s() devm_gpio_request vcc_12v_io request ERROR\n", __FUNCTION__);
			goto err;
		}

		ret = gpio_direction_output(pdata->vcc_12v_io,1); 
		if(ret < 0){
			printk("%s() gpio_direction_output vcc_12v_io set ERROR\n", __FUNCTION__);
			goto err;
		}
	}
#if 0
		//hub_5V_gpio
	ret = of_get_named_gpio_flags(node, "hub_5V_gpio", 0, &flags);
	if (ret < 0) {
		printk("%s() Can not read property hub_5V_gpio\n", __FUNCTION__);
		goto err;
	} else {
		
		pdata->hub_5V_gpio = ret;
		gpio_free(ret);
		ret = devm_gpio_request(&pdev->dev, pdata->hub_5V_gpio, "hub_5V_gpio");
		if(ret < 0){
			printk("%s() devm_gpio_request hub_5V_gpio request ERROR\n", __FUNCTION__);
			goto err;
		}

		ret = gpio_direction_output(pdata->hub_5V_gpio,1); 
		if(ret < 0){
			printk("%s() gpio_direction_output hub_5V_gpio set ERROR\n", __FUNCTION__);
			goto err;
		}
	}
#endif

	//hub_5V_rest_gpio
	ret = of_get_named_gpio_flags(node, "hub_5V_rest_gpio", 0, &flags);
	if (ret < 0) {
		printk("%s() Can not read property hub_5V_rest_gpio\n", __FUNCTION__);
		goto err;
	} else {
		pdata->hub_5V_rest_gpio = ret;
		ret = devm_gpio_request(&pdev->dev, pdata->hub_5V_rest_gpio, "hub_5V_rest_gpio");
		if(ret < 0){
			printk("%s() devm_gpio_request hub_5V_rest_gpio request ERROR\n", __FUNCTION__);
			goto err;
		}

		ret = gpio_direction_output(pdata->hub_5V_rest_gpio,0); 
		if(ret < 0){
			printk("%s() gpio_direction_output hub_5V_rest_gpio set ERROR\n", __FUNCTION__);
			goto err;
		}
		msleep(800);
		ret = gpio_direction_output(pdata->hub_5V_rest_gpio,1); 
		if(ret < 0){
			printk("%s() gpio_direction_output hub_5V_rest_gpio set ERROR\n", __FUNCTION__);
			goto err;
		}
	}

	   ret = of_get_named_gpio_flags(node, "ch342_power", 0, &flags);
           if (ret < 0) {
                   printk("%s() Can not read property ch342_power\n", __FUNCTION__);
           } else {
                   pdata->ch342_power = ret;

                   ret = devm_gpio_request(&pdev->dev, pdata->ch342_power, "wch342_power");
                   if(ret < 0){
                           printk("%s() devm_gpio_request ch342_power request ERROR\n", __FUNCTION__);
                   }
                   ret = gpio_direction_output(pdata->ch342_power,1);
                   if(ret < 0){
                           printk("%s() gpio_direction_input wake_4g_gpio set ERROR\n", __FUNCTION__);
                   }
           }

	#if 1
         // ch342_reset
           ret = of_get_named_gpio_flags(node, "ch342_reset", 0, &flags);
           if (ret < 0) {
                   printk("%s() Can not read property ch342_reset\n", __FUNCTION__);
           } else {
                   pdata->reset_ch342_gpio = ret;

                   ret = devm_gpio_request(&pdev->dev, pdata->reset_ch342_gpio, "ch342_reset");
                   if(ret < 0){
                           printk("%s() devm_gpio_request ch342_reset request ERROR\n", __FUNCTION__);
                   }
		
		    ret = gpio_direction_output(pdata->reset_ch342_gpio,0);
                if(ret < 0){
                        printk("%s() gpio_direction_output reset_ch342_gpio set ERROR\n", __FUNCTION__);
                        goto err;
                }
                msleep(200);
                ret = gpio_direction_output(pdata->reset_ch342_gpio,1);
                if(ret < 0){
                        printk("%s() gpio_direction_output reset_ch342_gpio set ERROR\n", __FUNCTION__);
                        goto err;
                }
           }

        ret = of_get_named_gpio_flags(node, "ch342_reset_2", 0, &flags);
           if (ret < 0) {
                   printk("%s() Can not read property ch342_reset_2\n", __FUNCTION__);
           } else {
                   pdata->reset_ch342_gpio_2 = ret;

                   ret = devm_gpio_request(&pdev->dev, pdata->reset_ch342_gpio_2, "ch342_reset_2");
                   if(ret < 0){
                           printk("%s() devm_gpio_request ch342_reset request ERROR\n", __FUNCTION__);
                   }
		    ret = gpio_direction_output(pdata->reset_ch342_gpio_2,0);
                if(ret < 0){
                        printk("%s() gpio_direction_output reset_ch342_gpio_2 set ERROR\n", __FUNCTION__);
                        goto err;
                }
                msleep(200);
                ret = gpio_direction_output(pdata->reset_ch342_gpio_2,1);
                if(ret < 0){
                        printk("%s() gpio_direction_output reset_ch342_gpio_2 set ERROR\n", __FUNCTION__);
                        goto err;
                }
           }
#endif
#if 1
           //reset_4g_gpio
           ret = of_get_named_gpio_flags(node, "reset_4g_gpio", 0, &flags);
           if (ret < 0) {
                   printk("%s() Can not read property reset_4g_gpio\n", __FUNCTION__);
           } else {
                   pdata->reset_4g_gpio = ret;

                   ret = devm_gpio_request(&pdev->dev, pdata->reset_4g_gpio, "reset_4g_gpio");
                   if(ret < 0){
                           printk("%s() devm_gpio_request reset_4g_gpio request ERROR\n", __FUNCTION__);
                   }
                   ret = gpio_direction_output(pdata->reset_4g_gpio,1);
                   if(ret < 0){
                           printk("%s() gpio_direction_input reset_4g_gpio set ERROR\n", __FUNCTION__);
                   }
	           mdelay(300);
                   ret = gpio_direction_output(pdata->reset_4g_gpio,0);
                   if(ret < 0){
                           printk("%s() gpio_direction_input reset_4g_gpio set ERROR\n", __FUNCTION__);
                   }
           }
#endif

	         //en_4g_gpio
           ret = of_get_named_gpio_flags(node, "en_4g_gpio", 0, &flags);
           if (ret < 0) {
                   printk("%s() Can not read property en_4g_gpio\n", __FUNCTION__);
           } else {
                   pdata->en_4g_gpio = ret;

                   ret = devm_gpio_request(&pdev->dev, pdata->en_4g_gpio, "en_4g_gpio");
                   if(ret < 0){
                           printk("%s() devm_gpio_request en_4g_gpio request ERROR\n", __FUNCTION__);
                   }
                   ret = gpio_direction_output(pdata->en_4g_gpio,1);
                   if(ret < 0){
                           printk("%s() gpio_direction_input en_4g_gpio set ERROR\n", __FUNCTION__);
                   }
           }


           //air_mode_4g_gpio
           ret = of_get_named_gpio_flags(node, "air_mode_4g_gpio", 0, &flags);
           if (ret < 0) {
                   printk("%s() Can not read property air_mode_4g_gpio\n", __FUNCTION__);
           } else {
                   pdata->air_mode_4g_gpio = ret;

                   ret = devm_gpio_request(&pdev->dev, pdata->air_mode_4g_gpio, "air_mode_4g_gpio");
                   if(ret < 0){
                           printk("%s() devm_gpio_request air_mode_4g_gpio request ERROR\n", __FUNCTION__);
                   }
                   ret = gpio_direction_output(pdata->air_mode_4g_gpio,0);
                   if(ret < 0){
                           printk("%s() gpio_direction_input air_mode_4g_gpio set ERROR\n", __FUNCTION__);
                   }
           }


	  //air_mode_4g_gpio
           ret = of_get_named_gpio_flags(node, "wake_4g_gpio", 0, &flags);
           if (ret < 0) {
                   printk("%s() Can not read property wake_4g_gpio\n", __FUNCTION__);
           } else {
                   pdata->air_mode_4g_gpio = ret;

                   ret = devm_gpio_request(&pdev->dev, pdata->air_mode_4g_gpio, "wake_4g_gpio");
                   if(ret < 0){
                           printk("%s() devm_gpio_request wake_4g_gpio request ERROR\n", __FUNCTION__);
                   }
                   ret = gpio_direction_output(pdata->wake_4g_gpio,0);
                   if(ret < 0){
                           printk("%s() gpio_direction_output wake_4g_gpio set ERROR\n", __FUNCTION__);
                   }
           }



	#if 0
		//audio_switch_gpio
	ret = of_get_named_gpio_flags(node, "audio_switch_gpio", 0, &flags);
	if (ret < 0) {
		printk("%s() Can not read property audio_switch_gpio\n", __FUNCTION__);
		goto err;
	} else {
		pdata->audio_switch_gpio = ret;
		ret = devm_gpio_request(&pdev->dev, pdata->audio_switch_gpio, "audio_switch_gpio");
		if(ret < 0){
			printk("%s() devm_gpio_request audio_switch_gpio request ERROR\n", __FUNCTION__);
			goto err;
		}
            ret = gpio_direction_output(pdata->audio_switch_gpio, !flags); 
		if(ret < 0){
		printk("%s() gpio_direction_input audio_switch_gpio set ERROR\n", __FUNCTION__);
		goto err;
	}
		}
		#endif

//    printk("fan_io_en ....\r\n"); 
    ret = of_get_named_gpio_flags(node, "fan_io_en", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property fan_io_en\n", __FUNCTION__);
        goto err;
    } else {
        int gpio = ret;
        ret = devm_gpio_request(&pdev->dev, gpio, "fan_io_en");
        if(ret < 0){
            printk("%s() devm_gpio_request vcc_5v_io request ERROR\n", __FUNCTION__);
            goto err;
        }

        ret = gpio_direction_output(gpio, !flags); 
        if(ret < 0){
            printk("%s() gpio_direction_input fan_io_en set ERROR\n", __FUNCTION__);
            goto err;
        }
    }
 //   printk("fan_io_en ....ok!\r\n"); 

	
	   
	NDJpdata_info = pdata;

	printk(" #######ndj_io_control_probe end####### \n");
	return 0;
err:
	kfree(pdata);
	return ret;
}

static int ndj_io_control_remove(struct platform_device *pdev)
{
	if(NDJpdata_info)
		kfree(NDJpdata_info);
	return 0;
}

static int ndj_io_control_suspend(struct platform_device *pdev, pm_message_t state)
{
	printk("LED_early_suspend LED_early_suspend LED_early_suspend !!!!\n");

	//enable = 0;
	//LED_SET(0);
	return 0;
}

static int ndj_io_control_resume(struct platform_device *pdev)
{
	printk("LED_early_resume LED_early_resume LED_early_resume !!!!\n");

	//enable = 1;
    //LED_SET(11);
	return 0;
}

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

static struct platform_driver ndj_io_control_driver = {
	.probe	= ndj_io_control_probe,
	.remove = ndj_io_control_remove,
	.resume = ndj_io_control_resume,	
	.suspend = ndj_io_control_suspend,	
	.driver	= {
		.name	= "ndj_io_control",
		.owner	= THIS_MODULE,
		.of_match_table = of_match_ptr(ndj_io_control_of_match),		
	},
};

static int __init ndj_io_control_init(void)
{
	platform_driver_register(&ndj_io_control_driver);
	return 0;
}

static void __exit ndj_io_control_exit(void)
{
	platform_driver_unregister(&ndj_io_control_driver);
}

subsys_initcall(ndj_io_control_init);

//late_initcall(ndj_io_control_init);
MODULE_DESCRIPTION("ndj io Core Driver");
MODULE_LICENSE("GPL");