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