projects / openwrt / svn-archive / archive.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[lantiq] cleanup patches
[openwrt/svn-archive/archive.git] / target / linux / lantiq / files / drivers / usb / ifxhcd / ifxusb_ctl.c
1 /*****************************************************************************
2 ** FILE NAME : ifxusb_ctl.c
3 ** PROJECT : IFX USB sub-system V3
4 ** MODULES : IFX USB sub-system Host and Device driver
5 ** SRC VERSION : 1.0
6 ** DATE : 1/Jan/2009
7 ** AUTHOR : Chen, Howard
8 ** DESCRIPTION : Implementing the procfs and sysfs for IFX USB driver
9 *****************************************************************************/
10
11 /*! \file ifxusb_ctl.c
12 \ingroup IFXUSB_DRIVER_V3
13 \brief Implementing the procfs and sysfs for IFX USB driver
14 */
15
16 #include <linux/version.h>
17 #include "ifxusb_version.h"
18
19
20 #include <linux/proc_fs.h>
21 #include <asm/byteorder.h>
22 #include <asm/unaligned.h>
23 #include <asm/uaccess.h>
24
25 #include "ifxusb_plat.h"
26 #include "ifxusb_regs.h"
27 #include "ifxusb_cif.h"
28
29 #ifdef __IS_DEVICE__
30 #include "ifxpcd.h"
31 #endif
32
33 #ifdef __IS_HOST__
34 #include "ifxhcd.h"
35 #endif
36
37 #include <linux/device.h>
38 #include <linux/platform_device.h>
39 #include <linux/gfp.h>
40
41
42 #ifdef __IS_HOST__
43 extern char ifxusb_driver_name[];
44
45 #ifdef __IS_DUAL__
46 extern ifxhcd_hcd_t ifxusb_hcd_1;
47 extern ifxhcd_hcd_t ifxusb_hcd_2;
48 extern char ifxusb_hcd_name_1[];
49 extern char ifxusb_hcd_name_2[];
50 #else
51 extern ifxhcd_hcd_t ifxusb_hcd;
52 extern char ifxusb_hcd_name[];
53 #endif
54
55 #endif
56
57 #ifdef __IS_DEVICE__
58 extern char ifxusb_driver_name[];
59
60 extern ifxpcd_pcd_t ifxusb_pcd;
61 extern char ifxusb_pcd_name[];
62 #endif
63
64
65 //Attributes for sysfs (for 2.6 only)
66
67 extern struct device_attribute dev_attr_dbglevel;
68
69 #ifdef __IS_DUAL__
70 extern struct device_attribute dev_attr_dump_params_1;
71 extern struct device_attribute dev_attr_dump_params_2;
72 #else
73 extern struct device_attribute dev_attr_dump_params;
74 #endif
75
76 #ifdef __IS_DUAL__
77 extern struct device_attribute dev_attr_mode_1;
78 extern struct device_attribute dev_attr_mode_2;
79 #else
80 extern struct device_attribute dev_attr_mode;
81 #endif
82
83 #ifdef __IS_HOST__
84 #ifdef __IS_DUAL__
85 extern struct device_attribute dev_attr_buspower_1;
86 extern struct device_attribute dev_attr_buspower_2;
87 extern struct device_attribute dev_attr_bussuspend_1;
88 extern struct device_attribute dev_attr_bussuspend_2;
89 extern struct device_attribute dev_attr_busconnected_1;
90 extern struct device_attribute dev_attr_busconnected_2;
91 extern struct device_attribute dev_attr_connectspeed_1;
92 extern struct device_attribute dev_attr_connectspeed_1;
93 #else
94 extern struct device_attribute dev_attr_buspower;
95 extern struct device_attribute dev_attr_bussuspend;
96 extern struct device_attribute dev_attr_busconnected;
97 extern struct device_attribute dev_attr_connectspeed;
98 #endif
99 #endif //__IS_HOST__
100
101 #ifdef __IS_DEVICE__
102 extern struct device_attribute dev_attr_devspeed;
103 extern struct device_attribute dev_attr_enumspeed;
104 #endif //__IS_DEVICE__
105
106 #ifdef __ENABLE_DUMP__
107 #ifdef __IS_DUAL__
108 extern struct device_attribute dev_attr_dump_reg_1;
109 extern struct device_attribute dev_attr_dump_reg_2;
110 extern struct device_attribute dev_attr_dump_spram_1;
111 extern struct device_attribute dev_attr_dump_spram_2;
112 #ifdef __IS_HOST__
113 extern struct device_attribute dev_attr_dump_host_state_1;
114 extern struct device_attribute dev_attr_dump_host_state_2;
115 #else
116 #endif
117 #else
118 extern struct device_attribute dev_attr_dump_reg;
119 extern struct device_attribute dev_attr_dump_spram;
120 #ifdef __IS_HOST__
121 extern struct device_attribute dev_attr_dump_host_state;
122 #else
123 #endif
124 #endif
125 #endif //__ENABLE_DUMP__
126
127
128 /////////////////////////////////////////////////////////////////////////////////////////////////////
129 /////////////////////////////////////////////////////////////////////////////////////////////////////
130 /////////////////////////////////////////////////////////////////////////////////////////////////////
131
132 static ssize_t procfs_dbglevel_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
133 {
134 #ifdef __IS_HOST__
135 return sprintf( buf, "%08X\n",h_dbg_lvl );
136 #else
137 return sprintf( buf, "%08X\n",d_dbg_lvl );
138 #endif
139 }
140
141 static ssize_t procfs_dbglevel_store(struct file *file, const char *buffer, unsigned long count, void *data)
142 {
143 char buf[10];
144 int i = 0;
145 uint32_t value;
146 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
147 return -EFAULT;
148 value = simple_strtoul(buf, NULL, 16);
149 #ifdef __IS_HOST__
150 h_dbg_lvl =value;
151 #else
152 d_dbg_lvl =value;
153 #endif
154 //turn on and off power
155 return count;
156 }
157
158 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
159 static ssize_t sysfs_dbglevel_show( struct device *_dev, struct device_attribute *attr,char *buf)
160 #else
161 static ssize_t sysfs_dbglevel_show( struct device *_dev, char *buf)
162 #endif
163 {
164 #ifdef __IS_HOST__
165 return sprintf( buf, "%08X\n",h_dbg_lvl );
166 #else
167 return sprintf( buf, "%08X\n",d_dbg_lvl );
168 #endif
169 }
170
171 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
172 static ssize_t sysfs_dbglevel_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
173 #else
174 static ssize_t sysfs_dbglevel_store( struct device *_dev, const char *buffer, size_t count )
175 #endif
176 {
177 char buf[10];
178 int i = 0;
179 uint32_t value;
180 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
181 return -EFAULT;
182 value = simple_strtoul(buf, NULL, 16);
183 #ifdef __IS_HOST__
184 h_dbg_lvl =value;
185 #else
186 d_dbg_lvl =value;
187 #endif
188 //turn on and off power
189 return count;
190 }
191
192 DEVICE_ATTR(dbglevel, S_IRUGO|S_IWUSR, sysfs_dbglevel_show, sysfs_dbglevel_store);
193
194
195 /////////////////////////////////////////////////////////////////////////////////////////////////////
196 /////////////////////////////////////////////////////////////////////////////////////////////////////
197 /////////////////////////////////////////////////////////////////////////////////////////////////////
198
199 static void ifxusb_dump_params(ifxusb_core_if_t *_core_if);
200
201 #ifdef __IS_DUAL__
202 static void dump_params_1(void)
203 {
204 ifxusb_dump_params(&ifxusb_hcd_1.core_if);
205 }
206 static void dump_params_2(void)
207 {
208 ifxusb_dump_params(&ifxusb_hcd_2.core_if);
209 }
210
211 static ssize_t procfs_dump_params_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
212 {
213 dump_params_1();
214 return 0;
215 }
216 static ssize_t procfs_dump_params_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
217 {
218 dump_params_2();
219 return 0;
220 }
221
222 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
223 static ssize_t sysfs_dump_params_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
224 #else
225 static ssize_t sysfs_dump_params_show_1( struct device *_dev,char *buf)
226 #endif
227 {
228 dump_params_1();
229 return 0;
230 }
231 DEVICE_ATTR(dump_params_1, S_IRUGO|S_IWUSR, sysfs_dump_params_show_1, NULL);
232
233 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
234 static ssize_t sysfs_dump_params_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
235 #else
236 static ssize_t sysfs_dump_params_show_2( struct device *_dev,char *buf)
237 #endif
238 {
239 dump_params_2();
240 return 0;
241 }
242
243 DEVICE_ATTR(dump_params_2, S_IRUGO|S_IWUSR, sysfs_dump_params_show_2, NULL);
244 #else
245 static void dump_params(void)
246 {
247 #ifdef __IS_HOST__
248 ifxusb_dump_params(&ifxusb_hcd.core_if);
249 #else
250 ifxusb_dump_params(&ifxusb_pcd.core_if);
251 #endif
252 }
253
254 static ssize_t procfs_dump_params_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
255 {
256 dump_params();
257 return 0;
258 }
259
260 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
261 static ssize_t sysfs_dump_params_show( struct device *_dev, struct device_attribute *attr,char *buf)
262 #else
263 static ssize_t sysfs_dump_params_show( struct device *_dev,char *buf)
264 #endif
265 {
266 dump_params();
267 return 0;
268 }
269 DEVICE_ATTR(dump_params, S_IRUGO|S_IWUSR, sysfs_dump_params_show, NULL);
270 #endif
271
272 /////////////////////////////////////////////////////////////////////////////////////////////////////
273 /////////////////////////////////////////////////////////////////////////////////////////////////////
274 /////////////////////////////////////////////////////////////////////////////////////////////////////
275
276 #ifdef __IS_DUAL__
277 static ssize_t mode_show_1(char *buf)
278 {
279 if((ifxusb_rreg(&ifxusb_hcd_1.core_if.core_global_regs->gintsts ) & 0x1) == 1)
280 return sprintf( buf, "HOST\n" );
281 else
282 return sprintf( buf, "DEVICE(INCORRECT!)\n" );
283 }
284
285 static ssize_t mode_show_2(char *buf)
286 {
287 if((ifxusb_rreg(&ifxusb_hcd_2.core_if.core_global_regs->gintsts ) & 0x1) == 1)
288 return sprintf( buf, "HOST\n" );
289 else
290 return sprintf( buf, "DEVICE(INCORRECT!)\n" );
291 }
292
293 static ssize_t procfs_mode_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
294 {
295 return mode_show_1(buf);
296 }
297 static ssize_t procfs_mode_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
298 {
299 return mode_show_2(buf);
300 }
301
302 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
303 static ssize_t sysfs_mode_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
304 #else
305 static ssize_t sysfs_mode_show_1( struct device *_dev,char *buf)
306 #endif
307 {
308 return mode_show_1(buf);
309 }
310
311 DEVICE_ATTR(mode_1, S_IRUGO|S_IWUSR, sysfs_mode_show_1, 0);
312
313 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
314 static ssize_t sysfs_mode_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
315 #else
316 static ssize_t sysfs_mode_show_2( struct device *_dev,char *buf)
317 #endif
318 {
319 return mode_show_2(buf);
320 }
321 DEVICE_ATTR(mode_2, S_IRUGO|S_IWUSR, sysfs_mode_show_2, NULL);
322 #else
323 static ssize_t mode_show(char *buf)
324 {
325 #ifdef __IS_HOST__
326 if((ifxusb_rreg(&ifxusb_hcd.core_if.core_global_regs->gintsts ) & 0x1) == 1)
327 return sprintf( buf, "HOST\n" );
328 else
329 return sprintf( buf, "DEVICE(INCORRECT!)\n" );
330 #else
331 if((ifxusb_rreg(&ifxusb_pcd.core_if.core_global_regs->gintsts ) & 0x1) != 1)
332 return sprintf( buf, "DEVICE\n" );
333 else
334 return sprintf( buf, "HOST(INCORRECT!)\n" );
335 #endif
336 }
337 static ssize_t procfs_mode_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
338 {
339 return mode_show(buf);
340 }
341 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
342 static ssize_t sysfs_mode_show( struct device *_dev, struct device_attribute *attr,char *buf)
343 #else
344 static ssize_t sysfs_mode_show( struct device *_dev, char *buf)
345 #endif
346 {
347 return mode_show(buf);
348 }
349 DEVICE_ATTR(mode, S_IRUGO|S_IWUSR, sysfs_mode_show, NULL);
350 #endif
351
352 /////////////////////////////////////////////////////////////////////////////////////////////////////
353 /////////////////////////////////////////////////////////////////////////////////////////////////////
354 /////////////////////////////////////////////////////////////////////////////////////////////////////
355
356 #ifdef __IS_HOST__
357 #ifdef __IS_DUAL__
358 static ssize_t buspower_show_1(char *buf)
359 {
360 if(ifxusb_vbus (&ifxusb_hcd_1.core_if)==1) return sprintf( buf, "1\n" );
361 if(ifxusb_vbus (&ifxusb_hcd_1.core_if)==0) return sprintf( buf, "0\n" );
362 return sprintf( buf, "UNKNOWN\n" );
363 }
364 static void buspower_store_1(uint32_t value)
365 {
366 if (value==1) ifxusb_vbus_on (&ifxusb_hcd_1.core_if);
367 else if(value==0) ifxusb_vbus_off(&ifxusb_hcd_1.core_if);
368 }
369 static ssize_t buspower_show_2(char *buf)
370 {
371 if(ifxusb_vbus (&ifxusb_hcd_2.core_if)==1) return sprintf( buf, "1\n" );
372 if(ifxusb_vbus (&ifxusb_hcd_2.core_if)==0) return sprintf( buf, "0\n" );
373 return sprintf( buf, "UNKNOWN\n" );
374 }
375 static void buspower_store_2(uint32_t value)
376 {
377 if (value==1) ifxusb_vbus_on (&ifxusb_hcd_2.core_if);
378 else if(value==0) ifxusb_vbus_off(&ifxusb_hcd_2.core_if);
379 }
380 static ssize_t procfs_buspower_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
381 {
382 return buspower_show_1(buf);
383 }
384 static ssize_t procfs_buspower_store_1(struct file *file, const char *buffer, unsigned long count, void *data)
385 {
386 char buf[10];
387 int i = 0;
388 uint32_t value;
389 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
390 return -EFAULT;
391 value = simple_strtoul(buf, NULL, 16);
392 buspower_store_1(value);
393 return count;
394 }
395 static ssize_t procfs_buspower_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
396 {
397 return buspower_show_2(buf);
398 }
399 static ssize_t procfs_buspower_store_2(struct file *file, const char *buffer, unsigned long count, void *data)
400 {
401 char buf[10];
402 int i = 0;
403 uint32_t value;
404 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
405 return -EFAULT;
406 value = simple_strtoul(buf, NULL, 16);
407 buspower_store_2(value);
408 return count;
409 }
410
411 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
412 static ssize_t sysfs_buspower_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
413 #else
414 static ssize_t sysfs_buspower_show_1( struct device *_dev,char *buf)
415 #endif
416 {
417 return buspower_show_1(buf);
418 }
419 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
420 static ssize_t sysfs_buspower_store_1( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
421 #else
422 static ssize_t sysfs_buspower_store_1( struct device *_dev, const char *buffer, size_t count )
423 #endif
424 {
425 char buf[10];
426 int i = 0;
427 uint32_t value;
428 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
429 return -EFAULT;
430 value = simple_strtoul(buf, NULL, 16);
431 buspower_store_1(value);
432 return count;
433 }
434 DEVICE_ATTR(buspower_1, S_IRUGO|S_IWUSR, sysfs_buspower_show_1, sysfs_buspower_store_1);
435
436 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
437 static ssize_t sysfs_buspower_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
438 #else
439 static ssize_t sysfs_buspower_show_2( struct device *_dev,char *buf)
440 #endif
441 {
442 return buspower_show_2(buf);
443 }
444 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
445 static ssize_t sysfs_buspower_store_2( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
446 #else
447 static ssize_t sysfs_buspower_store_2( struct device *_dev, const char *buffer, size_t count )
448 #endif
449 {
450 char buf[10];
451 int i = 0;
452 uint32_t value;
453 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
454 return -EFAULT;
455 value = simple_strtoul(buf, NULL, 16);
456 buspower_store_2(value);
457 return count;
458 }
459 DEVICE_ATTR(buspower_2, S_IRUGO|S_IWUSR, sysfs_buspower_show_2, sysfs_buspower_store_2);
460 #else
461 static ssize_t buspower_show(char *buf)
462 {
463 if(ifxusb_vbus (&ifxusb_hcd.core_if)==1) return sprintf( buf, "1\n" );
464 if(ifxusb_vbus (&ifxusb_hcd.core_if)==0) return sprintf( buf, "0\n" );
465 return sprintf( buf, "UNKNOWN\n" );
466 }
467 static void buspower_store(uint32_t value)
468 {
469 if (value==1) ifxusb_vbus_on (&ifxusb_hcd.core_if);
470 else if(value==0) ifxusb_vbus_off(&ifxusb_hcd.core_if);
471 }
472 static ssize_t procfs_buspower_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
473 {
474 return buspower_show(buf);
475 }
476 static ssize_t procfs_buspower_store(struct file *file, const char *buffer, unsigned long count, void *data)
477 {
478 char buf[10];
479 int i = 0;
480 uint32_t value;
481 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
482 return -EFAULT;
483 value = simple_strtoul(buf, NULL, 16);
484 buspower_store(value);
485 return count;
486 }
487 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
488 static ssize_t sysfs_buspower_show( struct device *_dev, struct device_attribute *attr,char *buf)
489 #else
490 static ssize_t sysfs_buspower_show( struct device *_dev, char *buf)
491 #endif
492 {
493 return buspower_show(buf);
494 }
495 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
496 static ssize_t sysfs_buspower_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
497 #else
498 static ssize_t sysfs_buspower_store( struct device *_dev, const char *buffer, size_t count )
499 #endif
500 {
501 char buf[10];
502 int i = 0;
503 uint32_t value;
504 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
505 return -EFAULT;
506 value = simple_strtoul(buf, NULL, 16);
507 buspower_store(value);
508 return count;
509 }
510 DEVICE_ATTR(buspower, S_IRUGO|S_IWUSR, sysfs_buspower_show, sysfs_buspower_store);
511 #endif
512
513 /////////////////////////////////////////////////////////////////////////////////////////////////////
514 /////////////////////////////////////////////////////////////////////////////////////////////////////
515 /////////////////////////////////////////////////////////////////////////////////////////////////////
516
517
518 #ifdef __IS_DUAL__
519 static ssize_t bussuspend_show_1(char *buf)
520 {
521 hprt0_data_t val;
522 val.d32 = ifxusb_rreg(ifxusb_hcd_1.core_if.hprt0);
523 return sprintf (buf, "Bus Suspend = 0x%x\n", val.b.prtsusp);
524 }
525 static ssize_t bussuspend_show_2(char *buf)
526 {
527 hprt0_data_t val;
528 val.d32 = ifxusb_rreg(ifxusb_hcd_2.core_if.hprt0);
529 return sprintf (buf, "Bus Suspend = 0x%x\n", val.b.prtsusp);
530 }
531
532 static ssize_t procfs_bussuspend_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
533 {
534 return bussuspend_show_1(buf);
535 }
536 static ssize_t procfs_bussuspend_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
537 {
538 return bussuspend_show_2(buf);
539 }
540 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
541 static ssize_t sysfs_bussuspend_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
542 #else
543 static ssize_t sysfs_bussuspend_show_1( struct device *_dev,char *buf)
544 #endif
545 {
546 return bussuspend_show_1(buf);
547 }
548 DEVICE_ATTR(bussuspend_1, S_IRUGO|S_IWUSR, sysfs_bussuspend_show_1, 0);
549 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
550 static ssize_t sysfs_bussuspend_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
551 #else
552 static ssize_t sysfs_bussuspend_show_2( struct device *_dev,char *buf)
553 #endif
554 {
555 return bussuspend_show_2(buf);
556 }
557 DEVICE_ATTR(bussuspend_2, S_IRUGO|S_IWUSR, sysfs_bussuspend_show_2, 0);
558 #else
559 static ssize_t bussuspend_show(char *buf)
560 {
561 hprt0_data_t val;
562 val.d32 = ifxusb_rreg(ifxusb_hcd.core_if.hprt0);
563 return sprintf (buf, "Bus Suspend = 0x%x\n", val.b.prtsusp);
564 }
565 static ssize_t procfs_bussuspend_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
566 {
567 return bussuspend_show(buf);
568 }
569
570 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
571 static ssize_t sysfs_bussuspend_show( struct device *_dev, struct device_attribute *attr,char *buf)
572 #else
573 static ssize_t sysfs_bussuspend_show( struct device *_dev, char *buf)
574 #endif
575 {
576 return bussuspend_show(buf);
577 }
578 DEVICE_ATTR(bussuspend, S_IRUGO|S_IWUSR, sysfs_bussuspend_show, 0);
579 #endif
580
581 /////////////////////////////////////////////////////////////////////////////////////////////////////
582 /////////////////////////////////////////////////////////////////////////////////////////////////////
583 /////////////////////////////////////////////////////////////////////////////////////////////////////
584
585 #ifdef __IS_DUAL__
586 static ssize_t busconnected_show_1(char *buf)
587 {
588 hprt0_data_t val;
589 val.d32 = ifxusb_rreg(ifxusb_hcd_1.core_if.hprt0);
590 return sprintf (buf, "Bus Connected = 0x%x\n", val.b.prtconnsts);
591 }
592 static ssize_t busconnected_show_2(char *buf)
593 {
594 hprt0_data_t val;
595 val.d32 = ifxusb_rreg(ifxusb_hcd_2.core_if.hprt0);
596 return sprintf (buf, "Bus Connected = 0x%x\n", val.b.prtconnsts);
597 }
598
599 static ssize_t procfs_busconnected_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
600 {
601 return busconnected_show_1(buf);
602 }
603 static ssize_t procfs_busconnected_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
604 {
605 return busconnected_show_2(buf);
606 }
607 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
608 static ssize_t sysfs_busconnected_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
609 #else
610 static ssize_t sysfs_busconnected_show_1( struct device *_dev,char *buf)
611 #endif
612 {
613 return busconnected_show_1(buf);
614 }
615 DEVICE_ATTR(busconnected_1, S_IRUGO|S_IWUSR, sysfs_busconnected_show_1, 0);
616 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
617 static ssize_t sysfs_busconnected_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
618 #else
619 static ssize_t sysfs_busconnected_show_2( struct device *_dev,char *buf)
620 #endif
621 {
622 return busconnected_show_2(buf);
623 }
624 DEVICE_ATTR(busconnected_2, S_IRUGO|S_IWUSR, sysfs_busconnected_show_2, 0);
625 #else
626 static ssize_t busconnected_show(char *buf)
627 {
628 hprt0_data_t val;
629 val.d32 = ifxusb_rreg(ifxusb_hcd.core_if.hprt0);
630 return sprintf (buf, "Bus Connected = 0x%x\n", val.b.prtconnsts);
631 }
632 static ssize_t procfs_busconnected_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
633 {
634 return busconnected_show(buf);
635 }
636
637 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
638 static ssize_t sysfs_busconnected_show( struct device *_dev, struct device_attribute *attr,char *buf)
639 #else
640 static ssize_t sysfs_busconnected_show( struct device *_dev, char *buf)
641 #endif
642 {
643 return busconnected_show(buf);
644 }
645 DEVICE_ATTR(busconnected, S_IRUGO|S_IWUSR, sysfs_busconnected_show, 0);
646 #endif
647
648 /////////////////////////////////////////////////////////////////////////////////////////////////////
649 /////////////////////////////////////////////////////////////////////////////////////////////////////
650 /////////////////////////////////////////////////////////////////////////////////////////////////////
651
652 #ifdef __IS_DUAL__
653 static ssize_t connectspeed_show_1(char *buf)
654 {
655 hprt0_data_t val;
656 val.d32 = ifxusb_rreg(ifxusb_hcd_1.core_if.hprt0);
657 if( val.b.prtspd ==0) return sprintf (buf, "Bus Speed = High (%d)\n", val.b.prtspd);
658 if( val.b.prtspd ==1) return sprintf (buf, "Bus Speed = Full (%d)\n", val.b.prtspd);
659 if( val.b.prtspd ==2) return sprintf (buf, "Bus Speed = Low (%d)\n", val.b.prtspd);
660 return sprintf (buf, "Bus Speed = Unknown (%d)\n", val.b.prtspd);
661 }
662 static ssize_t connectspeed_show_2(char *buf)
663 {
664 hprt0_data_t val;
665 val.d32 = ifxusb_rreg(ifxusb_hcd_2.core_if.hprt0);
666 if( val.b.prtspd ==0) return sprintf (buf, "Bus Speed = High (%d)\n", val.b.prtspd);
667 if( val.b.prtspd ==1) return sprintf (buf, "Bus Speed = Full (%d)\n", val.b.prtspd);
668 if( val.b.prtspd ==2) return sprintf (buf, "Bus Speed = Low (%d)\n", val.b.prtspd);
669 return sprintf (buf, "Bus Speed = Unknown (%d)\n", val.b.prtspd);
670 }
671
672 static ssize_t procfs_connectspeed_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
673 {
674 return connectspeed_show_1(buf);
675 }
676 static ssize_t procfs_connectspeed_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
677 {
678 return connectspeed_show_2(buf);
679 }
680 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
681 static ssize_t sysfs_connectspeed_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
682 #else
683 static ssize_t sysfs_connectspeed_show_1( struct device *_dev,char *buf)
684 #endif
685 {
686 return connectspeed_show_1(buf);
687 }
688 DEVICE_ATTR(connectspeed_1, S_IRUGO|S_IWUSR, sysfs_connectspeed_show_1, 0);
689 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
690 static ssize_t sysfs_connectspeed_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
691 #else
692 static ssize_t sysfs_connectspeed_show_2( struct device *_dev,char *buf)
693 #endif
694 {
695 return connectspeed_show_2(buf);
696 }
697 DEVICE_ATTR(connectspeed_2, S_IRUGO|S_IWUSR, sysfs_connectspeed_show_2, 0);
698 #else
699 static ssize_t connectspeed_show(char *buf)
700 {
701 hprt0_data_t val;
702 val.d32 = ifxusb_rreg(ifxusb_hcd.core_if.hprt0);
703 if( val.b.prtspd ==0) return sprintf (buf, "Bus Speed = High (%d)\n", val.b.prtspd);
704 if( val.b.prtspd ==1) return sprintf (buf, "Bus Speed = Full (%d)\n", val.b.prtspd);
705 if( val.b.prtspd ==2) return sprintf (buf, "Bus Speed = Low (%d)\n", val.b.prtspd);
706 return sprintf (buf, "Bus Speed = Unknown (%d)\n", val.b.prtspd);
707 }
708
709 static ssize_t procfs_connectspeed_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
710 {
711 return connectspeed_show(buf);
712 }
713
714 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
715 static ssize_t sysfs_connectspeed_show( struct device *_dev, struct device_attribute *attr,char *buf)
716 #else
717 static ssize_t sysfs_connectspeed_show( struct device *_dev, char *buf)
718 #endif
719 {
720 return connectspeed_show(buf);
721 }
722 DEVICE_ATTR(connectspeed, S_IRUGO|S_IWUSR, sysfs_connectspeed_show, 0);
723 #endif
724 /////////////////////////////////////////////////////////////////////////////////////////////////////
725 /////////////////////////////////////////////////////////////////////////////////////////////////////
726 /////////////////////////////////////////////////////////////////////////////////////////////////////
727 #endif
728
729
730 #ifdef __IS_DEVICE__
731 /////////////////////////////////////////////////////////////////////////////////////////////////////
732 /////////////////////////////////////////////////////////////////////////////////////////////////////
733 /////////////////////////////////////////////////////////////////////////////////////////////////////
734 static ssize_t devspeed_show(char *buf)
735 {
736 dcfg_data_t val;
737 val.d32 = ifxusb_rreg(&ifxusb_pcd.core_if.dev_global_regs->dcfg);
738 if( val.b.devspd ==0) return sprintf (buf, "Dev Speed = High (%d)\n", val.b.devspd);
739 if( val.b.devspd ==1) return sprintf (buf, "Dev Speed = Full (%d)\n", val.b.devspd);
740 if( val.b.devspd ==3) return sprintf (buf, "Dev Speed = Full (%d)\n", val.b.devspd);
741 return sprintf (buf, "Dev Speed = Unknown (%d)\n", val.b.devspd);
742 }
743
744 static ssize_t procfs_devspeed_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
745 {
746 return devspeed_show(buf);
747 }
748
749 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
750 static ssize_t sysfs_devspeed_show( struct device *_dev, struct device_attribute *attr,char *buf)
751 #else
752 static ssize_t sysfs_devspeed_show( struct device *_dev, char *buf)
753 #endif
754 {
755 return devspeed_show(buf);
756 }
757 DEVICE_ATTR(devspeed, S_IRUGO|S_IWUSR, sysfs_devspeed_show, 0);
758
759 static ssize_t enumspeed_show(char *buf)
760 {
761 dsts_data_t val;
762 val.d32 = ifxusb_rreg(&ifxusb_pcd.core_if.dev_global_regs->dsts);
763 if( val.b.enumspd ==0) return sprintf (buf, "Enum Speed = High (%d)\n", val.b.enumspd);
764 if( val.b.enumspd ==1) return sprintf (buf, "Enum Speed = Full (%d)\n", val.b.enumspd);
765 if( val.b.enumspd ==2) return sprintf (buf, "Enum Speed = Low (%d)\n", val.b.enumspd);
766 return sprintf (buf, "Enum Speed = invalid(%d)\n", val.b.enumspd);
767 }
768
769 static ssize_t procfs_enumspeed_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
770 {
771 return enumspeed_show(buf);
772 }
773
774 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
775 static ssize_t sysfs_enumspeed_show( struct device *_dev, struct device_attribute *attr,char *buf)
776 #else
777 static ssize_t sysfs_enumspeed_show( struct device *_dev, char *buf)
778 #endif
779 {
780 return enumspeed_show(buf);
781 }
782 DEVICE_ATTR(enumspeed, S_IRUGO|S_IWUSR, sysfs_enumspeed_show, 0);
783 /////////////////////////////////////////////////////////////////////////////////////////////////////
784 /////////////////////////////////////////////////////////////////////////////////////////////////////
785 /////////////////////////////////////////////////////////////////////////////////////////////////////
786 #endif
787
788
789 //////////////////////////////////////////////////////////////////////////////////
790 #ifdef __ENABLE_DUMP__
791
792 #ifdef __IS_DUAL__
793 static void dump_reg_1(void)
794 {
795 ifxusb_dump_registers(&ifxusb_hcd_1.core_if);
796 }
797 static void dump_reg_2(void)
798 {
799 ifxusb_dump_registers(&ifxusb_hcd_2.core_if);
800 }
801
802 static ssize_t procfs_dump_reg_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
803 {
804 dump_reg_1();
805 return 0;
806 }
807 static ssize_t procfs_dump_reg_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
808 {
809 dump_reg_2();
810 return 0;
811 }
812 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
813 static ssize_t sysfs_dump_reg_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
814 #else
815 static ssize_t sysfs_dump_reg_show_1( struct device *_dev,char *buf)
816 #endif
817 {
818 dump_reg_1();
819 return 0;
820 }
821 DEVICE_ATTR(dump_reg_1, S_IRUGO|S_IWUSR, sysfs_dump_reg_show_1, 0);
822 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
823 static ssize_t sysfs_dump_reg_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
824 #else
825 static ssize_t sysfs_dump_reg_show_2( struct device *_dev,char *buf)
826 #endif
827 {
828 dump_reg_2();
829 return 0;
830 }
831 DEVICE_ATTR(dump_reg_2, S_IRUGO|S_IWUSR, sysfs_dump_reg_show_2, 0);
832 #else
833 static void dump_reg(void)
834 {
835 #ifdef __IS_HOST__
836 ifxusb_dump_registers(&ifxusb_hcd.core_if);
837 #endif
838 #ifdef __IS_DEVICE__
839 ifxusb_dump_registers(&ifxusb_pcd.core_if);
840 #endif
841 }
842 static ssize_t procfs_dump_reg_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
843 {
844 dump_reg();
845 return 0;
846 }
847 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
848 static ssize_t sysfs_dump_reg_show( struct device *_dev, struct device_attribute *attr,char *buf)
849 #else
850 static ssize_t sysfs_dump_reg_show( struct device *_dev,char *buf)
851 #endif
852 {
853 dump_reg();
854 return 0;
855 }
856 DEVICE_ATTR(dump_reg, S_IRUGO|S_IWUSR, sysfs_dump_reg_show, 0);
857 #endif
858
859
860 /////////////////////////////////////////////////////////////////////////////////////////////////////
861 /////////////////////////////////////////////////////////////////////////////////////////////////////
862 /////////////////////////////////////////////////////////////////////////////////////////////////////
863
864 #ifdef __IS_DUAL__
865 static void dump_spram_1(void)
866 {
867 ifxusb_dump_spram(&ifxusb_hcd_1.core_if);
868 }
869 static void dump_spram_2(void)
870 {
871 ifxusb_dump_spram(&ifxusb_hcd_2.core_if);
872 }
873
874 static ssize_t procfs_dump_spram_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
875 {
876 dump_spram_1();
877 return 0;
878 }
879 static ssize_t procfs_dump_spram_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
880 {
881 dump_spram_2();
882 return 0;
883 }
884 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
885 static ssize_t sysfs_dump_spram_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
886 #else
887 static ssize_t sysfs_dump_spram_show_1( struct device *_dev,char *buf)
888 #endif
889 {
890 dump_spram_1();
891 return 0;
892 }
893 DEVICE_ATTR(dump_spram_1, S_IRUGO|S_IWUSR, sysfs_dump_spram_show_1, 0);
894
895 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
896 static ssize_t sysfs_dump_spram_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
897 #else
898 static ssize_t sysfs_dump_spram_show_2( struct device *_dev,char *buf)
899 #endif
900 {
901 dump_spram_2();
902 return 0;
903 }
904 DEVICE_ATTR(dump_spram_2, S_IRUGO|S_IWUSR, sysfs_dump_spram_show_2, 0);
905 #else
906 static void dump_spram(void)
907 {
908 #ifdef __IS_HOST__
909 ifxusb_dump_spram(&ifxusb_hcd.core_if);
910 #endif
911 #ifdef __IS_DEVICE__
912 ifxusb_dump_spram(&ifxusb_pcd.core_if);
913 #endif
914 }
915 static ssize_t procfs_dump_spram_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
916 {
917 dump_spram();
918 return 0;
919 }
920 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
921 static ssize_t sysfs_dump_spram_show( struct device *_dev, struct device_attribute *attr,char *buf)
922 #else
923 static ssize_t sysfs_dump_spram_show( struct device *_dev,char *buf)
924 #endif
925 {
926 dump_spram();
927 return 0;
928 }
929 DEVICE_ATTR(dump_spram, S_IRUGO|S_IWUSR, sysfs_dump_spram_show, 0);
930 #endif
931 /////////////////////////////////////////////////////////////////////////////////////////////////////
932 /////////////////////////////////////////////////////////////////////////////////////////////////////
933 /////////////////////////////////////////////////////////////////////////////////////////////////////
934
935 #ifdef __IS_HOST__
936 #ifdef __IS_DUAL__
937 static ssize_t procfs_dump_host_state_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
938 {
939 ifxhcd_dump_state(&ifxusb_hcd_1);
940 return 0;
941 }
942 static ssize_t procfs_dump_host_state_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
943 {
944 ifxhcd_dump_state(&ifxusb_hcd_2);
945 return 0;
946 }
947 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
948 static ssize_t sysfs_dump_host_state_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
949 #else
950 static ssize_t sysfs_dump_host_state_show_1( struct device *_dev,char *buf)
951 #endif
952 {
953 ifxhcd_dump_state(&ifxusb_hcd_1);
954 return 0;
955 }
956 DEVICE_ATTR(dump_host_state_1, S_IRUGO|S_IWUSR, sysfs_dump_host_state_show_1, 0);
957 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
958 static ssize_t sysfs_dump_host_state_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
959 #else
960 static ssize_t sysfs_dump_host_state_show_2( struct device *_dev,char *buf)
961 #endif
962 {
963 ifxhcd_dump_state(&ifxusb_hcd_2);
964 return 0;
965 }
966 DEVICE_ATTR(dump_host_state_2, S_IRUGO|S_IWUSR, sysfs_dump_host_state_show_2, 0);
967 #else
968 static ssize_t procfs_dump_host_state_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
969 {
970 ifxhcd_dump_state(&ifxusb_hcd);
971 return 0;
972 }
973 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
974 static ssize_t sysfs_dump_host_state_show( struct device *_dev, struct device_attribute *attr,char *buf)
975 #else
976 static ssize_t sysfs_dump_host_state_show( struct device *_dev,char *buf)
977 #endif
978 {
979 ifxhcd_dump_state(&ifxusb_hcd);
980 return 0;
981 }
982 DEVICE_ATTR(dump_host_state, S_IRUGO|S_IWUSR, sysfs_dump_host_state_show, 0);
983 #endif
984
985 /////////////////////////////////////////////////////////////////////////////////////////////////////
986 /////////////////////////////////////////////////////////////////////////////////////////////////////
987 /////////////////////////////////////////////////////////////////////////////////////////////////////
988
989 #endif //IS_HOST_
990
991 #endif //__ENABLE_DUMP__
992
993 //////////////////////////////////////////////////////////////////////////////////
994
995 static int ifx_proc_addproc(char *funcname, read_proc_t *hookfuncr, write_proc_t *hookfuncw);
996 static void ifx_proc_delproc(char *funcname);
997
998 //////////////////////////////////////////////////////////////////////////////////
999
1000 /*!
1001 \brief This function create the sysfs and procfs entries
1002 \param[in] _dev Pointer of device structure, if applied
1003 */
1004 void ifxusb_attr_create (void *_dev)
1005 {
1006 int error;
1007
1008 struct device *dev = (struct device *) _dev;
1009
1010 IFX_DEBUGPL(DBG_ENTRY, "%s() %d\n", __func__, __LINE__ );
1011 error = ifx_proc_addproc("dbglevel", procfs_dbglevel_show, procfs_dbglevel_store);
1012 error = device_create_file(dev, &dev_attr_dbglevel);
1013
1014 #ifdef __IS_DUAL__
1015 error = ifx_proc_addproc("dump_params_1", procfs_dump_params_show_1, NULL);
1016 error = ifx_proc_addproc("dump_params_2", procfs_dump_params_show_2, NULL);
1017 error = device_create_file(dev, &dev_attr_dump_params_1);
1018 error = device_create_file(dev, &dev_attr_dump_params_2);
1019 #else
1020 error = ifx_proc_addproc("dump_params", procfs_dump_params_show, NULL);
1021 error = device_create_file(dev, &dev_attr_dump_params);
1022 #endif
1023
1024 #ifdef __IS_DUAL__
1025 error = ifx_proc_addproc("mode_1", procfs_mode_show_1, NULL);
1026 error = ifx_proc_addproc("mode_2", procfs_mode_show_2, NULL);
1027 error = device_create_file(dev, &dev_attr_mode_1);
1028 error = device_create_file(dev, &dev_attr_mode_2);
1029 #else
1030 error = ifx_proc_addproc("mode", procfs_mode_show, NULL);
1031 error = device_create_file(dev, &dev_attr_mode);
1032 #endif
1033
1034 #ifdef __IS_HOST__
1035 #ifdef __IS_DUAL__
1036 error = ifx_proc_addproc("buspower_1", procfs_buspower_show_1, procfs_buspower_store_1);
1037 error = ifx_proc_addproc("buspower_2", procfs_buspower_show_2, procfs_buspower_store_2);
1038 error = device_create_file(dev, &dev_attr_buspower_1);
1039 error = device_create_file(dev, &dev_attr_buspower_2);
1040 #else
1041 error = ifx_proc_addproc("buspower", procfs_buspower_show, procfs_buspower_store);
1042 error = device_create_file(dev, &dev_attr_buspower);
1043 #endif
1044
1045 #ifdef __IS_DUAL__
1046 error = ifx_proc_addproc("bussuspend_1", procfs_bussuspend_show_1, NULL);
1047 error = ifx_proc_addproc("bussuspend_2", procfs_bussuspend_show_2, NULL);
1048 error = device_create_file(dev, &dev_attr_bussuspend_1);
1049 error = device_create_file(dev, &dev_attr_bussuspend_2);
1050 #else
1051 error = ifx_proc_addproc("bussuspend", procfs_bussuspend_show, NULL);
1052 error = device_create_file(dev, &dev_attr_bussuspend);
1053 #endif
1054
1055 #ifdef __IS_DUAL__
1056 error = ifx_proc_addproc("busconnected_1", procfs_busconnected_show_1, NULL);
1057 error = ifx_proc_addproc("busconnected_2", procfs_busconnected_show_2, NULL);
1058 error = device_create_file(dev, &dev_attr_busconnected_1);
1059 error = device_create_file(dev, &dev_attr_busconnected_2);
1060 #else
1061 error = ifx_proc_addproc("busconnected", procfs_busconnected_show, NULL);
1062 error = device_create_file(dev, &dev_attr_busconnected);
1063 #endif
1064
1065 #ifdef __IS_DUAL__
1066 error = ifx_proc_addproc("connectspeed_1", procfs_connectspeed_show_1, NULL);
1067 error = ifx_proc_addproc("connectspeed_2", procfs_connectspeed_show_2, NULL);
1068 error = device_create_file(dev, &dev_attr_connectspeed_1);
1069 error = device_create_file(dev, &dev_attr_connectspeed_2);
1070 #else
1071 error = ifx_proc_addproc("connectspeed", procfs_connectspeed_show, NULL);
1072 error = device_create_file(dev, &dev_attr_connectspeed);
1073 #endif
1074 #endif
1075
1076 #ifdef __IS_DEVICE__
1077 error = ifx_proc_addproc("devspeed", procfs_devspeed_show, NULL);
1078 error = device_create_file(dev, &dev_attr_devspeed);
1079 error = ifx_proc_addproc("enumspeed", procfs_enumspeed_show, NULL);
1080 error = device_create_file(dev, &dev_attr_enumspeed);
1081 #endif
1082
1083 //////////////////////////////////////////////////////
1084 #ifdef __ENABLE_DUMP__
1085 #ifdef __IS_DUAL__
1086 error = ifx_proc_addproc("dump_reg_1", procfs_dump_reg_show_1, NULL);
1087 error = ifx_proc_addproc("dump_reg_2", procfs_dump_reg_show_2, NULL);
1088 error = device_create_file(dev, &dev_attr_dump_reg_1);
1089 error = device_create_file(dev, &dev_attr_dump_reg_2);
1090 #else
1091 error = ifx_proc_addproc("dump_reg", procfs_dump_reg_show, NULL);
1092 error = device_create_file(dev, &dev_attr_dump_reg);
1093 #endif
1094
1095 #ifdef __IS_DUAL__
1096 error = ifx_proc_addproc("dump_spram_1", procfs_dump_spram_show_1, NULL);
1097 error = ifx_proc_addproc("dump_spram_2", procfs_dump_spram_show_2, NULL);
1098 error = device_create_file(dev, &dev_attr_dump_spram_1);
1099 error = device_create_file(dev, &dev_attr_dump_spram_2);
1100 #else
1101 error = ifx_proc_addproc("dump_spram", procfs_dump_spram_show, NULL);
1102 error = device_create_file(dev, &dev_attr_dump_spram);
1103 #endif
1104
1105 #ifdef __IS_HOST__
1106 #ifdef __IS_DUAL__
1107 error = ifx_proc_addproc("dump_host_state_1", procfs_dump_host_state_show_1, NULL);
1108 error = ifx_proc_addproc("dump_host_state_2", procfs_dump_host_state_show_2, NULL);
1109 error = device_create_file(dev, &dev_attr_dump_host_state_1);
1110 error = device_create_file(dev, &dev_attr_dump_host_state_2);
1111 #else
1112 error = ifx_proc_addproc("dump_host_state", procfs_dump_host_state_show, NULL);
1113 error = device_create_file(dev, &dev_attr_dump_host_state);
1114 #endif
1115 #endif
1116 #endif //__ENABLE_DUMP__
1117 //////////////////////////////////////////////////////
1118 }
1119
1120
1121 /*!
1122 \brief This function remove the sysfs and procfs entries
1123 \param[in] _dev Pointer of device structure, if applied
1124 */
1125 void ifxusb_attr_remove (void *_dev)
1126 {
1127 struct device *dev = (struct device *) _dev;
1128
1129 IFX_DEBUGPL(DBG_ENTRY, "%s() %d\n", __func__, __LINE__ );
1130 ifx_proc_delproc("dbglevel");
1131 device_remove_file(dev, &dev_attr_dbglevel);
1132
1133 #ifdef __IS_DUAL__
1134 ifx_proc_delproc("dump_params_1");
1135 ifx_proc_delproc("dump_params_2");
1136 device_remove_file(dev, &dev_attr_dump_params_1);
1137 device_remove_file(dev, &dev_attr_dump_params_2);
1138 #else
1139 ifx_proc_delproc("dump_params");
1140 device_remove_file(dev, &dev_attr_dump_params);
1141 #endif
1142
1143 #ifdef __IS_DUAL__
1144 ifx_proc_delproc("mode_1");
1145 ifx_proc_delproc("mode_2");
1146 device_remove_file(dev, &dev_attr_mode_1);
1147 device_remove_file(dev, &dev_attr_mode_2);
1148 #else
1149 ifx_proc_delproc("mode");
1150 device_remove_file(dev, &dev_attr_mode);
1151 #endif
1152
1153 #ifdef __IS_HOST__
1154 #ifdef __IS_DUAL__
1155 ifx_proc_delproc("buspower_1");
1156 ifx_proc_delproc("buspower_2");
1157 device_remove_file(dev, &dev_attr_buspower_1);
1158 device_remove_file(dev, &dev_attr_buspower_2);
1159 #else
1160 ifx_proc_delproc("buspower");
1161 device_remove_file(dev, &dev_attr_buspower);
1162 #endif
1163
1164 #ifdef __IS_DUAL__
1165 ifx_proc_delproc("bussuspend_1");
1166 ifx_proc_delproc("bussuspend_2");
1167 device_remove_file(dev, &dev_attr_bussuspend_1);
1168 device_remove_file(dev, &dev_attr_bussuspend_2);
1169 #else
1170 ifx_proc_delproc("bussuspend");
1171 device_remove_file(dev, &dev_attr_bussuspend);
1172 #endif
1173
1174 #ifdef __IS_DUAL__
1175 ifx_proc_delproc("busconnected_1");
1176 ifx_proc_delproc("busconnected_2");
1177 device_remove_file(dev, &dev_attr_busconnected_1);
1178 device_remove_file(dev, &dev_attr_busconnected_2);
1179 #else
1180 ifx_proc_delproc("busconnected");
1181 device_remove_file(dev, &dev_attr_busconnected);
1182 #endif
1183
1184 #ifdef __IS_DUAL__
1185 ifx_proc_delproc("connectspeed_1");
1186 ifx_proc_delproc("connectspeed_2");
1187 device_remove_file(dev, &dev_attr_connectspeed_1);
1188 device_remove_file(dev, &dev_attr_connectspeed_2);
1189 #else
1190 ifx_proc_delproc("connectspeed");
1191 device_remove_file(dev, &dev_attr_connectspeed);
1192 #endif
1193 #endif
1194
1195 #ifdef __IS_DEVICE__
1196 ifx_proc_delproc("devspeed");
1197 device_remove_file(dev, &dev_attr_devspeed);
1198 ifx_proc_delproc("enumspeed");
1199 device_remove_file(dev, &dev_attr_enumspeed);
1200 #endif
1201
1202 #ifdef __ENABLE_DUMP__
1203 #ifdef __IS_DUAL__
1204 ifx_proc_delproc("dump_reg_1");
1205 ifx_proc_delproc("dump_reg_2");
1206 device_remove_file(dev, &dev_attr_dump_reg_1);
1207 device_remove_file(dev, &dev_attr_dump_reg_2);
1208 #else
1209 ifx_proc_delproc("dump_reg");
1210 device_remove_file(dev, &dev_attr_dump_reg);
1211 #endif
1212
1213 #ifdef __IS_DUAL__
1214 ifx_proc_delproc("dump_spram_1");
1215 ifx_proc_delproc("dump_spram_2");
1216 device_remove_file(dev, &dev_attr_dump_spram_1);
1217 device_remove_file(dev, &dev_attr_dump_spram_2);
1218 #else
1219 ifx_proc_delproc("dump_spram");
1220 device_remove_file(dev, &dev_attr_dump_spram);
1221 #endif
1222
1223 #ifdef __IS_HOST__
1224 #ifdef __IS_DUAL__
1225 ifx_proc_delproc("dump_host_state_1");
1226 ifx_proc_delproc("dump_host_state_2");
1227 device_remove_file(dev, &dev_attr_dump_host_state_1);
1228 device_remove_file(dev, &dev_attr_dump_host_state_2);
1229 #else
1230 ifx_proc_delproc("dump_host_state");
1231 device_remove_file(dev, &dev_attr_dump_host_state);
1232 #endif
1233 #endif
1234 #endif //__ENABLE_DUMP__
1235 /* AVM/WK fix: del IFXUSB root dir*/
1236 ifx_proc_delproc(NULL);
1237 }
1238
1239 static struct proc_dir_entry * proc_ifx_root = NULL;
1240
1241 /* initialize the proc file system and make a dir named /proc/[name] */
1242 static void ifx_proc_init(void)
1243 {
1244 IFX_DEBUGPL(DBG_ENTRY, "%s() %d\n", __func__, __LINE__ );
1245 proc_ifx_root = proc_mkdir(ifxusb_driver_name, (void *)0);
1246 if (!proc_ifx_root){
1247 IFX_PRINT("%s proc initialization failed! \n", ifxusb_driver_name);
1248 return;
1249 }
1250 }
1251
1252 /* proc file system add function for debugging. */
1253 static int ifx_proc_addproc(char *funcname, read_proc_t *hookfuncr, write_proc_t *hookfuncw)
1254 {
1255 struct proc_dir_entry *pe;
1256 IFX_DEBUGPL(DBG_ENTRY, "%s() %d\n", __func__, __LINE__ );
1257 if (!proc_ifx_root)
1258 ifx_proc_init();
1259
1260 if (hookfuncw == NULL)
1261 {
1262 pe = create_proc_read_entry(funcname, S_IRUGO, proc_ifx_root, hookfuncr, NULL);
1263 if (!pe)
1264 {
1265 IFX_PRINT("ERROR in creating read proc entry (%s)! \n", funcname);
1266 return -1;
1267 }
1268 }
1269 else
1270 {
1271 pe = create_proc_entry(funcname, S_IRUGO | S_IWUGO, proc_ifx_root);
1272 if (pe)
1273 {
1274 pe->read_proc = hookfuncr;
1275 pe->write_proc = hookfuncw;
1276 }
1277 else
1278 {
1279 IFX_PRINT("ERROR in creating proc entry (%s)! \n", funcname);
1280 return -1;
1281 }
1282 }
1283 return 0;
1284 }
1285
1286
1287 /* proc file system del function for removing module. */
1288 static void ifx_proc_delproc(char *funcname)
1289 {
1290 /* AVM/WK Fix*/
1291 if (funcname != NULL) {
1292 remove_proc_entry(funcname, proc_ifx_root);
1293 } else {
1294 remove_proc_entry(ifxusb_driver_name, NULL);
1295 proc_ifx_root = NULL;
1296 }
1297 }
1298
1299 static void ifxusb_dump_params(ifxusb_core_if_t *_core_if)
1300 {
1301 ifxusb_params_t *params=&_core_if->params;
1302
1303 #ifdef __IS_HOST__
1304 IFX_PRINT("IFXUSB Dump Parameters ( Host Mode) \n");
1305 #endif //__IS_HOST__
1306 #ifdef __IS_DEVICE__
1307 IFX_PRINT("IFXUSB Dump Parameters ( Device Mode) \n");
1308 #endif //__IS_DEVICE__
1309
1310 #ifdef __DESC_DMA__
1311 IFX_PRINT("DMA: Hermes DMA\n");
1312 #else
1313 IFX_PRINT("DMA: Non-Desc DMA\n");
1314 #endif
1315 IFX_PRINT(" Burst size: %d\n",params->dma_burst_size);
1316
1317 if (params->speed==1)
1318 IFX_PRINT("Full Speed only\n");
1319 else if(params->speed==0)
1320 IFX_PRINT("Full/Hign Speed\n");
1321 else
1322 IFX_PRINT("Unkonwn setting (%d) for Speed\n",params->speed);
1323
1324 IFX_PRINT("Total Data FIFO size: %d(0x%06X) DWord, %d(0x%06X) Bytes\n",
1325 params->data_fifo_size,params->data_fifo_size,
1326 params->data_fifo_size*4, params->data_fifo_size*4
1327 );
1328
1329 #ifdef __IS_DEVICE__
1330 IFX_PRINT("Rx FIFO size: %d(0x%06X) DWord, %d(0x%06X) Bytes\n",
1331 params->rx_fifo_size,params->rx_fifo_size,
1332 params->rx_fifo_size*4, params->rx_fifo_size*4
1333 );
1334 {
1335 int i;
1336 for(i=0;i<MAX_EPS_CHANNELS;i++)
1337 {
1338 IFX_PRINT("Tx FIFO #%d size: %d(0x%06X) DWord, %d(0x%06X) Bytes\n",i,
1339 params->tx_fifo_size[i],params->tx_fifo_size[i],
1340 params->tx_fifo_size[i]*4, params->tx_fifo_size[i]*4
1341 );
1342 }
1343 }
1344 #ifdef __DED_FIFO__
1345 IFX_PRINT("Treshold : %s Rx:%d Tx:%d \n",
1346 (params->thr_ctl)?"On":"Off",params->tx_thr_length,params->rx_thr_length);
1347 #endif
1348 #else //__IS_HOST__
1349 IFX_PRINT("Host Channels: %d\n",params->host_channels);
1350
1351 IFX_PRINT("Rx FIFO size: %d(0x%06X) DWord, %d(0x%06X) Bytes\n",
1352 params->data_fifo_size,params->data_fifo_size,
1353 params->data_fifo_size*4, params->data_fifo_size*4
1354 );
1355
1356 IFX_PRINT("NP Tx FIFO size: %d(0x%06X) DWord, %d(0x%06X) Bytes\n",
1357 params->nperio_tx_fifo_size,params->nperio_tx_fifo_size,
1358 params->nperio_tx_fifo_size*4, params->nperio_tx_fifo_size*4
1359 );
1360
1361 IFX_PRINT(" P Tx FIFO size: %d(0x%06X) DWord, %d(0x%06X) Bytes\n",
1362 params->perio_tx_fifo_size,params->perio_tx_fifo_size,
1363 params->perio_tx_fifo_size*4, params->perio_tx_fifo_size*4
1364 );
1365 #endif //__IS_HOST__
1366
1367 IFX_PRINT("Max Transfer size: %d(0x%06X) Bytes\n",
1368 params->max_transfer_size,params->max_transfer_size
1369 );
1370 IFX_PRINT("Max Packet Count: %d(0x%06X)\n",
1371 params->max_packet_count,params->max_packet_count
1372 );
1373
1374 IFX_PRINT("PHY UTMI Width: %d\n",params->phy_utmi_width);
1375
1376 IFX_PRINT("Turn Around Time: HS:%d FS:%d\n",params->turn_around_time_hs,params->turn_around_time_fs);
1377 IFX_PRINT("Timeout Calibration: HS:%d FS:%d\n",params->timeout_cal_hs,params->timeout_cal_fs);
1378
1379
1380 IFX_PRINT("==================================================\n");
1381 IFX_PRINT("End of Parameters Dump\n");
1382 IFX_PRINT("==================================================\n");
1383 }
1384
1385
OpenWrt SVN history