~ljy/RK356X_SDK_RELEASE.git

..	..	@@ -1,619 +1,328 @@
1		-/*
2		- * Copyright (C) 2014 Rockchip Corporation.
3		- *
4		- * This software is licensed under the terms of the GNU General Public
5		- * License version 2, as published by the Free Software Foundation, and
6		- * may be copied, distributed, and modified under those terms.
7		- *
8		- * This program is distributed in the hope that it will be useful,
9		- * but WITHOUT ANY WARRANTY; without even the implied warranty of
10		- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11		- * GNU General Public License for more details.
12		- *
13		- */
14	1	#include <linux/module.h>
15		-#include <linux/moduleparam.h>
16		-#include <linux/init.h>
17		-#include <linux/delay.h>
18		-#include <linux/pm.h>
19		-#include <linux/i2c.h>
20		-#include <linux/spi/spi.h>
21		-#include <linux/platform_device.h>
22		-#include <linux/errno.h>
23	2	#include <linux/err.h>
24		-#include <linux/debugfs.h>
25		-#include <linux/of_gpio.h>
26	3	#include <linux/gpio.h>
27		-#include <linux/iio/consumer.h>
28		-#include <linux/of.h>
29		-#include "nkio.h"
	4	+#include <linux/kernel.h>
	5	+#include <linux/of_gpio.h>
	6	+#include <linux/of_platform.h>
	7	+#include <linux/delay.h>
	8	+#include <linux/input.h>
	9	+#include <linux/proc_fs.h>
	10	+#include <linux/kernel.h>
	11	+#include <linux/init.h>
	12	+#include <asm/uaccess.h>
	13	+#include <linux/string.h>
	14	+#include <linux/uaccess.h>
	15	+#include <linux/device.h>
	16	+
	17	+#define GPIO_FUNCTION_OUTPUT 0
	18	+#define GPIO_FUNCTION_INPUT 1
	19	+#define GPIO_FUNCTION_RESET 3
	20	+#define HIGH "1"
	21	+#define LOW "0"
30	22
31		-/* Debug */
32		-#if 1
33		-#define DBG(x...) printk(x)
34		-#else
35		-#define DBG(x...) do { } while (0)
36		-#endif
	23	+static int flash_flag = 0;
	24	+
	25	+struct ndj_gpio {
	26	+ int gpio_num; //gpio num
	27	+ int action; //gpio flag
	28	+ int gpio_event; //input only
	29	+ int send_mode; //input only
	30	+ int gpio_function; //gpio function,i/o
	31	+ int gpio_ctrl;
	32	+ char *gpio_name;
	33	+};
	34	+
	35	+struct ndj_gpio_data {
	36	+ struct ndj_gpio ndj_gpio_num[20];
	37	+ struct timer_list mytimer;
	38	+ int gpio_dts_num;
	39	+ unsigned int gpio_op0;
	40	+ unsigned int gpio_op1;
	41	+};
37	42
38		-struct nk_io_pdata *NKpdata_info;
39		-u32 op0_enable,op1_enable,op2_enable,op3_enable,op4_enable,op5_enable,mic_enable;
40		-u32 ip0_enable,ip1_enable,ip2_enable,ip3_enable,ip4_enable,ip5_enable;
41		-u32 module_enable;
42		-//static struct class *nk_class;
	43	+static struct ndj_gpio_data *gpio_data = NULL;
43	44
44		-
45		-
46		-void Audio_SET(int i);
47		-
48		- void Audio_SET(int i)
49		- {
50		- if(i==11){
51		- gpio_direction_output(NKpdata_info->audio_switch_gpio, 1);
52		- printk("Audio_SET ENABLE------andy\n");
53		- }else{
54		- gpio_direction_output(NKpdata_info->audio_switch_gpio, 0);
55		- printk("Audio_SET DISABLE------andy\n");
56		- }
57		- }
58		- EXPORT_SYMBOL_GPL(Audio_SET);
59		-
60		-static int nk_io_control_probe(struct platform_device *pdev)
61		-{
62		- struct device_node *node = pdev->dev.of_node;
63		- struct nk_io_pdata *pdata;
64		- int ret;
65		-
66		-
67		- enum of_gpio_flags flags;
68		-
69		- printk(" #######nk_io_control_probe####### \n");
70		-
71		- pdata = kzalloc(sizeof(struct nk_io_pdata), GFP_KERNEL);
72		- if (pdata == NULL) {
73		- printk("%s failed to allocate driver data\n",__FUNCTION__);
74		- return -ENOMEM;
75		- }
76		- memset(pdata,0,sizeof(struct nk_io_pdata));
77		-
78		- //vcc_5v_io
79		- ret = of_get_named_gpio_flags(node, "vcc_5v_io", 0, &flags);
80		- if (ret < 0) {
81		- printk("%s() Can not read property vcc_5v_io\n", __FUNCTION__);
82		- goto err;
83		- } else {
84		- pdata->vcc_5v_io = ret;
85		- ret = devm_gpio_request(&pdev->dev, pdata->vcc_5v_io, "vcc_5v_io");
86		- if(ret < 0){
87		- printk("%s() devm_gpio_request vcc_5v_io request ERROR\n", __FUNCTION__);
88		- goto err;
89		- }
90		-
91		- ret = gpio_direction_output(pdata->vcc_5v_io,1);
92		- if(ret < 0){
93		- printk("%s() gpio_direction_input vcc_5v_io set ERROR\n", __FUNCTION__);
94		- goto err;
95		- }
96		- }
97		-#if 0
98		- //vcc3_io_en_gpio
99		- ret = of_get_named_gpio_flags(node, "vcc3_io_en_gpio", 0, &flags);
100		- if (ret < 0) {
101		- printk("%s() Can not read property vcc3_io_en_gpio\n", __FUNCTION__);
102		- goto err;
103		- } else {
104		- pdata->vcc3_io_en_gpio = ret;
105		- ret = devm_gpio_request(&pdev->dev, pdata->vcc3_io_en_gpio, "vcc3_io_en_gpio");
106		- if(ret < 0){
107		- printk("%s() devm_gpio_request vcc3_io_en_gpio request ERROR\n", __FUNCTION__);
108		- goto err;
109		- }
110		-
111		- ret = gpio_direction_output(pdata->vcc3_io_en_gpio,1);
112		- if(ret < 0){
113		- printk("%s() gpio_direction_output vcc3_io_en_gpio set ERROR\n", __FUNCTION__);
114		- goto err;
115		- }
116		- }
117		-#endif
118		- //vcc_12v_io
119		- ret = of_get_named_gpio_flags(node, "vcc_12v_io", 0, &flags);
120		- if (ret < 0) {
121		- printk("%s() Can not read property vcc_12v_io\n", __FUNCTION__);
122		- goto err;
123		- } else {
124		- pdata->vcc_12v_io = ret;
125		- ret = devm_gpio_request(&pdev->dev, pdata->vcc_12v_io, "vcc_12v_io");
126		- if(ret < 0){
127		- printk("%s() devm_gpio_request vcc_12v_io request ERROR\n", __FUNCTION__);
128		- goto err;
129		- }
130		-
131		- ret = gpio_direction_output(pdata->vcc_12v_io,1);
132		- if(ret < 0){
133		- printk("%s() gpio_direction_input vcc_12v_io set ERROR\n", __FUNCTION__);
134		- goto err;
135		- }
136		- }
137		-
138		-
139		- //hub_host2_5V_rest_gpio
140		- ret = of_get_named_gpio_flags(node, "hub_host2_5V_rest_gpio", 0, &flags);
141		- if (ret < 0) {
142		- printk("%s() Can not read property hub_host2_5V_rest_gpio\n", __FUNCTION__);
143		- goto err;
144		- } else {
145		- pdata->hub_host2_5V_rest_gpio = ret;
146		- ret = devm_gpio_request(&pdev->dev, pdata->hub_host2_5V_rest_gpio, "hub_host2_5V_rest_gpio");
147		- if(ret < 0){
148		- printk("%s() devm_gpio_request hub_host2_5V_rest_gpio request ERROR\n", __FUNCTION__);
149		- goto err;
150		- }
151		-
152		- ret = gpio_direction_output(pdata->hub_host2_5V_rest_gpio,0);
153		- if(ret < 0){
154		- printk("%s() gpio_direction_input hub_host2_5V_rest_gpio set ERROR\n", __FUNCTION__);
155		- goto err;
156		- }
157		- msleep(800);
158		- ret = gpio_direction_output(pdata->hub_host2_5V_rest_gpio,1);
159		- if(ret < 0){
160		- printk("%s() gpio_direction_input hub_host2_5V_rest_gpio set ERROR\n", __FUNCTION__);
161		- goto err;
162		- }
163		- }
164		-
165		- //hub_host3_5v_gpio
166		- ret = of_get_named_gpio_flags(node, "hub_host3_5v_gpio", 0, &flags);
167		- if (ret < 0) {
168		- printk("%s() Can not read property hub_host3_5v_gpio\n", __FUNCTION__);
169		- goto err;
170		- } else {
171		- pdata->hub_host3_5v_gpio = ret;
172		- gpio_free(ret);
173		- ret = devm_gpio_request(&pdev->dev, pdata->hub_host3_5v_gpio, "hub_host3_5v_gpio");
174		- if(ret < 0){
175		- printk("%s() devm_gpio_request hub_host3_5v_gpio request ERROR\n", __FUNCTION__);
176		- goto err;
177		- }
178		-
179		- ret = gpio_direction_output(pdata->hub_host3_5v_gpio,1);
180		- if(ret < 0){
181		- printk("%s() gpio_direction_input hub_host3_5v_gpio set ERROR\n", __FUNCTION__);
182		- goto err;
183		- }
184		- }
	45	+/* creat sysfs gpio api node*/
185	46	#if 0
186		- //hub_host3_5V_rest_gpio
187		- ret = of_get_named_gpio_flags(node, "hub_host3_5V_rest_gpio", 0, &flags);
188		- if (ret < 0) {
189		- printk("%s() Can not read property hub_host3_5V_rest_gpio\n", __FUNCTION__);
190		- goto err;
191		- } else {
192		- pdata->hub_host3_5V_rest_gpio = ret;
193		- ret = devm_gpio_request(&pdev->dev, pdata->hub_host3_5V_rest_gpio, "hub_host3_5V_rest_gpio");
194		- if(ret < 0){
195		- printk("%s() devm_gpio_request hub_host3_5V_rest_gpio request ERROR\n", __FUNCTION__);
196		- goto err;
197		- }
	47	+static ssize_t gpio_op0_show(struct class class,struct class_attribute attr, char *buf)
	48	+{
	49	+ return sprintf(buf, "%d\n", gpio_get_value(gpio_data->gpio_op0));
	50	+}
198	51
199		- ret = gpio_direction_output(pdata->hub_host3_5V_rest_gpio,0);
200		- if(ret < 0){
201		- printk("%s() gpio_direction_input hub_host3_5V_rest_gpio set ERROR\n", __FUNCTION__);
202		- goto err;
203		- }
204		- msleep(800);
205		- ret = gpio_direction_output(pdata->hub_host3_5V_rest_gpio,1);
206		- if(ret < 0){
207		- printk("%s() gpio_direction_input hub_host3_5V_rest_gpio set ERROR\n", __FUNCTION__);
208		- goto err;
209		- }
210		- }
	52	+static ssize_t gpio_op0_store(struct class class,struct class_attribute attr, const char *buf, size_t size)
	53	+{
	54	+ if(!strncmp(buf, HIGH, strlen(HIGH))) {
	55	+ gpio_set_value(gpio_data->gpio_op0, 1);
	56	+
	57	+ } else if(!strncmp(buf, LOW, strlen(LOW))) {
	58	+ gpio_set_value(gpio_data->gpio_op0, 0);
	59	+ }
	60	+ return size;
	61	+}
	62	+
	63	+static ssize_t gpio_op1_show(struct class class,struct class_attribute attr, char *buf)
	64	+{
	65	+ return sprintf(buf, "%d\n", gpio_get_value(gpio_data->gpio_op1));
	66	+}
	67	+
	68	+static ssize_t gpio_op1_store(struct class class,struct class_attribute attr, const char *buf, size_t size)
	69	+{
	70	+ if(!strncmp(buf, HIGH, strlen(HIGH))) {
	71	+ gpio_set_value(gpio_data->gpio_op1, 1);
	72	+
	73	+ } else if(!strncmp(buf, LOW, strlen(LOW))) {
	74	+ gpio_set_value(gpio_data->gpio_op1, 0);
	75	+ }
	76	+ return size;
	77	+}
	78	+
	79	+static CLASS_ATTR_RW(gpio_op0);
	80	+static CLASS_ATTR_RW(gpio_op1);
	81	+
	82	+static struct attribute *ndj_gpio_attrs[] = {
	83	+ &class_attr_gpio_op0.attr,
	84	+ &class_attr_gpio_op1.attr,
	85	+ NULL,
	86	+};
	87	+
	88	+ATTRIBUTE_GROUPS(ndj_gpio);
	89	+
	90	+/** Device model classes */
	91	+struct class ndj_io_class = {
	92	+ .name = "io_control", //sysfs directory
	93	+ .class_groups = ndj_gpio_groups,
	94	+};
	95	+
211	96	#endif
212		- //wake_4g_gpio
213		- ret = of_get_named_gpio_flags(node, "wake_4g_gpio", 0, &flags);
214		- if (ret < 0) {
215		- printk("%s() Can not read property wake_4g_gpio\n", __FUNCTION__);
216		- } else {
217		- pdata->wake_4g_gpio = ret;
218		-
219		- ret = devm_gpio_request(&pdev->dev, pdata->wake_4g_gpio, "wake_4g_gpio");
220		- if(ret < 0){
221		- printk("%s() devm_gpio_request wake_4g_gpio request ERROR\n", __FUNCTION__);
222		- }
223		- ret = gpio_direction_output(pdata->wake_4g_gpio,0);
224		- if(ret < 0){
225		- printk("%s() gpio_direction_input wake_4g_gpio set ERROR\n", __FUNCTION__);
226		- }
227		- }
228		-
229		-
230		- //reset_4g_gpio
231		- ret = of_get_named_gpio_flags(node, "reset_4g_gpio", 0, &flags);
232		- if (ret < 0) {
233		- printk("%s() Can not read property reset_4g_gpio\n", __FUNCTION__);
234		- } else {
235		- pdata->reset_4g_gpio = ret;
236		-
237		- ret = devm_gpio_request(&pdev->dev, pdata->reset_4g_gpio, "reset_4g_gpio");
238		- if(ret < 0){
239		- printk("%s() devm_gpio_request reset_4g_gpio request ERROR\n", __FUNCTION__);
240		- }
241		- ret = gpio_direction_output(pdata->reset_4g_gpio,1);
242		- if(ret < 0){
243		- printk("%s() gpio_direction_input reset_4g_gpio set ERROR\n", __FUNCTION__);
244		- goto err;
245		- }
246		- msleep(800);
247		- ret = gpio_direction_output(pdata->reset_4g_gpio,0);
248		- if(ret < 0){
249		- printk("%s() gpio_direction_input reset_4g_gpio set ERROR\n", __FUNCTION__);
250		-
251		- }
252		- }
253		-
254		- //en_4g_gpio
255		- ret = of_get_named_gpio_flags(node, "en_4g_gpio", 0, &flags);
256		- if (ret < 0) {
257		- printk("%s() Can not read property en_4g_gpio\n", __FUNCTION__);
258		- } else {
259		- pdata->en_4g_gpio = ret;
260		-
261		- ret = devm_gpio_request(&pdev->dev, pdata->en_4g_gpio, "en_4g_gpio");
262		- if(ret < 0){
263		- printk("%s() devm_gpio_request en_4g_gpio request ERROR\n", __FUNCTION__);
264		- }
265		- ret = gpio_direction_output(pdata->en_4g_gpio,1);
266		- if(ret < 0){
267		- printk("%s() gpio_direction_output en_4g_gpio set ERROR\n", __FUNCTION__);
268		- }
269		- }
270		-
271		- //hp_en_gpio
272		- ret = of_get_named_gpio_flags(node, "hp_en_gpio", 0, &flags);
273		- if (ret < 0) {
274		- printk("%s() Can not read property hp_en_gpio\n", __FUNCTION__);
275		- } else {
276		- pdata->hp_en_gpio = ret;
277		-
278		- ret = devm_gpio_request(&pdev->dev, pdata->hp_en_gpio, "hp_en_gpio");
279		- if(ret < 0){
280		- printk("%s() devm_gpio_request hp_en_gpio request ERROR\n", __FUNCTION__);
281		- }
282		- ret = gpio_direction_output(pdata->hp_en_gpio,1);
283		- if(ret < 0){
284		- printk("%s() gpio_direction_output hp_en_gpio set ERROR\n", __FUNCTION__);
285		- }
286		- }
287		-#if 0
288		- //pcie_power_en_gpio
289		- ret = of_get_named_gpio_flags(node, "pcie_power_en_gpio", 0, &flags);
290		- if (ret < 0) {
291		- printk("%s() Can not read property pcie_power_en_gpio\n", __FUNCTION__);
292		- } else {
293		- pdata->pcie_power_en_gpio = ret;
294		-
295		- ret = devm_gpio_request(&pdev->dev, pdata->pcie_power_en_gpio, "pcie_power_en_gpio");
296		- if(ret < 0){
297		- printk("%s() devm_gpio_request pcie_power_en_gpio request ERROR\n", __FUNCTION__);
298		- }
299		- ret = gpio_direction_output(pdata->pcie_power_en_gpio,1);
300		- if(ret < 0){
301		- printk("%s() gpio_direction_output pcie_power_en_gpio set ERROR\n", __FUNCTION__);
302		- }
303		- }
304		-#endif
305		- //wifi_power_en_gpio
306		- ret = of_get_named_gpio_flags(node, "wifi_power_en_gpio", 0, &flags);
307		- if (ret < 0) {
308		- printk("%s() Can not read property wifi_power_en_gpio\n", __FUNCTION__);
309		- } else {
310		- pdata->wifi_power_en_gpio = ret;
311		-
312		- ret = devm_gpio_request(&pdev->dev, pdata->wifi_power_en_gpio, "wifi_power_en_gpio");
313		- if(ret < 0){
314		- printk("%s() devm_gpio_request wifi_power_en_gpio request ERROR\n", __FUNCTION__);
315		- }
316		- ret = gpio_direction_output(pdata->wifi_power_en_gpio,1);
317		- if(ret < 0){
318		- printk("%s() gpio_direction_output wifi_power_en_gpio set ERROR\n", __FUNCTION__);
319		- }
320		- }
321		-
322		-
323		- //spk_out_gpio
324		- ret = of_get_named_gpio_flags(node, "spk_out_gpio", 0, &flags);
325		- if (ret < 0) {
326		- printk("%s() Can not read property spk_out_gpio\n", __FUNCTION__);
327		- } else {
328		- pdata->spk_out_gpio = ret;
329		-
330		- ret = devm_gpio_request(&pdev->dev, pdata->spk_out_gpio, "spk_out_gpio");
331		- if(ret < 0){
332		- printk("%s() devm_gpio_request spk_out_gpio request ERROR\n", __FUNCTION__);
333		- }
334		- ret = gpio_direction_output(pdata->spk_out_gpio,0);
335		- if(ret < 0){
336		- printk("%s() gpio_direction_output spk_out_gpio set ERROR\n", __FUNCTION__);
337		- }
338		- }
339		- //air_mode_4g_gpio
340		- ret = of_get_named_gpio_flags(node, "air_mode_4g_gpio", 0, &flags);
341		- if (ret < 0) {
342		- printk("%s() Can not read property air_mode_4g_gpio\n", __FUNCTION__);
343		- } else {
344		- pdata->air_mode_4g_gpio = ret;
345		-
346		- ret = devm_gpio_request(&pdev->dev, pdata->air_mode_4g_gpio, "air_mode_4g_gpio");
347		- if(ret < 0){
348		- printk("%s() devm_gpio_request air_mode_4g_gpio request ERROR\n", __FUNCTION__);
349		- }
350		- ret = gpio_direction_output(pdata->air_mode_4g_gpio,0);
351		- if(ret < 0){
352		- printk("%s() gpio_direction_input air_mode_4g_gpio set ERROR\n", __FUNCTION__);
353		- }
354		- }
355		-
356		-
357		-/*
358		- //edp_power_supply_gpio;
359		- ret = of_get_named_gpio_flags(node, "edp_power_supply_gpio", 0, &flags);
360		- if (ret < 0) {
361		- printk("%s() Can not read property edp_power_supply_gpio\n", __FUNCTION__);
362		- } else {
363		- pdata->edp_power_supply_gpio = ret;
364		-
365		- ret = devm_gpio_request(&pdev->dev, pdata->edp_power_supply_gpio, "edp_power_supply_gpio");
366		- if(ret < 0){
367		- printk("%s() devm_gpio_request edp_power_supply_gpio request ERROR\n", __FUNCTION__);
368		- }
369		-
370		- ret = gpio_direction_output(pdata->edp_power_supply_gpio,1);
371		- if(ret < 0){
372		- printk("%s() gpio_direction_input edp_power_supply_gpio set ERROR\n", __FUNCTION__);
373		- }
374		- }
375		-
376		- //edp_enable-gpio;
377		- ret = of_get_named_gpio_flags(node, "edp_enable_gpio", 0, &flags);
378		- if (ret < 0) {
379		- printk("%s() Can not read property edp_enable_gpio\n", __FUNCTION__);
380		- } else {
381		- pdata->edp_enable_gpio = ret;
382		-
383		- ret = devm_gpio_request(&pdev->dev, pdata->edp_enable_gpio, "edp_enable_gpio");
384		- if(ret < 0){
385		- printk("%s() devm_gpio_request edp_enable_gpio request ERROR\n", __FUNCTION__);
386		- }
387		-
388		- ret = gpio_direction_output(pdata->edp_enable_gpio,1);
389		- if(ret < 0){
390		- printk("%s() gpio_direction_input edp_enable_gpio set ERROR\n", __FUNCTION__);
391		- }
392		- }
	97	+static int event_flag = 0;
	98	+static int open_now = 0;
	99	+static char* file_name = NULL;
	100	+
	101	+static int gpio_open(struct inode inode, struct file file)
	102	+{
	103	+ struct dentry* dent = file->f_path.dentry;
	104	+ int i = 0;
	105	+
	106	+ file_name = (char*)(dent->d_name.name);
	107	+
	108	+ for (i = 0; i < gpio_data->gpio_dts_num; i++){
	109	+ if(!strcmp(file_name,gpio_data->ndj_gpio_num[i].gpio_name)){
	110	+ open_now = i;
	111	+ }
	112	+ }
	113	+ return 0;
	114	+}
	115	+
	116	+static ssize_t gpio_write(struct file file, const char buffer,size_t count, loff_t *data)
	117	+{
	118	+ char buf[2]={0};
	119	+ char s1[]="1";
	120	+
	121	+ if(copy_from_user(&buf[0],buffer,1)){
	122	+ printk("failed to copy data to kernel space\n");
	123	+ return -EFAULT;
	124	+ }
	125	+
	126	+ if(!strcmp(buf,s1)){
	127	+ gpio_direction_output(gpio_data->ndj_gpio_num[open_now].gpio_num,1);
	128	+ //printk("%s write 1 succeed\n",gpio_data->ndj_gpio_num[open_now].gpio_name);
	129	+ }else{
	130	+ gpio_direction_output(gpio_data->ndj_gpio_num[open_now].gpio_num,0);
	131	+ //printk("%s write 0 succeed\n",gpio_data->ndj_gpio_num[open_now].gpio_name);
	132	+ }
	133	+ return count;
	134	+}
	135	+
	136	+
	137	+static ssize_t gpio_read(struct file file, char __user buffer, size_t count, loff_t *data)
	138	+{
	139	+ int gpio_val = 0;
	140	+ int len = 0;
	141	+ char s[10] = {0};
	142	+
	143	+ if(*data)
	144	+ return 0;
	145	+
	146	+ gpio_val = gpio_get_value(gpio_data->ndj_gpio_num[open_now].gpio_num);
	147	+ //printk("get %s value %d\n",gpio_data->ndj_gpio_num[open_now].gpio_name,gpio_val);
	148	+
	149	+ len = sprintf(s+len, "%d\n",gpio_val);
	150	+
	151	+ return simple_read_from_buffer(buffer, count, data, s, 2);
	152	+}
	153	+
	154	+
	155	+static const struct file_operations gpio_ops = {
	156	+ .owner = THIS_MODULE,
	157	+ .open = gpio_open,
	158	+ .write = gpio_write,
	159	+ .read = gpio_read,
	160	+};
	161	+
	162	+static int ndj_gpio_probe(struct platform_device *pdev) {
	163	+ struct device_node *np = pdev->dev.of_node;
	164	+ struct device_node *child_np;
	165	+ struct device *dev = &pdev->dev;
	166	+ static struct proc_dir_entry *root_entry_gpio;
	167	+ enum of_gpio_flags gpio_flags;
	168	+ int ret = 0;
	169	+ int gpio_cnt = 0;
	170	+ char gpio_name_num[20];
	171	+ int gpio_in_cnt = 0;
	172	+ int cnt =0;
	173	+ int i=0;
	174	+ enum of_gpio_flags flags;
	175	+
	176	+ gpio_data = devm_kzalloc(&pdev->dev, sizeof(struct ndj_gpio_data),GFP_KERNEL);
	177	+ if (!gpio_data) {
	178	+ dev_err(&pdev->dev, "failed to allocate memory\n");
	179	+ return -ENOMEM;
	180	+ }
	181	+
	182	+ gpio_data->gpio_dts_num = of_get_child_count(np);
	183	+// printk("ndj_gpio prepare build %d gpio\n",gpio_data->gpio_dts_num);
	184	+
	185	+ if (gpio_data->gpio_dts_num == 0){
	186	+ dev_info(&pdev->dev, "no gpio defined\n");
	187	+ }
393	188
394		- //lcd_bk_en_gpio;
395		- ret = of_get_named_gpio_flags(node, "lcd_bk_en_gpio", 0, &flags);
396		- if (ret < 0) {
397		- printk("%s() Can not read property lcd_bk_en_gpio\n", __FUNCTION__);
398		- } else {
399		- pdata->lcd_bk_en_gpio = ret;
400		-
401		- ret = devm_gpio_request(&pdev->dev, pdata->lcd_bk_en_gpio, "lcd_bk_en_gpio");
402		- if(ret < 0){
403		- printk("%s() devm_gpio_request lcd_bk_en_gpio request ERROR\n", __FUNCTION__);
404		- }
405		-
406		- ret = gpio_direction_output(pdata->lcd_bk_en_gpio,1);
407		- if(ret < 0){
408		- printk("%s() gpio_direction_output lcd_bk_en_gpio set ERROR\n", __FUNCTION__);
409		- }
410		- }
411		-
412		- //lcd_pwblk_gpio;
413		- ret = of_get_named_gpio_flags(node, "lcd_pwblk_gpio", 0, &flags);
414		- if (ret < 0) {
415		- printk("%s() Can not read property lcd_pwblk_gpio\n", __FUNCTION__);
416		- } else {
417		- pdata->lcd_pwblk_gpio = ret;
418		-
419		- ret = devm_gpio_request(&pdev->dev, pdata->lcd_pwblk_gpio, "lcd_pwblk_gpio");
420		- if(ret < 0){
421		- printk("%s() devm_gpio_request lcd_pwblk_gpio request ERROR\n", __FUNCTION__);
422		- }
423		-
424		- ret = gpio_direction_output(pdata->lcd_pwblk_gpio,1);
425		- if(ret < 0){
426		- printk("%s() gpio_direction_output lcd_pwblk_gpio set ERROR\n", __FUNCTION__);
427		- }
428		- }
429		-
430		-
431		- //edp_set_pixel-s
432		- ret = of_get_named_gpio_flags(node, "edp_reset", 0, &flags);
	189	+ #if 0
	190	+ /gpio_op0/
	191	+ ret = of_get_named_gpio_flags(np, "gpio_op0", 0, &gpio_flags);
433	192	if (ret < 0) {
434		- printk("%s() Can not read property edp_reset\n", __FUNCTION__);
435		- goto err;
	193	+ printk("%s() Can not read property gpio_op0\n", __func__);
	194	+ return -ENODEV;
436	195	}
437		-
438		- reset_pin = ret;
439		-
440		-// enable lvds
441		- ret = of_get_named_gpio_flags(node, "edp_gpio0", 0, &flags);
442		- if (ret < 0) {
443		- printk("%s() Can not read property edp_gpio0\n", __FUNCTION__);
444		- goto err;
445		- }
446		- gpio0 = ret;
447		-
448		-
449		-
450		- ret = of_get_named_gpio_flags(node, "edp_gpio1", 0, &flags);
451		- if (ret < 0) {
452		- printk("%s() Can not read property edp_gpio1\n", __FUNCTION__);
453		- goto err;
454		- }
455		-
456		- gpio1 = ret;
457		-
458		- ret = of_get_named_gpio_flags(node, "edp_gpio2", 0, &flags);
459		- if (ret < 0) {
460		- printk("%s() Can not read property edp_gpio2\n", __FUNCTION__);
461		- goto err;
462		- }
463		-
464		- gpio2 = ret;
465		-
466		- ret = of_get_named_gpio_flags(node, "edp_gpio3", 0, &flags);
467		- if (ret < 0) {
468		- printk("%s() Can not read property edp_gpio3\n", __FUNCTION__);
469		- goto err;
470		- }
471		-
472		- gpio3 = ret;
473		-
474		-
475		- ret = devm_gpio_request(&pdev->dev, reset_pin, "edp_reset");
	196	+ gpio_data->gpio_op0 = ret;
	197	+ ret = gpio_request(gpio_data->gpio_op0, "gpio_op0");
476	198	if(ret < 0){
477		- printk("%s() devm_gpio_request edp_reset request ERROR\n", __FUNCTION__);
478		- goto err;
479		- }
480		-
481		-
482		- ret = devm_gpio_request(&pdev->dev, gpio0, "edp_gpio0");
483		- if(ret < 0){
484		- printk("%s() devm_gpio_request edp_gpio0 request ERROR\n", __FUNCTION__);
485		- goto err;
486		- }
487		-
488		- ret = devm_gpio_request(&pdev->dev, gpio1, "edp_gpio1");
489		- if(ret < 0){
490		- printk("%s() devm_gpio_request edp_gpio1 request ERROR\n", __FUNCTION__);
491		- goto err;
492		- }
493		-
494		- ret = devm_gpio_request(&pdev->dev, gpio2, "edp_gpio2");
495		- if(ret < 0){
496		- printk("%s() devm_gpio_request edp_gpio2 request ERROR\n", __FUNCTION__);
497		- goto err;
498		- }
499		-
500		- ret = devm_gpio_request(&pdev->dev, gpio3, "edp_gpio3");
501		- if(ret < 0){
502		- printk("%s() devm_gpio_request edp_gpio3 request ERROR\n", __FUNCTION__);
503		- goto err;
	199	+ printk("%s() gpio_op0 request ERROR\n", __func__);
	200	+ return -ENODEV;
504	201	}
505	202
506		- ret = of_property_read_u32(node, "nodka_lvds", &lvds_index);
507		- if (ret < 0){
508		- printk("%s() Can not read property nodka_lvds\n", __FUNCTION__);
509		- }
510		-
511		- printk("nodka_lvds_index = %d\n",lvds_index);
512		-
513		- while ( i < 4 ){
514		- if ( lvds_index > 0)
515		- lvds_gpio[i] = lvds_index%2;
516		- else
517		- lvds_gpio[i] = 0;
518		- printk("lvds_gpio[%d]=%d\n",i,lvds_gpio[i]);
519		- lvds_index = lvds_index/2;
520		- i++;
521		- }
522		-
523		- gpio_direction_output(reset_pin, 0);
524		- usleep_range(80000, 100000);
525		- gpio_direction_output(reset_pin, 1);
526		- usleep_range(80000, 100000);
527		-
528		- gpio_direction_output(gpio0, lvds_gpio[0]);
529		- gpio_direction_output(gpio1, lvds_gpio[1]);
530		- gpio_direction_output(gpio2, lvds_gpio[2]);
531		- gpio_direction_output(gpio3, lvds_gpio[3]);
532		-
533		-
534		- gpio_direction_output(reset_pin, 0);
535		- usleep_range(80000, 100000);
536		- gpio_direction_output(reset_pin, 1);
537		- usleep_range(80000, 100000);
538		-*/
539		- printk(" #######nk_io_control_probe end####### \n");
540		- return 0;
541		-
542		-err:
543		- kfree(pdata);
544		- return ret;
545		-}
546		-
547		-
548		-static int nk_io_control_remove(struct platform_device *pdev)
549		-{
550		- if(NKpdata_info)
551		- kfree(NKpdata_info);
552		- return 0;
553		-}
554		-
555		-static int nk_io_control_suspend(struct platform_device *pdev, pm_message_t state)
556		-{
557		- int ret;
558		- struct nk_io_pdata *pdata;
559		- printk("nk_suspend !!!!\n");
560		-#if 0
561		- ret = gpio_get_value(8);
562		- printk("vcc12v gpio value : %d\n",ret);
563		- usleep_range(80000, 100000);
564		- gpio_set_value(8,0);
565		- ret = gpio_get_value(8);
566		- printk("vcc12v gpio value : %d\n",ret);
	203	+ gpio_direction_output(gpio_data->gpio_op0,!gpio_flags);
567	204	#endif
	205	+
	206	+ /* create node */
	207	+ root_entry_gpio = proc_mkdir("ndj_gpio", NULL);
	208	+
	209	+ for_each_child_of_node(np, child_np)
	210	+ {
	211	+ /* parse dts */
	212	+ gpio_data->ndj_gpio_num[gpio_cnt].gpio_num = of_get_named_gpio_flags(child_np, "gpio_num", 0, &gpio_flags);
	213	+ if (!gpio_is_valid(gpio_data->ndj_gpio_num[gpio_cnt].gpio_num)){
	214	+ return -1;
	215	+ }
	216	+
	217	+ gpio_data->ndj_gpio_num[gpio_cnt].gpio_name = (char*)child_np -> name;
	218	+ gpio_data->ndj_gpio_num[gpio_cnt].action = gpio_flags;
	219	+ gpio_data->ndj_gpio_num[gpio_cnt].gpio_ctrl = gpio_cnt;
	220	+ of_property_read_u32(child_np, "gpio_function", &(gpio_data->ndj_gpio_num[gpio_cnt].gpio_function));
	221	+
	222	+// printk("ndj_gpio request %s\n",gpio_data->ndj_gpio_num[gpio_cnt].gpio_name);
	223	+
	224	+
	225	+ switch(gpio_data->ndj_gpio_num[gpio_cnt].gpio_function) {
	226	+ case GPIO_FUNCTION_INPUT : /* init input gpio */
	227	+ ret = gpio_request(gpio_data->ndj_gpio_num[gpio_cnt].gpio_num, gpio_data->ndj_gpio_num[gpio_cnt].gpio_name);
	228	+ if (ret < 0)
	229	+ {
	230	+ printk("gpio%d request error\n",gpio_data->ndj_gpio_num[gpio_cnt].gpio_num);
	231	+ }else{
	232	+ // printk("success request gpio %d in\n",gpio_data->ndj_gpio_num[gpio_cnt].gpio_num);
	233	+
	234	+ gpio_direction_input(gpio_data->ndj_gpio_num[gpio_cnt].gpio_num);
	235	+ //gpio_direction_output(gpio_data->ndj_gpio_num[gpio_cnt].gpio_num,!gpio_data->ndj_gpio_num[gpio_cnt].action);
	236	+ //event_flag = gpio_flags;
	237	+ //of_property_read_u32(child_np, "send_mode", &(gpio_data->ndj_gpio_num[gpio_cnt].send_mode));
	238	+ //of_property_read_u32(child_np, "gpio_event", &(gpio_data->ndj_gpio_num[gpio_cnt].gpio_event));
	239	+ gpio_in_cnt++;
	240	+ }
	241	+ break;
	242	+
	243	+ case GPIO_FUNCTION_OUTPUT : /* init output gpio */
	244	+ ret = gpio_request(gpio_data->ndj_gpio_num[gpio_cnt].gpio_num, gpio_data->ndj_gpio_num[gpio_cnt].gpio_name);
	245	+ if (ret < 0){
	246	+ printk("gpio%d request error\n",gpio_data->ndj_gpio_num[gpio_cnt].gpio_num);
	247	+ //return ret;
	248	+ }else{
	249	+ gpio_direction_output(gpio_data->ndj_gpio_num[gpio_cnt].gpio_num,!gpio_data->ndj_gpio_num[gpio_cnt].action);
	250	+ //printk("success request gpio%d out\n",gpio_data->ndj_gpio_num[gpio_cnt].gpio_num);
	251	+ }
	252	+ break;
	253	+
	254	+ case GPIO_FUNCTION_RESET :
	255	+ ret = gpio_request(gpio_data->ndj_gpio_num[gpio_cnt].gpio_num, gpio_data->ndj_gpio_num[gpio_cnt].gpio_name);
	256	+ if (ret < 0){
	257	+ printk("gpio%d request error\n",gpio_data->ndj_gpio_num[gpio_cnt].gpio_num);
	258	+ //return ret;
	259	+ }else{
	260	+ gpio_direction_output(gpio_data->ndj_gpio_num[gpio_cnt].gpio_num,gpio_data->ndj_gpio_num[gpio_cnt].action);
	261	+ //printk("success request gpio%d reset\n",gpio_data->ndj_gpio_num[gpio_cnt].gpio_num);
	262	+ mdelay(200);
	263	+ gpio_direction_output(gpio_data->ndj_gpio_num[gpio_cnt].gpio_num,!gpio_data->ndj_gpio_num[gpio_cnt].action);
	264	+
	265	+// gpio_cnt++;
	266	+ }
	267	+ break;
	268	+ }
	269	+
	270	+ sprintf(gpio_name_num,gpio_data->ndj_gpio_num[gpio_cnt].gpio_name,gpio_cnt);
	271	+ proc_create(gpio_name_num, 0666 , root_entry_gpio , &gpio_ops);
	272	+ gpio_cnt++;
	273	+ }
	274	+
	275	+ platform_set_drvdata(pdev, gpio_data);
	276	+
568	277	#if 0
569		- ret = gpio_get_value(21);
570		- printk("hub_host3_5v_gpio value : %d\n",ret);
571		- usleep_range(80000, 100000);
572		- gpio_set_value(21,0);
573		- ret = gpio_get_value(21);
574		- printk("hub_host3_5v_gpio value : %d\n",ret);
575		- //enable = 0;
576		- //LED_SET(0);
	278	+ ret= class_register(&ndj_io_class);
	279	+ if(ret < 0) {
	280	+ return -EINVAL;
	281	+ }
577	282	#endif
578		- return 0;
	283	+ return 0;
579	284	}
580		-
581		-static int nk_io_control_resume(struct platform_device *pdev)
	285	+
	286	+
	287	+static int ndj_gpio_suspend(struct platform_device *pdev, pm_message_t state)
582	288	{
583		- return 0;
	289	+ int ret;
	290	+ struct nk_io_pdata *pdata;
	291	+ printk("nk_suspend !!!!\n");
	292	+ return 0;
584	293	}
585		-
586		-static const struct of_device_id nk_io_control_of_match[] = {
587		- { .compatible = "nk_io_control", },
588		- {},
	294	+
	295	+static int ndj_gpio_resume(struct platform_device *pdev)
	296	+{
	297	+ int ret,reset_pin;
	298	+ printk("nk_io resume !!!!\n");
	299	+ return 0;
	300	+}
	301	+
	302	+
	303	+static int ndj_gpio_remove(struct platform_device *pdev)
	304	+{
	305	+// class_unregister(&ndj_io_class);
	306	+ return 0;
	307	+}
	308	+
	309	+
	310	+static const struct of_device_id ndj_gpio_of_match[] = {
	311	+ { .compatible = "nk_io_control" },
	312	+ { }
589	313	};
590		-MODULE_DEVICE_TABLE(of, nk_io_control_of_match);
591		-
592		-static struct platform_driver nk_io_control_driver = {
593		- .probe = nk_io_control_probe,
594		- .remove = nk_io_control_remove,
595		- .resume = nk_io_control_resume,
596		- .suspend = nk_io_control_suspend,
597		- .driver = {
598		- .name = "nk_io_control",
599		- .owner = THIS_MODULE,
600		- .of_match_table = of_match_ptr(nk_io_control_of_match),
601		- },
	314	+
	315	+static struct platform_driver ndj_gpio_driver = {
	316	+ .probe = ndj_gpio_probe,
	317	+ .remove = ndj_gpio_remove,
	318	+ .resume = ndj_gpio_resume,
	319	+ .suspend = ndj_gpio_suspend,
	320	+ .driver = {
	321	+ .name = "nk_io_control",
	322	+ .of_match_table = of_match_ptr(ndj_gpio_of_match),
	323	+ },
602	324	};
603		-
604		-static int __init nk_io_control_init(void)
605		-{
606		- platform_driver_register(&nk_io_control_driver);
607		- return 0;
608		-}
609		-
610		-static void __exit nk_io_control_exit(void)
611		-{
612		- platform_driver_unregister(&nk_io_control_driver);
613		-}
614		-
615		-subsys_initcall(nk_io_control_init);
616		-
617		-//late_initcall(nk_io_control_init);
618		-MODULE_DESCRIPTION("nk io Core Driver");
	325	+
	326	+module_platform_driver(ndj_gpio_driver);
619	327	MODULE_LICENSE("GPL");
	328	+MODULE_LICENSE("GPL");