projects / openwrt / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
lantiq: Tune the XWAY subtarget cflags
[openwrt/openwrt.git] / package / platform / lantiq / ltq-hcd / src / 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 ** SRC VERSION : 3.2
7 ** DATE : 1/Jan/2011
8 ** DESCRIPTION : Implementing the procfs and sysfs for IFX USB driver
9 ** FUNCTIONS :
10 ** COMPILER : gcc
11 ** REFERENCE : Synopsys DWC-OTG Driver 2.7
12 ** COPYRIGHT : Copyright (c) 2010
13 ** LANTIQ DEUTSCHLAND GMBH,
14 ** Am Campeon 3, 85579 Neubiberg, Germany
15 **
16 ** This program is free software; you can redistribute it and/or modify
17 ** it under the terms of the GNU General Public License as published by
18 ** the Free Software Foundation; either version 2 of the License, or
19 ** (at your option) any later version.
20 **
21 ** Version Control Section **
22 ** $Author$
23 ** $Date$
24 ** $Revisions$
25 ** $Log$ Revision history
26 *****************************************************************************/
27
28 /*
29 * This file contains code fragments from Synopsys HS OTG Linux Software Driver.
30 * For this code the following notice is applicable:
31 *
32 * ==========================================================================
33 *
34 * Synopsys HS OTG Linux Software Driver and documentation (hereinafter,
35 * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless
36 * otherwise expressly agreed to in writing between Synopsys and you.
37 *
38 * The Software IS NOT an item of Licensed Software or Licensed Product under
39 * any End User Software License Agreement or Agreement for Licensed Product
40 * with Synopsys or any supplement thereto. You are permitted to use and
41 * redistribute this Software in source and binary forms, with or without
42 * modification, provided that redistributions of source code must retain this
43 * notice. You may not view, use, disclose, copy or distribute this file or
44 * any information contained herein except pursuant to this license grant from
45 * Synopsys. If you do not agree with this notice, including the disclaimer
46 * below, then you are not authorized to use the Software.
47 *
48 * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS
49 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
50 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
51 * ARE HEREBY DISCLAIMED. IN NO EVENT SHALL SYNOPSYS BE LIABLE FOR ANY DIRECT,
52 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
53 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
54 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
55 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
56 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
57 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
58 * DAMAGE.
59 * ========================================================================== */
60
61 /*! \file ifxusb_ctl.c
62 \ingroup IFXUSB_DRIVER_V3
63 \brief Implementing the procfs and sysfs for IFX USB driver
64 */
65
66 #include <linux/version.h>
67 #include "ifxusb_version.h"
68
69
70 #include <linux/proc_fs.h>
71 #include <asm/byteorder.h>
72 #include <asm/unaligned.h>
73 #include <asm/uaccess.h>
74
75 #include "ifxusb_plat.h"
76 #include "ifxusb_regs.h"
77 #include "ifxusb_cif.h"
78
79 #ifdef __IS_DEVICE__
80 #include "ifxpcd.h"
81 #ifdef __GADGET_COC__
82 #include <asm/ifx/ifx_types.h>
83 #include <asm/ifx/ifx_pmcu.h>
84 IFX_PMCU_REGISTER_t pmcuRegisterUSBGadget;
85 #endif
86 #endif
87
88 #ifdef __IS_HOST__
89 #include "ifxhcd.h"
90 #ifdef __HOST_COC__
91 #include <asm/ifx/ifx_types.h>
92 #include <asm/ifx/ifx_pmcu.h>
93 #ifdef __IS_DUAL__
94 IFX_PMCU_REGISTER_t pmcuRegisterUSBHost_1;
95 IFX_PMCU_REGISTER_t pmcuRegisterUSBHost_2;
96 #else
97 IFX_PMCU_REGISTER_t pmcuRegisterUSBHost;
98 #endif
99 #endif
100 #endif
101
102 #include <linux/device.h>
103 #include <linux/platform_device.h>
104 #include <linux/gfp.h>
105
106 #ifdef __IS_HOST__
107 extern char ifxusb_hcd_driver_name[];
108
109 #ifdef __IS_DUAL__
110 extern ifxhcd_hcd_t ifxusb_hcd_1;
111 extern ifxhcd_hcd_t ifxusb_hcd_2;
112 extern char ifxusb_hcd_name_1[];
113 extern char ifxusb_hcd_name_2[];
114 #else
115 extern ifxhcd_hcd_t ifxusb_hcd;
116 extern char ifxusb_hcd_name[];
117 #endif
118
119 #endif
120
121 #ifdef __IS_DEVICE__
122 extern char ifxusb_pcd_driver_name[];
123
124 extern ifxpcd_pcd_t ifxusb_pcd;
125 extern char ifxusb_pcd_name[];
126 #endif
127
128
129 //Attributes for sysfs (for 2.6 only)
130
131 #ifdef __IS_HOST__
132 extern struct device_attribute dev_attr_version_h;
133 #else
134 extern struct device_attribute dev_attr_version_d;
135 #endif
136 #ifdef __IS_HOST__
137 extern struct device_attribute dev_attr_dbglevel_h;
138 #else
139 extern struct device_attribute dev_attr_dbglevel_d;
140 #endif
141 #ifdef __IS_HOST__
142 #ifdef __IS_DUAL__
143 extern struct device_attribute dev_attr_suspend_host_1;
144 extern struct device_attribute dev_attr_suspend_host_2;
145 extern struct device_attribute dev_attr_probe_host_1;
146 extern struct device_attribute dev_attr_probe_host_2;
147 extern struct device_attribute dev_attr_probe_timer1_val_h;
148 extern struct device_attribute dev_attr_probe_timer2_val_h;
149 extern struct device_attribute dev_attr_autoprobe_timer1_val_h;
150 extern struct device_attribute dev_attr_autoprobe_timer2_val_h;
151 #else
152 extern struct device_attribute dev_attr_suspend_host;
153 extern struct device_attribute dev_attr_probe_host;
154 extern struct device_attribute dev_attr_probe_timer_val_h;
155 extern struct device_attribute dev_attr_autoprobe_timer_val_h;
156 #endif
157 #endif
158
159 #ifdef __IS_DEVICE__
160 extern struct device_attribute dev_attr_suspend_device;
161 extern struct device_attribute dev_attr_probe_device;
162 extern struct device_attribute dev_attr_probe_timer_val_d;
163 extern struct device_attribute dev_attr_autoprobe_timer_val_d;
164 #endif
165
166 #ifdef __IS_HOST__
167 #ifdef __IS_DUAL__
168 extern struct device_attribute dev_attr_dump_params_h_1;
169 extern struct device_attribute dev_attr_dump_params_h_2;
170 extern struct device_attribute dev_attr_mode_h_1;
171 extern struct device_attribute dev_attr_mode_h_2;
172 #else
173 extern struct device_attribute dev_attr_dump_params_h;
174 extern struct device_attribute dev_attr_mode_h;
175 #endif
176 #else
177 extern struct device_attribute dev_attr_dump_params_d;
178 extern struct device_attribute dev_attr_mode_d;
179 #endif
180
181 #ifdef __IS_HOST__
182 #ifdef __IS_DUAL__
183 extern struct device_attribute dev_attr_pkt_count_limit_bi_1;
184 extern struct device_attribute dev_attr_pkt_count_limit_bo_1;
185 extern struct device_attribute dev_attr_pkt_count_limit_bi_2;
186 extern struct device_attribute dev_attr_pkt_count_limit_bo_2;
187 extern struct device_attribute dev_attr_bandwidth_fs_1;
188 extern struct device_attribute dev_attr_bandwidth_ls_1;
189 extern struct device_attribute dev_attr_bandwidth_hs_2;
190 extern struct device_attribute dev_attr_bandwidth_fs_2;
191 extern struct device_attribute dev_attr_bandwidth_ls_2;
192 extern struct device_attribute dev_attr_buspower_1;
193 extern struct device_attribute dev_attr_buspower_2;
194 extern struct device_attribute dev_attr_bussuspend_1;
195 extern struct device_attribute dev_attr_bussuspend_2;
196 extern struct device_attribute dev_attr_busconnected_1;
197 extern struct device_attribute dev_attr_busconnected_2;
198 extern struct device_attribute dev_attr_connectspeed_1;
199 extern struct device_attribute dev_attr_connectspeed_1;
200 #else
201 extern struct device_attribute dev_attr_pkt_count_limit_bi;
202 extern struct device_attribute dev_attr_pkt_count_limit_bo;
203 extern struct device_attribute dev_attr_bandwidth_hs;
204 extern struct device_attribute dev_attr_bandwidth_fs;
205 extern struct device_attribute dev_attr_bandwidth_ls;
206 extern struct device_attribute dev_attr_buspower;
207 extern struct device_attribute dev_attr_bussuspend;
208 extern struct device_attribute dev_attr_busconnected;
209 extern struct device_attribute dev_attr_connectspeed;
210 #endif
211 #endif //__IS_HOST__
212
213 #ifdef __IS_DEVICE__
214 extern struct device_attribute dev_attr_devspeed;
215 extern struct device_attribute dev_attr_enumspeed;
216 #endif //__IS_DEVICE__
217
218 #ifdef __ENABLE_DUMP__
219 #ifdef __IS_HOST__
220 #ifdef __IS_DUAL__
221 extern struct device_attribute dev_attr_dump_reg_h_1;
222 extern struct device_attribute dev_attr_dump_reg_h_2;
223 extern struct device_attribute dev_attr_dump_spram_h_1;
224 extern struct device_attribute dev_attr_dump_spram_h_2;
225 extern struct device_attribute dev_attr_dump_host_state_1;
226 extern struct device_attribute dev_attr_dump_host_state_2;
227 #else
228 extern struct device_attribute dev_attr_dump_reg_h;
229 extern struct device_attribute dev_attr_dump_spram_h;
230 extern struct device_attribute dev_attr_dump_host_state;
231 #endif
232 #else
233 extern struct device_attribute dev_attr_dump_reg_d;
234 extern struct device_attribute dev_attr_dump_spram_d;
235 #endif
236 #endif //__ENABLE_DUMP__
237
238
239 /////////////////////////////////////////////////////////////////////////////////////////////////////
240 /////////////////////////////////////////////////////////////////////////////////////////////////////
241 /////////////////////////////////////////////////////////////////////////////////////////////////////
242
243 static ssize_t procfs_version_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
244 {
245 return sprintf( buf, "%s\n",IFXUSB_VERSION );
246 }
247
248 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
249 static ssize_t sysfs_version_show( struct device *_dev, struct device_attribute *attr,char *buf)
250 #else
251 static ssize_t sysfs_version_show( struct device *_dev, char *buf)
252 #endif
253 {
254 return sprintf( buf, "%s\n",IFXUSB_VERSION );
255 }
256
257 #ifdef __IS_HOST__
258 DEVICE_ATTR(version_h, S_IRUGO|S_IWUSR, sysfs_version_show, NULL);
259 #else
260 DEVICE_ATTR(version_d, S_IRUGO|S_IWUSR, sysfs_version_show, NULL);
261 #endif
262
263
264 /////////////////////////////////////////////////////////////////////////////////////////////////////
265 /////////////////////////////////////////////////////////////////////////////////////////////////////
266 /////////////////////////////////////////////////////////////////////////////////////////////////////
267 /////////////////////////////////////////////////////////////////////////////////////////////////////
268 /////////////////////////////////////////////////////////////////////////////////////////////////////
269 /////////////////////////////////////////////////////////////////////////////////////////////////////
270
271 static ssize_t procfs_dbglevel_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
272 {
273 #ifdef __IS_HOST__
274 return sprintf( buf, "%08X\n",h_dbg_lvl );
275 #else
276 return sprintf( buf, "%08X\n",d_dbg_lvl );
277 #endif
278 }
279
280 static ssize_t procfs_dbglevel_store(struct file *file, const char *buffer, unsigned long count, void *data)
281 {
282 char buf[10];
283 int i = 0;
284 uint32_t value;
285 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
286 return -EFAULT;
287 value = simple_strtoul(buf, NULL, 16);
288 #ifdef __IS_HOST__
289 h_dbg_lvl =value;
290 #else
291 d_dbg_lvl =value;
292 #endif
293 //turn on and off power
294 return count;
295 }
296
297 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
298 static ssize_t sysfs_dbglevel_show( struct device *_dev, struct device_attribute *attr,char *buf)
299 #else
300 static ssize_t sysfs_dbglevel_show( struct device *_dev, char *buf)
301 #endif
302 {
303 #ifdef __IS_HOST__
304 return sprintf( buf, "%08X\n",h_dbg_lvl );
305 #else
306 return sprintf( buf, "%08X\n",d_dbg_lvl );
307 #endif
308 }
309
310 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
311 static ssize_t sysfs_dbglevel_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
312 #else
313 static ssize_t sysfs_dbglevel_store( struct device *_dev, const char *buffer, size_t count )
314 #endif
315 {
316 char buf[10];
317 int i = 0;
318 uint32_t value;
319 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
320 return -EFAULT;
321 value = simple_strtoul(buf, NULL, 16);
322 #ifdef __IS_HOST__
323 h_dbg_lvl =value;
324 #else
325 d_dbg_lvl =value;
326 #endif
327 //turn on and off power
328 return count;
329 }
330
331 #ifdef __IS_HOST__
332 DEVICE_ATTR(dbglevel_h, S_IRUGO|S_IWUSR, sysfs_dbglevel_show, sysfs_dbglevel_store);
333 #else
334 DEVICE_ATTR(dbglevel_d, S_IRUGO|S_IWUSR, sysfs_dbglevel_show, sysfs_dbglevel_store);
335 #endif
336
337
338 /////////////////////////////////////////////////////////////////////////////////////////////////////
339 /////////////////////////////////////////////////////////////////////////////////////////////////////
340 /////////////////////////////////////////////////////////////////////////////////////////////////////
341
342 static void ifxusb_dump_params(ifxusb_core_if_t *_core_if);
343
344 #ifdef __IS_DUAL__
345 static void dump_params_1(void)
346 {
347 ifxusb_dump_params(&ifxusb_hcd_1.core_if);
348 }
349 static void dump_params_2(void)
350 {
351 ifxusb_dump_params(&ifxusb_hcd_2.core_if);
352 }
353
354 static ssize_t procfs_dump_params_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
355 {
356 dump_params_1();
357 return 0;
358 }
359 static ssize_t procfs_dump_params_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
360 {
361 dump_params_2();
362 return 0;
363 }
364
365 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
366 static ssize_t sysfs_dump_params_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
367 #else
368 static ssize_t sysfs_dump_params_show_1( struct device *_dev,char *buf)
369 #endif
370 {
371 dump_params_1();
372 return 0;
373 }
374 DEVICE_ATTR(dump_params_h_1, S_IRUGO|S_IWUSR, sysfs_dump_params_show_1, NULL);
375
376 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
377 static ssize_t sysfs_dump_params_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
378 #else
379 static ssize_t sysfs_dump_params_show_2( struct device *_dev,char *buf)
380 #endif
381 {
382 dump_params_2();
383 return 0;
384 }
385
386 DEVICE_ATTR(dump_params_h_2, S_IRUGO|S_IWUSR, sysfs_dump_params_show_2, NULL);
387 #else
388 static void dump_params(void)
389 {
390 #ifdef __IS_HOST__
391 ifxusb_dump_params(&ifxusb_hcd.core_if);
392 #else
393 ifxusb_dump_params(&ifxusb_pcd.core_if);
394 #endif
395 }
396
397 static ssize_t procfs_dump_params_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
398 {
399 dump_params();
400 return 0;
401 }
402
403 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
404 static ssize_t sysfs_dump_params_show( struct device *_dev, struct device_attribute *attr,char *buf)
405 #else
406 static ssize_t sysfs_dump_params_show( struct device *_dev,char *buf)
407 #endif
408 {
409 dump_params();
410 return 0;
411 }
412
413 #ifdef __IS_HOST__
414 DEVICE_ATTR(dump_params_h, S_IRUGO|S_IWUSR, sysfs_dump_params_show, NULL);
415 #else
416 DEVICE_ATTR(dump_params_d, S_IRUGO|S_IWUSR, sysfs_dump_params_show, NULL);
417 #endif
418 #endif
419
420 /////////////////////////////////////////////////////////////////////////////////////////////////////
421 /////////////////////////////////////////////////////////////////////////////////////////////////////
422 /////////////////////////////////////////////////////////////////////////////////////////////////////
423
424 #ifdef __IS_DUAL__
425 static ssize_t mode_show_1(char *buf)
426 {
427 if((ifxusb_rreg(&ifxusb_hcd_1.core_if.core_global_regs->gintsts ) & 0x1) == 1)
428 return sprintf( buf, "HOST\n" );
429 else
430 return sprintf( buf, "DEVICE(INCORRECT!)\n" );
431 }
432
433 static ssize_t mode_show_2(char *buf)
434 {
435 if((ifxusb_rreg(&ifxusb_hcd_2.core_if.core_global_regs->gintsts ) & 0x1) == 1)
436 return sprintf( buf, "HOST\n" );
437 else
438 return sprintf( buf, "DEVICE(INCORRECT!)\n" );
439 }
440
441 static ssize_t procfs_mode_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
442 {
443 return mode_show_1(buf);
444 }
445 static ssize_t procfs_mode_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
446 {
447 return mode_show_2(buf);
448 }
449
450 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
451 static ssize_t sysfs_mode_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
452 #else
453 static ssize_t sysfs_mode_show_1( struct device *_dev,char *buf)
454 #endif
455 {
456 return mode_show_1(buf);
457 }
458
459 DEVICE_ATTR(mode_h_1, S_IRUGO|S_IWUSR, sysfs_mode_show_1, 0);
460
461 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
462 static ssize_t sysfs_mode_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
463 #else
464 static ssize_t sysfs_mode_show_2( struct device *_dev,char *buf)
465 #endif
466 {
467 return mode_show_2(buf);
468 }
469 DEVICE_ATTR(mode_h_2, S_IRUGO|S_IWUSR, sysfs_mode_show_2, NULL);
470 #else
471 static ssize_t mode_show(char *buf)
472 {
473 #ifdef __IS_HOST__
474 if((ifxusb_rreg(&ifxusb_hcd.core_if.core_global_regs->gintsts ) & 0x1) == 1)
475 return sprintf( buf, "HOST\n" );
476 else
477 return sprintf( buf, "DEVICE(INCORRECT!)\n" );
478 #else
479 if((ifxusb_rreg(&ifxusb_pcd.core_if.core_global_regs->gintsts ) & 0x1) != 1)
480 return sprintf( buf, "DEVICE\n" );
481 else
482 return sprintf( buf, "HOST(INCORRECT!)\n" );
483 #endif
484 }
485 static ssize_t procfs_mode_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
486 {
487 return mode_show(buf);
488 }
489 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
490 static ssize_t sysfs_mode_show( struct device *_dev, struct device_attribute *attr,char *buf)
491 #else
492 static ssize_t sysfs_mode_show( struct device *_dev, char *buf)
493 #endif
494 {
495 return mode_show(buf);
496 }
497 #ifdef __IS_HOST__
498 DEVICE_ATTR(mode_h, S_IRUGO|S_IWUSR, sysfs_mode_show, NULL);
499 #else
500 DEVICE_ATTR(mode_d, S_IRUGO|S_IWUSR, sysfs_mode_show, NULL);
501 #endif
502 #endif
503
504 /////////////////////////////////////////////////////////////////////////////////////////////////////
505 /////////////////////////////////////////////////////////////////////////////////////////////////////
506 /////////////////////////////////////////////////////////////////////////////////////////////////////
507
508 #ifdef __IS_HOST__
509 /////////////////////////////////////////////////////////////////////////////////////////////////////
510 /////////////////////////////////////////////////////////////////////////////////////////////////////
511 /////////////////////////////////////////////////////////////////////////////////////////////////////
512 #ifdef __IS_DUAL__
513 static ssize_t bandwidth_hs_show_1(char *buf)
514 {
515 return sprintf( buf, "%d\n",ifxusb_hcd_1.pkt_remaining_reload_hs );
516 }
517 static ssize_t bandwidth_fs_show_1(char *buf)
518 {
519 return sprintf( buf, "%d\n",ifxusb_hcd_1.pkt_remaining_reload_fs );
520 }
521 static ssize_t bandwidth_ls_show_1(char *buf)
522 {
523 return sprintf( buf, "%d\n",ifxusb_hcd_1.pkt_remaining_reload_ls );
524 }
525 static void bandwidth_hs_store_1(uint32_t value)
526 {
527 if(value>16 && value<120)
528 {
529 hprt0_data_t hprt0;
530 ifxusb_hcd_1.pkt_remaining_reload_hs = value;
531 hprt0.d32 = ifxusb_rreg(ifxusb_hcd_1.core_if.hprt0);
532 if(hprt0.b.prtspd == IFXUSB_HPRT0_PRTSPD_HIGH_SPEED)
533 ifxusb_hcd_1.pkt_remaining_reload=value;
534 }
535 }
536 static void bandwidth_fs_store_1(uint32_t value)
537 {
538 if (value>2 && value<30)
539 {
540 hprt0_data_t hprt0;
541 ifxusb_hcd_1.pkt_remaining_reload_fs = value;
542 hprt0.d32 = ifxusb_rreg(ifxusb_hcd_1.core_if.hprt0);
543 if(hprt0.b.prtspd != IFXUSB_HPRT0_PRTSPD_LOW_SPEED && hprt0.b.prtspd != IFXUSB_HPRT0_PRTSPD_HIGH_SPEED)
544 ifxusb_hcd_1.pkt_remaining_reload=value;
545 }
546 }
547 static void bandwidth_ls_store_1(uint32_t value)
548 {
549 if (value>2 && value<30)
550 {
551 hprt0_data_t hprt0;
552 ifxusb_hcd_1.pkt_remaining_reload_ls = value;
553 hprt0.d32 = ifxusb_rreg(ifxusb_hcd_1.core_if.hprt0);
554 if(hprt0.b.prtspd == IFXUSB_HPRT0_PRTSPD_LOW_SPEED)
555 ifxusb_hcd_1.pkt_remaining_reload=value;
556 }
557 }
558 static ssize_t bandwidth_hs_show_2(char *buf)
559 {
560 return sprintf( buf, "%d\n",ifxusb_hcd_2.pkt_remaining_reload_hs );
561 }
562 static ssize_t bandwidth_fs_show_2(char *buf)
563 {
564 return sprintf( buf, "%d\n",ifxusb_hcd_2.pkt_remaining_reload_fs );
565 }
566 static ssize_t bandwidth_ls_show_2(char *buf)
567 {
568 return sprintf( buf, "%d\n",ifxusb_hcd_2.pkt_remaining_reload_ls );
569 }
570 static void bandwidth_hs_store_2(uint32_t value)
571 {
572 if(value>16 && value<120)
573 {
574 hprt0_data_t hprt0;
575 ifxusb_hcd_2.pkt_remaining_reload_hs = value;
576 hprt0.d32 = ifxusb_rreg(ifxusb_hcd_2.core_if.hprt0);
577 if(hprt0.b.prtspd == IFXUSB_HPRT0_PRTSPD_HIGH_SPEED)
578 ifxusb_hcd_2.pkt_remaining_reload=value;
579 }
580 }
581 static void bandwidth_fs_store_2(uint32_t value)
582 {
583 if (value>2 && value<30)
584 {
585 hprt0_data_t hprt0;
586 ifxusb_hcd_2.pkt_remaining_reload_fs = value;
587 hprt0.d32 = ifxusb_rreg(ifxusb_hcd_2.core_if.hprt0);
588 if(hprt0.b.prtspd != IFXUSB_HPRT0_PRTSPD_LOW_SPEED && hprt0.b.prtspd != IFXUSB_HPRT0_PRTSPD_HIGH_SPEED)
589 ifxusb_hcd_2.pkt_remaining_reload=value;
590 }
591 }
592 static void bandwidth_ls_store_2(uint32_t value)
593 {
594 if (value>2 && value<30)
595 {
596 hprt0_data_t hprt0;
597 ifxusb_hcd_2.pkt_remaining_reload_ls = value;
598 hprt0.d32 = ifxusb_rreg(ifxusb_hcd_2.core_if.hprt0);
599 if(hprt0.b.prtspd == IFXUSB_HPRT0_PRTSPD_LOW_SPEED)
600 ifxusb_hcd_2.pkt_remaining_reload=value;
601 }
602 }
603 static ssize_t procfs_bandwidth_hs_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
604 {
605 return bandwidth_hs_show_1(buf);
606 }
607 static ssize_t procfs_bandwidth_fs_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
608 {
609 return bandwidth_fs_show_1(buf);
610 }
611 static ssize_t procfs_bandwidth_ls_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
612 {
613 return bandwidth_ls_show_1(buf);
614 }
615 static ssize_t procfs_bandwidth_hs_store_1(struct file *file, const char *buffer, unsigned long count, void *data)
616 {
617 char buf[10];
618 int i = 0;
619 uint32_t value;
620 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
621 return -EFAULT;
622 value = simple_strtoul(buf, NULL, 10);
623 bandwidth_hs_store_1(value);
624 return count;
625 }
626 static ssize_t procfs_bandwidth_fs_store_1(struct file *file, const char *buffer, unsigned long count, void *data)
627 {
628 char buf[10];
629 int i = 0;
630 uint32_t value;
631 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
632 return -EFAULT;
633 value = simple_strtoul(buf, NULL, 10);
634 bandwidth_fs_store_1(value);
635 return count;
636 }
637 static ssize_t procfs_bandwidth_ls_store_1(struct file *file, const char *buffer, unsigned long count, void *data)
638 {
639 char buf[10];
640 int i = 0;
641 uint32_t value;
642 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
643 return -EFAULT;
644 value = simple_strtoul(buf, NULL, 10);
645 bandwidth_ls_store_1(value);
646 return count;
647 }
648 static ssize_t procfs_bandwidth_hs_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
649 {
650 return bandwidth_hs_show_2(buf);
651 }
652 static ssize_t procfs_bandwidth_fs_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
653 {
654 return bandwidth_fs_show_2(buf);
655 }
656 static ssize_t procfs_bandwidth_ls_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
657 {
658 return bandwidth_ls_show_2(buf);
659 }
660 static ssize_t procfs_bandwidth_hs_store_2(struct file *file, const char *buffer, unsigned long count, void *data)
661 {
662 char buf[10];
663 int i = 0;
664 uint32_t value;
665 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
666 return -EFAULT;
667 value = simple_strtoul(buf, NULL, 10);
668 bandwidth_hs_store_2(value);
669 return count;
670 }
671 static ssize_t procfs_bandwidth_fs_store_2(struct file *file, const char *buffer, unsigned long count, void *data)
672 {
673 char buf[10];
674 int i = 0;
675 uint32_t value;
676 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
677 return -EFAULT;
678 value = simple_strtoul(buf, NULL, 10);
679 bandwidth_fs_store_2(value);
680 return count;
681 }
682 static ssize_t procfs_bandwidth_ls_store_2(struct file *file, const char *buffer, unsigned long count, void *data)
683 {
684 char buf[10];
685 int i = 0;
686 uint32_t value;
687 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
688 return -EFAULT;
689 value = simple_strtoul(buf, NULL, 10);
690 bandwidth_ls_store_2(value);
691 return count;
692 }
693
694 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
695 static ssize_t sysfs_bandwidth_hs_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
696 #else
697 static ssize_t sysfs_bandwidth_hs_show_1( struct device *_dev,char *buf)
698 #endif
699 {
700 return bandwidth_hs_show_1(buf);
701 }
702 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
703 static ssize_t sysfs_bandwidth_hs_store_1( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
704 #else
705 static ssize_t sysfs_bandwidth_hs_store_1( struct device *_dev, const char *buffer, size_t count )
706 #endif
707 {
708 char buf[10];
709 int i = 0;
710 uint32_t value;
711 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
712 return -EFAULT;
713 value = simple_strtoul(buf, NULL, 10);
714 bandwidth_hs_store_1(value);
715 return count;
716 }
717 DEVICE_ATTR(bandwidth_hs_1, S_IRUGO|S_IWUSR, sysfs_bandwidth_hs_show_1, sysfs_bandwidth_hs_store_1);
718
719 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
720 static ssize_t sysfs_bandwidth_fs_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
721 #else
722 static ssize_t sysfs_bandwidth_fs_show_1( struct device *_dev,char *buf)
723 #endif
724 {
725 return bandwidth_fs_show_1(buf);
726 }
727 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
728 static ssize_t sysfs_bandwidth_fs_store_1( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
729 #else
730 static ssize_t sysfs_bandwidth_fs_store_1( struct device *_dev, const char *buffer, size_t count )
731 #endif
732 {
733 char buf[10];
734 int i = 0;
735 uint32_t value;
736 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
737 return -EFAULT;
738 value = simple_strtoul(buf, NULL, 10);
739 bandwidth_fs_store_1(value);
740 return count;
741 }
742 DEVICE_ATTR(bandwidth_fs_1, S_IRUGO|S_IWUSR, sysfs_bandwidth_fs_show_1, sysfs_bandwidth_fs_store_1);
743
744 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
745 static ssize_t sysfs_bandwidth_ls_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
746 #else
747 static ssize_t sysfs_bandwidth_ls_show_1( struct device *_dev,char *buf)
748 #endif
749 {
750 return bandwidth_ls_show_1(buf);
751 }
752 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
753 static ssize_t sysfs_bandwidth_ls_store_1( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
754 #else
755 static ssize_t sysfs_bandwidth_ls_store_1( struct device *_dev, const char *buffer, size_t count )
756 #endif
757 {
758 char buf[10];
759 int i = 0;
760 uint32_t value;
761 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
762 return -EFAULT;
763 value = simple_strtoul(buf, NULL, 10);
764 bandwidth_ls_store_1(value);
765 return count;
766 }
767 DEVICE_ATTR(bandwidth_ls_1, S_IRUGO|S_IWUSR, sysfs_bandwidth_ls_show_1, sysfs_bandwidth_ls_store_1);
768
769 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
770 static ssize_t sysfs_bandwidth_hs_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
771 #else
772 static ssize_t sysfs_bandwidth_hs_show_2( struct device *_dev,char *buf)
773 #endif
774 {
775 return bandwidth_hs_show_2(buf);
776 }
777 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
778 static ssize_t sysfs_bandwidth_hs_store_2( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
779 #else
780 static ssize_t sysfs_bandwidth_hs_store_2( struct device *_dev, const char *buffer, size_t count )
781 #endif
782 {
783 char buf[10];
784 int i = 0;
785 uint32_t value;
786 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
787 return -EFAULT;
788 value = simple_strtoul(buf, NULL, 10);
789 bandwidth_hs_store_2(value);
790 return count;
791 }
792 DEVICE_ATTR(bandwidth_hs_2, S_IRUGO|S_IWUSR, sysfs_bandwidth_hs_show_2, sysfs_bandwidth_hs_store_2);
793
794 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
795 static ssize_t sysfs_bandwidth_fs_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
796 #else
797 static ssize_t sysfs_bandwidth_fs_show_2( struct device *_dev,char *buf)
798 #endif
799 {
800 return bandwidth_fs_show_2(buf);
801 }
802 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
803 static ssize_t sysfs_bandwidth_fs_store_2( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
804 #else
805 static ssize_t sysfs_bandwidth_fs_store_2( struct device *_dev, const char *buffer, size_t count )
806 #endif
807 {
808 char buf[10];
809 int i = 0;
810 uint32_t value;
811 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
812 return -EFAULT;
813 value = simple_strtoul(buf, NULL, 10);
814 bandwidth_fs_store_2(value);
815 return count;
816 }
817 DEVICE_ATTR(bandwidth_fs_2, S_IRUGO|S_IWUSR, sysfs_bandwidth_fs_show_2, sysfs_bandwidth_fs_store_2);
818
819 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
820 static ssize_t sysfs_bandwidth_ls_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
821 #else
822 static ssize_t sysfs_bandwidth_ls_show_2( struct device *_dev,char *buf)
823 #endif
824 {
825 return bandwidth_ls_show_2(buf);
826 }
827 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
828 static ssize_t sysfs_bandwidth_ls_store_2( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
829 #else
830 static ssize_t sysfs_bandwidth_ls_store_2( struct device *_dev, const char *buffer, size_t count )
831 #endif
832 {
833 char buf[10];
834 int i = 0;
835 uint32_t value;
836 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
837 return -EFAULT;
838 value = simple_strtoul(buf, NULL, 10);
839 bandwidth_ls_store_2(value);
840 return count;
841 }
842 DEVICE_ATTR(bandwidth_ls_2, S_IRUGO|S_IWUSR, sysfs_bandwidth_ls_show_2, sysfs_bandwidth_ls_store_2);
843 #else
844 static ssize_t bandwidth_hs_show(char *buf)
845 {
846 return sprintf( buf, "%d\n",ifxusb_hcd.pkt_remaining_reload_hs );
847 }
848 static ssize_t bandwidth_fs_show(char *buf)
849 {
850 return sprintf( buf, "%d\n",ifxusb_hcd.pkt_remaining_reload_fs );
851 }
852 static ssize_t bandwidth_ls_show(char *buf)
853 {
854 return sprintf( buf, "%d\n",ifxusb_hcd.pkt_remaining_reload_ls );
855 }
856 static void bandwidth_hs_store(uint32_t value)
857 {
858 if (value>16 && value<120)
859 {
860 hprt0_data_t hprt0;
861 ifxusb_hcd.pkt_remaining_reload_hs = value;
862 hprt0.d32 = ifxusb_rreg(ifxusb_hcd.core_if.hprt0);
863 if(hprt0.b.prtspd == IFXUSB_HPRT0_PRTSPD_HIGH_SPEED)
864 ifxusb_hcd.pkt_remaining_reload=value;
865 }
866 }
867 static void bandwidth_fs_store(uint32_t value)
868 {
869 if (value>2 && value<30)
870 {
871 hprt0_data_t hprt0;
872 ifxusb_hcd.pkt_remaining_reload_fs = value;
873 hprt0.d32 = ifxusb_rreg(ifxusb_hcd.core_if.hprt0);
874 if(hprt0.b.prtspd != IFXUSB_HPRT0_PRTSPD_LOW_SPEED && hprt0.b.prtspd != IFXUSB_HPRT0_PRTSPD_HIGH_SPEED)
875 ifxusb_hcd.pkt_remaining_reload=value;
876 }
877 }
878 static void bandwidth_ls_store(uint32_t value)
879 {
880 if (value>2 && value<30)
881 {
882 hprt0_data_t hprt0;
883 ifxusb_hcd.pkt_remaining_reload_hs = value;
884 hprt0.d32 = ifxusb_rreg(ifxusb_hcd.core_if.hprt0);
885 if(hprt0.b.prtspd == IFXUSB_HPRT0_PRTSPD_LOW_SPEED)
886 ifxusb_hcd.pkt_remaining_reload=value;
887 }
888 }
889 static ssize_t procfs_bandwidth_hs_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
890 {
891 return bandwidth_hs_show(buf);
892 }
893 static ssize_t procfs_bandwidth_fs_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
894 {
895 return bandwidth_fs_show(buf);
896 }
897 static ssize_t procfs_bandwidth_ls_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
898 {
899 return bandwidth_ls_show(buf);
900 }
901 static ssize_t procfs_bandwidth_hs_store(struct file *file, const char *buffer, unsigned long count, void *data)
902 {
903 char buf[10];
904 int i = 0;
905 uint32_t value;
906 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
907 return -EFAULT;
908 value = simple_strtoul(buf, NULL, 10);
909 bandwidth_hs_store(value);
910 return count;
911 }
912 static ssize_t procfs_bandwidth_fs_store(struct file *file, const char *buffer, unsigned long count, void *data)
913 {
914 char buf[10];
915 int i = 0;
916 uint32_t value;
917 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
918 return -EFAULT;
919 value = simple_strtoul(buf, NULL, 10);
920 bandwidth_fs_store(value);
921 return count;
922 }
923 static ssize_t procfs_bandwidth_ls_store(struct file *file, const char *buffer, unsigned long count, void *data)
924 {
925 char buf[10];
926 int i = 0;
927 uint32_t value;
928 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
929 return -EFAULT;
930 value = simple_strtoul(buf, NULL, 10);
931 bandwidth_ls_store(value);
932 return count;
933 }
934
935 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
936 static ssize_t sysfs_bandwidth_hs_show( struct device *_dev, struct device_attribute *attr,char *buf)
937 #else
938 static ssize_t sysfs_bandwidth_hs_show( struct device *_dev,char *buf)
939 #endif
940 {
941 return bandwidth_hs_show(buf);
942 }
943 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
944 static ssize_t sysfs_bandwidth_hs_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
945 #else
946 static ssize_t sysfs_bandwidth_hs_store( struct device *_dev, const char *buffer, size_t count )
947 #endif
948 {
949 char buf[10];
950 int i = 0;
951 uint32_t value;
952 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
953 return -EFAULT;
954 value = simple_strtoul(buf, NULL, 10);
955 bandwidth_hs_store(value);
956 return count;
957 }
958 DEVICE_ATTR(bandwidth_hs, S_IRUGO|S_IWUSR, sysfs_bandwidth_hs_show, sysfs_bandwidth_hs_store);
959
960 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
961 static ssize_t sysfs_bandwidth_fs_show( struct device *_dev, struct device_attribute *attr,char *buf)
962 #else
963 static ssize_t sysfs_bandwidth_fs_show( struct device *_dev,char *buf)
964 #endif
965 {
966 return bandwidth_fs_show(buf);
967 }
968 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
969 static ssize_t sysfs_bandwidth_fs_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
970 #else
971 static ssize_t sysfs_bandwidth_fs_store( struct device *_dev, const char *buffer, size_t count )
972 #endif
973 {
974 char buf[10];
975 int i = 0;
976 uint32_t value;
977 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
978 return -EFAULT;
979 value = simple_strtoul(buf, NULL, 10);
980 bandwidth_fs_store(value);
981 return count;
982 }
983 DEVICE_ATTR(bandwidth_fs, S_IRUGO|S_IWUSR, sysfs_bandwidth_fs_show, sysfs_bandwidth_fs_store);
984
985 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
986 static ssize_t sysfs_bandwidth_ls_show( struct device *_dev, struct device_attribute *attr,char *buf)
987 #else
988 static ssize_t sysfs_bandwidth_ls_show( struct device *_dev,char *buf)
989 #endif
990 {
991 return bandwidth_ls_show(buf);
992 }
993 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
994 static ssize_t sysfs_bandwidth_ls_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
995 #else
996 static ssize_t sysfs_bandwidth_ls_store( struct device *_dev, const char *buffer, size_t count )
997 #endif
998 {
999 char buf[10];
1000 int i = 0;
1001 uint32_t value;
1002 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1003 return -EFAULT;
1004 value = simple_strtoul(buf, NULL, 10);
1005 bandwidth_ls_store(value);
1006 return count;
1007 }
1008 DEVICE_ATTR(bandwidth_ls, S_IRUGO|S_IWUSR, sysfs_bandwidth_ls_show, sysfs_bandwidth_ls_store);
1009 #endif
1010
1011 /////////////////////////////////////////////////////////////////////////////////////////////////////
1012 /////////////////////////////////////////////////////////////////////////////////////////////////////
1013 #ifdef __IS_DUAL__
1014 static ssize_t pkt_count_limit_bi_show_1(char *buf)
1015 {
1016 return sprintf( buf, "%d\n",ifxusb_hcd_1.pkt_count_limit_bi );
1017 }
1018 static ssize_t pkt_count_limit_bo_show_1(char *buf)
1019 {
1020 return sprintf( buf, "%d\n",ifxusb_hcd_1.pkt_count_limit_bo );
1021 }
1022 static void pkt_count_limit_bi_store_1(uint32_t value)
1023 {
1024 if(value<=13)
1025 ifxusb_hcd_1.pkt_count_limit_bi = value;
1026 }
1027 static void pkt_count_limit_bo_store_1(uint32_t value)
1028 {
1029 if (value<=13)
1030 ifxusb_hcd_1.pkt_count_limit_bo = value;
1031 }
1032 static ssize_t pkt_count_limit_bi_show_2(char *buf)
1033 {
1034 return sprintf( buf, "%d\n",ifxusb_hcd_2.pkt_count_limit_bi );
1035 }
1036 static ssize_t pkt_count_limit_bo_show_2(char *buf)
1037 {
1038 return sprintf( buf, "%d\n",ifxusb_hcd_2.pkt_count_limit_bo );
1039 }
1040 static void pkt_count_limit_bi_store_2(uint32_t value)
1041 {
1042 if(value<=13)
1043 ifxusb_hcd_2.pkt_count_limit_bi = value;
1044 }
1045 static void pkt_count_limit_bo_store_2(uint32_t value)
1046 {
1047 if(value<=13)
1048 ifxusb_hcd_2.pkt_count_limit_bo = value;
1049 }
1050 static ssize_t procfs_pkt_count_limit_bi_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1051 {
1052 return pkt_count_limit_bi_show_1(buf);
1053 }
1054 static ssize_t procfs_pkt_count_limit_bo_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1055 {
1056 return pkt_count_limit_bo_show_1(buf);
1057 }
1058 static ssize_t procfs_pkt_count_limit_bi_store_1(struct file *file, const char *buffer, unsigned long count, void *data)
1059 {
1060 char buf[10];
1061 int i = 0;
1062 uint32_t value;
1063 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1064 return -EFAULT;
1065 value = simple_strtoul(buf, NULL, 10);
1066 pkt_count_limit_bi_store_1(value);
1067 return count;
1068 }
1069 static ssize_t procfs_pkt_count_limit_bo_store_1(struct file *file, const char *buffer, unsigned long count, void *data)
1070 {
1071 char buf[10];
1072 int i = 0;
1073 uint32_t value;
1074 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1075 return -EFAULT;
1076 value = simple_strtoul(buf, NULL, 10);
1077 pkt_count_limit_bo_store_1(value);
1078 return count;
1079 }
1080 static ssize_t procfs_pkt_count_limit_bi_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1081 {
1082 return pkt_count_limit_bi_show_2(buf);
1083 }
1084 static ssize_t procfs_pkt_count_limit_bo_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1085 {
1086 return pkt_count_limit_bo_show_2(buf);
1087 }
1088 static ssize_t procfs_pkt_count_limit_bi_store_2(struct file *file, const char *buffer, unsigned long count, void *data)
1089 {
1090 char buf[10];
1091 int i = 0;
1092 uint32_t value;
1093 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1094 return -EFAULT;
1095 value = simple_strtoul(buf, NULL, 10);
1096 pkt_count_limit_bi_store_2(value);
1097 return count;
1098 }
1099 static ssize_t procfs_pkt_count_limit_bo_store_2(struct file *file, const char *buffer, unsigned long count, void *data)
1100 {
1101 char buf[10];
1102 int i = 0;
1103 uint32_t value;
1104 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1105 return -EFAULT;
1106 value = simple_strtoul(buf, NULL, 10);
1107 pkt_count_limit_bo_store_2(value);
1108 return count;
1109 }
1110
1111 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1112 static ssize_t sysfs_pkt_count_limit_bi_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
1113 #else
1114 static ssize_t sysfs_pkt_count_limit_bi_show_1( struct device *_dev,char *buf)
1115 #endif
1116 {
1117 return pkt_count_limit_bi_show_1(buf);
1118 }
1119 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1120 static ssize_t sysfs_pkt_count_limit_bi_store_1( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
1121 #else
1122 static ssize_t sysfs_pkt_count_limit_bi_store_1( struct device *_dev, const char *buffer, size_t count )
1123 #endif
1124 {
1125 char buf[10];
1126 int i = 0;
1127 uint32_t value;
1128 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1129 return -EFAULT;
1130 value = simple_strtoul(buf, NULL, 10);
1131 pkt_count_limit_bi_store_1(value);
1132 return count;
1133 }
1134 DEVICE_ATTR(pkt_count_limit_bi_1, S_IRUGO|S_IWUSR, sysfs_pkt_count_limit_bi_show_1, sysfs_pkt_count_limit_bi_store_1);
1135
1136 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1137 static ssize_t sysfs_pkt_count_limit_bo_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
1138 #else
1139 static ssize_t sysfs_pkt_count_limit_bo_show_1( struct device *_dev,char *buf)
1140 #endif
1141 {
1142 return pkt_count_limit_bo_show_1(buf);
1143 }
1144 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1145 static ssize_t sysfs_pkt_count_limit_bo_store_1( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
1146 #else
1147 static ssize_t sysfs_pkt_count_limit_bo_store_1( struct device *_dev, const char *buffer, size_t count )
1148 #endif
1149 {
1150 char buf[10];
1151 int i = 0;
1152 uint32_t value;
1153 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1154 return -EFAULT;
1155 value = simple_strtoul(buf, NULL, 10);
1156 pkt_count_limit_bo_store_1(value);
1157 return count;
1158 }
1159 DEVICE_ATTR(pkt_count_limit_bo_1, S_IRUGO|S_IWUSR, sysfs_pkt_count_limit_bo_show_1, sysfs_pkt_count_limit_bo_store_1);
1160
1161 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1162 static ssize_t sysfs_pkt_count_limit_bi_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
1163 #else
1164 static ssize_t sysfs_pkt_count_limit_bi_show_2( struct device *_dev,char *buf)
1165 #endif
1166 {
1167 return pkt_count_limit_bi_show_2(buf);
1168 }
1169 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1170 static ssize_t sysfs_pkt_count_limit_bi_store_2( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
1171 #else
1172 static ssize_t sysfs_pkt_count_limit_bi_2( struct device *_dev, const char *buffer, size_t count )
1173 #endif
1174 {
1175 char buf[10];
1176 int i = 0;
1177 uint32_t value;
1178 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1179 return -EFAULT;
1180 value = simple_strtoul(buf, NULL, 10);
1181 pkt_count_limit_bi_store_2(value);
1182 return count;
1183 }
1184 DEVICE_ATTR(pkt_count_limit_bi_2, S_IRUGO|S_IWUSR, sysfs_pkt_count_limit_bi_show_2, sysfs_pkt_count_limit_bi_store_2);
1185
1186 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1187 static ssize_t sysfs_pkt_count_limit_bo_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
1188 #else
1189 static ssize_t sysfs_pkt_count_limit_bo_show_2( struct device *_dev,char *buf)
1190 #endif
1191 {
1192 return pkt_count_limit_bo_show_2(buf);
1193 }
1194 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1195 static ssize_t sysfs_pkt_count_limit_bo_store_2( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
1196 #else
1197 static ssize_t sysfs_pkt_count_limit_bo_store_2( struct device *_dev, const char *buffer, size_t count )
1198 #endif
1199 {
1200 char buf[10];
1201 int i = 0;
1202 uint32_t value;
1203 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1204 return -EFAULT;
1205 value = simple_strtoul(buf, NULL, 10);
1206 pkt_count_limit_bo_store_2(value);
1207 return count;
1208 }
1209 DEVICE_ATTR(pkt_count_limit_bo_2, S_IRUGO|S_IWUSR, sysfs_pkt_count_limit_bo_show_2, sysfs_pkt_count_limit_bo_store_2);
1210 #else
1211 static ssize_t pkt_count_limit_bi_show(char *buf)
1212 {
1213 return sprintf( buf, "%d\n",ifxusb_hcd.pkt_count_limit_bi );
1214 }
1215 static ssize_t pkt_count_limit_bo_show(char *buf)
1216 {
1217 return sprintf( buf, "%d\n",ifxusb_hcd.pkt_count_limit_bo );
1218 }
1219 static void pkt_count_limit_bi_store(uint32_t value)
1220 {
1221 if (value<=13)
1222 ifxusb_hcd.pkt_count_limit_bi = value;
1223 }
1224 static void pkt_count_limit_bo_store(uint32_t value)
1225 {
1226 if (value<=13)
1227 ifxusb_hcd.pkt_count_limit_bo = value;
1228 }
1229 static ssize_t procfs_pkt_count_limit_bi_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1230 {
1231 return pkt_count_limit_bi_show(buf);
1232 }
1233 static ssize_t procfs_pkt_count_limit_bo_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1234 {
1235 return pkt_count_limit_bo_show(buf);
1236 }
1237 static ssize_t procfs_pkt_count_limit_bi_store(struct file *file, const char *buffer, unsigned long count, void *data)
1238 {
1239 char buf[10];
1240 int i = 0;
1241 uint32_t value;
1242 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1243 return -EFAULT;
1244 value = simple_strtoul(buf, NULL, 10);
1245 pkt_count_limit_bi_store(value);
1246 return count;
1247 }
1248 static ssize_t procfs_pkt_count_limit_bo_store(struct file *file, const char *buffer, unsigned long count, void *data)
1249 {
1250 char buf[10];
1251 int i = 0;
1252 uint32_t value;
1253 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1254 return -EFAULT;
1255 value = simple_strtoul(buf, NULL, 10);
1256 pkt_count_limit_bo_store(value);
1257 return count;
1258 }
1259
1260 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1261 static ssize_t sysfs_pkt_count_limit_bi_show( struct device *_dev, struct device_attribute *attr,char *buf)
1262 #else
1263 static ssize_t sysfs_pkt_count_limit_bi_show( struct device *_dev,char *buf)
1264 #endif
1265 {
1266 return pkt_count_limit_bi_show(buf);
1267 }
1268 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1269 static ssize_t sysfs_pkt_count_limit_bi_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
1270 #else
1271 static ssize_t sysfs_pkt_count_limit_bi_store( struct device *_dev, const char *buffer, size_t count )
1272 #endif
1273 {
1274 char buf[10];
1275 int i = 0;
1276 uint32_t value;
1277 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1278 return -EFAULT;
1279 value = simple_strtoul(buf, NULL, 10);
1280 pkt_count_limit_bi_store(value);
1281 return count;
1282 }
1283 DEVICE_ATTR(pkt_count_limit_bi, S_IRUGO|S_IWUSR, sysfs_pkt_count_limit_bi_show, sysfs_pkt_count_limit_bi_store);
1284
1285 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1286 static ssize_t sysfs_pkt_count_limit_bo_show( struct device *_dev, struct device_attribute *attr,char *buf)
1287 #else
1288 static ssize_t sysfs_pkt_count_limit_bo_show( struct device *_dev,char *buf)
1289 #endif
1290 {
1291 return pkt_count_limit_bo_show(buf);
1292 }
1293 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1294 static ssize_t sysfs_pkt_count_limit_bo_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
1295 #else
1296 static ssize_t sysfs_pkt_count_limit_bo_store( struct device *_dev, const char *buffer, size_t count )
1297 #endif
1298 {
1299 char buf[10];
1300 int i = 0;
1301 uint32_t value;
1302 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1303 return -EFAULT;
1304 value = simple_strtoul(buf, NULL, 10);
1305 pkt_count_limit_bo_store(value);
1306 return count;
1307 }
1308 DEVICE_ATTR(pkt_count_limit_bo, S_IRUGO|S_IWUSR, sysfs_pkt_count_limit_bo_show, sysfs_pkt_count_limit_bo_store);
1309 #endif
1310
1311 /////////////////////////////////////////////////////////////////////////////////////////////////////
1312 /////////////////////////////////////////////////////////////////////////////////////////////////////
1313 /////////////////////////////////////////////////////////////////////////////////////////////////////
1314
1315 #ifdef __IS_DUAL__
1316 static ssize_t buspower_show_1(char *buf)
1317 {
1318 if(ifxusb_vbus (&ifxusb_hcd_1.core_if)==1) return sprintf( buf, "1\n" );
1319 if(ifxusb_vbus (&ifxusb_hcd_1.core_if)==0) return sprintf( buf, "0\n" );
1320 return sprintf( buf, "UNKNOWN\n" );
1321 }
1322 static void buspower_store_1(uint32_t value)
1323 {
1324 if (value==1) ifxusb_vbus_on (&ifxusb_hcd_1.core_if);
1325 else if(value==0) ifxusb_vbus_off(&ifxusb_hcd_1.core_if);
1326 }
1327 static ssize_t buspower_show_2(char *buf)
1328 {
1329 if(ifxusb_vbus (&ifxusb_hcd_2.core_if)==1) return sprintf( buf, "1\n" );
1330 if(ifxusb_vbus (&ifxusb_hcd_2.core_if)==0) return sprintf( buf, "0\n" );
1331 return sprintf( buf, "UNKNOWN\n" );
1332 }
1333 static void buspower_store_2(uint32_t value)
1334 {
1335 if (value==1) ifxusb_vbus_on (&ifxusb_hcd_2.core_if);
1336 else if(value==0) ifxusb_vbus_off(&ifxusb_hcd_2.core_if);
1337 }
1338 static ssize_t procfs_buspower_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1339 {
1340 return buspower_show_1(buf);
1341 }
1342 static ssize_t procfs_buspower_store_1(struct file *file, const char *buffer, unsigned long count, void *data)
1343 {
1344 char buf[10];
1345 int i = 0;
1346 uint32_t value;
1347 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1348 return -EFAULT;
1349 value = simple_strtoul(buf, NULL, 10);
1350 buspower_store_1(value);
1351 return count;
1352 }
1353 static ssize_t procfs_buspower_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1354 {
1355 return buspower_show_2(buf);
1356 }
1357 static ssize_t procfs_buspower_store_2(struct file *file, const char *buffer, unsigned long count, void *data)
1358 {
1359 char buf[10];
1360 int i = 0;
1361 uint32_t value;
1362 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1363 return -EFAULT;
1364 value = simple_strtoul(buf, NULL, 10);
1365 buspower_store_2(value);
1366 return count;
1367 }
1368
1369 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1370 static ssize_t sysfs_buspower_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
1371 #else
1372 static ssize_t sysfs_buspower_show_1( struct device *_dev,char *buf)
1373 #endif
1374 {
1375 return buspower_show_1(buf);
1376 }
1377 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1378 static ssize_t sysfs_buspower_store_1( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
1379 #else
1380 static ssize_t sysfs_buspower_store_1( struct device *_dev, const char *buffer, size_t count )
1381 #endif
1382 {
1383 char buf[10];
1384 int i = 0;
1385 uint32_t value;
1386 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1387 return -EFAULT;
1388 value = simple_strtoul(buf, NULL, 10);
1389 buspower_store_1(value);
1390 return count;
1391 }
1392 DEVICE_ATTR(buspower_1, S_IRUGO|S_IWUSR, sysfs_buspower_show_1, sysfs_buspower_store_1);
1393
1394 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1395 static ssize_t sysfs_buspower_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
1396 #else
1397 static ssize_t sysfs_buspower_show_2( struct device *_dev,char *buf)
1398 #endif
1399 {
1400 return buspower_show_2(buf);
1401 }
1402 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1403 static ssize_t sysfs_buspower_store_2( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
1404 #else
1405 static ssize_t sysfs_buspower_store_2( struct device *_dev, const char *buffer, size_t count )
1406 #endif
1407 {
1408 char buf[10];
1409 int i = 0;
1410 uint32_t value;
1411 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1412 return -EFAULT;
1413 value = simple_strtoul(buf, NULL, 10);
1414 buspower_store_2(value);
1415 return count;
1416 }
1417 DEVICE_ATTR(buspower_2, S_IRUGO|S_IWUSR, sysfs_buspower_show_2, sysfs_buspower_store_2);
1418 #else
1419 static ssize_t buspower_show(char *buf)
1420 {
1421 if(ifxusb_vbus (&ifxusb_hcd.core_if)==1) return sprintf( buf, "1\n" );
1422 if(ifxusb_vbus (&ifxusb_hcd.core_if)==0) return sprintf( buf, "0\n" );
1423 return sprintf( buf, "UNKNOWN\n" );
1424 }
1425 static void buspower_store(uint32_t value)
1426 {
1427 if (value==1) ifxusb_vbus_on (&ifxusb_hcd.core_if);
1428 else if(value==0) ifxusb_vbus_off(&ifxusb_hcd.core_if);
1429 }
1430 static ssize_t procfs_buspower_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1431 {
1432 return buspower_show(buf);
1433 }
1434 static ssize_t procfs_buspower_store(struct file *file, const char *buffer, unsigned long count, void *data)
1435 {
1436 char buf[10];
1437 int i = 0;
1438 uint32_t value;
1439 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1440 return -EFAULT;
1441 value = simple_strtoul(buf, NULL, 10);
1442 buspower_store(value);
1443 return count;
1444 }
1445 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1446 static ssize_t sysfs_buspower_show( struct device *_dev, struct device_attribute *attr,char *buf)
1447 #else
1448 static ssize_t sysfs_buspower_show( struct device *_dev, char *buf)
1449 #endif
1450 {
1451 return buspower_show(buf);
1452 }
1453 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1454 static ssize_t sysfs_buspower_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
1455 #else
1456 static ssize_t sysfs_buspower_store( struct device *_dev, const char *buffer, size_t count )
1457 #endif
1458 {
1459 char buf[10];
1460 int i = 0;
1461 uint32_t value;
1462 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
1463 return -EFAULT;
1464 value = simple_strtoul(buf, NULL, 10);
1465 buspower_store(value);
1466 return count;
1467 }
1468 DEVICE_ATTR(buspower, S_IRUGO|S_IWUSR, sysfs_buspower_show, sysfs_buspower_store);
1469 #endif
1470
1471 /////////////////////////////////////////////////////////////////////////////////////////////////////
1472 /////////////////////////////////////////////////////////////////////////////////////////////////////
1473 /////////////////////////////////////////////////////////////////////////////////////////////////////
1474
1475
1476 #ifdef __IS_DUAL__
1477 static ssize_t bussuspend_show_1(char *buf)
1478 {
1479 hprt0_data_t val;
1480 val.d32 = ifxusb_rreg(ifxusb_hcd_1.core_if.hprt0);
1481 return sprintf (buf, "Bus Suspend = 0x%x\n", val.b.prtsusp);
1482 }
1483 static ssize_t bussuspend_show_2(char *buf)
1484 {
1485 hprt0_data_t val;
1486 val.d32 = ifxusb_rreg(ifxusb_hcd_2.core_if.hprt0);
1487 return sprintf (buf, "Bus Suspend = 0x%x\n", val.b.prtsusp);
1488 }
1489
1490 static ssize_t procfs_bussuspend_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1491 {
1492 return bussuspend_show_1(buf);
1493 }
1494 static ssize_t procfs_bussuspend_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1495 {
1496 return bussuspend_show_2(buf);
1497 }
1498 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1499 static ssize_t sysfs_bussuspend_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
1500 #else
1501 static ssize_t sysfs_bussuspend_show_1( struct device *_dev,char *buf)
1502 #endif
1503 {
1504 return bussuspend_show_1(buf);
1505 }
1506 DEVICE_ATTR(bussuspend_1, S_IRUGO|S_IWUSR, sysfs_bussuspend_show_1, 0);
1507 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1508 static ssize_t sysfs_bussuspend_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
1509 #else
1510 static ssize_t sysfs_bussuspend_show_2( struct device *_dev,char *buf)
1511 #endif
1512 {
1513 return bussuspend_show_2(buf);
1514 }
1515 DEVICE_ATTR(bussuspend_2, S_IRUGO|S_IWUSR, sysfs_bussuspend_show_2, 0);
1516 #else
1517 static ssize_t bussuspend_show(char *buf)
1518 {
1519 hprt0_data_t val;
1520 val.d32 = ifxusb_rreg(ifxusb_hcd.core_if.hprt0);
1521 return sprintf (buf, "Bus Suspend = 0x%x\n", val.b.prtsusp);
1522 }
1523 static ssize_t procfs_bussuspend_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1524 {
1525 return bussuspend_show(buf);
1526 }
1527
1528 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1529 static ssize_t sysfs_bussuspend_show( struct device *_dev, struct device_attribute *attr,char *buf)
1530 #else
1531 static ssize_t sysfs_bussuspend_show( struct device *_dev, char *buf)
1532 #endif
1533 {
1534 return bussuspend_show(buf);
1535 }
1536 DEVICE_ATTR(bussuspend, S_IRUGO|S_IWUSR, sysfs_bussuspend_show, 0);
1537 #endif
1538
1539 /////////////////////////////////////////////////////////////////////////////////////////////////////
1540 /////////////////////////////////////////////////////////////////////////////////////////////////////
1541 /////////////////////////////////////////////////////////////////////////////////////////////////////
1542
1543 #ifdef __IS_DUAL__
1544 static ssize_t busconnected_show_1(char *buf)
1545 {
1546 hprt0_data_t val;
1547 val.d32 = ifxusb_rreg(ifxusb_hcd_1.core_if.hprt0);
1548 return sprintf (buf, "Bus Connected = 0x%x\n", val.b.prtconnsts);
1549 }
1550 static ssize_t busconnected_show_2(char *buf)
1551 {
1552 hprt0_data_t val;
1553 val.d32 = ifxusb_rreg(ifxusb_hcd_2.core_if.hprt0);
1554 return sprintf (buf, "Bus Connected = 0x%x\n", val.b.prtconnsts);
1555 }
1556
1557 static ssize_t procfs_busconnected_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1558 {
1559 return busconnected_show_1(buf);
1560 }
1561 static ssize_t procfs_busconnected_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1562 {
1563 return busconnected_show_2(buf);
1564 }
1565 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1566 static ssize_t sysfs_busconnected_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
1567 #else
1568 static ssize_t sysfs_busconnected_show_1( struct device *_dev,char *buf)
1569 #endif
1570 {
1571 return busconnected_show_1(buf);
1572 }
1573 DEVICE_ATTR(busconnected_1, S_IRUGO|S_IWUSR, sysfs_busconnected_show_1, 0);
1574 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1575 static ssize_t sysfs_busconnected_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
1576 #else
1577 static ssize_t sysfs_busconnected_show_2( struct device *_dev,char *buf)
1578 #endif
1579 {
1580 return busconnected_show_2(buf);
1581 }
1582 DEVICE_ATTR(busconnected_2, S_IRUGO|S_IWUSR, sysfs_busconnected_show_2, 0);
1583 #else
1584 static ssize_t busconnected_show(char *buf)
1585 {
1586 hprt0_data_t val;
1587 val.d32 = ifxusb_rreg(ifxusb_hcd.core_if.hprt0);
1588 return sprintf (buf, "Bus Connected = 0x%x\n", val.b.prtconnsts);
1589 }
1590 static ssize_t procfs_busconnected_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1591 {
1592 return busconnected_show(buf);
1593 }
1594
1595 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1596 static ssize_t sysfs_busconnected_show( struct device *_dev, struct device_attribute *attr,char *buf)
1597 #else
1598 static ssize_t sysfs_busconnected_show( struct device *_dev, char *buf)
1599 #endif
1600 {
1601 return busconnected_show(buf);
1602 }
1603 DEVICE_ATTR(busconnected, S_IRUGO|S_IWUSR, sysfs_busconnected_show, 0);
1604 #endif
1605
1606 /////////////////////////////////////////////////////////////////////////////////////////////////////
1607 /////////////////////////////////////////////////////////////////////////////////////////////////////
1608 /////////////////////////////////////////////////////////////////////////////////////////////////////
1609
1610 #ifdef __IS_DUAL__
1611 static ssize_t connectspeed_show_1(char *buf)
1612 {
1613 hprt0_data_t val;
1614 val.d32 = ifxusb_rreg(ifxusb_hcd_1.core_if.hprt0);
1615 if( val.b.prtspd ==0) return sprintf (buf, "Bus Speed = High (%d)\n", val.b.prtspd);
1616 if( val.b.prtspd ==1) return sprintf (buf, "Bus Speed = Full (%d)\n", val.b.prtspd);
1617 if( val.b.prtspd ==2) return sprintf (buf, "Bus Speed = Low (%d)\n", val.b.prtspd);
1618 return sprintf (buf, "Bus Speed = Unknown (%d)\n", val.b.prtspd);
1619 }
1620 static ssize_t connectspeed_show_2(char *buf)
1621 {
1622 hprt0_data_t val;
1623 val.d32 = ifxusb_rreg(ifxusb_hcd_2.core_if.hprt0);
1624 if( val.b.prtspd ==0) return sprintf (buf, "Bus Speed = High (%d)\n", val.b.prtspd);
1625 if( val.b.prtspd ==1) return sprintf (buf, "Bus Speed = Full (%d)\n", val.b.prtspd);
1626 if( val.b.prtspd ==2) return sprintf (buf, "Bus Speed = Low (%d)\n", val.b.prtspd);
1627 return sprintf (buf, "Bus Speed = Unknown (%d)\n", val.b.prtspd);
1628 }
1629
1630 static ssize_t procfs_connectspeed_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1631 {
1632 return connectspeed_show_1(buf);
1633 }
1634 static ssize_t procfs_connectspeed_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1635 {
1636 return connectspeed_show_2(buf);
1637 }
1638 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1639 static ssize_t sysfs_connectspeed_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
1640 #else
1641 static ssize_t sysfs_connectspeed_show_1( struct device *_dev,char *buf)
1642 #endif
1643 {
1644 return connectspeed_show_1(buf);
1645 }
1646 DEVICE_ATTR(connectspeed_1, S_IRUGO|S_IWUSR, sysfs_connectspeed_show_1, 0);
1647 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1648 static ssize_t sysfs_connectspeed_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
1649 #else
1650 static ssize_t sysfs_connectspeed_show_2( struct device *_dev,char *buf)
1651 #endif
1652 {
1653 return connectspeed_show_2(buf);
1654 }
1655 DEVICE_ATTR(connectspeed_2, S_IRUGO|S_IWUSR, sysfs_connectspeed_show_2, 0);
1656 #else
1657 static ssize_t connectspeed_show(char *buf)
1658 {
1659 hprt0_data_t val;
1660 val.d32 = ifxusb_rreg(ifxusb_hcd.core_if.hprt0);
1661 if( val.b.prtspd ==0) return sprintf (buf, "Bus Speed = High (%d)\n", val.b.prtspd);
1662 if( val.b.prtspd ==1) return sprintf (buf, "Bus Speed = Full (%d)\n", val.b.prtspd);
1663 if( val.b.prtspd ==2) return sprintf (buf, "Bus Speed = Low (%d)\n", val.b.prtspd);
1664 return sprintf (buf, "Bus Speed = Unknown (%d)\n", val.b.prtspd);
1665 }
1666
1667 static ssize_t procfs_connectspeed_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1668 {
1669 return connectspeed_show(buf);
1670 }
1671
1672 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1673 static ssize_t sysfs_connectspeed_show( struct device *_dev, struct device_attribute *attr,char *buf)
1674 #else
1675 static ssize_t sysfs_connectspeed_show( struct device *_dev, char *buf)
1676 #endif
1677 {
1678 return connectspeed_show(buf);
1679 }
1680 DEVICE_ATTR(connectspeed, S_IRUGO|S_IWUSR, sysfs_connectspeed_show, 0);
1681 #endif
1682 /////////////////////////////////////////////////////////////////////////////////////////////////////
1683 /////////////////////////////////////////////////////////////////////////////////////////////////////
1684 /////////////////////////////////////////////////////////////////////////////////////////////////////
1685 #endif
1686
1687
1688 #ifdef __IS_DEVICE__
1689 /////////////////////////////////////////////////////////////////////////////////////////////////////
1690 /////////////////////////////////////////////////////////////////////////////////////////////////////
1691 /////////////////////////////////////////////////////////////////////////////////////////////////////
1692 static ssize_t devspeed_show(char *buf)
1693 {
1694 dcfg_data_t val;
1695 val.d32 = ifxusb_rreg(&ifxusb_pcd.core_if.dev_global_regs->dcfg);
1696 if( val.b.devspd ==0) return sprintf (buf, "Dev Speed = High (%d)\n", val.b.devspd);
1697 if( val.b.devspd ==1) return sprintf (buf, "Dev Speed = Full (%d)\n", val.b.devspd);
1698 if( val.b.devspd ==3) return sprintf (buf, "Dev Speed = Full (%d)\n", val.b.devspd);
1699 return sprintf (buf, "Dev Speed = Unknown (%d)\n", val.b.devspd);
1700 }
1701
1702 static ssize_t procfs_devspeed_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1703 {
1704 return devspeed_show(buf);
1705 }
1706
1707 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1708 static ssize_t sysfs_devspeed_show( struct device *_dev, struct device_attribute *attr,char *buf)
1709 #else
1710 static ssize_t sysfs_devspeed_show( struct device *_dev, char *buf)
1711 #endif
1712 {
1713 return devspeed_show(buf);
1714 }
1715 DEVICE_ATTR(devspeed, S_IRUGO|S_IWUSR, sysfs_devspeed_show, 0);
1716
1717 static ssize_t enumspeed_show(char *buf)
1718 {
1719 dsts_data_t val;
1720 val.d32 = ifxusb_rreg(&ifxusb_pcd.core_if.dev_global_regs->dsts);
1721 if( val.b.enumspd ==0) return sprintf (buf, "Enum Speed = High (%d)\n", val.b.enumspd);
1722 if( val.b.enumspd ==1) return sprintf (buf, "Enum Speed = Full (%d)\n", val.b.enumspd);
1723 if( val.b.enumspd ==2) return sprintf (buf, "Enum Speed = Low (%d)\n", val.b.enumspd);
1724 return sprintf (buf, "Enum Speed = invalid(%d)\n", val.b.enumspd);
1725 }
1726
1727 static ssize_t procfs_enumspeed_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1728 {
1729 return enumspeed_show(buf);
1730 }
1731
1732 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1733 static ssize_t sysfs_enumspeed_show( struct device *_dev, struct device_attribute *attr,char *buf)
1734 #else
1735 static ssize_t sysfs_enumspeed_show( struct device *_dev, char *buf)
1736 #endif
1737 {
1738 return enumspeed_show(buf);
1739 }
1740 DEVICE_ATTR(enumspeed, S_IRUGO|S_IWUSR, sysfs_enumspeed_show, 0);
1741 /////////////////////////////////////////////////////////////////////////////////////////////////////
1742 /////////////////////////////////////////////////////////////////////////////////////////////////////
1743 /////////////////////////////////////////////////////////////////////////////////////////////////////
1744 #endif
1745
1746
1747 //////////////////////////////////////////////////////////////////////////////////
1748 #ifdef __ENABLE_DUMP__
1749
1750 #ifdef __IS_DUAL__
1751 static void dump_reg_1(void)
1752 {
1753 ifxusb_dump_registers_h(&ifxusb_hcd_1.core_if);
1754 }
1755 static void dump_reg_2(void)
1756 {
1757 ifxusb_dump_registers_h(&ifxusb_hcd_2.core_if);
1758 }
1759
1760 static ssize_t procfs_dump_reg_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1761 {
1762 dump_reg_1();
1763 return 0;
1764 }
1765 static ssize_t procfs_dump_reg_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1766 {
1767 dump_reg_2();
1768 return 0;
1769 }
1770 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1771 static ssize_t sysfs_dump_reg_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
1772 #else
1773 static ssize_t sysfs_dump_reg_show_1( struct device *_dev,char *buf)
1774 #endif
1775 {
1776 dump_reg_1();
1777 return 0;
1778 }
1779 DEVICE_ATTR(dump_reg_h_1, S_IRUGO|S_IWUSR, sysfs_dump_reg_show_1, 0);
1780 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1781 static ssize_t sysfs_dump_reg_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
1782 #else
1783 static ssize_t sysfs_dump_reg_show_2( struct device *_dev,char *buf)
1784 #endif
1785 {
1786 dump_reg_2();
1787 return 0;
1788 }
1789 DEVICE_ATTR(dump_reg_h_2, S_IRUGO|S_IWUSR, sysfs_dump_reg_show_2, 0);
1790 #else
1791 static void dump_reg(void)
1792 {
1793 #ifdef __IS_HOST__
1794 ifxusb_dump_registers_h(&ifxusb_hcd.core_if);
1795 #endif
1796 #ifdef __IS_DEVICE__
1797 ifxusb_dump_registers_d(&ifxusb_pcd.core_if);
1798 #endif
1799 }
1800 static ssize_t procfs_dump_reg_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1801 {
1802 dump_reg();
1803 return 0;
1804 }
1805 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1806 static ssize_t sysfs_dump_reg_show( struct device *_dev, struct device_attribute *attr,char *buf)
1807 #else
1808 static ssize_t sysfs_dump_reg_show( struct device *_dev,char *buf)
1809 #endif
1810 {
1811 dump_reg();
1812 return 0;
1813 }
1814 #ifdef __IS_HOST__
1815 DEVICE_ATTR(dump_reg_h, S_IRUGO|S_IWUSR, sysfs_dump_reg_show, 0);
1816 #else
1817 DEVICE_ATTR(dump_reg_d, S_IRUGO|S_IWUSR, sysfs_dump_reg_show, 0);
1818 #endif
1819 #endif
1820
1821
1822 /////////////////////////////////////////////////////////////////////////////////////////////////////
1823 /////////////////////////////////////////////////////////////////////////////////////////////////////
1824 /////////////////////////////////////////////////////////////////////////////////////////////////////
1825
1826 #ifdef __IS_DUAL__
1827 static void dump_spram_1(void)
1828 {
1829 ifxusb_dump_spram_h(&ifxusb_hcd_1.core_if);
1830 }
1831 static void dump_spram_2(void)
1832 {
1833 ifxusb_dump_spram_h(&ifxusb_hcd_2.core_if);
1834 }
1835
1836 static ssize_t procfs_dump_spram_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1837 {
1838 dump_spram_1();
1839 return 0;
1840 }
1841 static ssize_t procfs_dump_spram_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1842 {
1843 dump_spram_2();
1844 return 0;
1845 }
1846 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1847 static ssize_t sysfs_dump_spram_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
1848 #else
1849 static ssize_t sysfs_dump_spram_show_1( struct device *_dev,char *buf)
1850 #endif
1851 {
1852 dump_spram_1();
1853 return 0;
1854 }
1855 DEVICE_ATTR(dump_spram_h_1, S_IRUGO|S_IWUSR, sysfs_dump_spram_show_1, 0);
1856
1857 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1858 static ssize_t sysfs_dump_spram_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
1859 #else
1860 static ssize_t sysfs_dump_spram_show_2( struct device *_dev,char *buf)
1861 #endif
1862 {
1863 dump_spram_2();
1864 return 0;
1865 }
1866 DEVICE_ATTR(dump_spram_h_2, S_IRUGO|S_IWUSR, sysfs_dump_spram_show_2, 0);
1867 #else
1868 static void dump_spram(void)
1869 {
1870 #ifdef __IS_HOST__
1871 ifxusb_dump_spram_h(&ifxusb_hcd.core_if);
1872 #endif
1873 #ifdef __IS_DEVICE__
1874 ifxusb_dump_spram_d(&ifxusb_pcd.core_if);
1875 #endif
1876 }
1877 static ssize_t procfs_dump_spram_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1878 {
1879 dump_spram();
1880 return 0;
1881 }
1882 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1883 static ssize_t sysfs_dump_spram_show( struct device *_dev, struct device_attribute *attr,char *buf)
1884 #else
1885 static ssize_t sysfs_dump_spram_show( struct device *_dev,char *buf)
1886 #endif
1887 {
1888 dump_spram();
1889 return 0;
1890 }
1891 #ifdef __IS_HOST__
1892 DEVICE_ATTR(dump_spram_h, S_IRUGO|S_IWUSR, sysfs_dump_spram_show, 0);
1893 #else
1894 DEVICE_ATTR(dump_spram_d, S_IRUGO|S_IWUSR, sysfs_dump_spram_show, 0);
1895 #endif
1896
1897 #endif
1898 /////////////////////////////////////////////////////////////////////////////////////////////////////
1899 /////////////////////////////////////////////////////////////////////////////////////////////////////
1900 /////////////////////////////////////////////////////////////////////////////////////////////////////
1901
1902 #ifdef __IS_HOST__
1903 #ifdef __IS_DUAL__
1904 static ssize_t procfs_dump_host_state_show_1(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1905 {
1906 ifxhcd_dump_state(&ifxusb_hcd_1);
1907 return 0;
1908 }
1909 static ssize_t procfs_dump_host_state_show_2(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1910 {
1911 ifxhcd_dump_state(&ifxusb_hcd_2);
1912 return 0;
1913 }
1914 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1915 static ssize_t sysfs_dump_host_state_show_1( struct device *_dev, struct device_attribute *attr,char *buf)
1916 #else
1917 static ssize_t sysfs_dump_host_state_show_1( struct device *_dev,char *buf)
1918 #endif
1919 {
1920 ifxhcd_dump_state(&ifxusb_hcd_1);
1921 return 0;
1922 }
1923 DEVICE_ATTR(dump_host_state_1, S_IRUGO|S_IWUSR, sysfs_dump_host_state_show_1, 0);
1924 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1925 static ssize_t sysfs_dump_host_state_show_2( struct device *_dev, struct device_attribute *attr,char *buf)
1926 #else
1927 static ssize_t sysfs_dump_host_state_show_2( struct device *_dev,char *buf)
1928 #endif
1929 {
1930 ifxhcd_dump_state(&ifxusb_hcd_2);
1931 return 0;
1932 }
1933 DEVICE_ATTR(dump_host_state_2, S_IRUGO|S_IWUSR, sysfs_dump_host_state_show_2, 0);
1934 #else
1935 static ssize_t procfs_dump_host_state_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
1936 {
1937 ifxhcd_dump_state(&ifxusb_hcd);
1938 return 0;
1939 }
1940 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
1941 static ssize_t sysfs_dump_host_state_show( struct device *_dev, struct device_attribute *attr,char *buf)
1942 #else
1943 static ssize_t sysfs_dump_host_state_show( struct device *_dev,char *buf)
1944 #endif
1945 {
1946 ifxhcd_dump_state(&ifxusb_hcd);
1947 return 0;
1948 }
1949 DEVICE_ATTR(dump_host_state, S_IRUGO|S_IWUSR, sysfs_dump_host_state_show, 0);
1950 #endif
1951
1952 /////////////////////////////////////////////////////////////////////////////////////////////////////
1953 /////////////////////////////////////////////////////////////////////////////////////////////////////
1954 /////////////////////////////////////////////////////////////////////////////////////////////////////
1955
1956 #endif //IS_HOST_
1957
1958 #endif //__ENABLE_DUMP__
1959 /////////////////////////////////////////////////////////////////////////////////////////////////////
1960 /////////////////////////////////////////////////////////////////////////////////////////////////////
1961 #ifdef __IS_HOST__
1962 static void host_probe(unsigned long _ptr)
1963 {
1964 ifxhcd_hcd_t *ifxhcd = (ifxhcd_hcd_t *)_ptr;
1965
1966 if(ifxhcd->flags.b.port_connect_status)
1967 {
1968 del_timer(&ifxhcd->host_probe_timer);
1969 del_timer(&ifxhcd->autoprobe_timer);
1970 ifxhcd->power_status = 0;
1971 }
1972 else
1973 {
1974 del_timer(&ifxhcd->autoprobe_timer);
1975 ifxhcd->autoprobe_timer.expires = jiffies + (HZ*ifxhcd->autoprobe_sec);
1976 add_timer(&ifxhcd->autoprobe_timer);
1977 ifxhcd->power_status = 2;
1978 del_timer(&ifxhcd->host_probe_timer);
1979 do_suspend_h(&ifxhcd->core_if);
1980 }
1981 }
1982
1983 static void host_autoprobe(unsigned long _ptr)
1984 {
1985 ifxhcd_hcd_t *ifxhcd = (ifxhcd_hcd_t *)_ptr;
1986 del_timer(&ifxhcd->host_probe_timer);
1987 ifxhcd->host_probe_timer.function = host_probe;
1988 ifxhcd->host_probe_timer.expires = jiffies + (HZ*ifxhcd->probe_sec);
1989 ifxhcd->host_probe_timer.data = (unsigned long)ifxhcd;
1990 add_timer(&ifxhcd->host_probe_timer);
1991 do_resume_h(&ifxhcd->core_if);
1992 }
1993
1994 static void suspend_host_store(ifxhcd_hcd_t *ifxhcd , uint32_t value)
1995 {
1996 if(value==2)
1997 {
1998 del_timer(&ifxhcd->autoprobe_timer);
1999 ifxhcd->autoprobe_timer.function = host_autoprobe;
2000 ifxhcd->autoprobe_timer.expires = jiffies + (HZ*ifxhcd->autoprobe_sec);
2001 ifxhcd->autoprobe_timer.data = (unsigned long)ifxhcd;
2002 add_timer(&ifxhcd->autoprobe_timer);
2003 ifxhcd->power_status = 2;
2004 }
2005 else if(value==1)
2006 {
2007 do_suspend_h(&ifxhcd->core_if);
2008 ifxhcd->power_status = 1;
2009 del_timer(&ifxhcd->host_probe_timer);
2010 del_timer(&ifxhcd->autoprobe_timer);
2011 }
2012 else if(value==0)
2013 {
2014 do_resume_h(&ifxhcd->core_if);
2015 ifxhcd->power_status = 0;
2016 del_timer(&ifxhcd->host_probe_timer);
2017 del_timer(&ifxhcd->autoprobe_timer);
2018 }
2019 }
2020 #ifdef __IS_DUAL__
2021 static ssize_t procfs_suspend_host_2_store(struct file *file, const char *buffer, unsigned long count, void *data)
2022 {
2023 char buf[10];
2024 int i = 0;
2025 uint32_t value;
2026 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2027 return -EFAULT;
2028 value = simple_strtoul(buf, NULL, 10);
2029 suspend_host_store(&ifxusb_hcd_2,value);
2030 return count;
2031 }
2032
2033 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2034 static ssize_t sysfs_suspend_host_2_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2035 #else
2036 static ssize_t sysfs_suspend_host_2_store( struct device *_dev, const char *buffer, size_t count )
2037 #endif
2038 {
2039 char buf[10];
2040 int i = 0;
2041 uint32_t value;
2042 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2043 return -EFAULT;
2044 value = simple_strtoul(buf, NULL, 10);
2045 suspend_host_store(&ifxusb_hcd_2,value);
2046 return count;
2047 }
2048
2049 static ssize_t procfs_suspend_host_1_store(struct file *file, const char *buffer, unsigned long count, void *data)
2050 {
2051 char buf[10];
2052 int i = 0;
2053 uint32_t value;
2054 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2055 return -EFAULT;
2056 value = simple_strtoul(buf, NULL, 10);
2057 suspend_host_store(&ifxusb_hcd_1,value);
2058 return count;
2059 }
2060
2061 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2062 static ssize_t sysfs_suspend_host_1_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2063 #else
2064 static ssize_t sysfs_suspend_host_1_store( struct device *_dev, const char *buffer, size_t count )
2065 #endif
2066 {
2067 char buf[10];
2068 int i = 0;
2069 uint32_t value;
2070 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2071 return -EFAULT;
2072 value = simple_strtoul(buf, NULL, 10);
2073 suspend_host_store(&ifxusb_hcd_1,value);
2074 return count;
2075 }
2076 DEVICE_ATTR(suspend_host_2, S_IWUSR,NULL, sysfs_suspend_host_2_store);
2077 DEVICE_ATTR(suspend_host_1, S_IWUSR,NULL, sysfs_suspend_host_1_store);
2078 /////////////////////////////////////////////////////////////////////////////////////////////////////
2079 #else
2080 static ssize_t procfs_suspend_host_store(struct file *file, const char *buffer, unsigned long count, void *data)
2081 {
2082 char buf[10];
2083 int i = 0;
2084 uint32_t value;
2085 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2086 return -EFAULT;
2087 value = simple_strtoul(buf, NULL, 10);
2088 suspend_host_store(&ifxusb_hcd,value);
2089 return count;
2090 }
2091
2092 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2093 static ssize_t sysfs_suspend_host_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2094 #else
2095 static ssize_t sysfs_suspend_host_store( struct device *_dev, const char *buffer, size_t count )
2096 #endif
2097 {
2098 char buf[10];
2099 int i = 0;
2100 uint32_t value;
2101 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2102 return -EFAULT;
2103 value = simple_strtoul(buf, NULL, 10);
2104 suspend_host_store(&ifxusb_hcd,value);
2105 return count;
2106 }
2107 DEVICE_ATTR(suspend_host, S_IWUSR,NULL, sysfs_suspend_host_store);
2108 #endif
2109 #endif
2110
2111 /////////////////////////////////////////////////////////////////////////////////////////////////////
2112 /////////////////////////////////////////////////////////////////////////////////////////////////////
2113 #ifdef __IS_HOST__
2114 static void probe_host_store(ifxhcd_hcd_t *ifxhcd, uint32_t value)
2115 {
2116 if(ifxhcd->power_status == 1)
2117 {
2118 del_timer(&ifxhcd->host_probe_timer);
2119 ifxhcd->host_probe_timer.function = host_probe;
2120 ifxhcd->host_probe_timer.expires = jiffies + (HZ*ifxhcd->probe_sec);
2121 ifxhcd->host_probe_timer.data = (unsigned long) ifxhcd;
2122 add_timer(&ifxhcd->host_probe_timer);
2123 do_resume_h(&ifxhcd->core_if);
2124 }
2125 }
2126 #ifdef __IS_DUAL__
2127 static ssize_t probe_host_2_show(char *buf)
2128 {
2129 if(ifxusb_hcd_2.power_status == 0)
2130 return sprintf (buf,"Host 2 power status is ON\n");
2131 else if(ifxusb_hcd_2.power_status == 1)
2132 return sprintf (buf,"Host 2 power status is Suspend\n");
2133 else
2134 return sprintf (buf,"Host 2 power status is Auto-probing\n");
2135 }
2136 static ssize_t probe_host_1_show(char *buf)
2137 {
2138 if(ifxusb_hcd_1.power_status == 0)
2139 return sprintf (buf,"Host 1 power status is ON\n");
2140 else if(ifxusb_hcd_1.power_status == 1)
2141 return sprintf (buf,"Host 1 power status is Suspend\n");
2142 else
2143 return sprintf (buf,"Host 1 power status is Auto-probing\n");
2144 }
2145 static ssize_t procfs_probe_host_2_store(struct file *file, const char *buffer, unsigned long count, void *data)
2146 {
2147 char buf[10];
2148 int i = 0;
2149 uint32_t value;
2150 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2151 return -EFAULT;
2152 value = simple_strtoul(buf, NULL, 10);
2153 probe_host_store(&ifxusb_hcd_2,value);
2154 return count;
2155 }
2156 static ssize_t procfs_probe_host_2_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
2157 {
2158 return probe_host_2_show(buf);
2159 }
2160 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2161 static ssize_t sysfs_probe_host_2_show( struct device *_dev, struct device_attribute *attr,char *buf)
2162 #else
2163 static ssize_t sysfs_probe_host_2_show( struct device *_dev, char *buf)
2164 #endif
2165 {
2166 return probe_host_2_show(buf);
2167 }
2168 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2169 static ssize_t sysfs_probe_host_2_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2170 #else
2171 static ssize_t sysfs_probe_host_2_store( struct device *_dev, const char *buffer, size_t count )
2172 #endif
2173 {
2174 char buf[10];
2175 int i = 0;
2176 uint32_t value;
2177 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2178 return -EFAULT;
2179 value = simple_strtoul(buf, NULL, 10);
2180 probe_host_store(&ifxusb_hcd_2,value);
2181 return count;
2182 }
2183
2184 static ssize_t procfs_probe_host_1_store(struct file *file, const char *buffer, unsigned long count, void *data)
2185 {
2186 char buf[10];
2187 int i = 0;
2188 uint32_t value;
2189 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2190 return -EFAULT;
2191 value = simple_strtoul(buf, NULL, 10);
2192 probe_host_store(&ifxusb_hcd_1,value);
2193 return count;
2194 }
2195 static ssize_t procfs_probe_host_1_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
2196 {
2197 return probe_host_1_show(buf);
2198 }
2199 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2200 static ssize_t sysfs_probe_host_1_show( struct device *_dev, struct device_attribute *attr,char *buf)
2201 #else
2202 static ssize_t sysfs_probe_host_1_show( struct device *_dev, char *buf)
2203 #endif
2204 {
2205 return probe_host_1_show(buf);
2206 }
2207 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2208 static ssize_t sysfs_probe_host_1_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2209 #else
2210 static ssize_t sysfs_probe_host_1_store( struct device *_dev, const char *buffer, size_t count )
2211 #endif
2212 {
2213 char buf[10];
2214 int i = 0;
2215 uint32_t value;
2216 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2217 return -EFAULT;
2218 value = simple_strtoul(buf, NULL, 10);
2219 probe_host_store(&ifxusb_hcd_1,value);
2220 return count;
2221 }
2222 DEVICE_ATTR(probe_host_2, S_IRUGO|S_IWUSR, sysfs_probe_host_2_show, sysfs_probe_host_2_store);
2223 DEVICE_ATTR(probe_host_1, S_IRUGO|S_IWUSR, sysfs_probe_host_1_show, sysfs_probe_host_1_store);
2224 /////////////////////////////////////////////////////////////////////////////////////////////////////
2225 #else
2226 static ssize_t probe_host_show(char *buf)
2227 {
2228 if(ifxusb_hcd.power_status == 0)
2229 return sprintf (buf,"Host power status is ON\n");
2230 else if(ifxusb_hcd.power_status == 1)
2231 return sprintf (buf,"Host power status is Suspend\n");
2232 else
2233 return sprintf (buf,"Host power status is Auto-probing\n");
2234 }
2235 static ssize_t procfs_probe_host_store(struct file *file, const char *buffer, unsigned long count, void *data)
2236 {
2237 char buf[10];
2238 int i = 0;
2239 uint32_t value;
2240 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2241 return -EFAULT;
2242 value = simple_strtoul(buf, NULL, 10);
2243 probe_host_store(&ifxusb_hcd,value);
2244 return count;
2245 }
2246 static ssize_t procfs_probe_host_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
2247 {
2248 return probe_host_show(buf);
2249 }
2250 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2251 static ssize_t sysfs_probe_host_show( struct device *_dev, struct device_attribute *attr,char *buf)
2252 #else
2253 static ssize_t sysfs_probe_host_show( struct device *_dev, char *buf)
2254 #endif
2255 {
2256 return probe_host_show(buf);
2257 }
2258 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2259 static ssize_t sysfs_probe_host_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2260 #else
2261 static ssize_t sysfs_probe_host_store( struct device *_dev, const char *buffer, size_t count )
2262 #endif
2263 {
2264 char buf[10];
2265 int i = 0;
2266 uint32_t value;
2267 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2268 return -EFAULT;
2269 value = simple_strtoul(buf, NULL, 10);
2270 probe_host_store(&ifxusb_hcd,value);
2271 return count;
2272 }
2273 DEVICE_ATTR(probe_host, S_IRUGO|S_IWUSR, sysfs_probe_host_show, sysfs_probe_host_store);
2274 #endif
2275 #endif
2276 /////////////////////////////////////////////////////////////////////////////////////////////////////
2277 /////////////////////////////////////////////////////////////////////////////////////////////////////
2278 #ifdef __IS_DEVICE__
2279 static void device_probe(unsigned long _ptr)
2280 {
2281 if(ifxusb_pcd.power_status == 2)
2282 {
2283 del_timer(&ifxusb_pcd.device_autoprobe_timer);
2284 ifxusb_pcd.device_autoprobe_timer.expires = jiffies + (HZ*ifxusb_pcd.autoprobe_sec);
2285 add_timer(&ifxusb_pcd.device_autoprobe_timer);
2286 ifxusb_pcd.power_status = 2;
2287 do_suspend_d(&ifxusb_pcd.core_if);
2288 }
2289 else if(ifxusb_pcd.power_status == 1)
2290 {
2291 do_suspend_d(&ifxusb_pcd.core_if);
2292 ifxusb_pcd.power_status = 1;
2293 }
2294 }
2295 static void device_autoprobe(unsigned long _ptr)
2296 {
2297 init_timer(&ifxusb_pcd.device_probe_timer);
2298 ifxusb_pcd.device_probe_timer.function = device_probe;
2299 ifxusb_pcd.device_probe_timer.expires = jiffies + (HZ*ifxusb_pcd.probe_sec);
2300 add_timer(&ifxusb_pcd.device_probe_timer);
2301 do_resume_d(&ifxusb_pcd.core_if);
2302 }
2303 static void suspend_device_store(uint32_t value)
2304 {
2305 if(value==2)
2306 {
2307 del_timer(&ifxusb_pcd.device_autoprobe_timer);
2308 ifxusb_pcd.device_autoprobe_timer.function = device_autoprobe;
2309 ifxusb_pcd.device_autoprobe_timer.expires = jiffies + (HZ*ifxusb_pcd.autoprobe_sec);
2310 add_timer(&ifxusb_pcd.device_autoprobe_timer);
2311 ifxusb_pcd.power_status = 2;
2312 }
2313 else if(value==1)
2314 {
2315 do_suspend_d(&ifxusb_pcd.core_if);
2316 ifxusb_pcd.power_status = 1;
2317 del_timer(&ifxusb_pcd.device_autoprobe_timer);
2318 del_timer(&ifxusb_pcd.device_probe_timer);
2319 }
2320 else if(value==0)
2321 {
2322 do_resume_d(&ifxusb_pcd.core_if);
2323 ifxusb_pcd.power_status = 0;
2324 del_timer(&ifxusb_pcd.device_autoprobe_timer);
2325 del_timer(&ifxusb_pcd.device_probe_timer);
2326 }
2327 }
2328 static ssize_t procfs_suspend_device_store(struct file *file, const char *buffer, unsigned long count, void *data)
2329 {
2330 char buf[10];
2331 int i = 0;
2332 uint32_t value;
2333 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2334 return -EFAULT;
2335 value = simple_strtoul(buf, NULL, 10);
2336 suspend_device_store(value);
2337 return count;
2338 }
2339 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2340 static ssize_t sysfs_suspend_device_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2341 #else
2342 static ssize_t sysfs_suspend_device_store( struct device *_dev, const char *buffer, size_t count )
2343 #endif
2344 {
2345 char buf[10];
2346 int i = 0;
2347 uint32_t value;
2348 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2349 return -EFAULT;
2350 value = simple_strtoul(buf, NULL, 10);
2351 suspend_device_store(value);
2352 return count;
2353 }
2354 DEVICE_ATTR(suspend_device, S_IWUSR,NULL,sysfs_suspend_device_store);
2355 #endif
2356 /////////////////////////////////////////////////////////////////////////////////////////////////////
2357 #ifdef __IS_DEVICE__
2358 static ssize_t probe_device_show(char *buf)
2359 {
2360 if(ifxusb_pcd.power_status == 0)
2361 return sprintf (buf,"Device power status is ON\n");
2362 else if(ifxusb_pcd.power_status == 1)
2363 return sprintf (buf,"Device power status is Suspend\n");
2364 else
2365 return printk(buf,"Device power status is Auto-probing\n");
2366 }
2367 static void probe_device_store(uint32_t value)
2368 {
2369
2370 if(ifxusb_pcd.power_status == 1)
2371 {
2372 del_timer(&ifxusb_pcd.device_probe_timer);
2373 ifxusb_pcd.device_probe_timer.function = device_probe;
2374 ifxusb_pcd.device_probe_timer.expires = jiffies + (HZ*ifxusb_pcd.probe_sec);
2375 add_timer(&ifxusb_pcd.device_probe_timer);
2376 do_resume_d(&ifxusb_pcd.core_if);
2377 }
2378 }
2379 static ssize_t procfs_probe_device_store(struct file *file, const char *buffer, unsigned long count, void *data)
2380 {
2381 char buf[10];
2382 int i = 0;
2383 uint32_t value;
2384 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2385 return -EFAULT;
2386 value = simple_strtoul(buf, NULL, 10);
2387 probe_device_store(value);
2388 return count;
2389 }
2390 static ssize_t procfs_probe_device_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
2391 {
2392 return probe_device_show(buf);
2393 }
2394 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2395 static ssize_t sysfs_probe_device_show( struct device *_dev, struct device_attribute *attr,char *buf)
2396 #else
2397 static ssize_t sysfs_probe_device_show( struct device *_dev, char *buf)
2398 #endif
2399 {
2400 return probe_device_show(buf);
2401 }
2402 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2403 static ssize_t sysfs_probe_device_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2404 #else
2405 static ssize_t sysfs_probe_device_store( struct device *_dev, const char *buffer, size_t count )
2406 #endif
2407 {
2408 char buf[10];
2409 int i = 0;
2410 uint32_t value;
2411 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2412 return -EFAULT;
2413 value = simple_strtoul(buf, NULL, 10);
2414 probe_device_store(value);
2415 return count;
2416 }
2417 DEVICE_ATTR(probe_device, S_IRUGO|S_IWUSR, sysfs_probe_device_show, sysfs_probe_device_store);
2418 #endif
2419 /////////////////////////////////////////////////////////////////////////////////////////////////////
2420 /////////////////////////////////////////////////////////////////////////////////////////////////////
2421 #ifdef __IS_HOST__
2422 #ifdef __IS_DUAL__
2423 static ssize_t autoprobe_timer2_val_show(char *buf)
2424 {
2425 return sprintf (buf,"Host 2 auto-probe timer is %d second\n",ifxusb_hcd_2.autoprobe_sec);
2426 }
2427 static ssize_t procfs_autoprobe_timer2_val_store(struct file *file, const char *buffer, unsigned long count, void *data)
2428 {
2429 char buf[10];
2430 int i = 0;
2431 uint32_t value;
2432 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2433 return -EFAULT;
2434 value = simple_strtoul(buf, NULL, 10);
2435 if((value > 0)&&(value < 300))
2436 ifxusb_hcd_2.autoprobe_sec = value;
2437 return count;
2438 }
2439 static ssize_t procfs_autoprobe_timer2_val_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
2440 {
2441 return autoprobe_timer2_val_show(buf);
2442 }
2443 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2444 static ssize_t sysfs_autoprobe_timer2_val_show( struct device *_dev, struct device_attribute *attr,char *buf)
2445 #else
2446 static ssize_t sysfs_autoprobe_timer2_val_show( struct device *_dev, char *buf)
2447 #endif
2448 {
2449 return autoprobe_timer2_val_show(buf);
2450 }
2451 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2452 static ssize_t sysfs_autoprobe_timer2_val_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2453 #else
2454 static ssize_t sysfs_autoprobe_timer2_val_store( struct device *_dev, const char *buffer, size_t count )
2455 #endif
2456 {
2457 char buf[10];
2458 int i = 0;
2459 uint32_t value;
2460 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2461 return -EFAULT;
2462 value = simple_strtoul(buf, NULL, 10);
2463 if((value > 0)&&(value < 300))
2464 ifxusb_hcd_2.autoprobe_sec = value;
2465 return count;
2466 }
2467
2468 static ssize_t autoprobe_timer1_val_show(char *buf)
2469 {
2470 return sprintf (buf,"Host 1 auto-probe timer is %d second\n",ifxusb_hcd_1.autoprobe_sec);
2471 }
2472 static ssize_t procfs_autoprobe_timer1_val_store(struct file *file, const char *buffer, unsigned long count, void *data)
2473 {
2474 char buf[10];
2475 int i = 0;
2476 uint32_t value;
2477 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2478 return -EFAULT;
2479 value = simple_strtoul(buf, NULL, 10);
2480 if((value > 0)&&(value < 300))
2481 ifxusb_hcd_1.autoprobe_sec = value;
2482 return count;
2483 }
2484 static ssize_t procfs_autoprobe_timer1_val_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
2485 {
2486 return autoprobe_timer1_val_show(buf);
2487 }
2488 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2489 static ssize_t sysfs_autoprobe_timer1_val_show( struct device *_dev, struct device_attribute *attr,char *buf)
2490 #else
2491 static ssize_t sysfs_autoprobe_timer1_val_show( struct device *_dev, char *buf)
2492 #endif
2493 {
2494 return autoprobe_timer1_val_show(buf);
2495 }
2496 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2497 static ssize_t sysfs_autoprobe_timer1_val_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2498 #else
2499 static ssize_t sysfs_autoautoprobe_timer1_val_store( struct device *_dev, const char *buffer, size_t count )
2500 #endif
2501 {
2502 char buf[10];
2503 int i = 0;
2504 uint32_t value;
2505 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2506 return -EFAULT;
2507 value = simple_strtoul(buf, NULL, 10);
2508 if((value > 0)&&(value < 300))
2509 ifxusb_hcd_1.autoprobe_sec = value;
2510 return count;
2511 }
2512
2513 static ssize_t probe_timer2_val_show(char *buf)
2514 {
2515 return sprintf (buf,"Host 2 probe timer is %d second\n",ifxusb_hcd_2.probe_sec);
2516 }
2517 static ssize_t procfs_probe_timer2_val_store(struct file *file, const char *buffer, unsigned long count, void *data)
2518 {
2519 char buf[10];
2520 int i = 0;
2521 uint32_t value;
2522 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2523 return -EFAULT;
2524 value = simple_strtoul(buf, NULL, 10);
2525 if((value > 0)&&(value < 10))
2526 ifxusb_hcd_2.probe_sec = value;
2527 return count;
2528 }
2529 static ssize_t procfs_probe_timer2_val_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
2530 {
2531 return probe_timer2_val_show(buf);
2532 }
2533 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2534 static ssize_t sysfs_probe_timer2_val_show( struct device *_dev, struct device_attribute *attr,char *buf)
2535 #else
2536 static ssize_t sysfs_probe_timer2_val_show( struct device *_dev, char *buf)
2537 #endif
2538 {
2539 return probe_timer2_val_show(buf);
2540 }
2541 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2542 static ssize_t sysfs_probe_timer2_val_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2543 #else
2544 static ssize_t sysfs_probe_timer2_val_store( struct device *_dev, const char *buffer, size_t count )
2545 #endif
2546 {
2547 char buf[10];
2548 int i = 0;
2549 uint32_t value;
2550 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2551 return -EFAULT;
2552 value = simple_strtoul(buf, NULL, 10);
2553 if((value > 0)&&(value < 10))
2554 ifxusb_hcd_2.probe_sec = value;
2555 return count;
2556 }
2557
2558 static ssize_t probe_timer1_val_show(char *buf)
2559 {
2560 return sprintf (buf,"Host 1 probe timer is %d second\n",ifxusb_hcd_1.probe_sec);
2561 }
2562 static ssize_t procfs_probe_timer1_val_store(struct file *file, const char *buffer, unsigned long count, void *data)
2563 {
2564 char buf[10];
2565 int i = 0;
2566 uint32_t value;
2567 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2568 return -EFAULT;
2569 value = simple_strtoul(buf, NULL, 10);
2570 if((value > 0)&&(value < 10))
2571 ifxusb_hcd_1.probe_sec = value;
2572 return count;
2573 }
2574 static ssize_t procfs_probe_timer1_val_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
2575 {
2576 return probe_timer1_val_show(buf);
2577 }
2578 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2579 static ssize_t sysfs_probe_timer1_val_show( struct device *_dev, struct device_attribute *attr,char *buf)
2580 #else
2581 static ssize_t sysfs_probe_timer1_val_show( struct device *_dev, char *buf)
2582 #endif
2583 {
2584 return probe_timer1_val_show(buf);
2585 }
2586 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2587 static ssize_t sysfs_probe_timer1_val_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2588 #else
2589 static ssize_t sysfs_probe_timer1_val_store( struct device *_dev, const char *buffer, size_t count )
2590 #endif
2591 {
2592 char buf[10];
2593 int i = 0;
2594 uint32_t value;
2595 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2596 return -EFAULT;
2597 value = simple_strtoul(buf, NULL, 10);
2598 if((value > 0)&&(value < 10))
2599 ifxusb_hcd_1.probe_sec = value;
2600 return count;
2601 }
2602 DEVICE_ATTR(probe_timer1_val_h, S_IRUGO|S_IWUSR, sysfs_probe_timer1_val_show, sysfs_probe_timer1_val_store);
2603 DEVICE_ATTR(probe_timer2_val_h, S_IRUGO|S_IWUSR, sysfs_probe_timer2_val_show, sysfs_probe_timer2_val_store);
2604 DEVICE_ATTR(autoprobe_timer1_val_h, S_IRUGO|S_IWUSR, sysfs_autoprobe_timer1_val_show, sysfs_autoprobe_timer1_val_store);
2605 DEVICE_ATTR(autoprobe_timer2_val_h, S_IRUGO|S_IWUSR, sysfs_autoprobe_timer2_val_show, sysfs_autoprobe_timer2_val_store);
2606 #else
2607 static ssize_t autoprobe_timer_val_show(char *buf)
2608 {
2609 return sprintf (buf,"Host auto-probe timer is %d second\n",ifxusb_hcd.autoprobe_sec);
2610 }
2611 static ssize_t procfs_autoprobe_timer_val_store(struct file *file, const char *buffer, unsigned long count, void *data)
2612 {
2613 char buf[10];
2614 int i = 0;
2615 uint32_t value;
2616 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2617 return -EFAULT;
2618 value = simple_strtoul(buf, NULL, 10);
2619 if((value > 0)&&(value < 300))
2620 ifxusb_hcd.autoprobe_sec = value;
2621 return count;
2622 }
2623 static ssize_t procfs_autoprobe_timer_val_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
2624 {
2625 return autoprobe_timer_val_show(buf);
2626 }
2627 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2628 static ssize_t sysfs_autoprobe_timer_val_show( struct device *_dev, struct device_attribute *attr,char *buf)
2629 #else
2630 static ssize_t sysfs_autoprobe_timer_val_show( struct device *_dev, char *buf)
2631 #endif
2632 {
2633 return autoprobe_timer_val_show(buf);
2634 }
2635 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2636 static ssize_t sysfs_autoprobe_timer_val_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2637 #else
2638 static ssize_t sysfs_autoautoprobe_timer_val_store( struct device *_dev, const char *buffer, size_t count )
2639 #endif
2640 {
2641 char buf[10];
2642 int i = 0;
2643 uint32_t value;
2644 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2645 return -EFAULT;
2646 value = simple_strtoul(buf, NULL, 10);
2647 if((value > 0)&&(value < 300))
2648 ifxusb_hcd.autoprobe_sec = value;
2649 return count;
2650 }
2651 static ssize_t probe_timer_val_show(char *buf)
2652 {
2653 return sprintf (buf,"Host probe timer is %d second\n",ifxusb_hcd.probe_sec);
2654 }
2655 static ssize_t procfs_probe_timer_val_store(struct file *file, const char *buffer, unsigned long count, void *data)
2656 {
2657 char buf[10];
2658 int i = 0;
2659 uint32_t value;
2660 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2661 return -EFAULT;
2662 value = simple_strtoul(buf, NULL, 10);
2663 if((value > 0)&&(value < 10))
2664 ifxusb_hcd.probe_sec = value;
2665 return count;
2666 }
2667 static ssize_t procfs_probe_timer_val_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
2668 {
2669 return probe_timer_val_show(buf);
2670 }
2671 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2672 static ssize_t sysfs_probe_timer_val_show( struct device *_dev, struct device_attribute *attr,char *buf)
2673 #else
2674 static ssize_t sysfs_probe_timer_val_show( struct device *_dev, char *buf)
2675 #endif
2676 {
2677 return probe_timer_val_show(buf);
2678 }
2679 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2680 static ssize_t sysfs_probe_timer_val_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2681 #else
2682 static ssize_t sysfs_probe_timer_val_store( struct device *_dev, const char *buffer, size_t count )
2683 #endif
2684 {
2685 char buf[10];
2686 int i = 0;
2687 uint32_t value;
2688 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2689 return -EFAULT;
2690 value = simple_strtoul(buf, NULL, 10);
2691 if((value > 0)&&(value < 10))
2692 ifxusb_hcd.probe_sec = value;
2693 return count;
2694 }
2695 DEVICE_ATTR(probe_timer_val_h, S_IRUGO|S_IWUSR, sysfs_probe_timer_val_show, sysfs_probe_timer_val_store);
2696 DEVICE_ATTR(autoprobe_timer_val_h, S_IRUGO|S_IWUSR, sysfs_autoprobe_timer_val_show, sysfs_autoprobe_timer_val_store);
2697 #endif
2698 #endif
2699 /////////////////////////////////////////////////////////////////////////////////////////////////////
2700 /////////////////////////////////////////////////////////////////////////////////////////////////////
2701 #ifdef __IS_DEVICE__
2702 static ssize_t autoprobe_timer_val_show(char *buf)
2703 {
2704 return sprintf (buf,"Device auto-probe timer is %d second\n",ifxusb_pcd.autoprobe_sec);
2705 }
2706 static ssize_t procfs_autoprobe_timer_val_store(struct file *file, const char *buffer, unsigned long count, void *data)
2707 {
2708 char buf[10];
2709 int i = 0;
2710 uint32_t value;
2711 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2712 return -EFAULT;
2713 value = simple_strtoul(buf, NULL, 10);
2714 if((value > 0)&&(value < 300))
2715 ifxusb_pcd.autoprobe_sec = value;
2716 return count;
2717 }
2718 static ssize_t procfs_autoprobe_timer_val_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
2719 {
2720 return autoprobe_timer_val_show(buf);
2721 }
2722 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2723 static ssize_t sysfs_autoprobe_timer_val_show( struct device *_dev, struct device_attribute *attr,char *buf)
2724 #else
2725 static ssize_t sysfs_autoprobe_timer_val_show( struct device *_dev, char *buf)
2726 #endif
2727 {
2728 return autoprobe_timer_val_show(buf);
2729 }
2730 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2731 static ssize_t sysfs_autoprobe_timer_val_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2732 #else
2733 static ssize_t sysfs_autoautoprobe_timer_val_store( struct device *_dev, const char *buffer, size_t count )
2734 #endif
2735 {
2736 char buf[10];
2737 int i = 0;
2738 uint32_t value;
2739 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2740 return -EFAULT;
2741 value = simple_strtoul(buf, NULL, 10);
2742 if((value > 0)&&(value < 300))
2743 ifxusb_pcd.autoprobe_sec = value;
2744 return count;
2745 }
2746 static ssize_t probe_timer_val_show(char *buf)
2747 {
2748 return sprintf (buf,"Device probe timer is %d second\n",ifxusb_pcd.probe_sec);
2749 }
2750 static ssize_t procfs_probe_timer_val_store(struct file *file, const char *buffer, unsigned long count, void *data)
2751 {
2752 char buf[10];
2753 int i = 0;
2754 uint32_t value;
2755 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2756 return -EFAULT;
2757 value = simple_strtoul(buf, NULL, 10);
2758 if((value > 0)&&(value < 10))
2759 ifxusb_pcd.probe_sec = value;
2760 return count;
2761 }
2762 static ssize_t procfs_probe_timer_val_show(char *buf, char **start, off_t offset, int count, int *eof, void *data)
2763 {
2764 return probe_timer_val_show(buf);
2765 }
2766 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2767 static ssize_t sysfs_probe_timer_val_show( struct device *_dev, struct device_attribute *attr,char *buf)
2768 #else
2769 static ssize_t sysfs_probe_timer_val_show( struct device *_dev, char *buf)
2770 #endif
2771 {
2772 return probe_timer_val_show(buf);
2773 }
2774 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)
2775 static ssize_t sysfs_probe_timer_val_store( struct device *_dev, struct device_attribute *attr,const char *buffer, size_t count )
2776 #else
2777 static ssize_t sysfs_probe_timer_val_store( struct device *_dev, const char *buffer, size_t count )
2778 #endif
2779 {
2780 char buf[10];
2781 int i = 0;
2782 uint32_t value;
2783 if (copy_from_user(buf, &buffer[i], sizeof("0xFFFFFFFF\n")+1))
2784 return -EFAULT;
2785 value = simple_strtoul(buf, NULL, 10);
2786 if((value > 0)&&(value < 10))
2787 ifxusb_pcd.probe_sec = value;
2788 return count;
2789 }
2790 DEVICE_ATTR(probe_timer_val_d, S_IRUGO|S_IWUSR, sysfs_probe_timer_val_show, sysfs_probe_timer_val_store);
2791 DEVICE_ATTR(autoprobe_timer_val_d, S_IRUGO|S_IWUSR, sysfs_autoprobe_timer_val_show, sysfs_autoprobe_timer_val_store);
2792 #endif
2793 //////////////////////////////////////////////////////////////////////////////////
2794 //////////////////////////////////////////////////////////////////////////////////
2795
2796 static int ifx_proc_addproc(char *funcname, read_proc_t *hookfuncr, write_proc_t *hookfuncw);
2797 static void ifx_proc_delproc(char *funcname);
2798
2799 //////////////////////////////////////////////////////////////////////////////////
2800
2801 #if defined(__IS_HOST__) && defined(__HOST_COC__)
2802 #ifdef __IS_DUAL__
2803 static IFX_PMCU_MODULE_DEP_t depListUSBHost_1=
2804 {
2805 1,
2806 {
2807 {IFX_PMCU_MODULE_CPU, IFX_PMCU_STATE_D0, IFX_PMCU_STATE_D0D3, IFX_PMCU_STATE_D0D3, IFX_PMCU_STATE_D0D3}
2808 }
2809 };
2810 static IFX_PMCU_MODULE_DEP_t depListUSBHost_2=
2811 {
2812 1,
2813 {
2814 {IFX_PMCU_MODULE_CPU, IFX_PMCU_STATE_D0, IFX_PMCU_STATE_D0D3, IFX_PMCU_STATE_D0D3, IFX_PMCU_STATE_D0D3}
2815 }
2816 };
2817 // This functions returns the current power state of the module
2818 static IFX_PMCU_RETURN_t
2819 ifx_usbhost_stateGet_1(IFX_PMCU_STATE_t *pmcuModState) {
2820 printk(KERN_DEBUG "ifx_usbhost_stateGet_1 is called\n");
2821 if(ifxusb_hcd_1.power_status == 0){
2822 printk(KERN_DEBUG "current power state of USB Host #1 is D0\n");
2823 *pmcuModState = IFX_PMCU_STATE_D0; // set here the right value
2824 }
2825 else if(ifxusb_hcd_1.power_status == 1){
2826 printk(KERN_DEBUG "current power state of USB Host #1 is D3 (Suspend)\n");
2827 *pmcuModState = IFX_PMCU_STATE_D3; // set here the right value
2828 }
2829 else if(ifxusb_hcd_1.power_status == 2){
2830 printk(KERN_DEBUG "current power state of USB Host #1 is D3 (Auto-Probing)\n");
2831 *pmcuModState = IFX_PMCU_STATE_D3; // set here the right value
2832 }
2833 else{
2834 printk(KERN_DEBUG "current power state of USB Host #1 is unknown (%d)\n",ifxusb_hcd_1.power_status);
2835 *pmcuModState = IFX_PMCU_STATE_INVALID; // must be set to INVALID
2836 }
2837 return IFX_PMCU_RETURN_SUCCESS;
2838 }
2839 static IFX_PMCU_RETURN_t
2840 ifx_usbhost_stateGet_2(IFX_PMCU_STATE_t *pmcuModState) {
2841 printk(KERN_DEBUG "ifx_usbhost_stateGet_2 is called\n");
2842 if(ifxusb_hcd_2.power_status == 0){
2843 printk(KERN_DEBUG "current power state of USB Host #2 is D0\n");
2844 *pmcuModState = IFX_PMCU_STATE_D0; // set here the right value
2845 }
2846 else if(ifxusb_hcd_2.power_status == 1){
2847 printk(KERN_DEBUG "current power state of USB Host #2 is D3 (Suspend)\n");
2848 *pmcuModState = IFX_PMCU_STATE_D3; // set here the right value
2849 }
2850 else if(ifxusb_hcd_2.power_status == 2){
2851 printk(KERN_DEBUG "current power state of USB Host #2 is D3 (Auto-Probing)\n");
2852 *pmcuModState = IFX_PMCU_STATE_D3; // set here the right value
2853 }
2854 else{
2855 printk(KERN_DEBUG "current power state of USB Host #2 is unknown (%d)\n",ifxusb_hcd_2.power_status);
2856 *pmcuModState = IFX_PMCU_STATE_INVALID; // must be set to INVALID
2857 }
2858 return IFX_PMCU_RETURN_SUCCESS;
2859 }
2860
2861
2862 // The function should be used to enable/disable the module specific power saving methods
2863 static IFX_PMCU_RETURN_t
2864 ifx_usbhost_pwrFeatureSwitch_1(IFX_PMCU_PWR_STATE_ENA_t pmcuPwrStateEna)
2865 {
2866 if (pmcuPwrStateEna == IFX_PMCU_PWR_STATE_ON) {
2867 suspend_host_store(&ifxusb_hcd_1, 0);
2868 return IFX_PMCU_RETURN_SUCCESS;
2869 }
2870 if (pmcuPwrStateEna == IFX_PMCU_PWR_STATE_OFF) {
2871 suspend_host_store(&ifxusb_hcd_1, 1);
2872 return IFX_PMCU_RETURN_SUCCESS;
2873 }
2874 return IFX_PMCU_RETURN_SUCCESS;
2875 }
2876 static IFX_PMCU_RETURN_t
2877 ifx_usbhost_pwrFeatureSwitch_2(IFX_PMCU_PWR_STATE_ENA_t pmcuPwrStateEna)
2878 {
2879 if (pmcuPwrStateEna == IFX_PMCU_PWR_STATE_ON) {
2880 suspend_host_store(&ifxusb_hcd_2, 0);
2881 return IFX_PMCU_RETURN_SUCCESS;
2882 }
2883 if (pmcuPwrStateEna == IFX_PMCU_PWR_STATE_OFF) {
2884 suspend_host_store(&ifxusb_hcd_2, 1);
2885 return IFX_PMCU_RETURN_SUCCESS;
2886 }
2887 return IFX_PMCU_RETURN_SUCCESS;
2888 }
2889
2890 // This function should be used to do all the necessary clean-up's before a the real
2891 // power state change is initiated; e.g. flush all serial buffers inside the UART before
2892 // the frequency will be changed.
2893 static IFX_PMCU_RETURN_t
2894 ifx_usbhost_preChange_1(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
2895 {
2896 printk(KERN_DEBUG "ifx_usbhost_preChange_1 is called\n");
2897 return IFX_PMCU_RETURN_SUCCESS;
2898 }
2899 static IFX_PMCU_RETURN_t
2900 ifx_usbhost_preChange_2(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
2901 {
2902 printk(KERN_DEBUG "ifx_usbhost_preChange_2 is called\n");
2903 return IFX_PMCU_RETURN_SUCCESS;
2904 }
2905
2906
2907 // This function initiate the real power state change. The module should do all the necessary
2908 // adpations to the new state.
2909 static IFX_PMCU_RETURN_t
2910 ifx_usbhost_stateChange_1(IFX_PMCU_STATE_t newState)
2911 {
2912 printk(KERN_DEBUG "ifx_usbhost_stateChange_1 is called\n");
2913 if (newState == IFX_PMCU_STATE_D0) {
2914 suspend_host_store(&ifxusb_hcd_1, 0);
2915 return IFX_PMCU_RETURN_SUCCESS;
2916 }
2917 if (newState == IFX_PMCU_STATE_D1) {
2918 suspend_host_store(&ifxusb_hcd_1, 1);
2919 return IFX_PMCU_RETURN_SUCCESS;
2920 }
2921 if (newState == IFX_PMCU_STATE_D2) {
2922 suspend_host_store(&ifxusb_hcd_1, 1);
2923 return IFX_PMCU_RETURN_SUCCESS;
2924 }
2925 if (newState == IFX_PMCU_STATE_D3) {
2926 suspend_host_store(&ifxusb_hcd_1, 1);
2927 return IFX_PMCU_RETURN_SUCCESS;
2928 }
2929 return IFX_PMCU_RETURN_SUCCESS;
2930 }
2931 static IFX_PMCU_RETURN_t
2932 ifx_usbhost_stateChange_2(IFX_PMCU_STATE_t newState)
2933 {
2934 printk(KERN_DEBUG "ifx_usbhost_stateChange_2 is called\n");
2935 if (newState == IFX_PMCU_STATE_D0) {
2936 suspend_host_store(&ifxusb_hcd_2, 0);
2937 return IFX_PMCU_RETURN_SUCCESS;
2938 }
2939 if (newState == IFX_PMCU_STATE_D1) {
2940 suspend_host_store(&ifxusb_hcd_2, 1);
2941 return IFX_PMCU_RETURN_SUCCESS;
2942 }
2943 if (newState == IFX_PMCU_STATE_D2) {
2944 suspend_host_store(&ifxusb_hcd_2, 1);
2945 return IFX_PMCU_RETURN_SUCCESS;
2946 }
2947 if (newState == IFX_PMCU_STATE_D3) {
2948 suspend_host_store(&ifxusb_hcd_2, 1);
2949 return IFX_PMCU_RETURN_SUCCESS;
2950 }
2951 return IFX_PMCU_RETURN_SUCCESS;
2952 }
2953
2954 // This function should be used to do all the necessary post processing after a the real
2955 // power state change was initiated.
2956 static IFX_PMCU_RETURN_t
2957 ifx_usbhost_postChange_1(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
2958 {
2959 printk(KERN_DEBUG "ifx_usbhost_postChange_1 is called\n");
2960 return IFX_PMCU_RETURN_SUCCESS;
2961 }
2962 static IFX_PMCU_RETURN_t
2963 ifx_usbhost_postChange_2(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
2964 {
2965 printk(KERN_DEBUG "ifx_usbhost_postChange_2 is called\n");
2966 return IFX_PMCU_RETURN_SUCCESS;
2967 }
2968 #else
2969 static IFX_PMCU_MODULE_DEP_t depListUSBHost=
2970 {
2971 1,
2972 {
2973 {IFX_PMCU_MODULE_CPU, IFX_PMCU_STATE_D0, IFX_PMCU_STATE_D0D3, IFX_PMCU_STATE_D0D3, IFX_PMCU_STATE_D0D3}
2974 }
2975 };
2976 // This functions returns the current power state of the module
2977 static IFX_PMCU_RETURN_t
2978 ifx_usbhost_stateGet(IFX_PMCU_STATE_t *pmcuModState) {
2979 printk(KERN_DEBUG "ifx_usbhost_stateGet is called\n");
2980 if(ifxusb_hcd.power_status == 0){
2981 printk(KERN_DEBUG "current power state of USB Host is D0\n");
2982 *pmcuModState = IFX_PMCU_STATE_D0; // set here the right value
2983 }
2984 else if(ifxusb_hcd.power_status == 1){
2985 printk(KERN_DEBUG "current power state of USB Host is D3 (Suspend)\n");
2986 *pmcuModState = IFX_PMCU_STATE_D3; // set here the right value
2987 }
2988 else if(ifxusb_hcd.power_status == 2){
2989 printk(KERN_DEBUG "current power state of USB Host is D3 (Auto-Probing)\n");
2990 *pmcuModState = IFX_PMCU_STATE_D3; // set here the right value
2991 }
2992 else{
2993 printk(KERN_DEBUG "current power state of USB Host is unknown (%d)\n",ifxusb_hcd.power_status);
2994 *pmcuModState = IFX_PMCU_STATE_INVALID; // must be set to INVALID
2995 }
2996 return IFX_PMCU_RETURN_SUCCESS;
2997 }
2998 // The function should be used to enable/disable the module specific power saving methods
2999 static IFX_PMCU_RETURN_t
3000 ifx_usbhost_pwrFeatureSwitch(IFX_PMCU_PWR_STATE_ENA_t pmcuPwrStateEna)
3001 {
3002 if (pmcuPwrStateEna == IFX_PMCU_PWR_STATE_ON) {
3003 suspend_host_store(&ifxusb_hcd, 0);
3004 return IFX_PMCU_RETURN_SUCCESS;
3005 }
3006 if (pmcuPwrStateEna == IFX_PMCU_PWR_STATE_OFF) {
3007 suspend_host_store(&ifxusb_hcd, 1);
3008 return IFX_PMCU_RETURN_SUCCESS;
3009 }
3010 return IFX_PMCU_RETURN_SUCCESS;
3011 }
3012
3013 // This function should be used to do all the necessary clean-up's before a the real
3014 // power state change is initiated; e.g. flush all serial buffers inside the UART before
3015 // the frequency will be changed.
3016 static IFX_PMCU_RETURN_t
3017 ifx_usbhost_preChange(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
3018 {
3019 printk(KERN_DEBUG "ifx_usbhost_preChange is called\n");
3020 return IFX_PMCU_RETURN_SUCCESS;
3021 }
3022
3023
3024 // This function initiate the real power state change. The module should do all the necessary
3025 // adpations to the new state.
3026 static IFX_PMCU_RETURN_t
3027 ifx_usbhost_stateChange(IFX_PMCU_STATE_t newState)
3028 {
3029 printk(KERN_DEBUG "ifx_usbhost_stateChange is called\n");
3030 if (newState == IFX_PMCU_STATE_D0) {
3031 suspend_host_store(&ifxusb_hcd, 0);
3032 return IFX_PMCU_RETURN_SUCCESS;
3033 }
3034 if (newState == IFX_PMCU_STATE_D1) {
3035 suspend_host_store(&ifxusb_hcd, 1);
3036 return IFX_PMCU_RETURN_SUCCESS;
3037 }
3038 if (newState == IFX_PMCU_STATE_D2) {
3039 suspend_host_store(&ifxusb_hcd, 1);
3040 return IFX_PMCU_RETURN_SUCCESS;
3041 }
3042 if (newState == IFX_PMCU_STATE_D3) {
3043 suspend_host_store(&ifxusb_hcd, 1);
3044 return IFX_PMCU_RETURN_SUCCESS;
3045 }
3046 return IFX_PMCU_RETURN_SUCCESS;
3047 }
3048
3049 // This function should be used to do all the necessary post processing after a the real
3050 // power state change was initiated.
3051 static IFX_PMCU_RETURN_t
3052 ifx_usbhost_postChange(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
3053 {
3054 printk(KERN_DEBUG "ifx_usbhost_postChange is called\n");
3055 return IFX_PMCU_RETURN_SUCCESS;
3056 }
3057 #endif
3058 #endif
3059 #if defined(__IS_DEVICE__) && defined(__GADGET_COC__)
3060 static IFX_PMCU_MODULE_DEP_t depListUSBGadget=
3061 {
3062 1,
3063 {
3064 {IFX_PMCU_MODULE_CPU, IFX_PMCU_STATE_D0, IFX_PMCU_STATE_D0D3, IFX_PMCU_STATE_D0D3, IFX_PMCU_STATE_D0D3}
3065 }
3066 };
3067 // This functions returns the current power state of the module
3068 static IFX_PMCU_RETURN_t
3069 ifx_usbgadget_stateGet(IFX_PMCU_STATE_t *pmcuModState) {
3070 printk(KERN_DEBUG "ifx_usbgadget_stateGet is called\n");
3071 if(ifxusb_pcd.power_status == 0){
3072 printk(KERN_DEBUG "current power state of USB Gadget is D0\n");
3073 *pmcuModState = IFX_PMCU_STATE_D0; // set here the right value
3074 }
3075 else if(ifxusb_pcd.power_status == 1){
3076 printk(KERN_DEBUG "current power state of USB Gadget is D3 (Suspend)\n");
3077 *pmcuModState = IFX_PMCU_STATE_D3; // set here the right value
3078 }
3079 else if(ifxusb_pcd.power_status == 2){
3080 printk(KERN_DEBUG "current power state of USB Gadget is D3 (Auto-Probing)\n");
3081 *pmcuModState = IFX_PMCU_STATE_D3; // set here the right value
3082 }
3083 else{
3084 printk(KERN_DEBUG "current power state of USB Gadget is unknown (%d)\n",ifxusb_pcd.power_status);
3085 *pmcuModState = IFX_PMCU_STATE_INVALID; // must be set to INVALID
3086 }
3087 return IFX_PMCU_RETURN_SUCCESS;
3088 }
3089 // The function should be used to enable/disable the module specific power saving methods
3090 static IFX_PMCU_RETURN_t
3091 ifx_usbgadget_pwrFeatureSwitch(IFX_PMCU_PWR_STATE_ENA_t pmcuPwrStateEna)
3092 {
3093 if (pmcuPwrStateEna == IFX_PMCU_PWR_STATE_ON) {
3094 suspend_device_store(0);
3095 return IFX_PMCU_RETURN_SUCCESS;
3096 }
3097 if (pmcuPwrStateEna == IFX_PMCU_PWR_STATE_OFF) {
3098 suspend_device_store(1);
3099 return IFX_PMCU_RETURN_SUCCESS;
3100 }
3101 return IFX_PMCU_RETURN_SUCCESS;
3102 }
3103
3104 // This function should be used to do all the necessary clean-up's before a the real
3105 // power state change is initiated; e.g. flush all serial buffers inside the UART before
3106 // the frequency will be changed.
3107 static IFX_PMCU_RETURN_t
3108 ifx_usbgadget_preChange(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
3109 {
3110 printk(KERN_DEBUG "ifx_usbgadget_preChange is called\n");
3111 return IFX_PMCU_RETURN_SUCCESS;
3112 }
3113
3114
3115 // This function initiate the real power state change. The module should do all the necessary
3116 // adpations to the new state.
3117 static IFX_PMCU_RETURN_t
3118 ifx_usbgadget_stateChange(IFX_PMCU_STATE_t newState)
3119 {
3120 printk(KERN_DEBUG "ifx_usbgadget_stateChange is called\n");
3121 if (newState == IFX_PMCU_STATE_D0) {
3122 suspend_device_store(0);
3123 return IFX_PMCU_RETURN_SUCCESS;
3124 }
3125 if (newState == IFX_PMCU_STATE_D1) {
3126 suspend_device_store(1);
3127 return IFX_PMCU_RETURN_SUCCESS;
3128 }
3129 if (newState == IFX_PMCU_STATE_D2) {
3130 suspend_device_store(1);
3131 return IFX_PMCU_RETURN_SUCCESS;
3132 }
3133 if (newState == IFX_PMCU_STATE_D3) {
3134 suspend_device_store(1);
3135 return IFX_PMCU_RETURN_SUCCESS;
3136 }
3137 return IFX_PMCU_RETURN_SUCCESS;
3138 }
3139
3140 // This function should be used to do all the necessary post processing after a the real
3141 // power state change was initiated.
3142 static IFX_PMCU_RETURN_t
3143 ifx_usbgadget_postChange(IFX_PMCU_MODULE_t pmcuModule, IFX_PMCU_STATE_t newState, IFX_PMCU_STATE_t oldState)
3144 {
3145 printk(KERN_DEBUG "ifx_usbgadget_postChange is called\n");
3146 return IFX_PMCU_RETURN_SUCCESS;
3147 }
3148 #endif
3149
3150
3151 /*!
3152 \brief This function create the sysfs and procfs entries
3153 \param[in] _dev Pointer of device structure, if applied
3154 */
3155 #ifdef __IS_HOST__
3156 void ifxusb_attr_create_h (void *_dev)
3157 #else
3158 void ifxusb_attr_create_d (void *_dev)
3159 #endif
3160 {
3161 int error;
3162
3163 struct device *dev = (struct device *) _dev;
3164
3165 IFX_DEBUGPL(DBG_ENTRY, "%s() %d\n", __func__, __LINE__ );
3166
3167 error = ifx_proc_addproc("dbglevel", procfs_dbglevel_show, procfs_dbglevel_store);
3168 #ifdef __IS_HOST__
3169 error = device_create_file(dev, &dev_attr_dbglevel_h);
3170 #else
3171 error = device_create_file(dev, &dev_attr_dbglevel_d);
3172 #endif
3173
3174 #ifdef __IS_HOST__
3175 #ifdef __IS_DUAL__
3176 error = ifx_proc_addproc("dump_params_1", procfs_dump_params_show_1, NULL);
3177 error = ifx_proc_addproc("dump_params_2", procfs_dump_params_show_2, NULL);
3178 error = device_create_file(dev, &dev_attr_dump_params_h_1);
3179 error = device_create_file(dev, &dev_attr_dump_params_h_2);
3180
3181 error = ifx_proc_addproc("mode_1", procfs_mode_show_1, NULL);
3182 error = ifx_proc_addproc("mode_2", procfs_mode_show_2, NULL);
3183 error = device_create_file(dev, &dev_attr_mode_h_1);
3184 error = device_create_file(dev, &dev_attr_mode_h_2);
3185 #else
3186 error = ifx_proc_addproc("dump_params", procfs_dump_params_show, NULL);
3187 error = device_create_file(dev, &dev_attr_dump_params_h);
3188 error = ifx_proc_addproc("mode", procfs_mode_show, NULL);
3189 error = device_create_file(dev, &dev_attr_mode_h);
3190 #endif
3191 #else
3192 error = ifx_proc_addproc("dump_params", procfs_dump_params_show, NULL);
3193 error = device_create_file(dev, &dev_attr_dump_params_d);
3194
3195 error = ifx_proc_addproc("mode", procfs_mode_show, NULL);
3196 error = device_create_file(dev, &dev_attr_mode_d);
3197 #endif
3198
3199 #ifdef __IS_HOST__
3200 error = ifx_proc_addproc("version", procfs_version_show, NULL);
3201 error = device_create_file(dev, &dev_attr_version_h);
3202 #else
3203 error = ifx_proc_addproc("version", procfs_version_show, NULL);
3204 error = device_create_file(dev, &dev_attr_version_d);
3205 #endif
3206
3207
3208 #ifdef __IS_HOST__
3209 #ifdef __IS_DUAL__
3210 error = ifx_proc_addproc("pkt_count_limit_bi_1", procfs_pkt_count_limit_bi_show_1, procfs_pkt_count_limit_bi_store_1);
3211 error = ifx_proc_addproc("pkt_count_limit_bo_1", procfs_pkt_count_limit_bo_show_1, procfs_pkt_count_limit_bo_store_1);
3212 error = ifx_proc_addproc("pkt_count_limit_bi_2", procfs_pkt_count_limit_bi_show_2, procfs_pkt_count_limit_bi_store_2);
3213 error = ifx_proc_addproc("pkt_count_limit_bo_2", procfs_pkt_count_limit_bo_show_2, procfs_pkt_count_limit_bo_store_2);
3214 error = ifx_proc_addproc("bandwidth_hs_1", procfs_bandwidth_hs_show_1, procfs_bandwidth_hs_store_1);
3215 error = ifx_proc_addproc("bandwidth_fs_1", procfs_bandwidth_fs_show_1, procfs_bandwidth_fs_store_1);
3216 error = ifx_proc_addproc("bandwidth_ls_1", procfs_bandwidth_ls_show_1, procfs_bandwidth_ls_store_1);
3217 error = ifx_proc_addproc("bandwidth_hs_2", procfs_bandwidth_hs_show_2, procfs_bandwidth_hs_store_2);
3218 error = ifx_proc_addproc("bandwidth_fs_2", procfs_bandwidth_fs_show_2, procfs_bandwidth_fs_store_2);
3219 error = ifx_proc_addproc("bandwidth_ls_2", procfs_bandwidth_ls_show_2, procfs_bandwidth_ls_store_2);
3220 error = device_create_file(dev, &dev_attr_pkt_count_limit_bi_1);
3221 error = device_create_file(dev, &dev_attr_pkt_count_limit_bo_1);
3222 error = device_create_file(dev, &dev_attr_pkt_count_limit_bi_2);
3223 error = device_create_file(dev, &dev_attr_pkt_count_limit_bo_2);
3224 error = device_create_file(dev, &dev_attr_bandwidth_hs_1);
3225 error = device_create_file(dev, &dev_attr_bandwidth_fs_1);
3226 error = device_create_file(dev, &dev_attr_bandwidth_ls_1);
3227 error = device_create_file(dev, &dev_attr_bandwidth_hs_2);
3228 error = device_create_file(dev, &dev_attr_bandwidth_fs_2);
3229 error = device_create_file(dev, &dev_attr_bandwidth_ls_2);
3230 #else
3231 error = ifx_proc_addproc("pkt_count_limit_bi", procfs_pkt_count_limit_bi_show, procfs_pkt_count_limit_bi_store);
3232 error = ifx_proc_addproc("pkt_count_limit_bo", procfs_pkt_count_limit_bo_show, procfs_pkt_count_limit_bo_store);
3233 error = ifx_proc_addproc("bandwidth_hs", procfs_bandwidth_hs_show, procfs_bandwidth_hs_store);
3234 error = ifx_proc_addproc("bandwidth_fs", procfs_bandwidth_fs_show, procfs_bandwidth_fs_store);
3235 error = ifx_proc_addproc("bandwidth_ls", procfs_bandwidth_ls_show, procfs_bandwidth_ls_store);
3236 error = device_create_file(dev, &dev_attr_pkt_count_limit_bi);
3237 error = device_create_file(dev, &dev_attr_pkt_count_limit_bo);
3238 error = device_create_file(dev, &dev_attr_bandwidth_hs);
3239 error = device_create_file(dev, &dev_attr_bandwidth_fs);
3240 error = device_create_file(dev, &dev_attr_bandwidth_ls);
3241 #endif
3242
3243 #ifdef __IS_DUAL__
3244 error = ifx_proc_addproc("buspower_1", procfs_buspower_show_1, procfs_buspower_store_1);
3245 error = ifx_proc_addproc("buspower_2", procfs_buspower_show_2, procfs_buspower_store_2);
3246 error = device_create_file(dev, &dev_attr_buspower_1);
3247 error = device_create_file(dev, &dev_attr_buspower_2);
3248 #else
3249 error = ifx_proc_addproc("buspower", procfs_buspower_show, procfs_buspower_store);
3250 error = device_create_file(dev, &dev_attr_buspower);
3251 #endif
3252
3253 #ifdef __IS_DUAL__
3254 error = ifx_proc_addproc("bussuspend_1", procfs_bussuspend_show_1, NULL);
3255 error = ifx_proc_addproc("bussuspend_2", procfs_bussuspend_show_2, NULL);
3256 error = device_create_file(dev, &dev_attr_bussuspend_1);
3257 error = device_create_file(dev, &dev_attr_bussuspend_2);
3258 #else
3259 error = ifx_proc_addproc("bussuspend", procfs_bussuspend_show, NULL);
3260 error = device_create_file(dev, &dev_attr_bussuspend);
3261 #endif
3262
3263 #ifdef __IS_DUAL__
3264 error = ifx_proc_addproc("busconnected_1", procfs_busconnected_show_1, NULL);
3265 error = ifx_proc_addproc("busconnected_2", procfs_busconnected_show_2, NULL);
3266 error = device_create_file(dev, &dev_attr_busconnected_1);
3267 error = device_create_file(dev, &dev_attr_busconnected_2);
3268 #else
3269 error = ifx_proc_addproc("busconnected", procfs_busconnected_show, NULL);
3270 error = device_create_file(dev, &dev_attr_busconnected);
3271 #endif
3272
3273 #ifdef __IS_DUAL__
3274 error = ifx_proc_addproc("connectspeed_1", procfs_connectspeed_show_1, NULL);
3275 error = ifx_proc_addproc("connectspeed_2", procfs_connectspeed_show_2, NULL);
3276 error = device_create_file(dev, &dev_attr_connectspeed_1);
3277 error = device_create_file(dev, &dev_attr_connectspeed_2);
3278 #else
3279 error = ifx_proc_addproc("connectspeed", procfs_connectspeed_show, NULL);
3280 error = device_create_file(dev, &dev_attr_connectspeed);
3281 #endif
3282 #endif
3283
3284 #ifdef __IS_DEVICE__
3285 error = ifx_proc_addproc("devspeed", procfs_devspeed_show, NULL);
3286 error = device_create_file(dev, &dev_attr_devspeed);
3287 error = ifx_proc_addproc("enumspeed", procfs_enumspeed_show, NULL);
3288 error = device_create_file(dev, &dev_attr_enumspeed);
3289 #endif
3290
3291 //////////////////////////////////////////////////////
3292 #ifdef __ENABLE_DUMP__
3293
3294 #ifdef __IS_HOST__
3295 #ifdef __IS_DUAL__
3296 error = ifx_proc_addproc("dump_reg_1", procfs_dump_reg_show_1, NULL);
3297 error = ifx_proc_addproc("dump_reg_2", procfs_dump_reg_show_2, NULL);
3298 error = device_create_file(dev, &dev_attr_dump_reg_h_1);
3299 error = device_create_file(dev, &dev_attr_dump_reg_h_2);
3300 #else
3301 error = ifx_proc_addproc("dump_reg", procfs_dump_reg_show, NULL);
3302 error = device_create_file(dev, &dev_attr_dump_reg_h);
3303 #endif
3304
3305 #ifdef __IS_DUAL__
3306 error = ifx_proc_addproc("dump_spram_1", procfs_dump_spram_show_1, NULL);
3307 error = ifx_proc_addproc("dump_spram_2", procfs_dump_spram_show_2, NULL);
3308 error = device_create_file(dev, &dev_attr_dump_spram_h_1);
3309 error = device_create_file(dev, &dev_attr_dump_spram_h_2);
3310 #else
3311 error = ifx_proc_addproc("dump_spram", procfs_dump_spram_show, NULL);
3312 error = device_create_file(dev, &dev_attr_dump_spram_h);
3313 #endif
3314
3315 #ifdef __IS_DUAL__
3316 error = ifx_proc_addproc("dump_host_state_1", procfs_dump_host_state_show_1, NULL);
3317 error = ifx_proc_addproc("dump_host_state_2", procfs_dump_host_state_show_2, NULL);
3318 error = device_create_file(dev, &dev_attr_dump_host_state_1);
3319 error = device_create_file(dev, &dev_attr_dump_host_state_2);
3320 #else
3321 error = ifx_proc_addproc("dump_host_state", procfs_dump_host_state_show, NULL);
3322 error = device_create_file(dev, &dev_attr_dump_host_state);
3323 #endif
3324 #else
3325 error = ifx_proc_addproc("dump_reg", procfs_dump_reg_show, NULL);
3326 error = device_create_file(dev, &dev_attr_dump_reg_d);
3327 error = ifx_proc_addproc("dump_spram", procfs_dump_spram_show, NULL);
3328 error = device_create_file(dev, &dev_attr_dump_spram_d);
3329 #endif
3330 #endif //__ENABLE_DUMP__
3331 //////////////////////////////////////////////////////
3332 #ifdef __IS_HOST__
3333 #ifdef __IS_DUAL__
3334 error = ifx_proc_addproc("suspend_host_1",NULL, procfs_suspend_host_1_store);
3335 error = device_create_file(dev, &dev_attr_suspend_host_1);
3336
3337 error = ifx_proc_addproc("probe_host_1", procfs_probe_host_1_show, procfs_probe_host_1_store);
3338 error = device_create_file(dev, &dev_attr_probe_host_1);
3339
3340 error = ifx_proc_addproc("suspend_host_2",NULL, procfs_suspend_host_2_store);
3341 error = device_create_file(dev, &dev_attr_suspend_host_2);
3342
3343 error = ifx_proc_addproc("probe_host_2", procfs_probe_host_2_show, procfs_probe_host_2_store);
3344 error = device_create_file(dev, &dev_attr_probe_host_2);
3345
3346 error = ifx_proc_addproc("probe_timer1", procfs_probe_timer1_val_show, procfs_probe_timer1_val_store);
3347 error = device_create_file(dev, &dev_attr_probe_timer1_val_h);
3348
3349 error = ifx_proc_addproc("probe_timer2", procfs_probe_timer2_val_show, procfs_probe_timer2_val_store);
3350 error = device_create_file(dev, &dev_attr_probe_timer2_val_h);
3351
3352 error = ifx_proc_addproc("autoprobe_timer1", procfs_autoprobe_timer1_val_show, procfs_autoprobe_timer1_val_store);
3353 error = device_create_file(dev, &dev_attr_autoprobe_timer1_val_h);
3354
3355 error = ifx_proc_addproc("autoprobe_timer2", procfs_autoprobe_timer2_val_show, procfs_autoprobe_timer2_val_store);
3356 error = device_create_file(dev, &dev_attr_autoprobe_timer2_val_h);
3357 #else
3358 error = ifx_proc_addproc("suspend_host",NULL, procfs_suspend_host_store);
3359 error = device_create_file(dev, &dev_attr_suspend_host);
3360
3361 error = ifx_proc_addproc("probe_host", procfs_probe_host_show, procfs_probe_host_store);
3362 error = device_create_file(dev, &dev_attr_probe_host);
3363
3364 error = ifx_proc_addproc("probe_timer", procfs_probe_timer_val_show, procfs_probe_timer_val_store);
3365 error = device_create_file(dev, &dev_attr_probe_timer_val_h);
3366
3367 error = ifx_proc_addproc("autoprobe_timer", procfs_autoprobe_timer_val_show, procfs_autoprobe_timer_val_store);
3368 error = device_create_file(dev, &dev_attr_autoprobe_timer_val_h);
3369 #endif
3370 #endif
3371
3372 #ifdef __IS_DEVICE__
3373 error = ifx_proc_addproc("suspend_device",NULL, procfs_suspend_device_store);
3374 error = device_create_file(dev, &dev_attr_suspend_device);
3375
3376 error = ifx_proc_addproc("probe_device", procfs_probe_device_show, procfs_probe_device_store);
3377 error = device_create_file(dev, &dev_attr_probe_device);
3378
3379 error = ifx_proc_addproc("probe_timer", procfs_probe_timer_val_show, procfs_probe_timer_val_store);
3380 error = device_create_file(dev, &dev_attr_probe_timer_val_d);
3381
3382 error = ifx_proc_addproc("autoprobe_timer", procfs_autoprobe_timer_val_show, procfs_autoprobe_timer_val_store);
3383 error = device_create_file(dev, &dev_attr_autoprobe_timer_val_d);
3384 #endif
3385 #if defined(__IS_HOST__) && defined(__HOST_COC__)
3386 #ifdef __IS_DUAL__
3387 memset (&pmcuRegisterUSBHost_1, 0, sizeof(pmcuRegisterUSBHost_1));
3388 memset (&pmcuRegisterUSBHost_2, 0, sizeof(pmcuRegisterUSBHost_2));
3389 pmcuRegisterUSBHost_1.pmcuModule=
3390 pmcuRegisterUSBHost_2.pmcuModule=IFX_PMCU_MODULE_USB;
3391 pmcuRegisterUSBHost_1.pmcuModuleNr=1;
3392 pmcuRegisterUSBHost_2.pmcuModuleNr=2;
3393 pmcuRegisterUSBHost_1.pmcuModuleDep = &depListUSBHost_1;
3394 pmcuRegisterUSBHost_2.pmcuModuleDep = &depListUSBHost_2;
3395 pmcuRegisterUSBHost_1.pre = ifx_usbhost_preChange_1;
3396 pmcuRegisterUSBHost_2.pre = ifx_usbhost_preChange_2;
3397 pmcuRegisterUSBHost_1.post = ifx_usbhost_postChange_1;
3398 pmcuRegisterUSBHost_2.post = ifx_usbhost_postChange_2;
3399 pmcuRegisterUSBHost_1.ifx_pmcu_state_change = ifx_usbhost_stateChange_1;
3400 pmcuRegisterUSBHost_2.ifx_pmcu_state_change = ifx_usbhost_stateChange_2;
3401 pmcuRegisterUSBHost_1.ifx_pmcu_state_get = ifx_usbhost_stateGet_1;
3402 pmcuRegisterUSBHost_2.ifx_pmcu_state_get = ifx_usbhost_stateGet_2;
3403 pmcuRegisterUSBHost_1.ifx_pmcu_pwr_feature_switch = ifx_usbhost_pwrFeatureSwitch_1;
3404 pmcuRegisterUSBHost_2.ifx_pmcu_pwr_feature_switch = ifx_usbhost_pwrFeatureSwitch_2;
3405 ifx_pmcu_register ( &pmcuRegisterUSBHost_1 );
3406 ifx_pmcu_register ( &pmcuRegisterUSBHost_2 );
3407 #else
3408 memset (&pmcuRegisterUSBHost, 0, sizeof(pmcuRegisterUSBHost));
3409 pmcuRegisterUSBHost.pmcuModule=IFX_PMCU_MODULE_USB;
3410 pmcuRegisterUSBHost.pmcuModuleNr=1;
3411 pmcuRegisterUSBHost.pmcuModuleDep = &depListUSBHost;
3412 pmcuRegisterUSBHost.pre = ifx_usbhost_preChange;
3413 pmcuRegisterUSBHost.post = ifx_usbhost_postChange;
3414 pmcuRegisterUSBHost.ifx_pmcu_state_change = ifx_usbhost_stateChange;
3415 pmcuRegisterUSBHost.ifx_pmcu_state_get = ifx_usbhost_stateGet;
3416 pmcuRegisterUSBHost.ifx_pmcu_pwr_feature_switch = ifx_usbhost_pwrFeatureSwitch;
3417 ifx_pmcu_register ( &pmcuRegisterUSBHost );
3418 #endif
3419 #endif
3420 #if defined(__IS_DEVICE__) && defined(__GADGET_COC__)
3421 memset (&pmcuRegisterUSBGadget, 0, sizeof(pmcuRegisterUSBGadget));
3422 pmcuRegisterUSBGadget.pmcuModule=IFX_PMCU_MODULE_USB;
3423 pmcuRegisterUSBGadget.pmcuModuleNr=0;
3424 pmcuRegisterUSBGadget.pmcuModuleDep = &depListUSBGadget;
3425 pmcuRegisterUSBGadget.pre = ifx_usbgadget_preChange;
3426 pmcuRegisterUSBGadget.post = ifx_usbgadget_postChange;
3427 pmcuRegisterUSBGadget.ifx_pmcu_state_change = ifx_usbgadget_stateChange;
3428 pmcuRegisterUSBGadget.ifx_pmcu_state_get = ifx_usbgadget_stateGet;
3429 pmcuRegisterUSBGadget.ifx_pmcu_pwr_feature_switch = ifx_usbgadget_pwrFeatureSwitch;
3430 ifx_pmcu_register ( &pmcuRegisterUSBGadget );
3431 #endif
3432 }
3433
3434
3435 /*!
3436 \brief This function remove the sysfs and procfs entries
3437 \param[in] _dev Pointer of device structure, if applied
3438 */
3439 #ifdef __IS_HOST__
3440 void ifxusb_attr_remove_h (void *_dev)
3441 #else
3442 void ifxusb_attr_remove_d (void *_dev)
3443 #endif
3444 {
3445 struct device *dev = (struct device *) _dev;
3446
3447 IFX_DEBUGPL(DBG_ENTRY, "%s() %d\n", __func__, __LINE__ );
3448 ifx_proc_delproc("dbglevel");
3449 #ifdef __IS_HOST__
3450 device_remove_file(dev, &dev_attr_dbglevel_h);
3451 #else
3452 device_remove_file(dev, &dev_attr_dbglevel_d);
3453 #endif
3454
3455 #ifdef __IS_HOST__
3456 #ifdef __IS_DUAL__
3457 ifx_proc_delproc("dump_params_1");
3458 ifx_proc_delproc("dump_params_2");
3459 device_remove_file(dev, &dev_attr_dump_params_h_1);
3460 device_remove_file(dev, &dev_attr_dump_params_h_2);
3461 #else
3462 ifx_proc_delproc("dump_params");
3463 device_remove_file(dev, &dev_attr_dump_params_h);
3464 #endif
3465
3466 #ifdef __IS_DUAL__
3467 ifx_proc_delproc("mode_1");
3468 ifx_proc_delproc("mode_2");
3469 device_remove_file(dev, &dev_attr_mode_h_1);
3470 device_remove_file(dev, &dev_attr_mode_h_2);
3471 #else
3472 ifx_proc_delproc("mode");
3473 device_remove_file(dev, &dev_attr_mode_h);
3474 #endif
3475 #else
3476 ifx_proc_delproc("dump_params");
3477 device_remove_file(dev, &dev_attr_dump_params_d);
3478 ifx_proc_delproc("mode");
3479 device_remove_file(dev, &dev_attr_mode_d);
3480 #endif
3481
3482 #ifdef __IS_HOST__
3483 ifx_proc_delproc("version");
3484 device_remove_file(dev, &dev_attr_version_h);
3485 #else
3486 ifx_proc_delproc("version");
3487 device_remove_file(dev, &dev_attr_version_d);
3488 #endif
3489
3490
3491 #ifdef __IS_HOST__
3492 #ifdef __IS_DUAL__
3493 ifx_proc_delproc("pkt_count_limit_bi_1");
3494 ifx_proc_delproc("pkt_count_limit_bo_1");
3495 ifx_proc_delproc("pkt_count_limit_bi_2");
3496 ifx_proc_delproc("pkt_count_limit_bo_2");
3497 ifx_proc_delproc("bandwidth_hs_1");
3498 ifx_proc_delproc("bandwidth_fs_1");
3499 ifx_proc_delproc("bandwidth_ls_1");
3500 ifx_proc_delproc("bandwidth_hs_2");
3501 ifx_proc_delproc("bandwidth_fs_2");
3502 ifx_proc_delproc("bandwidth_ls_2");
3503 device_remove_file(dev, &dev_attr_pkt_count_limit_bi_1);
3504 device_remove_file(dev, &dev_attr_pkt_count_limit_bo_1);
3505 device_remove_file(dev, &dev_attr_pkt_count_limit_bi_2);
3506 device_remove_file(dev, &dev_attr_pkt_count_limit_bo_2);
3507 device_remove_file(dev, &dev_attr_bandwidth_hs_1);
3508 device_remove_file(dev, &dev_attr_bandwidth_fs_1);
3509 device_remove_file(dev, &dev_attr_bandwidth_ls_1);
3510 device_remove_file(dev, &dev_attr_bandwidth_hs_2);
3511 device_remove_file(dev, &dev_attr_bandwidth_fs_2);
3512 device_remove_file(dev, &dev_attr_bandwidth_ls_2);
3513 #else
3514 ifx_proc_delproc("pkt_count_limit_bi");
3515 ifx_proc_delproc("pkt_count_limit_bo");
3516 ifx_proc_delproc("bandwidth_hs");
3517 ifx_proc_delproc("bandwidth_fs");
3518 ifx_proc_delproc("bandwidth_ls");
3519 device_remove_file(dev, &dev_attr_pkt_count_limit_bi);
3520 device_remove_file(dev, &dev_attr_pkt_count_limit_bo);
3521 device_remove_file(dev, &dev_attr_bandwidth_hs);
3522 device_remove_file(dev, &dev_attr_bandwidth_fs);
3523 device_remove_file(dev, &dev_attr_bandwidth_ls);
3524 #endif
3525 #endif
3526
3527 #ifdef __IS_HOST__
3528 #ifdef __IS_DUAL__
3529 ifx_proc_delproc("buspower_1");
3530 ifx_proc_delproc("buspower_2");
3531 device_remove_file(dev, &dev_attr_buspower_1);
3532 device_remove_file(dev, &dev_attr_buspower_2);
3533 #else
3534 ifx_proc_delproc("buspower");
3535 device_remove_file(dev, &dev_attr_buspower);
3536 #endif
3537
3538 #ifdef __IS_DUAL__
3539 ifx_proc_delproc("bussuspend_1");
3540 ifx_proc_delproc("bussuspend_2");
3541 device_remove_file(dev, &dev_attr_bussuspend_1);
3542 device_remove_file(dev, &dev_attr_bussuspend_2);
3543 #else
3544 ifx_proc_delproc("bussuspend");
3545 device_remove_file(dev, &dev_attr_bussuspend);
3546 #endif
3547
3548 #ifdef __IS_DUAL__
3549 ifx_proc_delproc("busconnected_1");
3550 ifx_proc_delproc("busconnected_2");
3551 device_remove_file(dev, &dev_attr_busconnected_1);
3552 device_remove_file(dev, &dev_attr_busconnected_2);
3553 #else
3554 ifx_proc_delproc("busconnected");
3555 device_remove_file(dev, &dev_attr_busconnected);
3556 #endif
3557
3558 #ifdef __IS_DUAL__
3559 ifx_proc_delproc("connectspeed_1");
3560 ifx_proc_delproc("connectspeed_2");
3561 device_remove_file(dev, &dev_attr_connectspeed_1);
3562 device_remove_file(dev, &dev_attr_connectspeed_2);
3563 #else
3564 ifx_proc_delproc("connectspeed");
3565 device_remove_file(dev, &dev_attr_connectspeed);
3566 #endif
3567 #endif
3568
3569 #ifdef __IS_DEVICE__
3570 ifx_proc_delproc("devspeed");
3571 device_remove_file(dev, &dev_attr_devspeed);
3572 ifx_proc_delproc("enumspeed");
3573 device_remove_file(dev, &dev_attr_enumspeed);
3574 #endif
3575
3576 #ifdef __ENABLE_DUMP__
3577 #ifdef __IS_HOST__
3578 #ifdef __IS_DUAL__
3579 ifx_proc_delproc("dump_reg_1");
3580 ifx_proc_delproc("dump_reg_2");
3581 device_remove_file(dev, &dev_attr_dump_reg_h_1);
3582 device_remove_file(dev, &dev_attr_dump_reg_h_2);
3583 #else
3584 ifx_proc_delproc("dump_reg");
3585 device_remove_file(dev, &dev_attr_dump_reg_h);
3586 #endif
3587
3588 #ifdef __IS_DUAL__
3589 ifx_proc_delproc("dump_spram_1");
3590 ifx_proc_delproc("dump_spram_2");
3591 device_remove_file(dev, &dev_attr_dump_spram_h_1);
3592 device_remove_file(dev, &dev_attr_dump_spram_h_2);
3593 #else
3594 ifx_proc_delproc("dump_spram");
3595 device_remove_file(dev, &dev_attr_dump_spram_h);
3596 #endif
3597
3598 #ifdef __IS_DUAL__
3599 ifx_proc_delproc("dump_host_state_1");
3600 ifx_proc_delproc("dump_host_state_2");
3601 device_remove_file(dev, &dev_attr_dump_host_state_1);
3602 device_remove_file(dev, &dev_attr_dump_host_state_2);
3603 #else
3604 ifx_proc_delproc("dump_host_state");
3605 device_remove_file(dev, &dev_attr_dump_host_state);
3606 #endif
3607 #else
3608 ifx_proc_delproc("dump_reg");
3609 device_remove_file(dev, &dev_attr_dump_reg_d);
3610 ifx_proc_delproc("dump_spram");
3611 device_remove_file(dev, &dev_attr_dump_spram_d);
3612 #endif
3613
3614 #ifdef __IS_HOST__
3615 #endif
3616 #endif //__ENABLE_DUMP__
3617 #ifdef __IS_HOST__
3618 #ifdef __IS_DUAL__
3619 ifx_proc_delproc("suspend_host_1");
3620 ifx_proc_delproc("probe_host_1");
3621 device_remove_file(dev, &dev_attr_suspend_host_1);
3622 device_remove_file(dev, &dev_attr_probe_host_1);
3623 ifx_proc_delproc("suspend_host_2");
3624 ifx_proc_delproc("probe_host_2");
3625 device_remove_file(dev, &dev_attr_suspend_host_2);
3626 device_remove_file(dev, &dev_attr_probe_host_2);
3627 ifx_proc_delproc("probe_timer1");
3628 ifx_proc_delproc("autoprobe_timer1");
3629 device_remove_file(dev, &dev_attr_probe_timer1_val_h);
3630 device_remove_file(dev, &dev_attr_autoprobe_timer1_val_h);
3631 ifx_proc_delproc("probe_timer2");
3632 ifx_proc_delproc("autoprobe_timer2");
3633 device_remove_file(dev, &dev_attr_probe_timer2_val_h);
3634 device_remove_file(dev, &dev_attr_autoprobe_timer2_val_h);
3635 #else
3636 ifx_proc_delproc("suspend_host");
3637 ifx_proc_delproc("probe_host");
3638 device_remove_file(dev, &dev_attr_suspend_host);
3639 device_remove_file(dev, &dev_attr_probe_host);
3640 ifx_proc_delproc("probe_timer");
3641 ifx_proc_delproc("autoprobe_timer");
3642 device_remove_file(dev, &dev_attr_probe_timer_val_h);
3643 device_remove_file(dev, &dev_attr_autoprobe_timer_val_h);
3644 #endif
3645 remove_proc_entry(ifxusb_hcd_driver_name, (void *)0);
3646 #endif
3647
3648 #ifdef __IS_DEVICE__
3649 ifx_proc_delproc("suspend_device");
3650 ifx_proc_delproc("probe_device");
3651 device_remove_file(dev, &dev_attr_suspend_device);
3652 device_remove_file(dev, &dev_attr_probe_device);
3653 ifx_proc_delproc("probe_timer");
3654 ifx_proc_delproc("autoprobe_timer");
3655 device_remove_file(dev, &dev_attr_probe_timer_val_d);
3656 device_remove_file(dev, &dev_attr_autoprobe_timer_val_d);
3657 remove_proc_entry(ifxusb_pcd_driver_name, (void *)0);
3658 #endif
3659 #if defined(__IS_HOST__) && defined(__HOST_COC__)
3660 #ifdef __IS_DUAL__
3661 ifx_pmcu_unregister ( &pmcuRegisterUSBHost_1 );
3662 ifx_pmcu_unregister ( &pmcuRegisterUSBHost_2 );
3663 #else
3664 ifx_pmcu_unregister ( &pmcuRegisterUSBHost );
3665 #endif
3666 #endif
3667 #if defined(__IS_DEVICE__) && defined(__GADGET_COC__)
3668 ifx_pmcu_unregister ( &pmcuRegisterUSBGadget );
3669 #endif
3670
3671 }
3672
3673 static struct proc_dir_entry * proc_ifx_root = NULL;
3674
3675 /* initialize the proc file system and make a dir named /proc/[name] */
3676 static void ifx_proc_init(void)
3677 {
3678 IFX_DEBUGPL(DBG_ENTRY, "%s() %d\n", __func__, __LINE__ );
3679 #ifdef __IS_HOST__
3680 proc_ifx_root = proc_mkdir(ifxusb_hcd_driver_name, (void *)0);
3681 if (!proc_ifx_root){
3682 IFX_PRINT("%s proc initialization failed! \n", ifxusb_hcd_driver_name);
3683 return;
3684 }
3685 #else
3686 proc_ifx_root = proc_mkdir(ifxusb_pcd_driver_name, (void *)0);
3687 if (!proc_ifx_root){
3688 IFX_PRINT("%s proc initialization failed! \n", ifxusb_pcd_driver_name);
3689 return;
3690 }
3691 #endif
3692 }
3693
3694 /* proc file system add function for debugging. */
3695 static int ifx_proc_addproc(char *funcname, read_proc_t *hookfuncr, write_proc_t *hookfuncw)
3696 {
3697 struct proc_dir_entry *pe;
3698 IFX_DEBUGPL(DBG_ENTRY, "%s() %d\n", __func__, __LINE__ );
3699 if (!proc_ifx_root)
3700 ifx_proc_init();
3701
3702 if (hookfuncw == NULL)
3703 {
3704 pe = create_proc_read_entry(funcname, S_IRUGO, proc_ifx_root, hookfuncr, NULL);
3705 if (!pe)
3706 {
3707 IFX_PRINT("ERROR in creating read proc entry (%s)! \n", funcname);
3708 return -1;
3709 }
3710 }
3711 else
3712 {
3713 pe = create_proc_entry(funcname, S_IRUGO | S_IWUGO, proc_ifx_root);
3714 if (pe)
3715 {
3716 pe->read_proc = hookfuncr;
3717 pe->write_proc = hookfuncw;
3718 }
3719 else
3720 {
3721 IFX_PRINT("ERROR in creating proc entry (%s)! \n", funcname);
3722 return -1;
3723 }
3724 }
3725 return 0;
3726 }
3727
3728
3729 /* proc file system del function for removing module. */
3730 static void ifx_proc_delproc(char *funcname)
3731 {
3732 char pname[30];
3733 IFX_DEBUGPL(DBG_ENTRY, "%s() %d\n", __func__, __LINE__ );
3734 sprintf(pname, "%s", funcname);
3735
3736 remove_proc_entry(pname, proc_ifx_root);
3737
3738 }
3739
3740 static void ifxusb_dump_params(ifxusb_core_if_t *_core_if)
3741 {
3742 ifxusb_params_t *params=&_core_if->params;
3743
3744 #ifdef __IS_HOST__
3745 IFX_PRINT("IFXUSB Dump Parameters ( Host Mode) \n");
3746 #endif //__IS_HOST__
3747 #ifdef __IS_DEVICE__
3748 IFX_PRINT("IFXUSB Dump Parameters ( Device Mode) \n");
3749 #endif //__IS_DEVICE__
3750
3751 #ifdef __DESC_DMA__
3752 IFX_PRINT("DMA: Hermes DMA\n");
3753 #else
3754 IFX_PRINT("DMA: Non-Desc DMA\n");
3755 #endif
3756 IFX_PRINT(" Burst size: %d\n",params->dma_burst_size);
3757
3758 if (params->speed==1)
3759 IFX_PRINT("Full Speed only\n");
3760 else if(params->speed==0)
3761 IFX_PRINT("Full/Hign Speed\n");
3762 else
3763 IFX_PRINT("Unkonwn setting (%d) for Speed\n",params->speed);
3764
3765 IFX_PRINT("Total Data FIFO size: %d(0x%06X) DWord, %d(0x%06X) Bytes\n",
3766 params->data_fifo_size,params->data_fifo_size,
3767 params->data_fifo_size*4, params->data_fifo_size*4
3768 );
3769
3770 #ifdef __IS_DEVICE__
3771 IFX_PRINT("Rx FIFO size: %d(0x%06X) DWord, %d(0x%06X) Bytes\n",
3772 params->rx_fifo_size,params->rx_fifo_size,
3773 params->rx_fifo_size*4, params->rx_fifo_size*4
3774 );
3775 {
3776 int i;
3777 for(i=0;i<MAX_EPS_CHANNELS;i++)
3778 {
3779 IFX_PRINT("Tx FIFO #%d size: %d(0x%06X) DWord, %d(0x%06X) Bytes\n",i,
3780 params->tx_fifo_size[i],params->tx_fifo_size[i],
3781 params->tx_fifo_size[i]*4, params->tx_fifo_size[i]*4
3782 );
3783 }
3784 }
3785 #ifdef __DED_FIFO__
3786 IFX_PRINT("Treshold : %s Rx:%d Tx:%d \n",
3787 (params->thr_ctl)?"On":"Off",params->tx_thr_length,params->rx_thr_length);
3788 #endif
3789 #else //__IS_HOST__
3790 IFX_PRINT("Host Channels: %d\n",params->host_channels);
3791
3792 IFX_PRINT("Rx FIFO size: %d(0x%06X) DWord, %d(0x%06X) Bytes\n",
3793 params->data_fifo_size,params->data_fifo_size,
3794 params->data_fifo_size*4, params->data_fifo_size*4
3795 );
3796
3797 IFX_PRINT("NP Tx FIFO size: %d(0x%06X) DWord, %d(0x%06X) Bytes\n",
3798 params->nperio_tx_fifo_size,params->nperio_tx_fifo_size,
3799 params->nperio_tx_fifo_size*4, params->nperio_tx_fifo_size*4
3800 );
3801
3802 IFX_PRINT(" P Tx FIFO size: %d(0x%06X) DWord, %d(0x%06X) Bytes\n",
3803 params->perio_tx_fifo_size,params->perio_tx_fifo_size,
3804 params->perio_tx_fifo_size*4, params->perio_tx_fifo_size*4
3805 );
3806 #endif //__IS_HOST__
3807
3808 IFX_PRINT("Max Transfer size: %d(0x%06X) Bytes\n",
3809 params->max_transfer_size,params->max_transfer_size
3810 );
3811 IFX_PRINT("Max Packet Count: %d(0x%06X)\n",
3812 params->max_packet_count,params->max_packet_count
3813 );
3814
3815 IFX_PRINT("PHY UTMI Width: %d\n",params->phy_utmi_width);
3816
3817 IFX_PRINT("Turn Around Time: HS:%d FS:%d\n",params->turn_around_time_hs,params->turn_around_time_fs);
3818 IFX_PRINT("Timeout Calibration: HS:%d FS:%d\n",params->timeout_cal_hs,params->timeout_cal_fs);
3819
3820
3821 IFX_PRINT("==================================================\n");
3822 IFX_PRINT("End of Parameters Dump\n");
3823 IFX_PRINT("==================================================\n");
3824 }
3825
OpenWrt Source Repository