/* 
 * 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 nk_io_pdata *NKpdata_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 *nk_class;


#if 0

 void mic_switch_control(int i)
{
if(i==11){
	gpio_direction_output(NKpdata_info->mic_switch_gpio, 1);
	printk("mic_switch_control ENABLE------andy\n");
}else{
	gpio_direction_output(NKpdata_info->mic_switch_gpio, 0);
	printk("mic_switch_control DISABLE------andy\n");
}
}




static ssize_t mic_switch_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &mic_enable);
		printk("MIC_SWITCH enable =%d\n",mic_enable);

	if (mic_enable)
		{
			printk("store_MIC_SWITCH ENABLE------andy\n");
			mic_switch_control(11);
		}
		else {
			mic_switch_control(0);
			printk("store_MIC_SWITCH DISABLE------andy\n");
		}
		return count;
}

static ssize_t mic_switch_show(struct class *class,struct class_attribute *attr, char *buf)
{
return snprintf(buf, 3, "%d\n",mic_enable);
}

static CLASS_ATTR(mic_switch, 0664, mic_switch_show, mic_switch_store);


 
  void Audio_SET(int i)
 {
	 if(i==11){
		 gpio_direction_output(NKpdata_info->audio_switch_gpio, 1);
		 printk("Audio_SET ENABLE------andy\n");
	 }else{
		 gpio_direction_output(NKWpdata_info->audio_switch_gpio, 0);
		 printk("Audio_SET DISABLE------andy\n");
	 }
 }
  EXPORT_SYMBOL_GPL(Audio_SET);



static void LED_SET(int i)
{
	if(i==11){
		gpio_direction_output(NKpdata_info->led_gpio, 1);
	}else{
		gpio_direction_output(NKpdata_info->led_gpio, 0);
	}
}



static ssize_t led_display_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &enable);
		printk("store_led enable =%d\n",enable);

	if (enable)
		{
			printk("store_led ENABLE------andy\n");
			LED_SET(11);
		}
		else {
			LED_SET(0);
			printk("store_led DISABLE------andy\n");
		}
		return count;
}

static ssize_t led_display_show(struct class *class,struct class_attribute *attr, char *buf)
{
return snprintf(buf, 3, "%d\n",enable);
}

static CLASS_ATTR(led_display, 0664, led_display_show, led_display_store);

#endif

void MODULE_SET(int i)
{
	if(i==11){
		gpio_direction_output(NKpdata_info->en_4g_gpio, 1);
	}else{
		gpio_direction_output(NKpdata_info->en_4g_gpio, 0);
	}
}

EXPORT_SYMBOL_GPL(MODULE_SET);


void LED_SET(int i)
{
	if(i==11){
		gpio_direction_output(NKpdata_info->led_gpio, 1);
	}else{
		gpio_direction_output(NKpdata_info->led_gpio, 0);
	}
}

EXPORT_SYMBOL_GPL(LED_SET);


void Audio_SET(int i);

  void Audio_SET(int i)
 {
	 if(i==11){
		 gpio_direction_output(NKpdata_info->audio_switch_gpio, 1);
		 printk("Audio_SET ENABLE------andy\n");
	 }else{
		 gpio_direction_output(NKpdata_info->audio_switch_gpio, 0);
		 printk("Audio_SET DISABLE------andy\n");
	 }
 }
  EXPORT_SYMBOL_GPL(Audio_SET);


//6 in 6 out-s
static void GPIO_IO_SET(int i)
{
	if(i==11){
		gpio_direction_output(NKpdata_info->gpio_op0, 1);
	}
	else if(i==10){
		gpio_direction_output(NKpdata_info->gpio_op0, 0);
	}
	else if(i==21){
		gpio_direction_output(NKpdata_info->gpio_op1, 1);
	}
	else if(i==20){
		gpio_direction_output(NKpdata_info->gpio_op1, 0);
	}
	else if(i==31){
		gpio_direction_output(NKpdata_info->gpio_op2, 1);
	}
	else if(i==30){
		gpio_direction_output(NKpdata_info->gpio_op2, 0);
	}
	else if(i==41){
		gpio_direction_output(NKpdata_info->gpio_op3, 1);
	}
	else if(i==40){
		gpio_direction_output(NKpdata_info->gpio_op3, 0);
	}
	else if(i==51){
		gpio_direction_output(NKpdata_info->gpio_op4, 1);
	}
	else if(i==50){
		gpio_direction_output(NKpdata_info->gpio_op4, 0);
	}
	else if(i==61){
		gpio_direction_output(NKpdata_info->gpio_op5, 1);
	}
	else if(i==60){
		gpio_direction_output(NKpdata_info->gpio_op5, 0);
	}
	/*
		else if(i==51){
		gpio_direction_output(NKpdata_info->gpio_ip0, 1);
	}
		else if(i==50){
		gpio_direction_output(NKpdata_info->gpio_ip0, 0);
	}
		else if(i==61){
		gpio_direction_output(NKpdata_info->gpio_ip1, 1);
	}
		else if(i==60){
		gpio_direction_output(NKpdata_info->gpio_ip1, 0);
	}
		else if(i==71){
		gpio_direction_output(NKpdata_info->gpio_ip2, 1);
	}
		else if(i==70){
		gpio_direction_output(NKpdata_info->gpio_ip2, 0);
	}
		else if(i==81){
		gpio_direction_output(NKpdata_info->gpio_ip3, 1);
	}
		else if(i==80){
		gpio_direction_output(NKpdata_info->gpio_ip3, 0);
	}
	*/	
		
}

EXPORT_SYMBOL_GPL(GPIO_IO_SET);

#if 0
static ssize_t en_4g_gpio_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &module_enable);
		printk("store en_4g_gpio ouput =%d\n",module_enable);

	if (module_enable)
		{
			printk("store en_4g_gpio output High \n");
			MODULE_SET(11);
		}
		else {
			MODULE_SET(10);
			printk("store en_4g_gpio output Low \n");
			
		}
		return count;
}

static ssize_t en_4g_gpio_show(struct class *class,struct class_attribute *attr, char *buf)
{
	module_enable = gpio_get_value(NKpdata_info->en_4g_gpio);
    return snprintf(buf,3,"%d\n",module_enable);
}



static ssize_t gpio_op0_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &op0_enable);
		printk("store_gpio_op0 ouput =%d\n",op0_enable);

	if (op0_enable)
		{
			printk("store_gpio_op0 output High------konby\n");
			GPIO_IO_SET(11);
		}
		else {
			GPIO_IO_SET(10);
			printk("tore_gpio_op0 output Low------konby\n");
			
		}
		return count;
}

static ssize_t gpio_op0_show(struct class *class,struct class_attribute *attr, char *buf)
{
	op0_enable = gpio_get_value(NKpdata_info->gpio_op0);
    return snprintf(buf,3,"%d\n",op0_enable);
}

static ssize_t gpio_op1_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &op1_enable);
		printk("store_gpio_op1 ouput =%d\n",op1_enable);

	if (op1_enable)
		{
			printk("store_gpio_op1 output High------konby\n");
			GPIO_IO_SET(21);
		}
		else {
			GPIO_IO_SET(20);
			printk("tore_gpio_op1 output Low------konby\n");
			
		}
		return count;
}

static ssize_t gpio_op1_show(struct class *class,struct class_attribute *attr, char *buf)
{
	op1_enable = gpio_get_value(NKpdata_info->gpio_op1);
    return snprintf(buf,3,"%d\n",op1_enable);
}

static ssize_t gpio_op2_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &op2_enable);
		printk("store_gpio_op2 ouput =%d\n",op2_enable);

	if (op2_enable)
		{
			printk("store_gpio_op2 output High------konby\n");
			GPIO_IO_SET(31);
		}
		else {
			GPIO_IO_SET(30);
			printk("tore_gpio_op2 output Low------konby\n");
			
		}
		return count;
}

static ssize_t gpio_op2_show(struct class *class,struct class_attribute *attr, char *buf)
{
	op2_enable = gpio_get_value(NKpdata_info->gpio_op2);
    return snprintf(buf,3,"%d\n",op2_enable);
}

static ssize_t gpio_op3_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &op3_enable);
		printk("store_gpio_op3 ouput =%d\n",op3_enable);

	if (op3_enable)
		{
			printk("store_gpio_op3 output High------konby\n");
			GPIO_IO_SET(41);
		}
		else {
			GPIO_IO_SET(40);
			printk("tore_gpio_op3 output Low------konby\n");
			
		}
		return count;
}

static ssize_t gpio_op3_show(struct class *class,struct class_attribute *attr, char *buf)
{
	op3_enable = gpio_get_value(NKpdata_info->gpio_op3);
    return snprintf(buf,3,"%d\n",op3_enable);
}

static ssize_t gpio_op4_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &op4_enable);
		printk("store_gpio_op3 ouput =%d\n",op4_enable);

	if (op4_enable)
		{
			printk("store_gpio_op4 output High------konby\n");
			GPIO_IO_SET(51);
		}
		else {
			GPIO_IO_SET(50);
			printk("tore_gpio_op4 output Low------konby\n");
			
		}
		return count;
}

static ssize_t gpio_op4_show(struct class *class,struct class_attribute *attr, char *buf)
{
	op4_enable = gpio_get_value(NKpdata_info->gpio_op4);
    return snprintf(buf,3,"%d\n",op4_enable);
}

static ssize_t gpio_op5_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &op5_enable);
		printk("store_gpio_op5 ouput =%d\n",op5_enable);

	if (op5_enable)
		{
			printk("store_gpio_op5 output High------konby\n");
			GPIO_IO_SET(61);
		}
		else {
			GPIO_IO_SET(60);
			printk("tore_gpio_op5 output Low------konby\n");
			
		}
		return count;
}

static ssize_t gpio_op5_show(struct class *class,struct class_attribute *attr, char *buf)
{
	op5_enable = gpio_get_value(NKpdata_info->gpio_op5);
    return snprintf(buf,3,"%d\n",op5_enable);
}




static ssize_t gpio_ip0_show(struct class *class,struct class_attribute *attr, char *buf)
{
	ip0_enable = gpio_get_value(NKpdata_info->gpio_ip0);
    return snprintf(buf,3,"%d\n",ip0_enable);

}

static ssize_t gpio_ip1_show(struct class *class,struct class_attribute *attr, char *buf)
{
	ip1_enable = gpio_get_value(NKpdata_info->gpio_ip1);
    return snprintf(buf,3,"%d\n",ip1_enable);
}

static ssize_t gpio_ip2_show(struct class *class,struct class_attribute *attr, char *buf)
{
	ip2_enable = gpio_get_value(NKpdata_info->gpio_ip2);
    return snprintf(buf,3,"%d\n",ip2_enable);
}

static ssize_t gpio_ip3_show(struct class *class,struct class_attribute *attr, char *buf)
{
	ip3_enable = gpio_get_value(NKpdata_info->gpio_ip3);
    return snprintf(buf,3,"%d\n",ip3_enable);
}

static ssize_t gpio_ip4_show(struct class *class,struct class_attribute *attr, char *buf)
{
	ip4_enable = gpio_get_value(NKpdata_info->gpio_ip4);
    return snprintf(buf,3,"%d\n",ip4_enable);
}

static ssize_t gpio_ip5_show(struct class *class,struct class_attribute *attr, char *buf)
{
	ip5_enable = gpio_get_value(NKpdata_info->gpio_ip5);
    return snprintf(buf,3,"%d\n",ip5_enable);
}
#endif


#if 0
static ssize_t gpio_ip0_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &ip0_enable);
		printk("store_gpio_op3 ouput =%d\n",ip0_enable);

	if (ip0_enable)
		{
			printk("store_gpio_op3 output High------konby\n");
			GPIO_IO_SET(51);
		}
		else {
			GPIO_IO_SET(50);
			printk("tore_gpio_op3 output Low------konby\n");
			
		}
		return count;
}

static ssize_t gpio_ip1_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &ip1_enable);
		printk("store_gpio_op3 ouput =%d\n",ip1_enable);

	if (ip1_enable)
		{
			printk("store_gpio_op3 output High------konby\n");
			GPIO_IO_SET(61);
		}
		else {
			GPIO_IO_SET(60);
			printk("tore_gpio_op3 output Low------konby\n");
			
		}
		return count;
}

static ssize_t gpio_ip2_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &ip2_enable);
		printk("store_gpio_op3 ouput =%d\n",ip2_enable);

	if (ip2_enable)
		{
			printk("store_gpio_op3 output High------konby\n");
			GPIO_IO_SET(71);
		}
		else {
			GPIO_IO_SET(70);
			printk("tore_gpio_op3 output Low------konby\n");
			
		}
		return count;
}

static ssize_t gpio_ip3_store(struct class *class,struct class_attribute *attr, const char *buf, size_t count)
{	
		sscanf(buf, "%d", &ip3_enable);
		printk("store_gpio_op3 ouput =%d\n",ip3_enable);

	if (ip3_enable)
		{
			printk("store_gpio_op3 output High------konby\n");
			GPIO_IO_SET(81);
		}
		else {
			GPIO_IO_SET(80);
			printk("tore_gpio_op3 output Low------konby\n");
			
		}
		return count;
}

#endif



#if 0

//static CLASS_ATTR(en_4g_gpio, 0666, module_show, module_store);
static CLASS_ATTR_RW(en_4g_gpio);


//static CLASS_ATTR(gpio_op0, 0666, gpio_op0_show, gpio_op0_store);
static CLASS_ATTR_RW(gpio_op0);
//static CLASS_ATTR(gpio_op1, 0666, gpio_op1_show, gpio_op1_store);
static CLASS_ATTR_RW(gpio_op1);
//static CLASS_ATTR(gpio_op2, 0666, gpio_op2_show, gpio_op2_store);
static CLASS_ATTR_RW(gpio_op2);
//static CLASS_ATTR(gpio_op3, 0666, gpio_op3_show, gpio_op3_store);
static CLASS_ATTR_RW(gpio_op3);
//static CLASS_ATTR(gpio_op4, 0666, gpio_op4_show, gpio_op4_store);
static CLASS_ATTR_RW(gpio_op4);
//static CLASS_ATTR(gpio_op5, 0666, gpio_op5_show, gpio_op5_store);
static CLASS_ATTR_RW(gpio_op5);



//static CLASS_ATTR(gpio_ip0, 0666, gpio_ip0_show, NULL);
static CLASS_ATTR_RO(gpio_ip0);
//static CLASS_ATTR(gpio_ip1, 0666, gpio_ip1_show, NULL);
static CLASS_ATTR_RO(gpio_ip1);
//static CLASS_ATTR(gpio_ip2, 0666, gpio_ip2_show, NULL);
static CLASS_ATTR_RO(gpio_ip2);
//static CLASS_ATTR(gpio_ip3, 0666, gpio_ip3_show, NULL);
static CLASS_ATTR_RO(gpio_ip3);
//static CLASS_ATTR(gpio_ip4, 0666, gpio_ip4_show, NULL);
static CLASS_ATTR_RO(gpio_ip4);
//static CLASS_ATTR(gpio_ip5, 0666, gpio_ip5_show, NULL);
static CLASS_ATTR_RO(gpio_ip5);


#endif




//ben
static int nk_io_control_probe(struct platform_device *pdev)
{
	struct device_node *node = pdev->dev.of_node;
	struct nk_io_pdata *pdata;	
	int gpio0, gpio1, gpio2, gpio3, reset_pin, ch342_reset;
	int ret;
        int lvds_index;
        int i=0;
        static int lvds_gpio[4] ;

	enum of_gpio_flags flags;
	
	printk(" #######nk_io_control_probe####### \n");

	pdata = kzalloc(sizeof(struct nk_io_pdata), GFP_KERNEL);
	if (pdata == NULL) {
		printk("%s failed to allocate driver data\n",__FUNCTION__);
		return -ENOMEM;
	}
	memset(pdata,0,sizeof(struct nk_io_pdata));
	
	//vcc_5v_io
#if 0
	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_input vcc_5v_io set ERROR\n", __FUNCTION__);
			goto err;
		}
	}
#endif
	//tp_enable
	ret = of_get_named_gpio_flags(node, "tp_enable", 0, &flags);
	if (ret < 0) {
		printk("%s() Can not read property tp_enable\n", __FUNCTION__);
		goto err;
	} else {
		pdata->tp_enable = ret;
		ret = devm_gpio_request(&pdev->dev, pdata->tp_enable, "tp_enable");
		if(ret < 0){
			printk("%s() devm_gpio_request tp_enable request ERROR\n", __FUNCTION__);
			goto err;
		}

		ret = gpio_direction_output(pdata->tp_enable,1); 
		if(ret < 0){
			printk("%s() gpio_direction_output tp_enable 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_input vcc_12v_io set ERROR\n", __FUNCTION__);
			goto err;
		}
	}
	
	//hub_hos2_5V_gpio
	ret = of_get_named_gpio_flags(node, "hub_host2_5v_gpio", 0, &flags);
	if (ret < 0) {
		printk("%s() Can not read property hub_host2_5v_gpio\n", __FUNCTION__);
		goto err;
	} else {
		pdata->hub_host2_5v_gpio = ret;
		gpio_free(ret);
		ret = devm_gpio_request(&pdev->dev, pdata->hub_host2_5v_gpio, "hub_host2_5v_gpio");
		if(ret < 0){
			printk("%s() devm_gpio_request hub_host2_5v_gpio request ERROR\n", __FUNCTION__);
			goto err;
		}

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

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

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

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

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

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

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

	//wake_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->wake_4g_gpio = ret;

	           ret = devm_gpio_request(&pdev->dev, pdata->wake_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_input wake_4g_gpio set ERROR\n", __FUNCTION__);
	           }
	   }

#if 0
	   //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,0);
	           if(ret < 0){
	                   printk("%s() gpio_direction_input reset_4g_gpio set ERROR\n", __FUNCTION__);
	           }
	   }

	   //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__);
	           }
	   }

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

		ret = devm_gpio_request(&pdev->dev, pdata->edp_power_supply_gpio, "edp_power_supply_gpio");
		if(ret < 0){
			printk("%s() devm_gpio_request edp_power_supply_gpio request ERROR\n", __FUNCTION__);
		}
		
		ret = gpio_direction_output(pdata->edp_power_supply_gpio,1);
		if(ret < 0){
			printk("%s() gpio_direction_input edp_power_supply_gpio set ERROR\n", __FUNCTION__);
		}
	}
*/	
   //edp_enable-gpio;
#if 0
	ret = of_get_named_gpio_flags(node, "edp_enable_gpio", 0, &flags);
	if (ret < 0) {
		printk("%s() Can not read property edp_enable_gpio\n", __FUNCTION__);
	} else {
		pdata->edp_enable_gpio = ret;

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

		ret = devm_gpio_request(&pdev->dev, pdata->ch342_power, "ch342_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 ch342_power set ERROR\n", __FUNCTION__);
		}
	}   


        //edp_set_pixel-s
         ret = of_get_named_gpio_flags(node, "edp_reset", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property edp_reset\n", __FUNCTION__);
        goto err;
    }

    reset_pin = ret;

	   // 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,1);
	           if(ret < 0){
	                   printk("%s() gpio_direction_output ch342_reset set ERROR\n", __FUNCTION__);
	           }
//    		 ch342_reset = ret;
	   }


// enable lvds
     ret = of_get_named_gpio_flags(node, "edp_gpio0", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property edp_gpio0\n", __FUNCTION__);
        goto err;
    }
	 gpio0 = ret;



    ret = of_get_named_gpio_flags(node, "edp_gpio1", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property edp_gpio1\n", __FUNCTION__);
        goto err;
    }

        gpio1 = ret;

    ret = of_get_named_gpio_flags(node, "edp_gpio2", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property edp_gpio2\n", __FUNCTION__);
        goto err;
    }

    gpio2 = ret;

    ret = of_get_named_gpio_flags(node, "edp_gpio3", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property edp_gpio3\n", __FUNCTION__);
        goto err;
    }

    gpio3 = ret;


	 ret = devm_gpio_request(&pdev->dev, reset_pin, "edp_reset");
    if(ret < 0){
        printk("%s() devm_gpio_request edp_reset request ERROR\n", __FUNCTION__);
        goto err;
    }


    ret = devm_gpio_request(&pdev->dev, gpio0, "edp_gpio0");
    if(ret < 0){
        printk("%s() devm_gpio_request edp_gpio0 request ERROR\n", __FUNCTION__);
        goto err;
    }

    ret = devm_gpio_request(&pdev->dev, gpio1, "edp_gpio1");
    if(ret < 0){
        printk("%s() devm_gpio_request edp_gpio1 request ERROR\n", __FUNCTION__);
        goto err;
    }

    ret = devm_gpio_request(&pdev->dev, gpio2, "edp_gpio2");
    if(ret < 0){
        printk("%s() devm_gpio_request edp_gpio2 request ERROR\n", __FUNCTION__);
        goto err;
    }

    ret = devm_gpio_request(&pdev->dev, gpio3, "edp_gpio3");
    if(ret < 0){
        printk("%s() devm_gpio_request edp_gpio3 request ERROR\n", __FUNCTION__);
        goto err;
    }
	
	   ret = of_property_read_u32(node, "nodka_lvds", &lvds_index);
        if (ret < 0){
                printk("%s() Can not read property nodka_lvds\n", __FUNCTION__);
        }

        printk("nodka_lvds_index = %d\n",lvds_index);

        while ( i < 4 ){
                if ( lvds_index > 0)
                        lvds_gpio[i] = lvds_index%2;
                else
                        lvds_gpio[i] = 0;
                printk("lvds_gpio[%d]=%d\n",i,lvds_gpio[i]);
                lvds_index = lvds_index/2;
                i++;
        }

    gpio_direction_output(reset_pin, 0);
    usleep_range(80000, 100000);
    gpio_direction_output(reset_pin, 1);
    usleep_range(80000, 100000);

//    gpio_direction_output(ch342_reset, 0);
//   usleep_range(80000, 100000);
//    gpio_direction_output(ch342_reset, 1);
//    usleep_range(80000, 100000);

/*
      //gpio_op0
         ret = of_get_named_gpio_flags(node, "gpio_op0", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_op0\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_op0 = ret;

         ret = devm_gpio_request(&pdev->dev, pdata->gpio_op0, "gpio_op0");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_op0 request ERROR\n", __FUNCTION__);
        goto err;
    }

	gpio_direction_output(pdata->gpio_op0, 1);
*/
	
	gpio_direction_output(gpio0, lvds_gpio[0]);
	gpio_direction_output(gpio1, lvds_gpio[1]);
	gpio_direction_output(gpio2, lvds_gpio[2]);
	gpio_direction_output(gpio3, lvds_gpio[3]);
	
	printk(" #######nk_io_control_probe end####### \n");
	return 0;
	
err:
	kfree(pdata);
	return ret;	
}	

//6 in 6 out-e
#if 0 
static int nk_io_control_probe1(struct platform_device *pdev)
{
	struct device_node *node = pdev->dev.of_node;
	struct nk_io_pdata *pdata;
	int ret;
	int gpio0, gpio1, gpio2, gpio3, reset_pin;
	enum of_gpio_flags flags;
	printk(" #######nk_io_control_probe####### \n");
	//enable = 0 ;


//	ret = gpio_direction_output(74,0); 
//	if(ret < 0){
//		printk("fuwei %s() gpio_direction_input vcc_12v_io set ERROR\n", __FUNCTION__);
//		goto err;
//	}


	pdata = kzalloc(sizeof(struct nk_io_pdata), GFP_KERNEL);
	if (pdata == NULL) {
		printk("%s failed to allocate driver data\n",__FUNCTION__);
		return -ENOMEM;
	}
	memset(pdata,0,sizeof(struct nk_io_pdata));


	//edp_set_pixel-s
	 ret = of_get_named_gpio_flags(node, "edp_reset", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property edp_reset\n", __FUNCTION__);
        goto err;
    }

    reset_pin = ret;

	ret = of_get_named_gpio_flags(node, "edp_gpio0", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property edp_gpio0\n", __FUNCTION__);
        goto err;
    } 

    gpio0 = ret;

    ret = of_get_named_gpio_flags(node, "edp_gpio1", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property edp_gpio1\n", __FUNCTION__);
        goto err;
    }

	gpio1 = ret;

    ret = of_get_named_gpio_flags(node, "edp_gpio2", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property edp_gpio2\n", __FUNCTION__);
        goto err;
    }

    gpio2 = ret;

    ret = of_get_named_gpio_flags(node, "edp_gpio3", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property edp_gpio3\n", __FUNCTION__);
        goto err;
    }

    gpio3 = ret;

    ret = devm_gpio_request(&pdev->dev, reset_pin, "edp_reset");
    if(ret < 0){
        printk("%s() devm_gpio_request edp_reset request ERROR\n", __FUNCTION__);
        goto err;
    }

    ret = devm_gpio_request(&pdev->dev, gpio0, "edp_gpio0");
    if(ret < 0){
        printk("%s() devm_gpio_request edp_gpio0 request ERROR\n", __FUNCTION__);
        goto err;
    }

    ret = devm_gpio_request(&pdev->dev, gpio1, "edp_gpio1");
    if(ret < 0){
        printk("%s() devm_gpio_request edp_gpio1 request ERROR\n", __FUNCTION__);
        goto err;
    }

    ret = devm_gpio_request(&pdev->dev, gpio2, "edp_gpio2");
    if(ret < 0){
        printk("%s() devm_gpio_request edp_gpio2 request ERROR\n", __FUNCTION__);
        goto err;
    }

    ret = devm_gpio_request(&pdev->dev, gpio3, "edp_gpio3");
    if(ret < 0){
        printk("%s() devm_gpio_request edp_gpio3 request ERROR\n", __FUNCTION__);
        goto err;
    }

    gpio_direction_output(reset_pin, 0); 
    usleep_range(80000, 100000);
    gpio_direction_output(reset_pin, 1); 
    usleep_range(80000, 100000);

    gpio_direction_output(gpio0, 0); 
    gpio_direction_output(gpio1, 1); 
    gpio_direction_output(gpio2, 1); 
    gpio_direction_output(gpio3, 0); 
	printk("edp set pixels success.\r\n");

	//edp_set_pixel-e

	//6 in 6 out-s	
	//gpio_op0
	 ret = of_get_named_gpio_flags(node, "gpio_op0", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_op0\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_op0 = ret;

	 ret = devm_gpio_request(&pdev->dev, pdata->gpio_op0, "gpio_op0");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_op0 request ERROR\n", __FUNCTION__);
        goto err;
    }


	//gpio_op1
	 ret = of_get_named_gpio_flags(node, "gpio_op1", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_op1\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_op1 = ret;

	 ret = devm_gpio_request(&pdev->dev, pdata->gpio_op1, "gpio_op1");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_op1 request ERROR\n", __FUNCTION__);
        goto err;
    }


	//gpio_op2
	 ret = of_get_named_gpio_flags(node, "gpio_op2", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_op2\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_op2 = ret;

	 ret = devm_gpio_request(&pdev->dev, pdata->gpio_op2, "gpio_op2");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_op2 request ERROR\n", __FUNCTION__);
        goto err;
    }



	//gpio_op3
	 ret = of_get_named_gpio_flags(node, "gpio_op3", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_op3\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_op3 = ret;

	 ret = devm_gpio_request(&pdev->dev, pdata->gpio_op3, "gpio_op3");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_op3 request ERROR\n", __FUNCTION__);
        goto err;
    }

	//gpio_op4
	 ret = of_get_named_gpio_flags(node, "gpio_op4", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_op4\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_op4 = ret;

	 ret = devm_gpio_request(&pdev->dev, pdata->gpio_op4, "gpio_op4");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_op4 request ERROR\n", __FUNCTION__);
        goto err;
    }

	//gpio_op5
	 ret = of_get_named_gpio_flags(node, "gpio_op5", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_op5\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_op5 = ret;

	 ret = devm_gpio_request(&pdev->dev, pdata->gpio_op5, "gpio_op5");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_op5 request ERROR\n", __FUNCTION__);
        goto err;
    }
	

	//d4 low
	gpio_direction_output(pdata->gpio_op0, 1);
	gpio_direction_output(pdata->gpio_op1, 1);
	gpio_direction_output(pdata->gpio_op2, 1);
	gpio_direction_output(pdata->gpio_op3, 1);
	gpio_direction_output(pdata->gpio_op4, 1);
	gpio_direction_output(pdata->gpio_op5, 1);

	



	//gpio_ip0
	 ret = of_get_named_gpio_flags(node, "gpio_ip0", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_ip0\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_ip0 = ret;

	 ret = devm_gpio_request(&pdev->dev, pdata->gpio_ip0, "gpio_ip0");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_ip0 request ERROR\n", __FUNCTION__);
        goto err;
    }

	//gpio_ip1
	 ret = of_get_named_gpio_flags(node, "gpio_ip1", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_ip1\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_ip1 = ret;

	 ret = devm_gpio_request(&pdev->dev, pdata->gpio_ip1, "gpio_ip1");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_ip1 request ERROR\n", __FUNCTION__);
        goto err;
    }

	//gpio_ip2
	 ret = of_get_named_gpio_flags(node, "gpio_ip2", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_ip2\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_ip2 = ret;

	 ret = devm_gpio_request(&pdev->dev, pdata->gpio_ip2, "gpio_ip2");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_ip2 request ERROR\n", __FUNCTION__);
        goto err;
    }

	//gpio_ip3
	 ret = of_get_named_gpio_flags(node, "gpio_ip3", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_ip3\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_ip3 = ret;

	 ret = devm_gpio_request(&pdev->dev, pdata->gpio_ip3, "gpio_ip3");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_ip3 request ERROR\n", __FUNCTION__);
        goto err;
    }

	//gpio_ip4
	 ret = of_get_named_gpio_flags(node, "gpio_ip4", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_ip4\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_ip4 = ret;

	 ret = devm_gpio_request(&pdev->dev, pdata->gpio_ip4, "gpio_ip4");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_ip4 request ERROR\n", __FUNCTION__);
        goto err;
    }

	//gpio_ip5
	 ret = of_get_named_gpio_flags(node, "gpio_ip5", 0, &flags);
    if (ret < 0) {
        printk("%s() Can not read property gpio_ip5\n", __FUNCTION__);
        goto err;
    }

    pdata->gpio_ip5 = ret;

	 ret = devm_gpio_request(&pdev->dev, pdata->gpio_ip5, "gpio_ip3");
    if(ret < 0){
        printk("%s() devm_gpio_request gpio_ip5 request ERROR\n", __FUNCTION__);
        goto err;
    }

	//d4 low
	gpio_direction_input(pdata->gpio_ip0);
	gpio_direction_input(pdata->gpio_ip1);
	gpio_direction_input(pdata->gpio_ip2);
	gpio_direction_input(pdata->gpio_ip3);
	gpio_direction_input(pdata->gpio_ip4);
	gpio_direction_input(pdata->gpio_ip5);


	//6 in 6 out-e


	   //wake_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->wake_4g_gpio = ret;

	           ret = devm_gpio_request(&pdev->dev, pdata->wake_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_input wake_4g_gpio set ERROR\n", __FUNCTION__);
	           }
	   }


	   //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,0);
	           if(ret < 0){
	                   printk("%s() gpio_direction_input reset_4g_gpio set ERROR\n", __FUNCTION__);
	           }
	   }

	   //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__);
	           }
	   }


       
	

	//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;
		}
				}
#if 0
	//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_input vcc_5v_io set ERROR\n", __FUNCTION__);
			goto err;
		}
	}
#endif
	//vcc_3.3v_io
	ret = of_get_named_gpio_flags(node, "vcc_3_3v_io", 0, &flags);
	if (ret < 0) {
		printk("%s() Can not read property vcc_3_3v_io\n", __FUNCTION__);
		goto err;
	} else {
		pdata->vcc_3_3v_io = ret;
		ret = devm_gpio_request(&pdev->dev, pdata->vcc_3_3v_io, "vcc_3_3v_io");
		if(ret < 0){
			printk("%s() devm_gpio_request vcc_3_3v_io request ERROR\n", __FUNCTION__);
			goto err;
		}

		ret = gpio_direction_output(pdata->vcc_3_3v_io,1); 
		if(ret < 0){
			printk("%s() gpio_direction_input vcc_3_3v_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_input vcc_12v_io set ERROR\n", __FUNCTION__);
			goto err;
		}
	}
	
		//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_input hub_5V_gpio set ERROR\n", __FUNCTION__);
			goto err;
		}
	}


	//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_input 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_input hub_5V_rest_gpio set ERROR\n", __FUNCTION__);
			goto err;
		}
	}
	
		//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;
	}
		}

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

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

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

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

    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 fan_io_en 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"); 


    //pcie_wakeup for ap6256 BT_wake
    /* Rfkill-bt.c bt driver config and set this pin already
    printk("pcie_wakeup ....\r\n"); 

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

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


	nk_class = class_create(THIS_MODULE, "io_control");
#if 0
	ret = class_create_file(nk_class, &class_attr_en_4g_gpio);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat en_4g_gpio class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control en_4g_gpio OK !!!!\n");
	
	ret = class_create_file(nk_class, &class_attr_gpio_op0);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat gpio_op0 class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control gpio_op0 OK !!!!\n");

	ret = class_create_file(nk_class, &class_attr_gpio_op1);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat gpio_op1 class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control gpio_op1 OK !!!!\n");

	ret = class_create_file(nk_class, &class_attr_gpio_op2);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat gpio_op2 class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control gpio_op2 OK !!!!\n");

	ret = class_create_file(nk_class, &class_attr_gpio_op3);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat gpio_op3 class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control gpio_op3 OK !!!!\n");

	ret = class_create_file(nk_class, &class_attr_gpio_op4);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat gpio_op4 class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control gpio_op4 OK !!!!\n");

	ret = class_create_file(nk_class, &class_attr_gpio_op5);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat gpio_op5 class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control gpio_op5 OK !!!!\n");

	ret = class_create_file(nk_class, &class_attr_gpio_ip0);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat gpio_ip0 class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control gpio_ip0 OK !!!!\n");

	ret = class_create_file(nk_class, &class_attr_gpio_ip1);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat gpio_ip1 class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control gpio_ip1 OK !!!!\n");

	ret = class_create_file(nk_class, &class_attr_gpio_ip2);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat gpio_ip2 class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control gpio_ip2 OK !!!!\n");

	ret = class_create_file(nk_class, &class_attr_gpio_ip3);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat gpio_ip3 class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control gpio_ip3 OK !!!!\n");

	ret = class_create_file(nk_class, &class_attr_gpio_ip4);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat gpio_ip4 class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control gpio_ip4 OK !!!!\n");

	ret = class_create_file(nk_class, &class_attr_gpio_ip5);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat gpio_ip5 class file\n", __func__);
		return ret;
	}else
	printk("class_create io_control gpio_ip5 OK !!!!\n");
	
	ret = class_create_file(nk_class, &class_attr_led_display);
	if (ret) {
		printk(KERN_ERR "%s:Fail to creat led_display class file\n", __func__);
		return ret;
	}else
	printk("class_create nk_io_control led OK !!!!\n");	

   ret = class_create_file(nk_class, &class_attr_mic_switch);
   if (ret) {
           printk(KERN_ERR "%s:Fail to creat mic_switch class file\n", __func__);
           return ret;
   }else
   printk("class_create nk_io_control mic OK !!!!\n");	
#endif
		   
	NKpdata_info = pdata;

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

static int nk_io_control_remove(struct platform_device *pdev)
{
	if(NKpdata_info)
		kfree(NKpdata_info);
	return 0;
}

static int nk_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 nk_io_control_resume(struct platform_device *pdev)
{
	int ret,reset_pin;
	printk("nk_io resume !!!!\n");
	ret = gpio_get_value(120);
	printk("edp_reset gpio value : %d\n",ret);

        usleep_range(80000, 100000);
	gpio_set_value(120,0);
//    	gpio_direction_output(120, 0);
        usleep_range(80000, 100000);
	ret = gpio_get_value(120);
	printk("edp_reset gpio value : %d\n",ret);
//    	gpio_direction_output(120, 1);
	gpio_set_value(120,1);
    	usleep_range(80000, 100000);
	ret = gpio_get_value(120);
	printk("edp_reset gpio value : %d\n",ret);

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

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

static struct platform_driver nk_io_control_driver = {
	.probe	= nk_io_control_probe,
	.remove = nk_io_control_remove,
	.resume = 	nk_io_control_resume,	
	.suspend = 	nk_io_control_suspend,	
	.driver	= {
		.name	= "nk_io_control",
		.owner	= THIS_MODULE,
		.of_match_table = of_match_ptr(nk_io_control_of_match),		
	},
};

static int __init nk_io_control_init(void)
{
	platform_driver_register(&nk_io_control_driver);
	return 0;
}

static void __exit nk_io_control_exit(void)
{
	platform_driver_unregister(&nk_io_control_driver);
}

subsys_initcall(nk_io_control_init);

//late_initcall(nk_io_control_init);
MODULE_DESCRIPTION("nk io Core Driver");
MODULE_LICENSE("GPL");