add at24 driver

hc

2023-11-06 15ade055295d13f95d49e3d99b09f3bbfb4a43e7

 kernel/drivers/misc/nkio/nk_io_core.c
..
..
@@ -1,622 +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
-void MODULE_SET(int i)
46
-{
47
-	if(i==11){
48
-		gpio_direction_output(NKpdata_info->en_4g_gpio, 1);
49
-	}else{
50
-		gpio_direction_output(NKpdata_info->en_4g_gpio, 0);
51
-	}
52
-}
53
-
54
-EXPORT_SYMBOL_GPL(MODULE_SET);
55
-
56
-
57
-void LED_SET(int i)
58
-{
59
-	if(i==11){
60
-		gpio_direction_output(NKpdata_info->led_gpio, 1);
61
-	}else{
62
-		gpio_direction_output(NKpdata_info->led_gpio, 0);
63
-	}
64
-}
65
-
66
-EXPORT_SYMBOL_GPL(LED_SET);
67
-
68
-
69
-void Audio_SET(int i);
70
-
71
-  void Audio_SET(int i)
72
- {
73
-	 if(i==11){
74
-		 gpio_direction_output(NKpdata_info->audio_switch_gpio, 1);
75
-		 printk("Audio_SET ENABLE------andy\n");
76
-	 }else{
77
-		 gpio_direction_output(NKpdata_info->audio_switch_gpio, 0);
78
-		 printk("Audio_SET DISABLE------andy\n");
79
-	 }
80
- }
81
-  EXPORT_SYMBOL_GPL(Audio_SET);
82
-
83
-static int nk_io_control_probe(struct platform_device *pdev)
84
-{
85
-	struct device_node *node = pdev->dev.of_node;
86
-	struct nk_io_pdata *pdata;	
87
-	int gpio0, gpio1, gpio2, gpio3, reset_pin, ch342_reset;
88
-	int ret;
89
-        int lvds_index;
90
-        int i=0;
91
-        static int lvds_gpio[4] ;
92
-
93
-	enum of_gpio_flags flags;
94
-	
95
-	printk(" #######nk_io_control_probe####### \n");
96
-
97
-	pdata = kzalloc(sizeof(struct nk_io_pdata), GFP_KERNEL);
98
-	if (pdata == NULL) {
99
-		printk("%s failed to allocate driver data\n",__FUNCTION__);
100
-		return -ENOMEM;
101
-	}
102
-	memset(pdata,0,sizeof(struct nk_io_pdata));
103
-	
104
-	//vcc_5v_io
105
-	ret = of_get_named_gpio_flags(node, "vcc_5v_io", 0, &flags);
106
-	if (ret < 0) {
107
-		printk("%s() Can not read property vcc_5v_io\n", __FUNCTION__);
108
-		goto err;
109
-	} else {
110
-		pdata->vcc_5v_io = ret;
111
-		ret = devm_gpio_request(&pdev->dev, pdata->vcc_5v_io, "vcc_5v_io");
112
-		if(ret < 0){
113
-			printk("%s() devm_gpio_request vcc_5v_io request ERROR\n", __FUNCTION__);
114
-			goto err;
115
-		}
116
-
117
-		ret = gpio_direction_output(pdata->vcc_5v_io,1); 
118
-		if(ret < 0){
119
-			printk("%s() gpio_direction_input vcc_5v_io set ERROR\n", __FUNCTION__);
120
-			goto err;
121
-		}
122
-	}
123
-	
124
-	//vcc3_io_en_gpio
125
-	ret = of_get_named_gpio_flags(node, "vcc3_io_en_gpio", 0, &flags);
126
-	if (ret < 0) {
127
-		printk("%s() Can not read property tp_enable\n", __FUNCTION__);
128
-		goto err;
129
-	} else {
130
-		pdata->vcc3_io_en_gpio = ret;
131
-		ret = devm_gpio_request(&pdev->dev, pdata->vcc3_io_en_gpio, "vcc3_io_en_gpio");
132
-		if(ret < 0){
133
-			printk("%s() devm_gpio_request vcc3_io_en_gpio request ERROR\n", __FUNCTION__);
134
-			goto err;
135
-		}
136
-
137
-		ret = gpio_direction_output(pdata->vcc3_io_en_gpio,1); 
138
-		if(ret < 0){
139
-			printk("%s() gpio_direction_output vcc3_io_en_gpio set ERROR\n", __FUNCTION__);
140
-			goto err;
141
-		}
142
-	}
143
-
144
-        //vcc_12v_io
145
-        ret = of_get_named_gpio_flags(node, "vcc_12v_io", 0, &flags);
146
-        if (ret < 0) {
147
-                printk("%s() Can not read property vcc_12v_io\n", __FUNCTION__);
148
-                goto err;
149
-        } else {
150
-                pdata->vcc_12v_io = ret;
151
-                ret = devm_gpio_request(&pdev->dev, pdata->vcc_12v_io, "vcc_12v_io");
152
-                if(ret < 0){
153
-                        printk("%s() devm_gpio_request vcc_12v_io request ERROR\n", __FUNCTION__);
154
-                        goto err;
155
-                }
156
-
157
-                ret = gpio_direction_output(pdata->vcc_12v_io,1);
158
-                if(ret < 0){
159
-                        printk("%s() gpio_direction_input vcc_12v_io set ERROR\n", __FUNCTION__);
160
-                        goto err;
161
-                }
162
-        }
163
-
164
-
165
-	
166
-	//hub_host2_5v_gpio
167
-	ret = of_get_named_gpio_flags(node, "hub_host2_5v_gpio", 0, &flags);
168
-	if (ret < 0) {
169
-		printk("%s() Can not read property hub_host2_5v_gpio\n", __FUNCTION__);
170
-		goto err;
171
-	} else {
172
-		pdata->hub_host2_5v_gpio = ret;
173
-		gpio_free(ret);
174
-		ret = devm_gpio_request(&pdev->dev, pdata->hub_host2_5v_gpio, "hub_host2_5v_gpio");
175
-		if (ret < 0){
176
-			printk("%s() devm_gpio_request hub_host2_5v_gpio request ERROR\n", __FUNCTION__);
177
-			goto err;
178
-		}
179
-
180
-		ret = gpio_direction_output(pdata->hub_host2_5v_gpio,1); 
181
-		if(ret < 0){
182
-			printk("%s() gpio_direction_input hub_host2_5v_gpio set ERROR\n", __FUNCTION__);
183
-			goto err;
184
-		}
185
-	}
186
-	
187
-	//usb_en_oc_gpio
188
-	ret = of_get_named_gpio_flags(node, "usb_en_oc_gpio", 0, &flags);
189
-	if (ret < 0) {
190
-		printk("%s() Can not read property usb_en_oc_gpio\n", __FUNCTION__);
191
-		goto err;
192
-	} else {
193
-		pdata->usb_en_oc_gpio = ret;
194
-		gpio_free(ret);
195
-		ret = devm_gpio_request(&pdev->dev, pdata->usb_en_oc_gpio, "usb_en_oc_gpio");
196
-		if (ret < 0){
197
-			printk("%s() devm_gpio_request usb_en_oc_gpio request ERROR\n", __FUNCTION__);
198
-			goto err;
199
-		}
200
-
201
-		ret = gpio_direction_output(pdata->usb_en_oc_gpio,1); 
202
-		if(ret < 0){
203
-			printk("%s() gpio_direction_input usb_en_oc_gpio set ERROR\n", __FUNCTION__);
204
-			goto err;
205
-		}
206
-	}
207
-
208
-	//hub_host2_5V_rest_gpio
209
-	ret = of_get_named_gpio_flags(node, "hub_host2_5V_rest_gpio", 0, &flags);
210
-	if (ret < 0) {
211
-		printk("%s() Can not read property hub_host2_5V_rest_gpio\n", __FUNCTION__);
212
-		goto err;
213
-	} else {
214
-		pdata->hub_host2_5V_rest_gpio = ret;
215
-		ret = devm_gpio_request(&pdev->dev, pdata->hub_host2_5V_rest_gpio, "hub_host2_5V_rest_gpio");
216
-		if(ret < 0){
217
-			printk("%s() devm_gpio_request hub_host2_5V_rest_gpio request ERROR\n", __FUNCTION__);
218
-			goto err;
219
-		}
220
-
221
-		ret = gpio_direction_output(pdata->hub_host2_5V_rest_gpio,0); 
222
-		if(ret < 0){
223
-			printk("%s() gpio_direction_input hub_host2_5V_rest_gpio set ERROR\n", __FUNCTION__);
224
-			goto err;
225
-		}
226
-		msleep(800);
227
-		ret = gpio_direction_output(pdata->hub_host2_5V_rest_gpio,1); 
228
-		if(ret < 0){
229
-			printk("%s() gpio_direction_input hub_host2_5V_rest_gpio set ERROR\n", __FUNCTION__);
230
-			goto err;
231
-		}
232
-	}
233
-
234
-	//hub_host3_5v_gpio
235
-	ret = of_get_named_gpio_flags(node, "hub_host3_5v_gpio", 0, &flags);
236
-	if (ret < 0) {
237
-		printk("%s() Can not read property hub_host3_5v_gpio\n", __FUNCTION__);
238
-		goto err;
239
-	} else {
240
-		pdata->hub_host3_5v_gpio = ret;
241
-		gpio_free(ret);
242
-		ret = devm_gpio_request(&pdev->dev, pdata->hub_host3_5v_gpio, "hub_host3_5v_gpio");
243
-		if(ret < 0){
244
-			printk("%s() devm_gpio_request hub_host3_5v_gpio request ERROR\n", __FUNCTION__);
245
-			goto err;
246
-		}
247
-
248
-		ret = gpio_direction_output(pdata->hub_host3_5v_gpio,1); 
249
-		if(ret < 0){
250
-			printk("%s() gpio_direction_input hub_host3_5v_gpio set ERROR\n", __FUNCTION__);
251
-			goto err;
252
-		}
253
-	}
45
+/* creat sysfs gpio api node*/
254
46
 #if 0
255
-	//hub_host3_5V_rest_gpio
256
-	ret = of_get_named_gpio_flags(node, "hub_host3_5V_rest_gpio", 0, &flags);
257
-	if (ret < 0) {
258
-		printk("%s() Can not read property hub_host3_5V_rest_gpio\n", __FUNCTION__);
259
-		goto err;
260
-	} else {
261
-		pdata->hub_host3_5V_rest_gpio = ret;
262
-		ret = devm_gpio_request(&pdev->dev, pdata->hub_host3_5V_rest_gpio, "hub_host3_5V_rest_gpio");
263
-		if(ret < 0){
264
-			printk("%s() devm_gpio_request hub_host3_5V_rest_gpio request ERROR\n", __FUNCTION__);
265
-			goto err;
266
-		}
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
+}
267
51
 
268
-		ret = gpio_direction_output(pdata->hub_host3_5V_rest_gpio,0); 
269
-		if(ret < 0){
270
-			printk("%s() gpio_direction_input hub_host3_5V_rest_gpio set ERROR\n", __FUNCTION__);
271
-			goto err;
272
-		}
273
-		msleep(800);
274
-		ret = gpio_direction_output(pdata->hub_host3_5V_rest_gpio,1); 
275
-		if(ret < 0){
276
-			printk("%s() gpio_direction_input hub_host3_5V_rest_gpio set ERROR\n", __FUNCTION__);
277
-			goto err;
278
-		}
279
-	}
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
+ 
280
96
 #endif
281
-	//wake_4g_gpio
282
-	   ret = of_get_named_gpio_flags(node, "wake_4g_gpio", 0, &flags);
283
-	   if (ret < 0) {
284
-	           printk("%s() Can not read property wake_4g_gpio\n", __FUNCTION__);
285
-	   } else {
286
-	           pdata->wake_4g_gpio = ret;
287
-
288
-	           ret = devm_gpio_request(&pdev->dev, pdata->wake_4g_gpio, "wake_4g_gpio");
289
-	           if(ret < 0){
290
-	                   printk("%s() devm_gpio_request wake_4g_gpio request ERROR\n", __FUNCTION__);
291
-	           }
292
-	           ret = gpio_direction_output(pdata->wake_4g_gpio,0);
293
-	           if(ret < 0){
294
-	                   printk("%s() gpio_direction_input wake_4g_gpio set ERROR\n", __FUNCTION__);
295
-	           }
296
-	   }
297
-
298
-
299
-	   //reset_4g_gpio
300
-	   ret = of_get_named_gpio_flags(node, "reset_4g_gpio", 0, &flags);
301
-	   if (ret < 0) {
302
-	           printk("%s() Can not read property reset_4g_gpio\n", __FUNCTION__);
303
-	   } else {
304
-	           pdata->reset_4g_gpio = ret;
305
-
306
-	           ret = devm_gpio_request(&pdev->dev, pdata->reset_4g_gpio, "reset_4g_gpio");
307
-	           if(ret < 0){
308
-	                   printk("%s() devm_gpio_request reset_4g_gpio request ERROR\n", __FUNCTION__);
309
-	           }
310
-	           ret = gpio_direction_output(pdata->reset_4g_gpio,0);
311
-	           if(ret < 0){
312
-	                   printk("%s() gpio_direction_input reset_4g_gpio set ERROR\n", __FUNCTION__);
313
-	           }
314
-	   }
315
-
316
-	   //en_4g_gpio
317
-	   ret = of_get_named_gpio_flags(node, "en_4g_gpio", 0, &flags);
318
-	   if (ret < 0) {
319
-	           printk("%s() Can not read property en_4g_gpio\n", __FUNCTION__);
320
-	   } else {
321
-	           pdata->en_4g_gpio = ret;
322
-
323
-	           ret = devm_gpio_request(&pdev->dev, pdata->en_4g_gpio, "en_4g_gpio");
324
-	           if(ret < 0){
325
-	                   printk("%s() devm_gpio_request en_4g_gpio request ERROR\n", __FUNCTION__);
326
-	           }
327
-	           ret = gpio_direction_output(pdata->en_4g_gpio,1);
328
-	           if(ret < 0){
329
-	                   printk("%s() gpio_direction_input en_4g_gpio set ERROR\n", __FUNCTION__);
330
-	           }
331
-	   }
332
-
333
-
334
-	   //air_mode_4g_gpio
335
-	   ret = of_get_named_gpio_flags(node, "air_mode_4g_gpio", 0, &flags);
336
-	   if (ret < 0) {
337
-	           printk("%s() Can not read property air_mode_4g_gpio\n", __FUNCTION__);
338
-	   } else {
339
-	           pdata->air_mode_4g_gpio = ret;
340
-
341
-	           ret = devm_gpio_request(&pdev->dev, pdata->air_mode_4g_gpio, "air_mode_4g_gpio");
342
-	           if(ret < 0){
343
-	                   printk("%s() devm_gpio_request air_mode_4g_gpio request ERROR\n", __FUNCTION__);
344
-	           }
345
-	           ret = gpio_direction_output(pdata->air_mode_4g_gpio,0);
346
-	           if(ret < 0){
347
-	                   printk("%s() gpio_direction_input air_mode_4g_gpio set ERROR\n", __FUNCTION__);
348
-	           }
349
-	   }
350
-
351
-	  
352
-/*
353
-	//edp_power_supply_gpio;
354
-	ret = of_get_named_gpio_flags(node, "edp_power_supply_gpio", 0, &flags);
355
-	if (ret < 0) {
356
-		printk("%s() Can not read property edp_power_supply_gpio\n", __FUNCTION__);
357
-	} else {
358
-		pdata->edp_power_supply_gpio = ret;
359
-
360
-		ret = devm_gpio_request(&pdev->dev, pdata->edp_power_supply_gpio, "edp_power_supply_gpio");
361
-		if(ret < 0){
362
-			printk("%s() devm_gpio_request edp_power_supply_gpio request ERROR\n", __FUNCTION__);
363
-		}
364
-		
365
-		ret = gpio_direction_output(pdata->edp_power_supply_gpio,1);
366
-		if(ret < 0){
367
-			printk("%s() gpio_direction_input edp_power_supply_gpio set ERROR\n", __FUNCTION__);
368
-		}
369
-	}
370
-	
371
-   //edp_enable-gpio;
372
-	ret = of_get_named_gpio_flags(node, "edp_enable_gpio", 0, &flags);
373
-	if (ret < 0) {
374
-		printk("%s() Can not read property edp_enable_gpio\n", __FUNCTION__);
375
-	} else {
376
-		pdata->edp_enable_gpio = ret;
377
-
378
-		ret = devm_gpio_request(&pdev->dev, pdata->edp_enable_gpio, "edp_enable_gpio");
379
-		if(ret < 0){
380
-			printk("%s() devm_gpio_request edp_enable_gpio request ERROR\n", __FUNCTION__);
381
-		}
382
-		
383
-		ret = gpio_direction_output(pdata->edp_enable_gpio,1);
384
-		if(ret < 0){
385
-			printk("%s() gpio_direction_input edp_enable_gpio set ERROR\n", __FUNCTION__);
386
-		}
387
-	} 
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
+   }
388
188
   
389
-   //ch342_enable-gpio;
390
-	ret = of_get_named_gpio_flags(node, "ch342_power", 0, &flags);
391
-	if (ret < 0) {
392
-		printk("%s() Can not read property ch342_gpio\n", __FUNCTION__);
393
-	} else {
394
-		pdata->ch342_power = ret;
395
-
396
-		ret = devm_gpio_request(&pdev->dev, pdata->ch342_power, "ch342_power");
397
-		if(ret < 0){
398
-			printk("%s() devm_gpio_request ch342_power request ERROR\n", __FUNCTION__);
399
-		}
400
-		
401
-		ret = gpio_direction_output(pdata->ch342_power,1);
402
-		if(ret < 0){
403
-			printk("%s() gpio_direction_input ch342_power set ERROR\n", __FUNCTION__);
404
-		}
405
-	}   
406
-*/
407
-
408
-        //edp_set_pixel-s
409
-         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);
410
192
     if (ret < 0) {
411
-        printk("%s() Can not read property edp_reset\n", __FUNCTION__);
412
-        goto err;
193
+        printk("%s() Can not read property gpio_op0\n", __func__);
194
+        return -ENODEV;
413
195
     }
414
-
415
-    reset_pin = ret;
416
-
417
-// enable lvds
418
-     ret = of_get_named_gpio_flags(node, "edp_gpio0", 0, &flags);
419
-    if (ret < 0) {
420
-        printk("%s() Can not read property edp_gpio0\n", __FUNCTION__);
421
-        goto err;
422
-    }
423
-	 gpio0 = ret;
424
-
425
-
426
-
427
-    ret = of_get_named_gpio_flags(node, "edp_gpio1", 0, &flags);
428
-    if (ret < 0) {
429
-        printk("%s() Can not read property edp_gpio1\n", __FUNCTION__);
430
-        goto err;
431
-    }
432
-
433
-        gpio1 = ret;
434
-
435
-    ret = of_get_named_gpio_flags(node, "edp_gpio2", 0, &flags);
436
-    if (ret < 0) {
437
-        printk("%s() Can not read property edp_gpio2\n", __FUNCTION__);
438
-        goto err;
439
-    }
440
-
441
-    gpio2 = ret;
442
-
443
-    ret = of_get_named_gpio_flags(node, "edp_gpio3", 0, &flags);
444
-    if (ret < 0) {
445
-        printk("%s() Can not read property edp_gpio3\n", __FUNCTION__);
446
-        goto err;
447
-    }
448
-
449
-    gpio3 = ret;
450
-
451
-
452
-	 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");
453
198
     if(ret < 0){
454
-        printk("%s() devm_gpio_request edp_reset request ERROR\n", __FUNCTION__);
455
-        goto err;
456
-    }
457
-
458
-
459
-    ret = devm_gpio_request(&pdev->dev, gpio0, "edp_gpio0");
460
-    if(ret < 0){
461
-        printk("%s() devm_gpio_request edp_gpio0 request ERROR\n", __FUNCTION__);
462
-        goto err;
463
-    }
464
-
465
-    ret = devm_gpio_request(&pdev->dev, gpio1, "edp_gpio1");
466
-    if(ret < 0){
467
-        printk("%s() devm_gpio_request edp_gpio1 request ERROR\n", __FUNCTION__);
468
-        goto err;
469
-    }
470
-
471
-    ret = devm_gpio_request(&pdev->dev, gpio2, "edp_gpio2");
472
-    if(ret < 0){
473
-        printk("%s() devm_gpio_request edp_gpio2 request ERROR\n", __FUNCTION__);
474
-        goto err;
475
-    }
476
-
477
-    ret = devm_gpio_request(&pdev->dev, gpio3, "edp_gpio3");
478
-    if(ret < 0){
479
-        printk("%s() devm_gpio_request edp_gpio3 request ERROR\n", __FUNCTION__);
480
-        goto err;
199
+        printk("%s() gpio_op0 request ERROR\n", __func__);
200
+        return -ENODEV;
481
201
     }
482
202
 	
483
-	   ret = of_property_read_u32(node, "nodka_lvds", &lvds_index);
484
-        if (ret < 0){
485
-                printk("%s() Can not read property nodka_lvds\n", __FUNCTION__);
486
-        }
203
+	gpio_direction_output(gpio_data->gpio_op0,!gpio_flags);
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);  
487
276
 
488
-        printk("nodka_lvds_index = %d\n",lvds_index);
489
-
490
-        while ( i < 4 ){
491
-                if ( lvds_index > 0)
492
-                        lvds_gpio[i] = lvds_index%2;
493
-                else
494
-                        lvds_gpio[i] = 0;
495
-                printk("lvds_gpio[%d]=%d\n",i,lvds_gpio[i]);
496
-                lvds_index = lvds_index/2;
497
-                i++;
498
-        }
499
-
500
-    gpio_direction_output(reset_pin, 0);
501
-    usleep_range(80000, 100000);
502
-    gpio_direction_output(reset_pin, 1);
503
-    usleep_range(80000, 100000);
504
-
505
-	gpio_direction_output(gpio0, lvds_gpio[0]);
506
-	gpio_direction_output(gpio1, lvds_gpio[1]);
507
-	gpio_direction_output(gpio2, lvds_gpio[2]);
508
-	gpio_direction_output(gpio3, lvds_gpio[3]);
509
-	
510
-	printk(" #######nk_io_control_probe end####### \n");
511
-	return 0;
512
-	
513
-err:
514
-	kfree(pdata);
515
-	return ret;	
516
-}	
517
-
518
-
519
-static int nk_io_control_remove(struct platform_device *pdev)
520
-{
521
-	if(NKpdata_info)
522
-		kfree(NKpdata_info);
523
-	return 0;
277
+#if 0
278
+	ret= class_register(&ndj_io_class);
279
+	if(ret < 0) {
280
+		return -EINVAL; 
281
+	}
282
+#endif
283
+   return 0;
524
284
 }
525
-
526
-static int nk_io_control_suspend(struct platform_device *pdev, pm_message_t state)
285
+ 
286
+ 
287
+static int ndj_gpio_suspend(struct platform_device *pdev, pm_message_t state)
527
288
 {
528
-	int ret;
529
-	struct nk_io_pdata *pdata;
530
-	printk("nk_suspend  !!!!\n");
531
-#if 0
532
-	ret = gpio_get_value(8);
533
-	printk("vcc12v gpio value : %d\n",ret);
534
-        usleep_range(80000, 100000);
535
-        gpio_set_value(8,0);
536
-	ret = gpio_get_value(8);
537
-	printk("vcc12v gpio value : %d\n",ret);
538
-#endif
539
-#if 0
540
-	ret = gpio_get_value(21);
541
-	printk("hub_host3_5v_gpio value : %d\n",ret);
542
-        usleep_range(80000, 100000);
543
-        gpio_set_value(21,0);
544
-	ret = gpio_get_value(21);
545
-	printk("hub_host3_5v_gpio value : %d\n",ret);
546
-	//enable = 0;
547
-	//LED_SET(0);
548
-#endif
549
-	return 0;
289
+   int ret;
290
+   struct nk_io_pdata *pdata;
291
+   printk("nk_suspend  !!!!\n");
292
+   return 0;
550
293
 }
551
-
552
-static int nk_io_control_resume(struct platform_device *pdev)
294
+ 
295
+static int ndj_gpio_resume(struct platform_device *pdev)
553
296
 {
554
-       int ret,reset_pin;
555
-        printk("nk_io resume !!!!\n");
556
-        ret = gpio_get_value(120);
557
-
558
-#if 0
559
-        gpio_set_value(8,1);
560
-	ret = gpio_get_value(8);
561
-	printk("vcc12v gpio value : %d\n",ret);
562
-#endif
563
-#if 0
564
-        gpio_set_value(15,1);
565
-	ret = gpio_get_value(15);
566
-	printk("edp_en gpio value : %d\n",ret);
567
-        gpio_set_value(21,1);
568
-	ret = gpio_get_value(21);
569
-	printk("hub_host3_5v_gpio value : %d\n",ret);
570
-#endif
571
-#if 0
572
-        usleep_range(80000, 100000);
573
-        gpio_set_value(120,0);
574
-//      gpio_direction_output(120, 0);
575
-        usleep_range(80000, 100000);
576
-        ret = gpio_get_value(120);
577
-        printk("edp_reset gpio value : %d\n",ret);
578
-//      gpio_direction_output(120, 1);
579
-        gpio_set_value(120,1);
580
-        usleep_range(80000, 100000);
581
-        ret = gpio_get_value(120);
582
-        printk("edp_reset gpio value : %d\n",ret);
583
-#endif
584
-        //enable = 1;
585
-        //LED_SET(11);
586
-        return 0;
297
+    int ret,reset_pin;
298
+    printk("nk_io resume !!!!\n");
299
+    return 0;
587
300
 }
588
-
589
-static const struct of_device_id nk_io_control_of_match[] = {
590
-        { .compatible = "nk_io_control", },
591
-        {},
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
+    { }
592
313
 };
593
-MODULE_DEVICE_TABLE(of, nk_io_control_of_match);
594
-
595
-static struct platform_driver nk_io_control_driver = {
596
-	.probe	= nk_io_control_probe,
597
-	.remove = nk_io_control_remove,
598
-	.resume = 	nk_io_control_resume,	
599
-	.suspend = 	nk_io_control_suspend,	
600
-	.driver	= {
601
-		.name	= "nk_io_control",
602
-		.owner	= THIS_MODULE,
603
-		.of_match_table = of_match_ptr(nk_io_control_of_match),		
604
-	},
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
+        },
605
324
 };
606
-
607
-static int __init nk_io_control_init(void)
608
-{
609
-	platform_driver_register(&nk_io_control_driver);
610
-	return 0;
611
-}
612
-
613
-static void __exit nk_io_control_exit(void)
614
-{
615
-	platform_driver_unregister(&nk_io_control_driver);
616
-}
617
-
618
-subsys_initcall(nk_io_control_init);
619
-
620
-//late_initcall(nk_io_control_init);
621
-MODULE_DESCRIPTION("nk io Core Driver");
325
+ 
326
+module_platform_driver(ndj_gpio_driver);
622
327
 MODULE_LICENSE("GPL");
328
+MODULE_LICENSE("GPL");