Changeset 32953


Ignore:
Timestamp:
2012-08-03T10:53:02+02:00 (6 years ago)
Author:
blogic
Message:

[lantiq] cleanup patches

Location:
trunk/target/linux/lantiq
Files:
126 added
76 deleted
14 copied
11 moved

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/lantiq/files/arch/mips/include/asm/mach-lantiq/falcon/irq.h

    r32951 r32953  
    11/* 
    2  *  Copyright (C) 2011 John Crispin <blogic@openwrt.org> 
    3  * 
    42 *  This program is free software; you can redistribute it and/or modify it 
    53 *  under the terms of the GNU General Public License version 2 as published 
    64 *  by the Free Software Foundation. 
     5 * 
     6 *  Copyright (C) 2011 Thomas Langer <thomas.langer@lantiq.com> 
    77 */ 
    88 
    9 #ifndef _DEV_WIFI_RT2X00_H__ 
    10 #define _DEV_WIFI_RT2X00_H__ 
     9#ifndef __FALCON_IRQ_H 
     10#define __FALCON_IRQ_H 
    1111 
    12 extern void ltq_register_rt2x00(const char *firmware, const u8 *mac); 
     12#include <falcon_irq.h> 
     13 
     14#define NR_IRQS 328 
     15 
     16#include_next <irq.h> 
    1317 
    1418#endif 
  • trunk/target/linux/lantiq/files/arch/mips/include/asm/mach-lantiq/svip/irq.h

    r32951 r32953  
    11/* 
     2 *   arch/mips/include/asm/mach-lantiq/svip/irq.h 
     3 * 
    24 *   This program is free software; you can redistribute it and/or modify 
    35 *   it under the terms of the GNU General Public License as published by 
    4  *   the Free Software Foundation; version 2 of the License 
     6 *   the Free Software Foundation; either version 2 of the License, or 
     7 *   (at your option) any later version. 
    58 * 
    69 *   This program is distributed in the hope that it will be useful, 
     
    1316 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA. 
    1417 * 
    15  *   based on Ralink SDK3.3 
    16  *   Copyright (C) 2009 John Crispin <blogic@openwrt.org> 
     18 *   Copyright (C) 2010 Lantiq 
     19 * 
    1720 */ 
    1821 
    19 #ifndef _RAMIPS_ETH_PLATFORM_H 
    20 #define _RAMIPS_ETH_PLATFORM_H 
     22#ifndef __IRQ_H 
     23#define __IRQ_H 
    2124 
    22 #include <linux/phy.h> 
     25#include <svip_irq.h> 
    2326 
    24 struct ramips_eth_platform_data 
    25 { 
    26         unsigned char mac[6]; 
    27         void (*reset_fe)(void); 
    28         int min_pkt_len; 
    29         unsigned long sys_freq; 
     27#define NR_IRQS 264 
    3028 
    31         int speed; 
    32         int duplex; 
    33         int tx_fc; 
    34         int rx_fc; 
     29#include_next <irq.h> 
    3530 
    36         u32 phy_mask; 
    37         phy_interface_t phy_if_mode; 
    38 }; 
     31/* Functions for EXINT handling */ 
     32extern int ifx_enable_external_int(u32 exint, u32 mode); 
     33extern int ifx_disable_external_int(u32 exint); 
     34extern int ifx_external_int_level(u32 exint); 
    3935 
    40 #endif /* _RAMIPS_ETH_PLATFORM_H */ 
    41  
     36#endif 
  • trunk/target/linux/lantiq/files/arch/mips/lantiq/xway/dev-ifxhcd.c

    r32951 r32953  
    55 * (at your option) any later version. 
    66 * 
    7  * Copyright (C) 2010 John Crispin <blogic@openwrt.org> 
     7 * Copyright (C) 2012 John Crispin <blogic@openwrt.org> 
    88 */ 
    99 
     
    3131#include <lantiq_platform.h> 
    3232 
    33 #define LTQ_USB_IOMEM_BASE 0x1e101000 
    34 #define LTQ_USB_IOMEM_SIZE 0x00001000 
    35  
    36 static struct resource resources[] = 
    37 { 
    38         [0] = { 
    39                 .name   = "dwc_otg_membase", 
    40                 .start  = LTQ_USB_IOMEM_BASE, 
    41                 .end    = LTQ_USB_IOMEM_BASE + LTQ_USB_IOMEM_SIZE - 1, 
    42                 .flags  = IORESOURCE_MEM, 
    43         }, 
    44         [1] = { 
    45                 .name   = "dwc_otg_irq", 
    46                 .flags  = IORESOURCE_IRQ, 
    47         }, 
    48 }; 
    49  
    50 static u64 dwc_dmamask = (u32)0x1fffffff; 
     33static u64 dmamask = (u32)0x1fffffff; 
    5134 
    5235static struct platform_device platform_dev = { 
    53         .name = "dwc_otg", 
    54         .dev = { 
    55                 .dma_mask       = &dwc_dmamask, 
    56         }, 
    57         .resource               = resources, 
    58         .num_resources          = ARRAY_SIZE(resources), 
     36        .name = "ifxusb_hcd", 
     37        .dev.dma_mask = &dmamask, 
    5938}; 
    6039 
    6140int __init 
    62 xway_register_dwc(int pin) 
     41xway_register_hcd(int *pins) 
    6342{ 
    64         struct irq_data d; 
    65         d.irq = resources[1].start; 
    66         ltq_enable_irq(&d); 
    67         resources[1].start = ltq_is_ase() ? LTQ_USB_ASE_INT : LTQ_USB_INT; 
    68         platform_dev.dev.platform_data = (void*) pin; 
     43        platform_dev.dev.platform_data = pins; 
    6944        return platform_device_register(&platform_dev); 
    7045} 
  • trunk/target/linux/lantiq/files/arch/mips/lantiq/xway/dev-ifxhcd.h

    r32951 r32953  
    55 * (at your option) any later version. 
    66 * 
    7  * Copyright (C) 2010 John Crispin <blogic@openwrt.org> 
     7 * Copyright (C) 2012 John Crispin <blogic@openwrt.org> 
    88 */ 
    99 
    10 #ifndef _LTQ_DEV_DWC_H__ 
    11 #define _LTQ_DEV_DWC_H__ 
     10#ifndef _LTQ_DEV_HCD_H__ 
     11#define _LTQ_DEV_HCD_H__ 
    1212 
    1313#include <lantiq_platform.h> 
    1414 
    15 extern void __init xway_register_dwc(int pin); 
     15extern void __init xway_register_hcd(int *pin); 
    1616 
    1717#endif 
  • trunk/target/linux/lantiq/files/drivers/usb/dwc_otg/dwc_otg_attr.c

    r32951 r32953  
    11/* ========================================================================== 
    2  * $File: //dwh/usb_iip/dev/software/otg/linux/drivers/dwc_otg_attr.c $ 
    3  * $Revision: 1.2 $ 
    4  * $Date: 2008-11-21 05:39:15 $ 
    5  * $Change: 1064918 $ 
     2 * $File: //dwh/usb_iip/dev/software/otg_ipmate/linux/drivers/dwc_otg_attr.c $ 
     3 * $Revision: 1.1.1.1 $ 
     4 * $Date: 2009-04-17 06:15:34 $ 
     5 * $Change: 537387 $ 
    66 * 
    77 * Synopsys HS OTG Linux Software Driver and documentation (hereinafter, 
    88 * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless 
    99 * otherwise expressly agreed to in writing between Synopsys and you. 
    10  * 
     10 *  
    1111 * The Software IS NOT an item of Licensed Software or Licensed Product under 
    1212 * any End User Software License Agreement or Agreement for Licensed Product 
     
    1818 * Synopsys. If you do not agree with this notice, including the disclaimer 
    1919 * below, then you are not authorized to use the Software. 
    20  * 
     20 *  
    2121 * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS 
    2222 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
     
    3232 * ========================================================================== */ 
    3333 
    34 /** @file 
     34/** @file  
    3535 * 
    3636 * The diagnostic interface will provide access to the controller for 
     
    4040 */ 
    4141 
    42 /** @page "Linux Module Attributes" 
     42/** @page "Linux Module Attributes"  
    4343 * 
    4444 * The Linux module attributes feature is used to provide the Linux 
     
    5555 <td><b> Access</b></td> 
    5656 </tr> 
    57  
     57  
    5858 <tr> 
    5959 <td> mode </td> 
     
    6161 <td> Read</td> 
    6262 </tr> 
    63  
     63  
    6464 <tr> 
    6565 <td> hnpcapable </td> 
     
    6868 <td> Read/Write</td> 
    6969 </tr> 
    70  
     70  
    7171 <tr> 
    7272 <td> srpcapable </td> 
     
    7575 <td> Read/Write</td> 
    7676 </tr> 
    77  
     77  
    7878 <tr> 
    7979 <td> hnp </td> 
     
    8181 <td> Read/Write</td> 
    8282 </tr> 
    83  
     83  
    8484 <tr> 
    8585 <td> srp </td> 
     
    8787 <td> Read/Write</td> 
    8888 </tr> 
    89  
     89  
    9090 <tr> 
    9191 <td> buspower </td> 
     
    9393 <td> Read/Write</td> 
    9494 </tr> 
    95  
     95  
    9696 <tr> 
    9797 <td> bussuspend </td> 
     
    9999 <td> Read/Write</td> 
    100100 </tr> 
    101  
     101  
    102102 <tr> 
    103103 <td> busconnected </td> 
     
    105105 <td> Read</td> 
    106106 </tr> 
    107  
     107  
    108108 <tr> 
    109109 <td> gotgctl </td> 
     
    111111 <td> Read/Write</td> 
    112112 </tr> 
    113  
     113  
    114114 <tr> 
    115115 <td> gusbcfg </td> 
     
    117117 <td> Read/Write</td> 
    118118 </tr> 
    119  
     119  
    120120 <tr> 
    121121 <td> grxfsiz </td> 
     
    123123 <td> Read/Write</td> 
    124124 </tr> 
    125  
     125  
    126126 <tr> 
    127127 <td> gnptxfsiz </td> 
     
    129129 <td> Read/Write</td> 
    130130 </tr> 
    131  
     131  
    132132 <tr> 
    133133 <td> gpvndctl </td> 
     
    135135 <td> Read/Write</td> 
    136136 </tr> 
    137  
     137  
    138138 <tr> 
    139139 <td> ggpio </td> 
     
    142142 <td> Read/Write</td> 
    143143 </tr> 
    144  
     144  
    145145 <tr> 
    146146 <td> guid </td> 
     
    148148 <td> Read/Write</td> 
    149149 </tr> 
    150  
     150  
    151151 <tr> 
    152152 <td> gsnpsid </td> 
     
    154154 <td> Read</td> 
    155155 </tr> 
    156  
     156  
    157157 <tr> 
    158158 <td> devspeed </td> 
     
    160160 <td> Read/Write</td> 
    161161 </tr> 
    162  
     162  
    163163 <tr> 
    164164 <td> enumspeed </td> 
     
    166166 <td> Read</td> 
    167167 </tr> 
    168  
     168  
    169169 <tr> 
    170170 <td> hptxfsiz </td> 
     
    172172 <td> Read</td> 
    173173 </tr> 
    174  
     174  
    175175 <tr> 
    176176 <td> hprt0 </td> 
     
    178178 <td> Read/Write</td> 
    179179 </tr> 
    180  
     180  
    181181 <tr> 
    182182 <td> regoffset </td> 
     
    184184 <td> Read/Write</td> 
    185185 </tr> 
    186  
     186  
    187187 <tr> 
    188188 <td> regvalue </td> 
     
    190190 <td> Read/Write</td> 
    191191 </tr> 
    192  
     192  
    193193 <tr> 
    194194 <td> remote_wakeup </td> 
     
    199199 <td> Read/Write</td> 
    200200 </tr> 
    201  
     201  
    202202 <tr> 
    203203 <td> regdump </td> 
     
    205205 <td> Read</td> 
    206206 </tr> 
    207  
    208  <tr> 
    209  <td> spramdump </td> 
    210  <td> Dumps the contents of core registers.</td> 
    211  <td> Read</td> 
    212  </tr> 
    213  
     207  
    214208 <tr> 
    215209 <td> hcddump </td> 
     
    217211 <td> Read</td> 
    218212 </tr> 
    219  
     213  
    220214 <tr> 
    221215 <td> hcd_frrem </td> 
     
    228222 <td> Read</td> 
    229223 </tr> 
    230  
     224  
    231225 <tr> 
    232226 <td> rd_reg_test </td> 
     
    235229 <td> Read</td> 
    236230 </tr> 
    237  
     231  
    238232 <tr> 
    239233 <td> wr_reg_test </td> 
     
    242236 <td> Read</td> 
    243237 </tr> 
    244  
     238  
    245239 </table> 
    246  
     240  
    247241 Example usage: 
    248242 To get the current mode: 
    249243 cat /sys/devices/lm0/mode 
    250  
     244  
    251245 To power down the USB: 
    252246 echo 0 > /sys/devices/lm0/buspower 
    253247 */ 
    254  
    255248#include <linux/kernel.h> 
    256249#include <linux/module.h> 
     
    261254#include <linux/types.h> 
    262255#include <linux/stat.h>  /* permission constants */ 
    263 #include <linux/version.h> 
    264256 
    265257#include <asm/io.h> 
    266258 
    267 #include "linux/dwc_otg_plat.h" 
     259#include "dwc_otg_plat.h" 
    268260#include "dwc_otg_attr.h" 
    269261#include "dwc_otg_driver.h" 
    270 #include "dwc_otg_pcd.h" 
     262// #include "dwc_otg_pcd.h" 
    271263#include "dwc_otg_hcd.h" 
    272264 
    273 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
     265// 20070316, winder added. 
     266#ifndef SZ_256K 
     267#define SZ_256K                         0x00040000 
     268#endif 
     269 
    274270/* 
    275271 * MACROs for defining sysfs attribute 
     
    278274static ssize_t _otg_attr_name_##_show (struct device *_dev, struct device_attribute *attr, char *buf) \ 
    279275{ \ 
    280         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev);              \ 
     276        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev);\ 
    281277        uint32_t val; \ 
    282278        val = dwc_read_reg32 (_addr_); \ 
     
    285281} 
    286282#define DWC_OTG_DEVICE_ATTR_BITFIELD_STORE(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
    287 static ssize_t _otg_attr_name_##_store (struct device *_dev, struct device_attribute *attr, \ 
    288                                         const char *buf, size_t count) \ 
     283static ssize_t _otg_attr_name_##_store (struct device *_dev, struct device_attribute *attr, const char *buf, size_t count) \ 
    289284{ \ 
    290         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); \ 
     285        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev);\ 
    291286        uint32_t set = simple_strtoul(buf, NULL, 16); \ 
    292287        uint32_t clear = set; \ 
     
    298293} 
    299294 
     295#define DWC_OTG_DEVICE_ATTR_BITFIELD_RW(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
     296DWC_OTG_DEVICE_ATTR_BITFIELD_SHOW(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
     297DWC_OTG_DEVICE_ATTR_BITFIELD_STORE(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
     298DEVICE_ATTR(_otg_attr_name_,0644,_otg_attr_name_##_show,_otg_attr_name_##_store); 
     299 
     300#define DWC_OTG_DEVICE_ATTR_BITFIELD_RO(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
     301DWC_OTG_DEVICE_ATTR_BITFIELD_SHOW(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
     302DEVICE_ATTR(_otg_attr_name_,0444,_otg_attr_name_##_show,NULL); 
     303 
    300304/* 
    301305 * MACROs for defining sysfs attribute for 32-bit registers 
     
    304308static ssize_t _otg_attr_name_##_show (struct device *_dev, struct device_attribute *attr, char *buf) \ 
    305309{ \ 
    306         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); \ 
     310        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev);\ 
    307311        uint32_t val; \ 
    308312        val = dwc_read_reg32 (_addr_); \ 
     
    310314} 
    311315#define DWC_OTG_DEVICE_ATTR_REG_STORE(_otg_attr_name_,_addr_,_string_) \ 
    312 static ssize_t _otg_attr_name_##_store (struct device *_dev, struct device_attribute *attr, \ 
    313                                         const char *buf, size_t count) \ 
     316static ssize_t _otg_attr_name_##_store (struct device *_dev, struct device_attribute *attr, const char *buf, size_t count) \ 
    314317{ \ 
    315         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); \ 
     318        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev);\ 
    316319        uint32_t val = simple_strtoul(buf, NULL, 16); \ 
    317320        dev_dbg(_dev, "Storing Address=0x%08x Val=0x%08x\n", (uint32_t)_addr_, val); \ 
     
    320323} 
    321324 
    322 #else 
    323  
    324 /* 
    325  * MACROs for defining sysfs attribute 
    326  */ 
    327 #define DWC_OTG_DEVICE_ATTR_BITFIELD_SHOW(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
    328 static ssize_t _otg_attr_name_##_show (struct device *_dev, char *buf) \ 
    329 { \ 
    330         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev);\ 
    331         uint32_t val; \ 
    332         val = dwc_read_reg32 (_addr_); \ 
    333         val = (val & (_mask_)) >> _shift_; \ 
    334         return sprintf (buf, "%s = 0x%x\n", _string_, val); \ 
    335 } 
    336 #define DWC_OTG_DEVICE_ATTR_BITFIELD_STORE(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
    337 static ssize_t _otg_attr_name_##_store (struct device *_dev, const char *buf, size_t count) \ 
    338 { \ 
    339         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev);\ 
    340         uint32_t set = simple_strtoul(buf, NULL, 16); \ 
    341         uint32_t clear = set; \ 
    342         clear = ((~clear) << _shift_) & _mask_; \ 
    343         set = (set << _shift_) & _mask_; \ 
    344         dev_dbg(_dev, "Storing Address=0x%08x Set=0x%08x Clear=0x%08x\n", (uint32_t)_addr_, set, clear); \ 
    345         dwc_modify_reg32(_addr_, clear, set); \ 
    346         return count; \ 
    347 } 
    348  
    349 /* 
    350  * MACROs for defining sysfs attribute for 32-bit registers 
    351  */ 
    352 #define DWC_OTG_DEVICE_ATTR_REG_SHOW(_otg_attr_name_,_addr_,_string_) \ 
    353 static ssize_t _otg_attr_name_##_show (struct device *_dev, char *buf) \ 
    354 { \ 
    355         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev);\ 
    356         uint32_t val; \ 
    357         val = dwc_read_reg32 (_addr_); \ 
    358         return sprintf (buf, "%s = 0x%08x\n", _string_, val); \ 
    359 } 
    360 #define DWC_OTG_DEVICE_ATTR_REG_STORE(_otg_attr_name_,_addr_,_string_) \ 
    361 static ssize_t _otg_attr_name_##_store (struct device *_dev, const char *buf, size_t count) \ 
    362 { \ 
    363         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev);\ 
    364         uint32_t val = simple_strtoul(buf, NULL, 16); \ 
    365         dev_dbg(_dev, "Storing Address=0x%08x Val=0x%08x\n", (uint32_t)_addr_, val); \ 
    366         dwc_write_reg32(_addr_, val); \ 
    367         return count; \ 
    368 } 
    369  
    370 #endif 
    371  
    372 #define DWC_OTG_DEVICE_ATTR_BITFIELD_RW(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
    373 DWC_OTG_DEVICE_ATTR_BITFIELD_SHOW(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
    374 DWC_OTG_DEVICE_ATTR_BITFIELD_STORE(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
    375 DEVICE_ATTR(_otg_attr_name_,0644,_otg_attr_name_##_show,_otg_attr_name_##_store); 
    376  
    377 #define DWC_OTG_DEVICE_ATTR_BITFIELD_RO(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
    378 DWC_OTG_DEVICE_ATTR_BITFIELD_SHOW(_otg_attr_name_,_addr_,_mask_,_shift_,_string_) \ 
    379 DEVICE_ATTR(_otg_attr_name_,0444,_otg_attr_name_##_show,NULL); 
    380  
    381325#define DWC_OTG_DEVICE_ATTR_REG32_RW(_otg_attr_name_,_addr_,_string_) \ 
    382326DWC_OTG_DEVICE_ATTR_REG_SHOW(_otg_attr_name_,_addr_,_string_) \ 
     
    395339 * Show the register offset of the Register Access. 
    396340 */ 
    397 static ssize_t regoffset_show( struct device *_dev, 
    398 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    399                                struct device_attribute *attr, 
    400 #endif 
    401                                char *buf) 
    402 { 
    403         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
     341static ssize_t regoffset_show( struct device *_dev, struct device_attribute *attr, char *buf)  
     342{ 
     343        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    404344        return snprintf(buf, sizeof("0xFFFFFFFF\n")+1,"0x%08x\n", otg_dev->reg_offset); 
    405345} 
     
    408348 * Set the register offset for the next Register Access         Read/Write 
    409349 */ 
    410 static ssize_t regoffset_store( struct device *_dev, 
    411 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    412                                 struct device_attribute *attr, 
    413 #endif 
    414                                 const char *buf, 
    415                                 size_t count ) 
    416 { 
    417         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    418  
     350static ssize_t regoffset_store( struct device *_dev, struct device_attribute *attr, const char *buf,  
     351                                size_t count )  
     352{ 
     353        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    419354        uint32_t offset = simple_strtoul(buf, NULL, 16); 
    420355        //dev_dbg(_dev, "Offset=0x%08x\n", offset); 
    421         if (offset < 0x00040000 ) { 
     356        if (offset < SZ_256K ) { 
    422357                otg_dev->reg_offset = offset; 
    423358        } 
     
    428363        return count; 
    429364} 
    430 DEVICE_ATTR(regoffset, S_IRUGO|S_IWUSR, (void *)regoffset_show, regoffset_store); 
    431  
     365DEVICE_ATTR(regoffset, S_IRUGO|S_IWUSR, regoffset_show, regoffset_store); 
    432366 
    433367/** 
     
    435369 * attribute. 
    436370 */ 
    437 static ssize_t regvalue_show( struct device *_dev, 
    438 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    439                               struct device_attribute *attr, 
    440 #endif 
    441                               char *buf) 
     371static ssize_t regvalue_show( struct device *_dev, struct device_attribute *attr, char *buf)  
    442372{ 
    443373        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    444  
    445374        uint32_t val; 
    446375        volatile uint32_t *addr; 
    447  
    448         if (otg_dev->reg_offset != 0xFFFFFFFF && 
    449             0 != otg_dev->base) { 
     376         
     377        if (otg_dev->reg_offset != 0xFFFFFFFF &&  0 != otg_dev->base) { 
    450378                /* Calculate the address */ 
    451                 addr = (uint32_t*)(otg_dev->reg_offset + 
     379                addr = (uint32_t*)(otg_dev->reg_offset +  
    452380                                   (uint8_t*)otg_dev->base); 
    453                 //dev_dbg(_dev, "@0x%08x\n", (unsigned)addr); 
    454                 val = dwc_read_reg32( addr ); 
     381                //dev_dbg(_dev, "@0x%08x\n", (unsigned)addr);  
     382                val = dwc_read_reg32( addr );              
    455383                return snprintf(buf, sizeof("Reg@0xFFFFFFFF = 0xFFFFFFFF\n")+1, 
    456                                 "Reg@0x%06x = 0x%08x\n", 
     384                                "Reg@0x%06x = 0x%08x\n",  
    457385                                otg_dev->reg_offset, val); 
    458386        } 
    459387        else { 
    460                 dev_err(_dev, "Invalid offset (0x%0x)\n", 
     388                dev_err(_dev, "Invalid offset (0x%0x)\n",  
    461389                        otg_dev->reg_offset); 
    462390                return sprintf(buf, "invalid offset\n" ); 
     
    467395 * Store the value in the register at the offset in the reg_offset 
    468396 * attribute. 
    469  * 
    470  */ 
    471 static ssize_t regvalue_store( struct device *_dev, 
    472 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    473                                struct device_attribute *attr, 
    474 #endif 
    475                                const char *buf, 
    476                                size_t count ) 
    477 { 
    478         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    479  
     397 *  
     398 */ 
     399static ssize_t regvalue_store( struct device *_dev, struct device_attribute *attr, const char *buf,  
     400                               size_t count )  
     401{ 
     402        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    480403        volatile uint32_t * addr; 
    481404        uint32_t val = simple_strtoul(buf, NULL, 16); 
     
    483406        if (otg_dev->reg_offset != 0xFFFFFFFF && 0 != otg_dev->base) { 
    484407                /* Calculate the address */ 
    485                 addr = (uint32_t*)(otg_dev->reg_offset + 
     408                addr = (uint32_t*)(otg_dev->reg_offset +  
    486409                                   (uint8_t*)otg_dev->base); 
    487                 //dev_dbg(_dev, "@0x%08x\n", (unsigned)addr); 
     410                //dev_dbg(_dev, "@0x%08x\n", (unsigned)addr);  
    488411                dwc_write_reg32( addr, val ); 
    489412        } 
    490413        else { 
    491                 dev_err(_dev, "Invalid Register Offset (0x%08x)\n", 
     414                dev_err(_dev, "Invalid Register Offset (0x%08x)\n",  
    492415                        otg_dev->reg_offset); 
    493416        } 
     
    528451 * Show the HNP status bit 
    529452 */ 
    530 static ssize_t hnp_show( struct device *_dev, 
    531 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    532                          struct device_attribute *attr, 
    533 #endif 
    534                          char *buf) 
    535 { 
    536         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    537  
     453static ssize_t hnp_show( struct device *_dev, struct device_attribute *attr, char *buf)  
     454{ 
     455        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    538456        gotgctl_data_t val; 
    539457        val.d32 = dwc_read_reg32 (&(otg_dev->core_if->core_global_regs->gotgctl)); 
     
    544462 * Set the HNP Request bit 
    545463 */ 
    546 static ssize_t hnp_store( struct device *_dev, 
    547 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    548                           struct device_attribute *attr, 
    549 #endif 
    550                           const char *buf, 
    551                           size_t count ) 
    552 { 
    553         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    554  
     464static ssize_t hnp_store( struct device *_dev, struct device_attribute *attr, const char *buf,  
     465                          size_t count )  
     466{ 
     467        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    555468        uint32_t in = simple_strtoul(buf, NULL, 16); 
    556469        uint32_t *addr = (uint32_t *)&(otg_dev->core_if->core_global_regs->gotgctl); 
     
    570483 * Show the SRP status bit 
    571484 */ 
    572 static ssize_t srp_show( struct device *_dev, 
    573 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    574                          struct device_attribute *attr, 
    575 #endif 
    576                          char *buf) 
     485static ssize_t srp_show( struct device *_dev, struct device_attribute *attr, char *buf)  
    577486{ 
    578487#ifndef DWC_HOST_ONLY 
    579         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    580  
     488        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    581489        gotgctl_data_t val; 
    582490        val.d32 = dwc_read_reg32 (&(otg_dev->core_if->core_global_regs->gotgctl)); 
     
    587495} 
    588496 
    589  
    590  
    591497/** 
    592498 * Set the SRP Request bit 
    593499 */ 
    594 static ssize_t srp_store( struct device *_dev, 
    595 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    596                           struct device_attribute *attr, 
    597 #endif 
    598                           const char *buf, 
    599                           size_t count ) 
     500static ssize_t srp_store( struct device *_dev, struct device_attribute *attr, const char *buf,  
     501                          size_t count )  
    600502{ 
    601503#ifndef DWC_HOST_ONLY 
    602         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    603  
     504        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    604505        dwc_otg_pcd_initiate_srp(otg_dev->pcd); 
    605506#endif 
     
    614515 * Show the Bus Power status 
    615516 */ 
    616 static ssize_t buspower_show( struct device *_dev, 
    617 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    618                               struct device_attribute *attr, 
    619 #endif 
    620                               char *buf) 
    621 { 
    622         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    623  
     517static ssize_t buspower_show( struct device *_dev, struct device_attribute *attr, char *buf)  
     518{ 
     519        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    624520        hprt0_data_t val; 
    625521        val.d32 = dwc_read_reg32 (otg_dev->core_if->host_if->hprt0); 
     
    631527 * Set the Bus Power status 
    632528 */ 
    633 static ssize_t buspower_store( struct device *_dev, 
    634 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    635                                struct device_attribute *attr, 
    636 #endif 
    637                                const char *buf, 
    638                                size_t count ) 
    639 { 
    640         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    641  
     529static ssize_t buspower_store( struct device *_dev, struct device_attribute *attr, const char *buf,  
     530                               size_t count )  
     531{ 
     532        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    642533        uint32_t on = simple_strtoul(buf, NULL, 16); 
    643534        uint32_t *addr = (uint32_t *)otg_dev->core_if->host_if->hprt0; 
     
    660551 * Show the Bus Suspend status 
    661552 */ 
    662 static ssize_t bussuspend_show( struct device *_dev, 
    663 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    664                                 struct device_attribute *attr, 
    665 #endif 
    666                                 char *buf) 
    667 { 
    668         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    669  
     553static ssize_t bussuspend_show( struct device *_dev, struct device_attribute *attr, char *buf)  
     554{ 
     555        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    670556        hprt0_data_t val; 
    671557        val.d32 = dwc_read_reg32 (otg_dev->core_if->host_if->hprt0); 
     
    676562 * Set the Bus Suspend status 
    677563 */ 
    678 static ssize_t bussuspend_store( struct device *_dev, 
    679 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    680                                  struct device_attribute *attr, 
    681 #endif 
    682                                  const char *buf, 
    683                                  size_t count ) 
    684 { 
    685         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    686  
     564static ssize_t bussuspend_store( struct device *_dev, struct device_attribute *attr, const char *buf,  
     565                                 size_t count )  
     566{ 
     567        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    687568        uint32_t in = simple_strtoul(buf, NULL, 16); 
    688569        uint32_t *addr = (uint32_t *)otg_dev->core_if->host_if->hprt0; 
     
    699580 * Show the status of Remote Wakeup. 
    700581 */ 
    701 static ssize_t remote_wakeup_show( struct device *_dev, 
    702 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    703                                    struct device_attribute *attr, 
    704 #endif 
    705                                    char *buf) 
     582static ssize_t remote_wakeup_show( struct device *_dev, struct device_attribute *attr, char *buf)  
    706583{ 
    707584#ifndef DWC_HOST_ONLY 
    708         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    709  
     585        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    710586        dctl_data_t val; 
    711         val.d32 = 
    712                 dwc_read_reg32( &otg_dev->core_if->dev_if->dev_global_regs->dctl); 
    713         return sprintf( buf, "Remote Wakeup = %d Enabled = %d\n", 
    714                         val.b.rmtwkupsig, otg_dev->pcd->remote_wakeup_enable); 
     587        val.d32 = dwc_read_reg32( &otg_dev->core_if->dev_if->dev_global_regs->dctl); 
     588        return sprintf( buf, "Remote Wakeup = %d Enabled = %d\n",  
     589                        val.b.rmtwkupsig, otg_dev->pcd->remote_wakeup_enable); 
    715590#else 
    716591        return sprintf(buf, "Host Only Mode!\n"); 
    717592#endif 
    718593} 
     594 
    719595/** 
    720596 * Initiate a remote wakeup of the host.  The Device control register 
    721597 * Remote Wakeup Signal bit is written if the PCD Remote wakeup enable 
    722598 * flag is set. 
    723  * 
    724  */ 
    725 static ssize_t remote_wakeup_store( struct device *_dev, 
    726 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    727                                     struct device_attribute *attr, 
    728 #endif 
    729                                     const char *buf, 
    730                                     size_t count ) 
     599 *  
     600 */ 
     601static ssize_t remote_wakeup_store( struct device *_dev, struct device_attribute *attr, const char *buf,  
     602                                    size_t count )  
    731603{ 
    732604#ifndef DWC_HOST_ONLY 
     605        uint32_t val = simple_strtoul(buf, NULL, 16);         
    733606        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    734  
    735         uint32_t val = simple_strtoul(buf, NULL, 16); 
    736607        if (val&1) { 
    737608                dwc_otg_pcd_remote_wakeup(otg_dev->pcd, 1); 
     
    743614        return count; 
    744615} 
    745 DEVICE_ATTR(remote_wakeup,  S_IRUGO|S_IWUSR, remote_wakeup_show, 
    746             remote_wakeup_store); 
     616DEVICE_ATTR(remote_wakeup,  S_IRUGO|S_IWUSR, remote_wakeup_show,  
     617            remote_wakeup_store); 
    747618 
    748619/** 
     
    750621 * current mode of the core). 
    751622 */ 
    752 static ssize_t regdump_show( struct device *_dev, 
    753 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    754                              struct device_attribute *attr, 
    755 #endif 
    756                              char *buf) 
    757 { 
     623static ssize_t regdump_show( struct device *_dev, struct device_attribute *attr, char *buf)  
     624{ 
     625#ifdef DEBUG 
    758626        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
     627        printk("%s otg_dev=0x%p\n", __FUNCTION__, otg_dev); 
    759628 
    760629        dwc_otg_dump_global_registers( otg_dev->core_if); 
     
    763632        } else { 
    764633                dwc_otg_dump_dev_registers( otg_dev->core_if); 
    765  
    766634        } 
     635#endif 
     636 
    767637        return sprintf( buf, "Register Dump\n" ); 
    768638} 
     
    771641 
    772642/** 
    773  * Dump global registers and either host or device registers (depending on the 
    774  * current mode of the core). 
    775  */ 
    776 static ssize_t spramdump_show( struct device *_dev, 
    777 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    778                                struct device_attribute *attr, 
    779 #endif 
    780                                char *buf) 
    781 { 
    782         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    783  
    784         dwc_otg_dump_spram( otg_dev->core_if); 
    785  
    786         return sprintf( buf, "SPRAM Dump\n" ); 
    787 } 
    788  
    789 DEVICE_ATTR(spramdump, S_IRUGO|S_IWUSR, spramdump_show, 0); 
    790  
    791 /** 
    792643 * Dump the current hcd state. 
    793644 */ 
    794 static ssize_t hcddump_show( struct device *_dev, 
    795 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    796                              struct device_attribute *attr, 
    797 #endif 
    798                              char *buf) 
     645static ssize_t hcddump_show( struct device *_dev, struct device_attribute *attr, char *buf)  
    799646{ 
    800647#ifndef DWC_DEVICE_ONLY 
    801         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    802  
     648        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    803649        dwc_otg_hcd_dump_state(otg_dev->hcd); 
    804650#endif 
     
    813659 * start transfer and two additional sample points. 
    814660 */ 
    815 static ssize_t hcd_frrem_show( struct device *_dev, 
    816 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    817                                struct device_attribute *attr, 
    818 #endif 
    819                                char *buf) 
     661static ssize_t hcd_frrem_show( struct device *_dev, struct device_attribute *attr, char *buf)  
    820662{ 
    821663#ifndef DWC_DEVICE_ONLY 
    822         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    823  
     664        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    824665        dwc_otg_hcd_dump_frrem(otg_dev->hcd); 
    825666#endif 
     
    834675 */ 
    835676#define RW_REG_COUNT 10000000 
    836 #define MSEC_PER_JIFFIE 1000/HZ 
    837 static ssize_t rd_reg_test_show( struct device *_dev, 
    838 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    839                                  struct device_attribute *attr, 
    840 #endif 
    841                                  char *buf) 
    842 { 
    843         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    844  
     677#define MSEC_PER_JIFFIE 1000/HZ  
     678static ssize_t rd_reg_test_show( struct device *_dev, struct device_attribute *attr, char *buf)  
     679{ 
    845680        int i; 
    846681        int time; 
    847682        int start_jiffies; 
     683        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    848684 
    849685        printk("HZ %d, MSEC_PER_JIFFIE %d, loops_per_jiffy %lu\n", 
     
    864700 * output shows the number of times the register is written). 
    865701 */ 
    866 static ssize_t wr_reg_test_show( struct device *_dev, 
    867 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    868                                  struct device_attribute *attr, 
    869 #endif 
    870                                  char *buf) 
    871 { 
    872         dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
    873  
    874         uint32_t reg_val; 
     702static ssize_t wr_reg_test_show( struct device *_dev, struct device_attribute *attr, char *buf)  
     703{ 
    875704        int i; 
    876705        int time; 
    877706        int start_jiffies; 
     707        dwc_otg_device_t *otg_dev = dev_get_drvdata(_dev); 
     708        uint32_t reg_val; 
    878709 
    879710        printk("HZ %d, MSEC_PER_JIFFIE %d, loops_per_jiffy %lu\n", 
     
    895726 * Create the device files 
    896727 */ 
    897 void dwc_otg_attr_create (struct device *dev) 
    898 { 
    899         int error; 
    900  
    901         error = device_create_file(dev, &dev_attr_regoffset); 
    902         error = device_create_file(dev, &dev_attr_regvalue); 
    903         error = device_create_file(dev, &dev_attr_mode); 
    904         error = device_create_file(dev, &dev_attr_hnpcapable); 
    905         error = device_create_file(dev, &dev_attr_srpcapable); 
    906         error = device_create_file(dev, &dev_attr_hnp); 
    907         error = device_create_file(dev, &dev_attr_srp); 
    908         error = device_create_file(dev, &dev_attr_buspower); 
    909         error = device_create_file(dev, &dev_attr_bussuspend); 
    910         error = device_create_file(dev, &dev_attr_busconnected); 
    911         error = device_create_file(dev, &dev_attr_gotgctl); 
    912         error = device_create_file(dev, &dev_attr_gusbcfg); 
    913         error = device_create_file(dev, &dev_attr_grxfsiz); 
    914         error = device_create_file(dev, &dev_attr_gnptxfsiz); 
    915         error = device_create_file(dev, &dev_attr_gpvndctl); 
    916         error = device_create_file(dev, &dev_attr_ggpio); 
    917         error = device_create_file(dev, &dev_attr_guid); 
    918         error = device_create_file(dev, &dev_attr_gsnpsid); 
    919         error = device_create_file(dev, &dev_attr_devspeed); 
    920         error = device_create_file(dev, &dev_attr_enumspeed); 
    921         error = device_create_file(dev, &dev_attr_hptxfsiz); 
    922         error = device_create_file(dev, &dev_attr_hprt0); 
    923         error = device_create_file(dev, &dev_attr_remote_wakeup); 
    924         error = device_create_file(dev, &dev_attr_regdump); 
    925         error = device_create_file(dev, &dev_attr_spramdump); 
    926         error = device_create_file(dev, &dev_attr_hcddump); 
    927         error = device_create_file(dev, &dev_attr_hcd_frrem); 
    928         error = device_create_file(dev, &dev_attr_rd_reg_test); 
    929         error = device_create_file(dev, &dev_attr_wr_reg_test); 
     728void dwc_otg_attr_create (struct device *_dev) 
     729{ 
     730    int retval; 
     731     
     732    retval = device_create_file(_dev, &dev_attr_regoffset); 
     733    retval += device_create_file(_dev, &dev_attr_regvalue); 
     734    retval += device_create_file(_dev, &dev_attr_mode); 
     735    retval += device_create_file(_dev, &dev_attr_hnpcapable); 
     736    retval += device_create_file(_dev, &dev_attr_srpcapable); 
     737    retval += device_create_file(_dev, &dev_attr_hnp); 
     738    retval += device_create_file(_dev, &dev_attr_srp); 
     739    retval += device_create_file(_dev, &dev_attr_buspower); 
     740    retval += device_create_file(_dev, &dev_attr_bussuspend); 
     741    retval += device_create_file(_dev, &dev_attr_busconnected); 
     742    retval += device_create_file(_dev, &dev_attr_gotgctl); 
     743    retval += device_create_file(_dev, &dev_attr_gusbcfg); 
     744    retval += device_create_file(_dev, &dev_attr_grxfsiz); 
     745    retval += device_create_file(_dev, &dev_attr_gnptxfsiz); 
     746    retval += device_create_file(_dev, &dev_attr_gpvndctl); 
     747    retval += device_create_file(_dev, &dev_attr_ggpio); 
     748    retval += device_create_file(_dev, &dev_attr_guid); 
     749    retval += device_create_file(_dev, &dev_attr_gsnpsid); 
     750    retval += device_create_file(_dev, &dev_attr_devspeed); 
     751    retval += device_create_file(_dev, &dev_attr_enumspeed); 
     752    retval += device_create_file(_dev, &dev_attr_hptxfsiz); 
     753    retval += device_create_file(_dev, &dev_attr_hprt0); 
     754    retval += device_create_file(_dev, &dev_attr_remote_wakeup); 
     755    retval += device_create_file(_dev, &dev_attr_regdump); 
     756    retval += device_create_file(_dev, &dev_attr_hcddump); 
     757    retval += device_create_file(_dev, &dev_attr_hcd_frrem); 
     758    retval += device_create_file(_dev, &dev_attr_rd_reg_test); 
     759    retval += device_create_file(_dev, &dev_attr_wr_reg_test); 
     760 
     761    if(retval != 0) 
     762    { 
     763        DWC_PRINT("cannot create sysfs device files.\n"); 
     764        // DWC_PRINT("killing own sysfs device files!\n"); 
     765        dwc_otg_attr_remove(_dev); 
     766    } 
    930767} 
    931768 
     
    933770 * Remove the device files 
    934771 */ 
    935 void dwc_otg_attr_remove (struct device *dev) 
    936 { 
    937         device_remove_file(dev, &dev_attr_regoffset); 
    938         device_remove_file(dev, &dev_attr_regvalue); 
    939         device_remove_file(dev, &dev_attr_mode); 
    940         device_remove_file(dev, &dev_attr_hnpcapable); 
    941         device_remove_file(dev, &dev_attr_srpcapable); 
    942         device_remove_file(dev, &dev_attr_hnp); 
    943         device_remove_file(dev, &dev_attr_srp); 
    944         device_remove_file(dev, &dev_attr_buspower); 
    945         device_remove_file(dev, &dev_attr_bussuspend); 
    946         device_remove_file(dev, &dev_attr_busconnected); 
    947         device_remove_file(dev, &dev_attr_gotgctl); 
    948         device_remove_file(dev, &dev_attr_gusbcfg); 
    949         device_remove_file(dev, &dev_attr_grxfsiz); 
    950         device_remove_file(dev, &dev_attr_gnptxfsiz); 
    951         device_remove_file(dev, &dev_attr_gpvndctl); 
    952         device_remove_file(dev, &dev_attr_ggpio); 
    953         device_remove_file(dev, &dev_attr_guid); 
    954         device_remove_file(dev, &dev_attr_gsnpsid); 
    955         device_remove_file(dev, &dev_attr_devspeed); 
    956         device_remove_file(dev, &dev_attr_enumspeed); 
    957         device_remove_file(dev, &dev_attr_hptxfsiz); 
    958         device_remove_file(dev, &dev_attr_hprt0); 
    959         device_remove_file(dev, &dev_attr_remote_wakeup); 
    960         device_remove_file(dev, &dev_attr_regdump); 
    961         device_remove_file(dev, &dev_attr_spramdump); 
    962         device_remove_file(dev, &dev_attr_hcddump); 
    963         device_remove_file(dev, &dev_attr_hcd_frrem); 
    964         device_remove_file(dev, &dev_attr_rd_reg_test); 
    965         device_remove_file(dev, &dev_attr_wr_reg_test); 
    966 } 
     772void dwc_otg_attr_remove (struct device *_dev) 
     773{ 
     774        device_remove_file(_dev, &dev_attr_regoffset); 
     775        device_remove_file(_dev, &dev_attr_regvalue); 
     776        device_remove_file(_dev, &dev_attr_mode); 
     777        device_remove_file(_dev, &dev_attr_hnpcapable); 
     778        device_remove_file(_dev, &dev_attr_srpcapable); 
     779        device_remove_file(_dev, &dev_attr_hnp); 
     780        device_remove_file(_dev, &dev_attr_srp); 
     781        device_remove_file(_dev, &dev_attr_buspower); 
     782        device_remove_file(_dev, &dev_attr_bussuspend); 
     783        device_remove_file(_dev, &dev_attr_busconnected); 
     784        device_remove_file(_dev, &dev_attr_gotgctl); 
     785        device_remove_file(_dev, &dev_attr_gusbcfg); 
     786        device_remove_file(_dev, &dev_attr_grxfsiz); 
     787        device_remove_file(_dev, &dev_attr_gnptxfsiz); 
     788        device_remove_file(_dev, &dev_attr_gpvndctl); 
     789        device_remove_file(_dev, &dev_attr_ggpio); 
     790        device_remove_file(_dev, &dev_attr_guid); 
     791        device_remove_file(_dev, &dev_attr_gsnpsid); 
     792        device_remove_file(_dev, &dev_attr_devspeed); 
     793        device_remove_file(_dev, &dev_attr_enumspeed); 
     794        device_remove_file(_dev, &dev_attr_hptxfsiz); 
     795        device_remove_file(_dev, &dev_attr_hprt0);       
     796        device_remove_file(_dev, &dev_attr_remote_wakeup);       
     797        device_remove_file(_dev, &dev_attr_regdump); 
     798        device_remove_file(_dev, &dev_attr_hcddump); 
     799        device_remove_file(_dev, &dev_attr_hcd_frrem); 
     800        device_remove_file(_dev, &dev_attr_rd_reg_test); 
     801        device_remove_file(_dev, &dev_attr_wr_reg_test); 
     802} 
  • trunk/target/linux/lantiq/files/drivers/usb/dwc_otg/dwc_otg_attr.h

    r32951 r32953  
    11/* ========================================================================== 
    2  * $File: //dwh/usb_iip/dev/software/otg/linux/drivers/dwc_otg_attr.h $ 
    3  * $Revision: 1.2 $ 
    4  * $Date: 2008-11-21 05:39:15 $ 
    5  * $Change: 477051 $ 
     2 * $File: //dwh/usb_iip/dev/software/otg_ipmate/linux/drivers/dwc_otg_attr.h $ 
     3 * $Revision: 1.1.1.1 $ 
     4 * $Date: 2009-04-17 06:15:34 $ 
     5 * $Change: 510275 $ 
    66 * 
    77 * Synopsys HS OTG Linux Software Driver and documentation (hereinafter, 
    88 * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless 
    99 * otherwise expressly agreed to in writing between Synopsys and you. 
    10  * 
     10 *  
    1111 * The Software IS NOT an item of Licensed Software or Licensed Product under 
    1212 * any End User Software License Agreement or Agreement for Licensed Product 
     
    1818 * Synopsys. If you do not agree with this notice, including the disclaimer 
    1919 * below, then you are not authorized to use the Software. 
    20  * 
     20 *  
    2121 * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS 
    2222 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
     
    6262extern struct device_attribute dev_attr_hprt0; 
    6363 
    64 void dwc_otg_attr_create (struct device *dev); 
    65 void dwc_otg_attr_remove (struct device *dev); 
     64void dwc_otg_attr_create (struct device *_dev); 
     65void dwc_otg_attr_remove (struct device *_dev); 
    6666 
    6767#endif 
  • trunk/target/linux/lantiq/files/drivers/usb/dwc_otg/dwc_otg_cil.h

    r32951 r32953  
    11/* ========================================================================== 
    2  * $File: //dwh/usb_iip/dev/software/otg/linux/drivers/dwc_otg_cil.h $ 
    3  * $Revision: 1.2 $ 
    4  * $Date: 2008-11-21 05:39:15 $ 
    5  * $Change: 1099526 $ 
     2 * $File: //dwh/usb_iip/dev/software/otg_ipmate/linux/drivers/dwc_otg_cil.h $ 
     3 * $Revision: 1.1.1.1 $ 
     4 * $Date: 2009-04-17 06:15:34 $ 
     5 * $Change: 631780 $ 
    66 * 
    77 * Synopsys HS OTG Linux Software Driver and documentation (hereinafter, 
    88 * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless 
    99 * otherwise expressly agreed to in writing between Synopsys and you. 
    10  * 
     10 *  
    1111 * The Software IS NOT an item of Licensed Software or Licensed Product under 
    1212 * any End User Software License Agreement or Agreement for Licensed Product 
     
    1818 * Synopsys. If you do not agree with this notice, including the disclaimer 
    1919 * below, then you are not authorized to use the Software. 
    20  * 
     20 *  
    2121 * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS 
    2222 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
     
    3535#define __DWC_CIL_H__ 
    3636 
    37 #include <linux/workqueue.h> 
    38 #include <linux/version.h> 
    39 #include <asm/param.h> 
    40  
    41 #include "linux/dwc_otg_plat.h" 
     37#include "dwc_otg_plat.h" 
     38 
    4239#include "dwc_otg_regs.h" 
    4340#ifdef DEBUG 
     
    4542#endif 
    4643 
     44/* the OTG capabilities. */ 
     45#define DWC_OTG_CAP_PARAM_HNP_SRP_CAPABLE 0 
     46#define DWC_OTG_CAP_PARAM_SRP_ONLY_CAPABLE 1 
     47#define DWC_OTG_CAP_PARAM_NO_HNP_SRP_CAPABLE 2 
     48/* the maximum speed of operation in host and device mode. */ 
     49#define DWC_SPEED_PARAM_HIGH 0 
     50#define DWC_SPEED_PARAM_FULL 1 
     51/* the PHY clock rate in low power mode when connected to a 
     52 * Low Speed device in host mode. */ 
     53#define DWC_HOST_LS_LOW_POWER_PHY_CLK_PARAM_48MHZ 0 
     54#define DWC_HOST_LS_LOW_POWER_PHY_CLK_PARAM_6MHZ 1 
     55/* the type of PHY interface to use. */ 
     56#define DWC_PHY_TYPE_PARAM_FS 0 
     57#define DWC_PHY_TYPE_PARAM_UTMI 1 
     58#define DWC_PHY_TYPE_PARAM_ULPI 2 
     59/* whether to use the internal or external supply to  
     60 * drive the vbus with a ULPI phy. */ 
     61#define DWC_PHY_ULPI_INTERNAL_VBUS 0 
     62#define DWC_PHY_ULPI_EXTERNAL_VBUS 1 
     63/* EP type. */ 
     64 
    4765/** 
    4866 * @file 
     
    5068 */ 
    5169 
    52  
    53 /** Macros defined for DWC OTG HW Release verison */ 
    54 #define OTG_CORE_REV_2_00       0x4F542000 
    55 #define OTG_CORE_REV_2_60a      0x4F54260A 
    56 #define OTG_CORE_REV_2_71a      0x4F54271A 
    57 #define OTG_CORE_REV_2_72a      0x4F54272A 
    58  
    59 /** 
    60 */ 
    61 typedef struct iso_pkt_info 
    62 { 
    63         uint32_t        offset; 
    64         uint32_t        length; 
    65         int32_t         status; 
    66 } iso_pkt_info_t; 
    6770/** 
    6871 * The <code>dwc_ep</code> structure represents the state of a single 
     
    7073 * needed for an endpoint to be activated and transfer packets. 
    7174 */ 
    72 typedef struct dwc_ep 
    73 { 
    74         /** EP number used for register address lookup */ 
    75         uint8_t  num; 
    76         /** EP direction 0 = OUT */ 
    77         unsigned is_in : 1; 
    78         /** EP active. */ 
    79         unsigned active : 1; 
     75typedef struct dwc_ep { 
     76        /** EP number used for register address lookup */ 
     77        uint8_t  num; 
     78        /** EP direction 0 = OUT */ 
     79        unsigned is_in : 1;            
     80        /** EP active. */ 
     81        unsigned active : 1; 
    8082 
    8183        /** Periodic Tx FIFO # for IN EPs For INTR EP set to 0 to use non-periodic Tx FIFO 
    8284                If dedicated Tx FIFOs are enabled for all IN Eps - Tx FIFO # FOR IN EPs*/ 
    83         unsigned tx_fifo_num : 4; 
    84         /** EP type: 0 - Control, 1 - ISOC,      2 - BULK,      3 - INTR */ 
    85         unsigned type : 2; 
    86 #define DWC_OTG_EP_TYPE_CONTROL    0 
    87 #define DWC_OTG_EP_TYPE_ISOC       1 
    88 #define DWC_OTG_EP_TYPE_BULK       2 
    89 #define DWC_OTG_EP_TYPE_INTR       3 
    90  
    91         /** DATA start PID for INTR and BULK EP */ 
    92         unsigned data_pid_start : 1; 
    93         /** Frame (even/odd) for ISOC EP */ 
    94         unsigned even_odd_frame : 1; 
    95         /** Max Packet bytes */ 
    96         unsigned maxpacket : 11; 
    97  
    98         /** Max Transfer size */ 
    99         unsigned maxxfer : 16; 
    100  
    101         /** @name Transfer state */ 
     85        unsigned tx_fifo_num : 4;   
     86        /** EP type: 0 - Control, 1 - ISOC,  2 - BULK,  3 - INTR */ 
     87        unsigned type : 2;       
     88#define DWC_OTG_EP_TYPE_CONTROL    0 
     89#define DWC_OTG_EP_TYPE_ISOC       1 
     90#define DWC_OTG_EP_TYPE_BULK       2 
     91#define DWC_OTG_EP_TYPE_INTR       3 
     92 
     93        /** DATA start PID for INTR and BULK EP */ 
     94        unsigned data_pid_start : 1;   
     95        /** Frame (even/odd) for ISOC EP */ 
     96        unsigned even_odd_frame : 1;   
     97        /** Max Packet bytes */ 
     98        unsigned maxpacket : 11; 
     99 
     100        /** @name Transfer state */ 
    102101        /** @{ */ 
    103102 
     
    106105         * during transfer. 
    107106         */ 
    108  
     107         
    109108        uint32_t dma_addr; 
    110109 
    111         uint32_t dma_desc_addr; 
    112         dwc_otg_dma_desc_t* desc_addr; 
    113  
    114  
    115110        uint8_t *start_xfer_buff; 
    116         /** pointer to the transfer buffer */ 
    117         uint8_t *xfer_buff; 
    118         /** Number of bytes to transfer */ 
    119         unsigned xfer_len : 19; 
    120         /** Number of bytes transferred. */ 
    121         unsigned xfer_count : 19; 
    122         /** Sent ZLP */ 
    123         unsigned sent_zlp : 1; 
    124         /** Total len for control transfer */ 
    125         unsigned total_len : 19; 
    126  
    127         /** stall clear flag */ 
    128         unsigned stall_clear_flag : 1; 
    129  
    130         /** Allocated DMA Desc count */ 
    131         uint32_t        desc_cnt; 
    132  
    133 #ifdef DWC_EN_ISOC 
    134         /** 
    135          * Variables specific for ISOC EPs 
    136          * 
    137          */ 
    138         /** DMA addresses of ISOC buffers */ 
    139         uint32_t        dma_addr0; 
    140         uint32_t        dma_addr1; 
    141  
    142         uint32_t        iso_dma_desc_addr; 
    143         dwc_otg_dma_desc_t* iso_desc_addr; 
    144  
    145         /** pointer to the transfer buffers */ 
    146         uint8_t         *xfer_buff0; 
    147         uint8_t         *xfer_buff1; 
    148  
    149         /** number of ISOC Buffer is processing */ 
    150         uint32_t        proc_buf_num; 
    151         /** Interval of ISOC Buffer processing */ 
    152         uint32_t        buf_proc_intrvl; 
    153         /** Data size for regular frame */ 
    154         uint32_t        data_per_frame; 
    155  
    156         /* todo - pattern data support is to be implemented in the future */ 
    157         /** Data size for pattern frame */ 
    158         uint32_t        data_pattern_frame; 
    159         /** Frame number of pattern data */ 
    160         uint32_t        sync_frame; 
    161  
    162         /** bInterval */ 
    163         uint32_t        bInterval; 
    164         /** ISO Packet number per frame */ 
    165         uint32_t        pkt_per_frm; 
    166         /** Next frame num for which will be setup DMA Desc */ 
    167         uint32_t        next_frame; 
    168         /** Number of packets per buffer processing */ 
    169         uint32_t        pkt_cnt; 
    170         /** Info for all isoc packets */ 
    171         iso_pkt_info_t  *pkt_info; 
    172         /** current pkt number */ 
    173         uint32_t        cur_pkt; 
    174         /** current pkt number */ 
    175         uint8_t         *cur_pkt_addr; 
    176         /** current pkt number */ 
    177         uint32_t        cur_pkt_dma_addr; 
    178 #endif //DWC_EN_ISOC 
    179 /** @} */ 
     111        /** pointer to the transfer buffer */ 
     112        uint8_t *xfer_buff;           
     113        /** Number of bytes to transfer */ 
     114        unsigned xfer_len : 19;        
     115        /** Number of bytes transferred. */ 
     116        unsigned xfer_count : 19; 
     117        /** Sent ZLP */ 
     118        unsigned sent_zlp : 1; 
     119        /** Total len for control transfer */ 
     120        unsigned total_len : 19; 
     121 
     122                /** stall clear flag */ 
     123                unsigned stall_clear_flag : 1; 
     124 
     125        /** @} */ 
    180126} dwc_ep_t; 
    181127 
     
    183129 * Reasons for halting a host channel. 
    184130 */ 
    185 typedef enum dwc_otg_halt_status 
    186 { 
     131typedef enum dwc_otg_halt_status { 
    187132        DWC_OTG_HC_XFER_NO_HALT_STATUS, 
    188133        DWC_OTG_HC_XFER_COMPLETE, 
     
    200145        DWC_OTG_HC_XFER_URB_DEQUEUE 
    201146} dwc_otg_halt_status_e; 
    202  
     147         
    203148/** 
    204149 * Host channel descriptor. This structure represents the state of a single 
     
    206151 * transfer packets to an endpoint via a host channel. 
    207152 */ 
    208 typedef struct dwc_hc 
    209 { 
     153typedef struct dwc_hc { 
    210154        /** Host channel number used for register address lookup */ 
    211         uint8_t  hc_num; 
     155        uint8_t  hc_num; 
    212156 
    213157        /** Device to access */ 
     
    223167         * EP speed. 
    224168         * One of the following values: 
    225          *      - DWC_OTG_EP_SPEED_LOW 
     169         *      - DWC_OTG_EP_SPEED_LOW 
    226170         *      - DWC_OTG_EP_SPEED_FULL 
    227171         *      - DWC_OTG_EP_SPEED_HIGH 
     
    230174#define DWC_OTG_EP_SPEED_LOW    0 
    231175#define DWC_OTG_EP_SPEED_FULL   1 
    232 #define DWC_OTG_EP_SPEED_HIGH   2 
     176#define DWC_OTG_EP_SPEED_HIGH   2        
    233177 
    234178        /** 
     
    251195         * 2: DATA1,<br> 
    252196         * 3: MDATA (non-Control EP), 
    253          *        SETUP (Control EP) 
     197         *    SETUP (Control EP) 
    254198         */ 
    255199        unsigned data_pid_start : 2; 
     
    285229         * channel. If 0, process normally. 
    286230         */ 
    287         uint8_t do_ping; 
     231        uint8_t do_ping; 
    288232 
    289233        /** 
     
    310254         * Reason for halting the host channel. 
    311255         */ 
    312         dwc_otg_halt_status_e   halt_status; 
     256        dwc_otg_halt_status_e   halt_status; 
    313257 
    314258        /* 
    315259         * Split settings for the host channel 
    316260         */ 
    317         uint8_t do_split;                  /**< Enable split for the channel */ 
    318         uint8_t complete_split;    /**< Enable complete split */ 
    319         uint8_t hub_addr;                  /**< Address of high speed hub */ 
    320  
    321         uint8_t port_addr;                 /**< Port of the low/full speed device */ 
    322         /** Split transaction position 
     261        uint8_t do_split;          /**< Enable split for the channel */ 
     262        uint8_t complete_split;    /**< Enable complete split */ 
     263        uint8_t hub_addr;          /**< Address of high speed hub */ 
     264 
     265        uint8_t port_addr;         /**< Port of the low/full speed device */ 
     266        /** Split transaction position  
    323267         * One of the following values: 
    324          *        - DWC_HCSPLIT_XACTPOS_MID 
    325          *        - DWC_HCSPLIT_XACTPOS_BEGIN 
    326          *        - DWC_HCSPLIT_XACTPOS_END 
    327          *        - DWC_HCSPLIT_XACTPOS_ALL */ 
     268         *    - DWC_HCSPLIT_XACTPOS_MID  
     269         *    - DWC_HCSPLIT_XACTPOS_BEGIN 
     270         *    - DWC_HCSPLIT_XACTPOS_END 
     271         *    - DWC_HCSPLIT_XACTPOS_ALL */ 
    328272        uint8_t xact_pos; 
    329273 
     
    354298 * dwc_otg_cil_init. 
    355299 */ 
    356 typedef struct dwc_otg_core_params 
     300 
     301typedef struct dwc_otg_core_params  
    357302{ 
    358303        int32_t opt; 
    359 #define dwc_param_opt_default 1 
    360  
    361         /** 
     304//#define dwc_param_opt_default 1 
     305        /** 
    362306         * Specifies the OTG capabilities. The driver will automatically 
    363307         * detect the value for this parameter if none is specified. 
    364         * 0 - HNP and SRP capable (default) 
    365         * 1 - SRP Only capable 
    366         * 2 - No HNP/SRP capable 
    367         */ 
    368         int32_t otg_cap; 
     308        * 0 - HNP and SRP capable (default) 
     309        * 1 - SRP Only capable 
     310        * 2 - No HNP/SRP capable 
     311        */ 
     312        int32_t otg_cap; 
    369313#define DWC_OTG_CAP_PARAM_HNP_SRP_CAPABLE 0 
    370314#define DWC_OTG_CAP_PARAM_SRP_ONLY_CAPABLE 1 
    371315#define DWC_OTG_CAP_PARAM_NO_HNP_SRP_CAPABLE 2 
    372 #define dwc_param_otg_cap_default DWC_OTG_CAP_PARAM_HNP_SRP_CAPABLE 
    373  
    374         /** 
    375          * Specifies whether to use slave or DMA mode for accessing the data 
    376          * FIFOs. The driver will automatically detect the value for this 
    377          * parameter if none is specified. 
    378          * 0 - Slave 
    379          * 1 - DMA (default, if available) 
    380          */ 
     316//#define dwc_param_otg_cap_default DWC_OTG_CAP_PARAM_HNP_SRP_CAPABLE 
     317        /** 
     318         * Specifies whether to use slave or DMA mode for accessing the data 
     319         * FIFOs. The driver will automatically detect the value for this 
     320         * parameter if none is specified. 
     321         * 0 - Slave 
     322         * 1 - DMA (default, if available) 
     323         */ 
    381324        int32_t dma_enable; 
    382 #define dwc_param_dma_enable_default 1 
    383  
    384         /** 
    385          * When DMA mode is enabled specifies whether to use address DMA or DMA Descritor mode for accessing the data 
    386          * FIFOs in device mode. The driver will automatically detect the value for this 
    387          * parameter if none is specified. 
    388          * 0 - address DMA 
    389          * 1 - DMA Descriptor(default, if available) 
    390          */ 
    391         int32_t dma_desc_enable; 
    392 #define dwc_param_dma_desc_enable_default 0 
     325//#define dwc_param_dma_enable_default 1 
    393326        /** The DMA Burst size (applicable only for External DMA 
    394          * Mode). 1, 4, 8 16, 32, 64, 128, 256 (default 32) 
    395          */ 
    396         int32_t dma_burst_size;  /* Translate this to GAHBCFG values */ 
    397 #define dwc_param_dma_burst_size_default 32 
    398  
     327         * Mode). 1, 4, 8 16, 32, 64, 128, 256 (default 32) 
     328         */ 
     329        int32_t dma_burst_size;  /* Translate this to GAHBCFG values */ 
     330//#define dwc_param_dma_burst_size_default 32 
    399331        /** 
    400332         * Specifies the maximum speed of operation in host and device mode. 
     
    405337         * 1 - Full Speed 
    406338         */ 
    407         int32_t speed; 
    408 #define dwc_param_speed_default 0 
     339        int32_t speed; 
     340//#define dwc_param_speed_default 0 
    409341#define DWC_SPEED_PARAM_HIGH 0 
    410342#define DWC_SPEED_PARAM_FULL 1 
    411343 
    412         /** Specifies whether low power mode is supported when attached 
    413          *      to a Full Speed or Low Speed device in host mode. 
     344        /** Specifies whether low power mode is supported when attached  
     345         *  to a Full Speed or Low Speed device in host mode. 
    414346         * 0 - Don't support low power mode (default) 
    415347         * 1 - Support low power mode 
    416348         */ 
    417349        int32_t host_support_fs_ls_low_power; 
    418 #define dwc_param_host_support_fs_ls_low_power_default 0 
    419  
     350//#define dwc_param_host_support_fs_ls_low_power_default 0 
    420351        /** Specifies the PHY clock rate in low power mode when connected to a 
    421352         * Low Speed device in host mode. This parameter is applicable only if 
    422          * HOST_SUPPORT_FS_LS_LOW_POWER is enabled.      If PHY_TYPE is set to FS 
     353         * HOST_SUPPORT_FS_LS_LOW_POWER is enabled.  If PHY_TYPE is set to FS 
    423354         * then defaults to 6 MHZ otherwise 48 MHZ. 
    424355         * 
     
    427358         */ 
    428359        int32_t host_ls_low_power_phy_clk; 
    429 #define dwc_param_host_ls_low_power_phy_clk_default 0 
     360//#define dwc_param_host_ls_low_power_phy_clk_default 0 
    430361#define DWC_HOST_LS_LOW_POWER_PHY_CLK_PARAM_48MHZ 0 
    431362#define DWC_HOST_LS_LOW_POWER_PHY_CLK_PARAM_6MHZ 1 
    432  
    433363        /** 
    434364         * 0 - Use cC FIFO size parameters 
     
    436366         */ 
    437367        int32_t enable_dynamic_fifo; 
    438 #define dwc_param_enable_dynamic_fifo_default 1 
    439  
    440         /** Total number of 4-byte words in the data FIFO memory. This 
    441          * memory includes the Rx FIFO, non-periodic Tx FIFO, and periodic 
     368//#define dwc_param_enable_dynamic_fifo_default 1 
     369        /** Total number of 4-byte words in the data FIFO memory. This  
     370         * memory includes the Rx FIFO, non-periodic Tx FIFO, and periodic  
    442371         * Tx FIFOs. 
    443372         * 32 to 32768 (default 8192) 
     
    445374         */ 
    446375        int32_t data_fifo_size; 
    447 #define dwc_param_data_fifo_size_default 8192 
    448  
    449         /** Number of 4-byte words in the Rx FIFO in device mode when dynamic 
     376//#define dwc_param_data_fifo_size_default 8192 
     377        /** Number of 4-byte words in the Rx FIFO in device mode when dynamic  
    450378         * FIFO sizing is enabled. 
    451379         * 16 to 32768 (default 1064) 
    452380         */ 
    453381        int32_t dev_rx_fifo_size; 
    454 #define dwc_param_dev_rx_fifo_size_default  1064 
    455  
    456         /** Number of 4-byte words in the non-periodic Tx FIFO in device mode 
     382//#define dwc_param_dev_rx_fifo_size_default 1064 
     383        /** Number of 4-byte words in the non-periodic Tx FIFO in device mode  
    457384         * when dynamic FIFO sizing is enabled. 
    458385         * 16 to 32768 (default 1024) 
    459386         */ 
    460387        int32_t dev_nperio_tx_fifo_size; 
    461 #define dwc_param_dev_nperio_tx_fifo_size_default 1024 
    462  
     388//#define dwc_param_dev_nperio_tx_fifo_size_default 1024 
    463389        /** Number of 4-byte words in each of the periodic Tx FIFOs in device 
    464390         * mode when dynamic FIFO sizing is enabled. 
     
    466392         */ 
    467393        uint32_t dev_perio_tx_fifo_size[MAX_PERIO_FIFOS]; 
    468 #define dwc_param_dev_perio_tx_fifo_size_default 256 
    469  
    470         /** Number of 4-byte words in the Rx FIFO in host mode when dynamic 
     394//#define dwc_param_dev_perio_tx_fifo_size_default 256 
     395        /** Number of 4-byte words in the Rx FIFO in host mode when dynamic  
    471396         * FIFO sizing is enabled. 
     397         * 16 to 32768 (default 1024)   
     398         */ 
     399        int32_t host_rx_fifo_size; 
     400//#define dwc_param_host_rx_fifo_size_default 1024 
     401        /** Number of 4-byte words in the non-periodic Tx FIFO in host mode  
     402         * when Dynamic FIFO sizing is enabled in the core.  
    472403         * 16 to 32768 (default 1024) 
    473404         */ 
    474         int32_t host_rx_fifo_size; 
    475 #define dwc_param_host_rx_fifo_size_default 1024 
    476  
    477         /** Number of 4-byte words in the non-periodic Tx FIFO in host mode 
    478          * when Dynamic FIFO sizing is enabled in the core. 
     405        int32_t host_nperio_tx_fifo_size; 
     406//#define dwc_param_host_nperio_tx_fifo_size_default 1024 
     407        /** Number of 4-byte words in the host periodic Tx FIFO when dynamic  
     408         * FIFO sizing is enabled.  
    479409         * 16 to 32768 (default 1024) 
    480410         */ 
    481         int32_t host_nperio_tx_fifo_size; 
    482 #define dwc_param_host_nperio_tx_fifo_size_default 1024 
    483  
    484         /** Number of 4-byte words in the host periodic Tx FIFO when dynamic 
    485          * FIFO sizing is enabled. 
    486          * 16 to 32768 (default 1024) 
    487          */ 
    488411        int32_t host_perio_tx_fifo_size; 
    489 #define dwc_param_host_perio_tx_fifo_size_default 1024 
    490  
    491         /** The maximum transfer size supported in bytes. 
     412//#define dwc_param_host_perio_tx_fifo_size_default 1024 
     413        /** The maximum transfer size supported in bytes.   
    492414         * 2047 to 65,535  (default 65,535) 
    493415         */ 
    494416        int32_t max_transfer_size; 
    495 #define dwc_param_max_transfer_size_default 65535 
    496  
    497         /** The maximum number of packets in a transfer. 
     417//#define dwc_param_max_transfer_size_default 65535 
     418        /** The maximum number of packets in a transfer.   
    498419         * 15 to 511  (default 511) 
    499420         */ 
    500421        int32_t max_packet_count; 
    501 #define dwc_param_max_packet_count_default 511 
    502  
    503         /** The number of host channel registers to use. 
    504          * 1 to 16 (default 12) 
     422//#define dwc_param_max_packet_count_default 511 
     423        /** The number of host channel registers to use.   
     424         * 1 to 16 (default 12)  
    505425         * Note: The FPGA configuration supports a maximum of 12 host channels. 
    506426         */ 
    507427        int32_t host_channels; 
    508 #define dwc_param_host_channels_default 12 
    509  
    510         /** The number of endpoints in addition to EP0 available for device 
    511          * mode operations. 
    512          * 1 to 15 (default 6 IN and OUT) 
    513          * Note: The FPGA configuration supports a maximum of 6 IN and OUT 
     428//#define dwc_param_host_channels_default 12 
     429        /** The number of endpoints in addition to EP0 available for device  
     430         * mode operations.  
     431         * 1 to 15 (default 6 IN and OUT)  
     432         * Note: The FPGA configuration supports a maximum of 6 IN and OUT  
    514433         * endpoints in addition to EP0. 
    515434         */ 
    516435        int32_t dev_endpoints; 
    517 #define dwc_param_dev_endpoints_default 6 
    518  
    519                 /** 
    520                  * Specifies the type of PHY interface to use. By default, the driver 
    521                  * will automatically detect the phy_type. 
    522                  * 
    523                  * 0 - Full Speed PHY 
    524                  * 1 - UTMI+ (default) 
    525                  * 2 - ULPI 
    526                  */ 
    527         int32_t phy_type; 
     436//#define dwc_param_dev_endpoints_default 6 
     437        /**  
     438         * Specifies the type of PHY interface to use. By default, the driver 
     439         * will automatically detect the phy_type. 
     440         *  
     441         * 0 - Full Speed PHY 
     442         * 1 - UTMI+ (default) 
     443         * 2 - ULPI 
     444         */ 
     445        int32_t phy_type;  
    528446#define DWC_PHY_TYPE_PARAM_FS 0 
    529447#define DWC_PHY_TYPE_PARAM_UTMI 1 
    530448#define DWC_PHY_TYPE_PARAM_ULPI 2 
    531 #define dwc_param_phy_type_default DWC_PHY_TYPE_PARAM_UTMI 
    532  
    533         /** 
    534          * Specifies the UTMI+ Data Width.      This parameter is 
    535          * applicable for a PHY_TYPE of UTMI+ or ULPI. (For a ULPI 
    536          * PHY_TYPE, this parameter indicates the data width between 
    537          * the MAC and the ULPI Wrapper.) Also, this parameter is 
    538          * applicable only if the OTG_HSPHY_WIDTH cC parameter was set 
    539          * to "8 and 16 bits", meaning that the core has been 
    540          * configured to work at either data path width. 
    541          * 
    542          * 8 or 16 bits (default 16) 
    543          */ 
    544         int32_t phy_utmi_width; 
    545 #define dwc_param_phy_utmi_width_default 16 
    546  
    547         /** 
    548          * Specifies whether the ULPI operates at double or single 
    549          * data rate. This parameter is only applicable if PHY_TYPE is 
    550          * ULPI. 
    551          * 
    552          * 0 - single data rate ULPI interface with 8 bit wide data 
    553          * bus (default) 
    554          * 1 - double data rate ULPI interface with 4 bit wide data 
    555          * bus 
    556          */ 
    557         int32_t phy_ulpi_ddr; 
    558 #define dwc_param_phy_ulpi_ddr_default 0 
    559  
    560         /** 
    561          * Specifies whether to use the internal or external supply to 
     449//#define dwc_param_phy_type_default DWC_PHY_TYPE_PARAM_UTMI 
     450        /** 
     451         * Specifies the UTMI+ Data Width.  This parameter is 
     452         * applicable for a PHY_TYPE of UTMI+ or ULPI. (For a ULPI 
     453         * PHY_TYPE, this parameter indicates the data width between 
     454         * the MAC and the ULPI Wrapper.) Also, this parameter is 
     455         * applicable only if the OTG_HSPHY_WIDTH cC parameter was set 
     456         * to "8 and 16 bits", meaning that the core has been 
     457         * configured to work at either data path width.  
     458         * 
     459         * 8 or 16 bits (default 16) 
     460         */ 
     461        int32_t phy_utmi_width; 
     462//#define dwc_param_phy_utmi_width_default 16 
     463        /** 
     464         * Specifies whether the ULPI operates at double or single 
     465         * data rate. This parameter is only applicable if PHY_TYPE is 
     466         * ULPI. 
     467         *  
     468         * 0 - single data rate ULPI interface with 8 bit wide data 
     469         * bus (default) 
     470         * 1 - double data rate ULPI interface with 4 bit wide data 
     471         * bus 
     472         */ 
     473        int32_t phy_ulpi_ddr; 
     474//#define dwc_param_phy_ulpi_ddr_default 0 
     475        /** 
     476         * Specifies whether to use the internal or external supply to  
    562477         * drive the vbus with a ULPI phy. 
    563478         */ 
     
    565480#define DWC_PHY_ULPI_INTERNAL_VBUS 0 
    566481#define DWC_PHY_ULPI_EXTERNAL_VBUS 1 
    567 #define dwc_param_phy_ulpi_ext_vbus_default DWC_PHY_ULPI_INTERNAL_VBUS 
    568  
    569         /** 
     482//#define dwc_param_phy_ulpi_ext_vbus_default DWC_PHY_ULPI_INTERNAL_VBUS 
     483        /** 
    570484         * Specifies whether to use the I2Cinterface for full speed PHY. This 
    571485         * parameter is only applicable if PHY_TYPE is FS. 
    572         * 0 - No (default) 
    573         * 1 - Yes 
    574         */ 
    575         int32_t i2c_enable; 
    576 #define dwc_param_i2c_enable_default 0 
    577  
    578         int32_t ulpi_fs_ls; 
    579 #define dwc_param_ulpi_fs_ls_default 0 
     486        * 0 - No (default) 
     487        * 1 - Yes 
     488        */ 
     489        int32_t i2c_enable; 
     490//#define dwc_param_i2c_enable_default 0 
     491 
     492        int32_t ulpi_fs_ls; 
     493//#define dwc_param_ulpi_fs_ls_default 0 
    580494 
    581495        int32_t ts_dline; 
    582 #define dwc_param_ts_dline_default 0 
     496//#define dwc_param_ts_dline_default 0 
    583497 
    584498        /** 
     
    617531        uint32_t rx_thr_length; 
    618532#define dwc_param_rx_thr_length_default 64 
    619  
    620         /** Per Transfer Interrupt 
    621          *      mode enable flag 
    622          * 1 - Enabled 
    623          * 0 - Disabled 
    624          */ 
    625         uint32_t pti_enable; 
    626 #define dwc_param_pti_enable_default 0 
    627  
    628         /** Molti Processor Interrupt 
    629          *      mode enable flag 
    630          * 1 - Enabled 
    631          * 0 - Disabled 
    632          */ 
    633         uint32_t mpi_enable; 
    634 #define dwc_param_mpi_enable_default 0 
    635  
    636533} dwc_otg_core_params_t; 
    637534 
    638535#ifdef DEBUG 
    639536struct dwc_otg_core_if; 
    640 typedef struct hc_xfer_info 
     537typedef struct hc_xfer_info 
    641538{ 
    642539        struct dwc_otg_core_if  *core_if; 
     
    650547 * represents the programming view of the controller as a whole. 
    651548 */ 
    652 typedef struct dwc_otg_core_if 
    653 { 
    654         /** Parameters that define how the core should be configured.*/ 
    655         dwc_otg_core_params_t      *core_params; 
    656  
    657         /** Core Global registers starting at offset 000h. */ 
    658         dwc_otg_core_global_regs_t *core_global_regs; 
    659  
    660         /** Device-specific information */ 
    661         dwc_otg_dev_if_t                   *dev_if; 
    662         /** Host-specific information */ 
    663         dwc_otg_host_if_t                  *host_if; 
    664  
    665         /** Value from SNPSID register */ 
    666         uint32_t snpsid; 
    667  
    668         /* 
    669          * Set to 1 if the core PHY interface bits in USBCFG have been 
    670          * initialized. 
    671          */ 
    672         uint8_t phy_init_done; 
    673  
    674         /* 
    675          * SRP Success flag, set by srp success interrupt in FS I2C mode 
    676          */ 
    677         uint8_t srp_success; 
    678         uint8_t srp_timer_started; 
    679  
    680         /* Common configuration information */ 
    681         /** Power and Clock Gating Control Register */ 
    682         volatile uint32_t *pcgcctl; 
     549typedef struct dwc_otg_core_if  
     550{ 
     551    /** Parameters that define how the core should be configured.*/ 
     552    dwc_otg_core_params_t      *core_params; 
     553 
     554    /** Core Global registers starting at offset 000h. */ 
     555    dwc_otg_core_global_regs_t *core_global_regs; 
     556 
     557    /** Device-specific information */ 
     558    dwc_otg_dev_if_t           *dev_if; 
     559    /** Host-specific information */ 
     560    dwc_otg_host_if_t          *host_if; 
     561 
     562    /* 
     563     * Set to 1 if the core PHY interface bits in USBCFG have been 
     564     * initialized. 
     565     */ 
     566    uint8_t phy_init_done; 
     567 
     568    /* 
     569     * SRP Success flag, set by srp success interrupt in FS I2C mode 
     570     */ 
     571    uint8_t srp_success; 
     572    uint8_t srp_timer_started; 
     573 
     574    /* Common configuration information */ 
     575    /** Power and Clock Gating Control Register */ 
     576    volatile uint32_t *pcgcctl; 
    683577#define DWC_OTG_PCGCCTL_OFFSET 0xE00 
    684578 
    685         /** Push/pop addresses for endpoints or host channels.*/ 
    686         uint32_t *data_fifo[MAX_EPS_CHANNELS]; 
     579    /** Push/pop addresses for endpoints or host channels.*/ 
     580    uint32_t *data_fifo[MAX_EPS_CHANNELS]; 
    687581#define DWC_OTG_DATA_FIFO_OFFSET 0x1000 
    688582#define DWC_OTG_DATA_FIFO_SIZE 0x1000 
    689583 
    690         /** Total RAM for FIFOs (Bytes) */ 
    691         uint16_t total_fifo_size; 
    692         /** Size of Rx FIFO (Bytes) */ 
    693         uint16_t rx_fifo_size; 
    694         /** Size of Non-periodic Tx FIFO (Bytes) */ 
    695         uint16_t nperio_tx_fifo_size; 
    696  
    697  
    698         /** 1 if DMA is enabled, 0 otherwise. */ 
    699         uint8_t dma_enable; 
    700  
    701         /** 1 if Descriptor DMA mode is enabled, 0 otherwise. */ 
    702         uint8_t dma_desc_enable; 
    703  
    704         /** 1 if PTI Enhancement mode is enabled, 0 otherwise. */ 
    705         uint8_t pti_enh_enable; 
    706  
    707         /** 1 if MPI Enhancement mode is enabled, 0 otherwise. */ 
    708         uint8_t multiproc_int_enable; 
     584    /** Total RAM for FIFOs (Bytes) */ 
     585    uint16_t total_fifo_size; 
     586    /** Size of Rx FIFO (Bytes) */ 
     587    uint16_t rx_fifo_size; 
     588    /** Size of Non-periodic Tx FIFO (Bytes) */ 
     589    uint16_t nperio_tx_fifo_size; 
     590         
     591    /** 1 if DMA is enabled, 0 otherwise. */ 
     592    uint8_t     dma_enable; 
    709593 
    710594        /** 1 if dedicated Tx FIFOs are enabled, 0 otherwise. */ 
    711595        uint8_t en_multiple_tx_fifo; 
    712596 
    713         /** Set to 1 if multiple packets of a high-bandwidth transfer is in 
    714          * process of being queued */ 
    715         uint8_t queuing_high_bandwidth; 
    716  
    717         /** Hardware Configuration -- stored here for convenience.*/ 
    718         hwcfg1_data_t hwcfg1; 
    719         hwcfg2_data_t hwcfg2; 
    720         hwcfg3_data_t hwcfg3; 
    721         hwcfg4_data_t hwcfg4; 
    722  
    723         /** Host and Device Configuration -- stored here for convenience.*/ 
    724         hcfg_data_t hcfg; 
    725         dcfg_data_t dcfg; 
    726  
    727         /** The operational State, during transations 
    728          * (a_host>>a_peripherial and b_device=>b_host) this may not 
    729          * match the core but allows the software to determine 
    730          * transitions. 
    731          */ 
    732         uint8_t op_state; 
    733  
    734         /** 
    735          * Set to 1 if the HCD needs to be restarted on a session request 
    736          * interrupt. This is required if no connector ID status change has 
    737          * occurred since the HCD was last disconnected. 
    738          */ 
    739         uint8_t restart_hcd_on_session_req; 
    740  
    741         /** HCD callbacks */ 
    742         /** A-Device is a_host */ 
    743 #define A_HOST          (1) 
    744         /** A-Device is a_suspend */ 
    745 #define A_SUSPEND       (2) 
    746         /** A-Device is a_peripherial */ 
    747 #define A_PERIPHERAL    (3) 
    748         /** B-Device is operating as a Peripheral. */ 
     597    /** Set to 1 if multiple packets of a high-bandwidth transfer is in 
     598     * process of being queued */ 
     599    uint8_t queuing_high_bandwidth; 
     600 
     601    /** Hardware Configuration -- stored here for convenience.*/ 
     602    hwcfg1_data_t hwcfg1; 
     603    hwcfg2_data_t hwcfg2; 
     604    hwcfg3_data_t hwcfg3; 
     605    hwcfg4_data_t hwcfg4; 
     606 
     607    /** The operational State, during transations 
     608     * (a_host>>a_peripherial and b_device=>b_host) this may not 
     609     * match the core but allows the software to determine 
     610     * transitions. 
     611     */ 
     612    uint8_t op_state; 
     613         
     614    /** 
     615     * Set to 1 if the HCD needs to be restarted on a session request 
     616     * interrupt. This is required if no connector ID status change has 
     617     * occurred since the HCD was last disconnected. 
     618     */ 
     619    uint8_t restart_hcd_on_session_req; 
     620 
     621    /** HCD callbacks */ 
     622    /** A-Device is a_host */ 
     623#define A_HOST          (1) 
     624    /** A-Device is a_suspend */ 
     625#define A_SUSPEND       (2) 
     626    /** A-Device is a_peripherial */ 
     627#define A_PERIPHERAL    (3) 
     628    /** B-Device is operating as a Peripheral. */ 
    749629#define B_PERIPHERAL    (4) 
    750         /** B-Device is operating as a Host. */ 
    751 #define B_HOST          (5) 
    752  
    753         /** HCD callbacks */ 
    754         struct dwc_otg_cil_callbacks *hcd_cb; 
    755         /** PCD callbacks */ 
    756         struct dwc_otg_cil_callbacks *pcd_cb; 
     630    /** B-Device is operating as a Host. */ 
     631#define B_HOST          (5)         
     632 
     633    /** HCD callbacks */ 
     634    struct dwc_otg_cil_callbacks *hcd_cb; 
     635    /** PCD callbacks */ 
     636    struct dwc_otg_cil_callbacks *pcd_cb; 
    757637 
    758638        /** Device mode Periodic Tx FIFO Mask */ 
     
    761641        uint32_t tx_msk; 
    762642 
    763         /** Workqueue object used for handling several interrupts */ 
    764         struct workqueue_struct *wq_otg; 
    765  
    766         /** Work object used for handling "Connector ID Status Change" Interrupt */ 
    767         struct work_struct      w_conn_id; 
    768  
    769         /** Work object used for handling "Wakeup Detected" Interrupt */ 
    770 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) 
    771         struct work_struct      w_wkp; 
     643#ifdef DEBUG 
     644    uint32_t            start_hcchar_val[MAX_EPS_CHANNELS]; 
     645 
     646    hc_xfer_info_t              hc_xfer_info[MAX_EPS_CHANNELS]; 
     647    struct timer_list   hc_xfer_timer[MAX_EPS_CHANNELS]; 
     648 
     649#if 1 // winder 
     650    uint32_t            hfnum_7_samples; 
     651    uint32_t            hfnum_7_frrem_accum; 
     652    uint32_t            hfnum_0_samples; 
     653    uint32_t            hfnum_0_frrem_accum; 
     654    uint32_t            hfnum_other_samples; 
     655    uint32_t            hfnum_other_frrem_accum; 
    772656#else 
    773         struct delayed_work     w_wkp; 
     657    uint32_t            hfnum_7_samples; 
     658    uint64_t            hfnum_7_frrem_accum; 
     659    uint32_t            hfnum_0_samples; 
     660    uint64_t            hfnum_0_frrem_accum; 
     661    uint32_t            hfnum_other_samples; 
     662    uint64_t            hfnum_other_frrem_accum; 
    774663#endif 
    775  
    776 #ifdef DEBUG 
    777         uint32_t                start_hcchar_val[MAX_EPS_CHANNELS]; 
    778  
    779         hc_xfer_info_t          hc_xfer_info[MAX_EPS_CHANNELS]; 
    780         struct timer_list       hc_xfer_timer[MAX_EPS_CHANNELS]; 
    781  
    782         uint32_t                hfnum_7_samples; 
    783         uint64_t                hfnum_7_frrem_accum; 
    784         uint32_t                hfnum_0_samples; 
    785         uint64_t                hfnum_0_frrem_accum; 
    786         uint32_t                hfnum_other_samples; 
    787         uint64_t                hfnum_other_frrem_accum; 
    788 #endif 
    789  
     664        resource_size_t phys_addr;              /* Added to support PLB DMA : phys-virt mapping */ 
     665#endif   
    790666 
    791667} dwc_otg_core_if_t; 
    792  
    793 /*We must clear S3C24XX_EINTPEND external interrupt register 
    794  * because after clearing in this register trigerred IRQ from 
    795  * H/W core in kernel interrupt can be occured again before OTG 
    796  * handlers clear all IRQ sources of Core registers because of 
    797  * timing latencies and Low Level IRQ Type. 
    798  */ 
    799  
    800 #ifdef CONFIG_MACH_IPMATE 
    801 #define  S3C2410X_CLEAR_EINTPEND()   \ 
    802 do { \ 
    803         if (!dwc_otg_read_core_intr(core_if)) { \ 
    804         __raw_writel(1UL << 11,S3C24XX_EINTPEND); \ 
    805         } \ 
    806 } while (0) 
    807 #else 
    808 #define  S3C2410X_CLEAR_EINTPEND()   do { } while (0) 
    809 #endif 
    810  
    811 /* 
    812  * The following functions are functions for works 
    813  * using during handling some interrupts 
    814  */ 
    815 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) 
    816  
    817 extern void w_conn_id_status_change(void *p); 
    818 extern void w_wakeup_detected(void *p); 
    819  
    820 #else 
    821  
    822 extern void w_conn_id_status_change(struct work_struct *p); 
    823 extern void w_wakeup_detected(struct work_struct *p); 
    824  
    825 #endif 
    826  
    827668 
    828669/* 
     
    831672 */ 
    832673extern dwc_otg_core_if_t *dwc_otg_cil_init(const uint32_t *_reg_base_addr, 
    833                                            dwc_otg_core_params_t *_core_params); 
     674                                           dwc_otg_core_params_t *_core_params); 
    834675extern void dwc_otg_cil_remove(dwc_otg_core_if_t *_core_if); 
    835676extern void dwc_otg_core_init(dwc_otg_core_if_t *_core_if); 
     
    851692extern void dwc_otg_ep_deactivate(dwc_otg_core_if_t *_core_if, dwc_ep_t *_ep); 
    852693extern void dwc_otg_ep_start_transfer(dwc_otg_core_if_t *_core_if, dwc_ep_t *_ep); 
    853 extern void dwc_otg_ep_start_zl_transfer(dwc_otg_core_if_t *_core_if, dwc_ep_t *_ep); 
    854694extern void dwc_otg_ep0_start_transfer(dwc_otg_core_if_t *_core_if, dwc_ep_t *_ep); 
    855695extern void dwc_otg_ep0_continue_transfer(dwc_otg_core_if_t *_core_if, dwc_ep_t *_ep); 
     
    859699extern void dwc_otg_enable_device_interrupts(dwc_otg_core_if_t *_core_if); 
    860700extern void dwc_otg_dump_dev_registers(dwc_otg_core_if_t *_core_if); 
    861 extern void dwc_otg_dump_spram(dwc_otg_core_if_t *_core_if); 
    862 #ifdef DWC_EN_ISOC 
    863 extern void dwc_otg_iso_ep_start_frm_transfer(dwc_otg_core_if_t *core_if, dwc_ep_t *ep); 
    864 extern void dwc_otg_iso_ep_start_buf_transfer(dwc_otg_core_if_t *core_if, dwc_ep_t *ep); 
    865 #endif //DWC_EN_ISOC 
    866701/**@}*/ 
    867702 
     
    873708extern void dwc_otg_hc_init(dwc_otg_core_if_t *_core_if, dwc_hc_t *_hc); 
    874709extern void dwc_otg_hc_halt(dwc_otg_core_if_t *_core_if, 
    875                                 dwc_hc_t *_hc, 
    876                                 dwc_otg_halt_status_e _halt_status); 
     710                            dwc_hc_t *_hc, 
     711                            dwc_otg_halt_status_e _halt_status); 
    877712extern void dwc_otg_hc_cleanup(dwc_otg_core_if_t *_core_if, dwc_hc_t *_hc); 
    878713extern void dwc_otg_hc_start_transfer(dwc_otg_core_if_t *_core_if, dwc_hc_t *_hc); 
     
    884719 
    885720/** 
    886  * This function Reads HPRT0 in preparation to modify.  It keeps the 
     721 * This function Reads HPRT0 in preparation to modify.  It keeps the 
    887722 * WC bits 0 so that if they are read as 1, they won't clear when you 
    888  * write it back 
    889  */ 
    890 static inline uint32_t dwc_otg_read_hprt0(dwc_otg_core_if_t *_core_if) 
    891 { 
    892         hprt0_data_t hprt0; 
    893         hprt0.d32 = dwc_read_reg32(_core_if->host_if->hprt0); 
    894         hprt0.b.prtena = 0; 
    895         hprt0.b.prtconndet = 0; 
    896         hprt0.b.prtenchng = 0; 
    897         hprt0.b.prtovrcurrchng = 0; 
    898         return hprt0.d32; 
     723 * write it back  
     724 */ 
     725static inline uint32_t dwc_otg_read_hprt0(dwc_otg_core_if_t *_core_if)  
     726{ 
     727        hprt0_data_t hprt0; 
     728        hprt0.d32 = dwc_read_reg32(_core_if->host_if->hprt0); 
     729        hprt0.b.prtena = 0; 
     730        hprt0.b.prtconndet = 0; 
     731        hprt0.b.prtenchng = 0; 
     732        hprt0.b.prtovrcurrchng = 0; 
     733        return hprt0.d32; 
    899734} 
    900735 
     
    909744 
    910745extern void dwc_otg_read_packet(dwc_otg_core_if_t *core_if, 
    911                                 uint8_t *dest, 
     746                                uint8_t *dest,  
    912747                                uint16_t bytes); 
    913748 
    914749extern void dwc_otg_dump_global_registers(dwc_otg_core_if_t *_core_if); 
    915750 
    916 extern void dwc_otg_flush_tx_fifo( dwc_otg_core_if_t *_core_if, 
    917                                                                    const int _num ); 
     751extern void dwc_otg_flush_tx_fifo( dwc_otg_core_if_t *_core_if,  
     752                                   const int _num ); 
    918753extern void dwc_otg_flush_rx_fifo( dwc_otg_core_if_t *_core_if ); 
    919754extern void dwc_otg_core_reset( dwc_otg_core_if_t *_core_if ); 
    920755 
    921 extern dwc_otg_dma_desc_t* dwc_otg_ep_alloc_desc_chain(uint32_t * dma_desc_addr, uint32_t count); 
    922 extern void dwc_otg_ep_free_desc_chain(dwc_otg_dma_desc_t* desc_addr, uint32_t dma_desc_addr, uint32_t count); 
    923  
     756#define NP_TXFIFO_EMPTY -1 
     757#define MAX_NP_TXREQUEST_Q_SLOTS 8 
     758/** 
     759 * This function returns the endpoint number of the request at 
     760 * the top of non-periodic TX FIFO, or -1 if the request FIFO is 
     761 * empty. 
     762 */ 
     763static inline int dwc_otg_top_nptxfifo_epnum(dwc_otg_core_if_t *_core_if) { 
     764        gnptxsts_data_t txstatus = {.d32 = 0}; 
     765 
     766        txstatus.d32 = dwc_read_reg32(&_core_if->core_global_regs->gnptxsts); 
     767        return (txstatus.b.nptxqspcavail == MAX_NP_TXREQUEST_Q_SLOTS ? 
     768                -1 : txstatus.b.nptxqtop_chnep); 
     769} 
    924770/** 
    925771 * This function returns the Core Interrupt register. 
    926772 */ 
    927 static inline uint32_t dwc_otg_read_core_intr(dwc_otg_core_if_t *_core_if) 
    928 { 
     773static inline uint32_t dwc_otg_read_core_intr(dwc_otg_core_if_t *_core_if) { 
    929774        return (dwc_read_reg32(&_core_if->core_global_regs->gintsts) & 
    930                 dwc_read_reg32(&_core_if->core_global_regs->gintmsk)); 
     775                dwc_read_reg32(&_core_if->core_global_regs->gintmsk)); 
    931776} 
    932777 
     
    934779 * This function returns the OTG Interrupt register. 
    935780 */ 
    936 static inline uint32_t dwc_otg_read_otg_intr (dwc_otg_core_if_t *_core_if) 
    937 { 
     781static inline uint32_t dwc_otg_read_otg_intr (dwc_otg_core_if_t *_core_if) { 
    938782        return (dwc_read_reg32 (&_core_if->core_global_regs->gotgint)); 
    939783} 
     
    943787 * returns the IN endpoint interrupt bits. 
    944788 */ 
    945 static inline uint32_t dwc_otg_read_dev_all_in_ep_intr(dwc_otg_core_if_t *core_if) 
    946 { 
    947         uint32_t v; 
    948  
    949         if(core_if->multiproc_int_enable) { 
    950                 v = dwc_read_reg32(&core_if->dev_if->dev_global_regs->deachint) & 
    951                                 dwc_read_reg32(&core_if->dev_if->dev_global_regs->deachintmsk); 
    952         } else { 
    953                 v = dwc_read_reg32(&core_if->dev_if->dev_global_regs->daint) & 
    954                                 dwc_read_reg32(&core_if->dev_if->dev_global_regs->daintmsk); 
    955         } 
    956         return (v & 0xffff); 
    957  
     789static inline uint32_t dwc_otg_read_dev_all_in_ep_intr(dwc_otg_core_if_t *_core_if) { 
     790        uint32_t v; 
     791        v = dwc_read_reg32(&_core_if->dev_if->dev_global_regs->daint) & 
     792                dwc_read_reg32(&_core_if->dev_if->dev_global_regs->daintmsk); 
     793        return (v & 0xffff); 
     794         
    958795} 
    959796 
     
    962799 * returns the OUT endpoint interrupt bits. 
    963800 */ 
    964 static inline uint32_t dwc_otg_read_dev_all_out_ep_intr(dwc_otg_core_if_t *core_if) 
    965 { 
    966         uint32_t v; 
    967  
    968         if(core_if->multiproc_int_enable) { 
    969                 v = dwc_read_reg32(&core_if->dev_if->dev_global_regs->deachint) & 
    970                                 dwc_read_reg32(&core_if->dev_if->dev_global_regs->deachintmsk); 
    971         } else { 
    972                 v = dwc_read_reg32(&core_if->dev_if->dev_global_regs->daint) & 
    973                                 dwc_read_reg32(&core_if->dev_if->dev_global_regs->daintmsk); 
    974         } 
    975  
    976         return ((v & 0xffff0000) >> 16); 
     801static inline uint32_t dwc_otg_read_dev_all_out_ep_intr(dwc_otg_core_if_t *_core_if) { 
     802        uint32_t v; 
     803        v = dwc_read_reg32(&_core_if->dev_if->dev_global_regs->daint) & 
     804                dwc_read_reg32(&_core_if->dev_if->dev_global_regs->daintmsk); 
     805        return ((v & 0xffff0000) >> 16); 
    977806} 
    978807 
     
    980809 * This function returns the Device IN EP Interrupt register 
    981810 */ 
    982 static inline uint32_t dwc_otg_read_dev_in_ep_intr(dwc_otg_core_if_t *core_if, 
    983                                                         dwc_ep_t *ep) 
    984 { 
    985         dwc_otg_dev_if_t *dev_if = core_if->dev_if; 
     811static inline uint32_t dwc_otg_read_dev_in_ep_intr(dwc_otg_core_if_t *_core_if, 
     812                                                   dwc_ep_t *_ep) 
     813{ 
     814        dwc_otg_dev_if_t *dev_if = _core_if->dev_if; 
    986815        uint32_t v, msk, emp; 
    987  
    988         if(core_if->multiproc_int_enable) { 
    989                 msk = dwc_read_reg32(&dev_if->dev_global_regs->diepeachintmsk[ep->num]); 
    990                 emp = dwc_read_reg32(&dev_if->dev_global_regs->dtknqr4_fifoemptymsk); 
    991                 msk |= ((emp >> ep->num) & 0x1) << 7; 
    992                 v = dwc_read_reg32(&dev_if->in_ep_regs[ep->num]->diepint) & msk; 
    993         } else { 
    994                 msk = dwc_read_reg32(&dev_if->dev_global_regs->diepmsk); 
    995                 emp = dwc_read_reg32(&dev_if->dev_global_regs->dtknqr4_fifoemptymsk); 
    996                 msk |= ((emp >> ep->num) & 0x1) << 7; 
    997                 v = dwc_read_reg32(&dev_if->in_ep_regs[ep->num]->diepint) & msk; 
    998         } 
    999  
    1000  
    1001         return v; 
     816        msk = dwc_read_reg32(&dev_if->dev_global_regs->diepmsk); 
     817        emp = dwc_read_reg32(&dev_if->dev_global_regs->dtknqr4_fifoemptymsk); 
     818        msk |= ((emp >> _ep->num) & 0x1) << 7; 
     819        v = dwc_read_reg32(&dev_if->in_ep_regs[_ep->num]->diepint) & msk; 
     820/* 
     821        dwc_otg_dev_if_t *dev_if = _core_if->dev_if; 
     822        uint32_t v; 
     823        v = dwc_read_reg32(&dev_if->in_ep_regs[_ep->num]->diepint) & 
     824                dwc_read_reg32(&dev_if->dev_global_regs->diepmsk); 
     825*/ 
     826        return v;         
    1002827} 
    1003828/** 
    1004829 * This function returns the Device OUT EP Interrupt register 
    1005830 */ 
    1006 static inline uint32_t dwc_otg_read_dev_out_ep_intr(dwc_otg_core_if_t *_core_if, 
    1007                                                         dwc_ep_t *_ep) 
    1008 { 
    1009         dwc_otg_dev_if_t *dev_if = _core_if->dev_if; 
    1010         uint32_t v; 
    1011         doepmsk_data_t msk = { .d32 = 0 }; 
    1012  
    1013         if(_core_if->multiproc_int_enable) { 
    1014                 msk.d32 = dwc_read_reg32(&dev_if->dev_global_regs->doepeachintmsk[_ep->num]); 
    1015                 if(_core_if->pti_enh_enable) { 
    1016                         msk.b.pktdrpsts = 1; 
    1017                 } 
    1018                 v = dwc_read_reg32( &dev_if->out_ep_regs[_ep->num]->doepint) & msk.d32; 
    1019         } else { 
    1020                 msk.d32 = dwc_read_reg32(&dev_if->dev_global_regs->doepmsk); 
    1021                 if(_core_if->pti_enh_enable) { 
    1022                         msk.b.pktdrpsts = 1; 
    1023                 } 
    1024                 v = dwc_read_reg32( &dev_if->out_ep_regs[_ep->num]->doepint) & msk.d32; 
    1025         } 
    1026         return v; 
     831static inline uint32_t dwc_otg_read_dev_out_ep_intr(dwc_otg_core_if_t *_core_if,  
     832                                                    dwc_ep_t *_ep) 
     833{ 
     834        dwc_otg_dev_if_t *dev_if = _core_if->dev_if; 
     835        uint32_t v; 
     836        v = dwc_read_reg32( &dev_if->out_ep_regs[_ep->num]->doepint) & 
     837                        dwc_read_reg32(&dev_if->dev_global_regs->doepmsk); 
     838        return v;         
    1027839} 
    1028840 
     
    1044856 * This function returns the mode of the operation, host or device. 
    1045857 * 
    1046  * @return 0 - Device Mode, 1 - Host Mode 
    1047  */ 
    1048 static inline uint32_t dwc_otg_mode(dwc_otg_core_if_t *_core_if) 
    1049 { 
    1050         return (dwc_read_reg32( &_core_if->core_global_regs->gintsts ) & 0x1); 
    1051 } 
    1052  
    1053 static inline uint8_t dwc_otg_is_device_mode(dwc_otg_core_if_t *_core_if) 
    1054 { 
    1055         return (dwc_otg_mode(_core_if) != DWC_HOST_MODE); 
    1056 } 
    1057 static inline uint8_t dwc_otg_is_host_mode(dwc_otg_core_if_t *_core_if) 
    1058 { 
    1059         return (dwc_otg_mode(_core_if) == DWC_HOST_MODE); 
     858 * @return 0 - Device Mode, 1 - Host Mode  
     859 */ 
     860static inline uint32_t dwc_otg_mode(dwc_otg_core_if_t *_core_if) { 
     861        return (dwc_read_reg32( &_core_if->core_global_regs->gintsts ) & 0x1); 
     862} 
     863 
     864static inline uint8_t dwc_otg_is_device_mode(dwc_otg_core_if_t *_core_if)  
     865{ 
     866        return (dwc_otg_mode(_core_if) != DWC_HOST_MODE); 
     867} 
     868static inline uint8_t dwc_otg_is_host_mode(dwc_otg_core_if_t *_core_if)  
     869{ 
     870        return (dwc_otg_mode(_core_if) == DWC_HOST_MODE); 
    1060871} 
    1061872 
     
    1066877 
    1067878/** 
    1068  * DWC_otg CIL callback structure.      This structure allows the HCD and 
     879 * DWC_otg CIL callback structure.  This structure allows the HCD and 
    1069880 * PCD to register functions used for starting and stopping the PCD 
    1070881 * and HCD for role change on for a DRD. 
    1071882 */ 
    1072 typedef struct dwc_otg_cil_callbacks 
    1073 { 
    1074         /** Start function for role change */ 
    1075         int (*start) (void *_p); 
    1076         /** Stop Function for role change */ 
    1077         int (*stop) (void *_p); 
    1078         /** Disconnect Function for role change */ 
    1079         int (*disconnect) (void *_p); 
    1080         /** Resume/Remote wakeup Function */ 
    1081         int (*resume_wakeup) (void *_p); 
    1082         /** Suspend function */ 
    1083         int (*suspend) (void *_p); 
    1084         /** Session Start (SRP) */ 
    1085         int (*session_start) (void *_p); 
    1086         /** Pointer passed to start() and stop() */ 
    1087         void *p; 
     883typedef struct dwc_otg_cil_callbacks  
     884{ 
     885        /** Start function for role change */ 
     886        int (*start) (void *_p); 
     887        /** Stop Function for role change */ 
     888        int (*stop) (void *_p); 
     889        /** Disconnect Function for role change */ 
     890        int (*disconnect) (void *_p); 
     891        /** Resume/Remote wakeup Function */ 
     892        int (*resume_wakeup) (void *_p); 
     893        /** Suspend function */ 
     894        int (*suspend) (void *_p); 
     895        /** Session Start (SRP) */ 
     896        int (*session_start) (void *_p); 
     897        /** Pointer passed to start() and stop() */ 
     898        void *p; 
    1088899} dwc_otg_cil_callbacks_t; 
    1089900 
     901 
     902 
    1090903extern void dwc_otg_cil_register_pcd_callbacks( dwc_otg_core_if_t *_core_if, 
    1091                                                 dwc_otg_cil_callbacks_t *_cb, 
    1092                                                 void *_p); 
     904                                                dwc_otg_cil_callbacks_t *_cb, 
     905                                                void *_p); 
    1093906extern void dwc_otg_cil_register_hcd_callbacks( dwc_otg_core_if_t *_core_if, 
    1094                                                 dwc_otg_cil_callbacks_t *_cb, 
    1095                                                 void *_p); 
     907                                                dwc_otg_cil_callbacks_t *_cb, 
     908                                                void *_p); 
     909 
    1096910 
    1097911#endif 
    1098  
  • trunk/target/linux/lantiq/files/drivers/usb/dwc_otg/dwc_otg_cil_intr.c

    r32951 r32953  
    11/* ========================================================================== 
    2  * $File: //dwh/usb_iip/dev/software/otg/linux/drivers/dwc_otg_cil_intr.c $ 
    3  * $Revision: 1.2 $ 
    4  * $Date: 2008-11-21 05:39:15 $ 
    5  * $Change: 1065567 $ 
     2 * $File: //dwh/usb_iip/dev/software/otg_ipmate/linux/drivers/dwc_otg_cil_intr.c $ 
     3 * $Revision: 1.1.1.1 $ 
     4 * $Date: 2009-04-17 06:15:34 $ 
     5 * $Change: 553126 $ 
    66 * 
    77 * Synopsys HS OTG Linux Software Driver and documentation (hereinafter, 
    88 * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless 
    99 * otherwise expressly agreed to in writing between Synopsys and you. 
    10  * 
     10 *  
    1111 * The Software IS NOT an item of Licensed Software or Licensed Product under 
    1212 * any End User Software License Agreement or Agreement for Licensed Product 
     
    1818 * Synopsys. If you do not agree with this notice, including the disclaimer 
    1919 * below, then you are not authorized to use the Software. 
    20  * 
     20 *  
    2121 * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS 
    2222 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
     
    3232 * ========================================================================== */ 
    3333 
    34 /** @file 
     34/** @file  
    3535 * 
    3636 * The Core Interface Layer provides basic services for accessing and 
     
    4040 * This file contains the Common Interrupt handlers. 
    4141 */ 
    42 #include "linux/dwc_otg_plat.h" 
     42#include "dwc_otg_plat.h" 
    4343#include "dwc_otg_regs.h" 
    4444#include "dwc_otg_cil.h" 
    4545 
    4646#ifdef DEBUG 
    47 inline const char *op_state_str(dwc_otg_core_if_t *core_if) 
    48 { 
    49         return (core_if->op_state==A_HOST?"a_host": 
    50                 (core_if->op_state==A_SUSPEND?"a_suspend": 
    51                  (core_if->op_state==A_PERIPHERAL?"a_peripheral": 
    52                   (core_if->op_state==B_PERIPHERAL?"b_peripheral": 
    53                    (core_if->op_state==B_HOST?"b_host": 
     47inline const char *op_state_str( dwc_otg_core_if_t *_core_if )  
     48{ 
     49        return (_core_if->op_state==A_HOST?"a_host": 
     50                (_core_if->op_state==A_SUSPEND?"a_suspend": 
     51                 (_core_if->op_state==A_PERIPHERAL?"a_peripheral": 
     52                  (_core_if->op_state==B_PERIPHERAL?"b_peripheral": 
     53                   (_core_if->op_state==B_HOST?"b_host": 
    5454                    "unknown"))))); 
    5555} 
    5656#endif 
    5757 
    58 /** This function will log a debug message 
    59  * 
    60  * @param core_if Programming view of DWC_otg controller. 
    61  */ 
    62 int32_t dwc_otg_handle_mode_mismatch_intr (dwc_otg_core_if_t *core_if) 
     58/** This function will log a debug message  
     59 * 
     60 * @param _core_if Programming view of DWC_otg controller. 
     61 */ 
     62int32_t dwc_otg_handle_mode_mismatch_intr (dwc_otg_core_if_t *_core_if) 
    6363{ 
    6464        gintsts_data_t gintsts; 
    65         DWC_WARN("Mode Mismatch Interrupt: currently in %s mode\n", 
    66                  dwc_otg_mode(core_if) ? "Host" : "Device"); 
     65        DWC_WARN("Mode Mismatch Interrupt: currently in %s mode\n",  
     66                 dwc_otg_mode(_core_if) ? "Host" : "Device"); 
    6767 
    6868        /* Clear interrupt */ 
    6969        gintsts.d32 = 0; 
    70         gintsts.b.modemismatch = 1; 
    71         dwc_write_reg32 (&core_if->core_global_regs->gintsts, gintsts.d32); 
     70        gintsts.b.modemismatch = 1;      
     71        dwc_write_reg32 (&_core_if->core_global_regs->gintsts, gintsts.d32); 
    7272        return 1; 
    7373} 
     
    7575/** Start the HCD.  Helper function for using the HCD callbacks. 
    7676 * 
    77  * @param core_if Programming view of DWC_otg controller. 
    78  */ 
    79 static inline void hcd_start(dwc_otg_core_if_t *core_if) 
    80 { 
    81         if (core_if->hcd_cb && core_if->hcd_cb->start) { 
    82                 core_if->hcd_cb->start(core_if->hcd_cb->p); 
    83         } 
    84 } 
    85 /** Stop the HCD.  Helper function for using the HCD callbacks. 
    86  * 
    87  * @param core_if Programming view of DWC_otg controller. 
    88  */ 
    89 static inline void hcd_stop(dwc_otg_core_if_t *core_if) 
    90 { 
    91         if (core_if->hcd_cb && core_if->hcd_cb->stop) { 
    92                 core_if->hcd_cb->stop(core_if->hcd_cb->p); 
     77 * @param _core_if Programming view of DWC_otg controller. 
     78 */ 
     79static inline void hcd_start( dwc_otg_core_if_t *_core_if )  
     80{         
     81        if (_core_if->hcd_cb && _core_if->hcd_cb->start) { 
     82                _core_if->hcd_cb->start( _core_if->hcd_cb->p ); 
     83        } 
     84} 
     85/** Stop the HCD.  Helper function for using the HCD callbacks.  
     86 * 
     87 * @param _core_if Programming view of DWC_otg controller. 
     88 */ 
     89static inline void hcd_stop( dwc_otg_core_if_t *_core_if )  
     90{         
     91        if (_core_if->hcd_cb && _core_if->hcd_cb->stop) { 
     92                _core_if->hcd_cb->stop( _core_if->hcd_cb->p ); 
    9393        } 
    9494} 
    9595/** Disconnect the HCD.  Helper function for using the HCD callbacks. 
    9696 * 
    97  * @param core_if Programming view of DWC_otg controller. 
    98  */ 
    99 static inline void hcd_disconnect(dwc_otg_core_if_t *core_if) 
    100 { 
    101         if (core_if->hcd_cb && core_if->hcd_cb->disconnect) { 
    102                 core_if->hcd_cb->disconnect(core_if->hcd_cb->p); 
     97 * @param _core_if Programming view of DWC_otg controller. 
     98 */ 
     99static inline void hcd_disconnect( dwc_otg_core_if_t *_core_if )  
     100{ 
     101        if (_core_if->hcd_cb && _core_if->hcd_cb->disconnect) { 
     102                _core_if->hcd_cb->disconnect( _core_if->hcd_cb->p ); 
    103103        } 
    104104} 
     
    106106 * using the HCD callbacks. 
    107107 * 
    108  * @param core_if Programming view of DWC_otg controller. 
    109  */ 
    110 static inline void hcd_session_start(dwc_otg_core_if_t *core_if) 
    111 { 
    112         if (core_if->hcd_cb && core_if->hcd_cb->session_start) { 
    113                 core_if->hcd_cb->session_start(core_if->hcd_cb->p); 
     108 * @param _core_if Programming view of DWC_otg controller. 
     109 */ 
     110static inline void hcd_session_start( dwc_otg_core_if_t *_core_if )  
     111{ 
     112        if (_core_if->hcd_cb && _core_if->hcd_cb->session_start) { 
     113                _core_if->hcd_cb->session_start( _core_if->hcd_cb->p ); 
    114114        } 
    115115} 
     
    117117/** Start the PCD.  Helper function for using the PCD callbacks. 
    118118 * 
    119  * @param core_if Programming view of DWC_otg controller. 
    120  */ 
    121 static inline void pcd_start(dwc_otg_core_if_t *core_if) 
    122 { 
    123         if (core_if->pcd_cb && core_if->pcd_cb->start) { 
    124                 core_if->pcd_cb->start(core_if->pcd_cb->p); 
    125         } 
    126 } 
    127 /** Stop the PCD.  Helper function for using the PCD callbacks. 
    128  * 
    129  * @param core_if Programming view of DWC_otg controller. 
    130  */ 
    131 static inline void pcd_stop(dwc_otg_core_if_t *core_if) 
    132 { 
    133         if (core_if->pcd_cb && core_if->pcd_cb->stop) { 
    134                 core_if->pcd_cb->stop(core_if->pcd_cb->p); 
    135         } 
    136 } 
    137 /** Suspend the PCD.  Helper function for using the PCD callbacks. 
    138  * 
    139  * @param core_if Programming view of DWC_otg controller. 
    140  */ 
    141 static inline void pcd_suspend(dwc_otg_core_if_t *core_if) 
    142 { 
    143         if (core_if->pcd_cb && core_if->pcd_cb->suspend) { 
    144                 core_if->pcd_cb->suspend(core_if->pcd_cb->p); 
    145         } 
    146 } 
    147 /** Resume the PCD.  Helper function for using the PCD callbacks. 
    148  * 
    149  * @param core_if Programming view of DWC_otg controller. 
    150  */ 
    151 static inline void pcd_resume(dwc_otg_core_if_t *core_if) 
    152 { 
    153         if (core_if->pcd_cb && core_if->pcd_cb->resume_wakeup) { 
    154                 core_if->pcd_cb->resume_wakeup(core_if->pcd_cb->p); 
     119 * @param _core_if Programming view of DWC_otg controller. 
     120 */ 
     121static inline void pcd_start( dwc_otg_core_if_t *_core_if )  
     122{ 
     123        if (_core_if->pcd_cb && _core_if->pcd_cb->start ) { 
     124                _core_if->pcd_cb->start( _core_if->pcd_cb->p ); 
     125        } 
     126} 
     127/** Stop the PCD.  Helper function for using the PCD callbacks.  
     128 * 
     129 * @param _core_if Programming view of DWC_otg controller. 
     130 */ 
     131static inline void pcd_stop( dwc_otg_core_if_t *_core_if )  
     132{ 
     133        if (_core_if->pcd_cb && _core_if->pcd_cb->stop ) { 
     134                _core_if->pcd_cb->stop( _core_if->pcd_cb->p ); 
     135        } 
     136} 
     137/** Suspend the PCD.  Helper function for using the PCD callbacks.  
     138 * 
     139 * @param _core_if Programming view of DWC_otg controller. 
     140 */ 
     141static inline void pcd_suspend( dwc_otg_core_if_t *_core_if )  
     142{ 
     143        if (_core_if->pcd_cb && _core_if->pcd_cb->suspend ) { 
     144                _core_if->pcd_cb->suspend( _core_if->pcd_cb->p ); 
     145        } 
     146} 
     147/** Resume the PCD.  Helper function for using the PCD callbacks.  
     148 * 
     149 * @param _core_if Programming view of DWC_otg controller. 
     150 */ 
     151static inline void pcd_resume( dwc_otg_core_if_t *_core_if )  
     152{ 
     153        if (_core_if->pcd_cb && _core_if->pcd_cb->resume_wakeup ) { 
     154                _core_if->pcd_cb->resume_wakeup( _core_if->pcd_cb->p ); 
    155155        } 
    156156} 
     
    161161 * occurred. 
    162162 * 
    163  * @param core_if Programming view of DWC_otg controller. 
    164  */ 
    165 int32_t dwc_otg_handle_otg_intr(dwc_otg_core_if_t *core_if) 
    166 { 
    167         dwc_otg_core_global_regs_t *global_regs = 
    168                 core_if->core_global_regs; 
     163 * @param _core_if Programming view of DWC_otg controller. 
     164 */ 
     165int32_t dwc_otg_handle_otg_intr(dwc_otg_core_if_t *_core_if) 
     166{ 
     167        dwc_otg_core_global_regs_t *global_regs =  
     168                _core_if->core_global_regs; 
    169169        gotgint_data_t gotgint; 
    170170        gotgctl_data_t gotgctl; 
    171171        gintmsk_data_t gintmsk; 
    172172 
    173         gotgint.d32 = dwc_read_reg32(&global_regs->gotgint); 
    174         gotgctl.d32 = dwc_read_reg32(&global_regs->gotgctl); 
    175         DWC_DEBUGPL(DBG_CIL, "gotgctl=%08x\n", gotgctl.d32); 
     173        gotgint.d32 = dwc_read_reg32( &global_regs->gotgint); 
     174        gotgctl.d32 = dwc_read_reg32( &global_regs->gotgctl); 
     175        DWC_DEBUGPL(DBG_CIL, "++OTG Interrupt gotgint=%0x [%s]\n", gotgint.d32, 
     176                    op_state_str(_core_if)); 
     177        //DWC_DEBUGPL(DBG_CIL, "gotgctl=%08x\n", gotgctl.d32 ); 
    176178 
    177179        if (gotgint.b.sesenddet) { 
    178                 DWC_DEBUGPL(DBG_ANY, "OTG Interrupt: " 
     180                DWC_DEBUGPL(DBG_ANY, " ++OTG Interrupt: " 
    179181                            "Session End Detected++ (%s)\n", 
    180                             op_state_str(core_if)); 
    181                 gotgctl.d32 = dwc_read_reg32(&global_regs->gotgctl); 
    182  
    183                 if (core_if->op_state == B_HOST) { 
    184                         pcd_start(core_if); 
    185                         core_if->op_state = B_PERIPHERAL; 
     182                            op_state_str(_core_if)); 
     183                gotgctl.d32 = dwc_read_reg32( &global_regs->gotgctl); 
     184 
     185                if (_core_if->op_state == B_HOST) { 
     186                        pcd_start( _core_if ); 
     187                        _core_if->op_state = B_PERIPHERAL; 
    186188                } else { 
    187189                        /* If not B_HOST and Device HNP still set. HNP 
     
    189191                        if (gotgctl.b.devhnpen) { 
    190192                                DWC_DEBUGPL(DBG_ANY, "Session End Detected\n"); 
    191                                 DWC_ERROR("Device Not Connected/Responding!\n"); 
     193                                DWC_ERROR( "Device Not Connected/Responding!\n" ); 
    192194                        } 
    193195 
     
    196198                        /* Reset PCD and Gadget driver to a 
    197199                         * clean state. */ 
    198                         pcd_stop(core_if); 
     200                        pcd_stop(_core_if); 
    199201                } 
    200202                gotgctl.d32 = 0; 
    201203                gotgctl.b.devhnpen = 1; 
    202                 dwc_modify_reg32(&global_regs->gotgctl, 
     204                dwc_modify_reg32( &global_regs->gotgctl,  
    203205                                  gotgctl.d32, 0); 
    204206        } 
    205207        if (gotgint.b.sesreqsucstschng) { 
    206                 DWC_DEBUGPL(DBG_ANY, " OTG Interrupt: " 
     208                DWC_DEBUGPL(DBG_ANY, " ++OTG Interrupt: " 
    207209                            "Session Reqeust Success Status Change++\n"); 
    208                 gotgctl.d32 = dwc_read_reg32(&global_regs->gotgctl); 
     210                gotgctl.d32 = dwc_read_reg32( &global_regs->gotgctl); 
    209211                if (gotgctl.b.sesreqscs) { 
    210                         if ((core_if->core_params->phy_type == DWC_PHY_TYPE_PARAM_FS) && 
    211                             (core_if->core_params->i2c_enable)) { 
    212                                 core_if->srp_success = 1; 
     212                        if ((_core_if->core_params->phy_type == DWC_PHY_TYPE_PARAM_FS) &&  
     213                            (_core_if->core_params->i2c_enable)) { 
     214                                _core_if->srp_success = 1; 
    213215                        } 
    214216                        else { 
    215                                 pcd_resume(core_if); 
     217                                pcd_resume( _core_if ); 
    216218                                /* Clear Session Request */ 
    217219                                gotgctl.d32 = 0; 
    218220                                gotgctl.b.sesreq = 1; 
    219                                 dwc_modify_reg32(&global_regs->gotgctl, 
     221                                dwc_modify_reg32( &global_regs->gotgctl,  
    220222                                                  gotgctl.d32, 0); 
    221223                        } 
     
    227229                gotgctl.d32 = dwc_read_reg32(&global_regs->gotgctl); 
    228230                if (gotgctl.b.hstnegscs) { 
    229                         if (dwc_otg_is_host_mode(core_if)) { 
    230                                 core_if->op_state = B_HOST; 
     231                        if (dwc_otg_is_host_mode(_core_if) ) { 
     232                                _core_if->op_state = B_HOST; 
    231233                                /* 
    232234                                 * Need to disable SOF interrupt immediately. 
     
    243245                                dwc_modify_reg32(&global_regs->gintmsk, 
    244246                                                 gintmsk.d32, 0); 
    245                                 pcd_stop(core_if); 
     247                                pcd_stop(_core_if); 
    246248                                /* 
    247249                                 * Initialize the Core for Host mode. 
    248250                                 */ 
    249                                 hcd_start(core_if); 
    250                                 core_if->op_state = B_HOST; 
     251                                hcd_start( _core_if ); 
     252                                _core_if->op_state = B_HOST; 
    251253                        } 
    252254                } else { 
     
    254256                        gotgctl.b.hnpreq = 1; 
    255257                        gotgctl.b.devhnpen = 1; 
    256                         dwc_modify_reg32(&global_regs->gotgctl, 
     258                        dwc_modify_reg32( &global_regs->gotgctl,  
    257259                                          gotgctl.d32, 0); 
    258                         DWC_DEBUGPL(DBG_ANY, "HNP Failed\n"); 
    259                         DWC_ERROR("Device Not Connected/Responding\n"); 
     260                        DWC_DEBUGPL( DBG_ANY, "HNP Failed\n"); 
     261                        DWC_ERROR( "Device Not Connected/Responding\n" ); 
    260262                } 
    261263        } 
     
    267269                 */ 
    268270                DWC_DEBUGPL(DBG_ANY, " ++OTG Interrupt: " 
    269                             "Host Negotiation Detected++ (%s)\n", 
    270                             (dwc_otg_is_host_mode(core_if)?"Host":"Device")); 
    271                 if (dwc_otg_is_device_mode(core_if)){ 
    272                         DWC_DEBUGPL(DBG_ANY, "a_suspend->a_peripheral (%d)\n", core_if->op_state); 
    273                         hcd_disconnect(core_if); 
    274                         pcd_start(core_if); 
    275                         core_if->op_state = A_PERIPHERAL; 
     271                            "Host Negotiation Detected++ (%s)\n",  
     272                            (dwc_otg_is_host_mode(_core_if)?"Host":"Device")); 
     273                if (dwc_otg_is_device_mode(_core_if)){ 
     274                        DWC_DEBUGPL(DBG_ANY, "a_suspend->a_peripheral (%d)\n",_core_if->op_state); 
     275                        hcd_disconnect( _core_if ); 
     276                        pcd_start( _core_if ); 
     277                        _core_if->op_state = A_PERIPHERAL; 
    276278                } else { 
    277279                        /* 
     
    288290                        dwc_modify_reg32(&global_regs->gintmsk, 
    289291                                         gintmsk.d32, 0); 
    290                         pcd_stop(core_if); 
    291                         hcd_start(core_if); 
    292                         core_if->op_state = A_HOST; 
     292                        pcd_stop( _core_if ); 
     293                        hcd_start( _core_if ); 
     294                        _core_if->op_state = A_HOST; 
    293295                } 
    294296        } 
     
    303305 
    304306        /* Clear GOTGINT */ 
    305         dwc_write_reg32 (&core_if->core_global_regs->gotgint, gotgint.d32); 
     307        dwc_write_reg32 (&_core_if->core_global_regs->gotgint, gotgint.d32); 
    306308 
    307309        return 1; 
    308310} 
    309  
    310  
    311 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) 
    312  
    313 void w_conn_id_status_change(void *p) 
    314 { 
    315         dwc_otg_core_if_t *core_if = p; 
    316  
    317 #else 
    318  
    319 void w_conn_id_status_change(struct work_struct *p) 
    320 { 
    321         dwc_otg_core_if_t *core_if = container_of(p, dwc_otg_core_if_t, w_conn_id); 
    322  
    323 #endif 
    324  
    325  
    326         uint32_t count = 0; 
    327         gotgctl_data_t gotgctl = { .d32 = 0 }; 
    328  
    329         gotgctl.d32 = dwc_read_reg32(&core_if->core_global_regs->gotgctl); 
    330         DWC_DEBUGPL(DBG_CIL, "gotgctl=%0x\n", gotgctl.d32); 
    331         DWC_DEBUGPL(DBG_CIL, "gotgctl.b.conidsts=%d\n", gotgctl.b.conidsts); 
    332  
    333         /* B-Device connector (Device Mode) */ 
    334         if (gotgctl.b.conidsts) { 
    335                 /* Wait for switch to device mode. */ 
    336                 while (!dwc_otg_is_device_mode(core_if)){ 
    337                         DWC_PRINT("Waiting for Peripheral Mode, Mode=%s\n", 
    338                                   (dwc_otg_is_host_mode(core_if)?"Host":"Peripheral")); 
    339                         MDELAY(100); 
    340                         if (++count > 10000) *(uint32_t*)NULL=0; 
    341                 } 
    342                 core_if->op_state = B_PERIPHERAL; 
    343                 dwc_otg_core_init(core_if); 
    344                 dwc_otg_enable_global_interrupts(core_if); 
    345                 pcd_start(core_if); 
    346         } else { 
    347                 /* A-Device connector (Host Mode) */ 
    348                 while (!dwc_otg_is_host_mode(core_if)) { 
    349                         DWC_PRINT("Waiting for Host Mode, Mode=%s\n", 
    350                                   (dwc_otg_is_host_mode(core_if)?"Host":"Peripheral")); 
    351                         MDELAY(100); 
    352                         if (++count > 10000) *(uint32_t*)NULL=0; 
    353                 } 
    354                 core_if->op_state = A_HOST; 
    355                 /* 
    356                  * Initialize the Core for Host mode. 
    357                  */ 
    358                 dwc_otg_core_init(core_if); 
    359                 dwc_otg_enable_global_interrupts(core_if); 
    360                 hcd_start(core_if); 
    361         } 
    362 } 
    363  
    364311 
    365312/** 
     
    367314 * reads the OTG Interrupt Register (GOTCTL) to determine whether this 
    368315 * is a Device to Host Mode transition or a Host Mode to Device 
    369  * Transition. 
     316 * Transition.   
    370317 * 
    371318 * This only occurs when the cable is connected/removed from the PHY 
    372319 * connector. 
    373320 * 
    374  * @param core_if Programming view of DWC_otg controller. 
    375  */ 
    376 int32_t dwc_otg_handle_conn_id_status_change_intr(dwc_otg_core_if_t *core_if) 
    377 { 
     321 * @param _core_if Programming view of DWC_otg controller. 
     322 */ 
     323int32_t dwc_otg_handle_conn_id_status_change_intr(dwc_otg_core_if_t *_core_if) 
     324{ 
     325        uint32_t count = 0; 
     326         
     327        gintsts_data_t gintsts = { .d32 = 0 }; 
     328        gintmsk_data_t gintmsk = { .d32 = 0 }; 
     329        gotgctl_data_t gotgctl = { .d32 = 0 };  
    378330 
    379331        /* 
     
    384336         * not get handled and Linux complains loudly. 
    385337         */ 
    386         gintmsk_data_t gintmsk = { .d32 = 0 }; 
    387         gintsts_data_t gintsts = { .d32 = 0 }; 
    388  
    389338        gintmsk.b.sofintr = 1; 
    390         dwc_modify_reg32(&core_if->core_global_regs->gintmsk, gintmsk.d32, 0); 
     339        dwc_modify_reg32(&_core_if->core_global_regs->gintmsk, gintmsk.d32, 0); 
    391340 
    392341        DWC_DEBUGPL(DBG_CIL, " ++Connector ID Status Change Interrupt++  (%s)\n", 
    393                     (dwc_otg_is_host_mode(core_if)?"Host":"Device")); 
    394  
    395         /* 
    396          * Need to schedule a work, as there are possible DELAY function calls 
    397         */ 
    398         queue_work(core_if->wq_otg, &core_if->w_conn_id); 
     342                    (dwc_otg_is_host_mode(_core_if)?"Host":"Device")); 
     343        gotgctl.d32 = dwc_read_reg32(&_core_if->core_global_regs->gotgctl); 
     344        DWC_DEBUGPL(DBG_CIL, "gotgctl=%0x\n", gotgctl.d32); 
     345        DWC_DEBUGPL(DBG_CIL, "gotgctl.b.conidsts=%d\n", gotgctl.b.conidsts); 
     346         
     347        /* B-Device connector (Device Mode) */ 
     348        if (gotgctl.b.conidsts) { 
     349                /* Wait for switch to device mode. */ 
     350                while (!dwc_otg_is_device_mode(_core_if) ){ 
     351                        DWC_PRINT("Waiting for Peripheral Mode, Mode=%s\n", 
     352                                  (dwc_otg_is_host_mode(_core_if)?"Host":"Peripheral")); 
     353                        MDELAY(100); 
     354                        if (++count > 10000) *(uint32_t*)NULL=0; 
     355                } 
     356                _core_if->op_state = B_PERIPHERAL; 
     357                dwc_otg_core_init(_core_if); 
     358                dwc_otg_enable_global_interrupts(_core_if); 
     359                pcd_start( _core_if ); 
     360        } else { 
     361                /* A-Device connector (Host Mode) */ 
     362                while (!dwc_otg_is_host_mode(_core_if) ) { 
     363                        DWC_PRINT("Waiting for Host Mode, Mode=%s\n", 
     364                                  (dwc_otg_is_host_mode(_core_if)?"Host":"Peripheral")); 
     365                        MDELAY(100); 
     366                        if (++count > 10000) *(uint32_t*)NULL=0; 
     367                } 
     368                _core_if->op_state = A_HOST; 
     369                /* 
     370                 * Initialize the Core for Host mode. 
     371                 */ 
     372                dwc_otg_core_init(_core_if); 
     373                dwc_otg_enable_global_interrupts(_core_if); 
     374                hcd_start( _core_if ); 
     375        } 
    399376 
    400377        /* Set flag and clear interrupt */ 
    401378        gintsts.b.conidstschng = 1; 
    402         dwc_write_reg32 (&core_if->core_global_regs->gintsts, gintsts.d32); 
     379        dwc_write_reg32 (&_core_if->core_global_regs->gintsts, gintsts.d32); 
    403380 
    404381        return 1; 
    405382} 
    406383 
    407 /** 
     384/**  
    408385 * This interrupt indicates that a device is initiating the Session 
    409386 * Request Protocol to request the host to turn on bus power so a new 
    410387 * session can begin. The handler responds by turning on bus power. If 
    411388 * the DWC_otg controller is in low power mode, the handler brings the 
    412  * controller out of low power mode before turning on bus power. 
    413  * 
    414  * @param core_if Programming view of DWC_otg controller. 
    415  */ 
    416 int32_t dwc_otg_handle_session_req_intr(dwc_otg_core_if_t *core_if) 
    417 { 
    418         gintsts_data_t gintsts; 
     389 * controller out of low power mode before turning on bus power.  
     390 * 
     391 * @param _core_if Programming view of DWC_otg controller. 
     392 */ 
     393int32_t dwc_otg_handle_session_req_intr( dwc_otg_core_if_t *_core_if ) 
     394{ 
     395#ifndef DWC_HOST_ONLY // winder 
     396    hprt0_data_t hprt0; 
     397#endif 
     398    gintsts_data_t gintsts; 
    419399 
    420400#ifndef DWC_HOST_ONLY 
    421         hprt0_data_t hprt0; 
    422         DWC_DEBUGPL(DBG_ANY, "++Session Request Interrupt++\n"); 
    423  
    424         if (dwc_otg_is_device_mode(core_if)) { 
    425                 DWC_PRINT("SRP: Device mode\n"); 
    426         } else { 
    427                 DWC_PRINT("SRP: Host mode\n"); 
    428  
    429                 /* Turn on the port power bit. */ 
    430                 hprt0.d32 = dwc_otg_read_hprt0(core_if); 
    431                 hprt0.b.prtpwr = 1; 
    432                 dwc_write_reg32(core_if->host_if->hprt0, hprt0.d32); 
    433  
    434                 /* Start the Connection timer. So a message can be displayed 
    435                  * if connect does not occur within 10 seconds. */ 
    436                 hcd_session_start(core_if); 
    437         } 
     401    DWC_DEBUGPL(DBG_ANY, "++Session Request Interrupt++\n");     
     402 
     403    if (dwc_otg_is_device_mode(_core_if) ) { 
     404        DWC_PRINT("SRP: Device mode\n"); 
     405    } else { 
     406        DWC_PRINT("SRP: Host mode\n"); 
     407 
     408        /* Turn on the port power bit. */ 
     409        hprt0.d32 = dwc_otg_read_hprt0( _core_if ); 
     410        hprt0.b.prtpwr = 1; 
     411        dwc_write_reg32(_core_if->host_if->hprt0, hprt0.d32); 
     412 
     413        /* Start the Connection timer. So a message can be displayed 
     414        * if connect does not occur within 10 seconds. */  
     415        hcd_session_start( _core_if ); 
     416    } 
    438417#endif 
    439418 
    440         /* Clear interrupt */ 
    441         gintsts.d32 = 0; 
    442         gintsts.b.sessreqintr = 1; 
    443         dwc_write_reg32 (&core_if->core_global_regs->gintsts, gintsts.d32); 
    444  
    445         return 1; 
    446 } 
    447  
    448  
    449 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) 
    450 void w_wakeup_detected(void *p) 
    451 { 
    452         dwc_otg_core_if_t* core_if = p; 
    453  
    454 #else 
    455  
    456 void w_wakeup_detected(struct work_struct *p) 
    457 { 
    458         struct delayed_work *dw = container_of(p, struct delayed_work, work); 
    459         dwc_otg_core_if_t *core_if = container_of(dw, dwc_otg_core_if_t, w_wkp); 
    460  
    461 #endif 
    462         /* 
    463          * Clear the Resume after 70ms. (Need 20 ms minimum. Use 70 ms 
    464          * so that OPT tests pass with all PHYs). 
    465          */ 
    466         hprt0_data_t hprt0 = {.d32=0}; 
    467 #if 0 
    468         pcgcctl_data_t pcgcctl = {.d32=0}; 
    469         /* Restart the Phy Clock */ 
    470         pcgcctl.b.stoppclk = 1; 
    471         dwc_modify_reg32(core_if->pcgcctl, pcgcctl.d32, 0); 
    472         UDELAY(10); 
    473 #endif //0 
    474         hprt0.d32 = dwc_otg_read_hprt0(core_if); 
    475         DWC_DEBUGPL(DBG_ANY,"Resume: HPRT0=%0x\n", hprt0.d32); 
    476 //      MDELAY(70); 
    477         hprt0.b.prtres = 0; /* Resume */ 
    478         dwc_write_reg32(core_if->host_if->hprt0, hprt0.d32); 
    479         DWC_DEBUGPL(DBG_ANY,"Clear Resume: HPRT0=%0x\n", dwc_read_reg32(core_if->host_if->hprt0)); 
    480 } 
    481 /** 
     419    /* Clear interrupt */ 
     420    gintsts.d32 = 0; 
     421    gintsts.b.sessreqintr = 1; 
     422    dwc_write_reg32 (&_core_if->core_global_regs->gintsts, gintsts.d32); 
     423 
     424    return 1; 
     425} 
     426 
     427/**  
    482428 * This interrupt indicates that the DWC_otg controller has detected a 
    483429 * resume or remote wakeup sequence. If the DWC_otg controller is in 
     
    486432 * signaling. The handler schedules a time to stop resume signaling. 
    487433 */ 
    488 int32_t dwc_otg_handle_wakeup_detected_intr(dwc_otg_core_if_t *core_if) 
     434int32_t dwc_otg_handle_wakeup_detected_intr( dwc_otg_core_if_t *_core_if ) 
    489435{ 
    490436        gintsts_data_t gintsts; 
     
    492438        DWC_DEBUGPL(DBG_ANY, "++Resume and Remote Wakeup Detected Interrupt++\n"); 
    493439 
    494         if (dwc_otg_is_device_mode(core_if)) { 
     440        if (dwc_otg_is_device_mode(_core_if) ) {  
    495441                dctl_data_t dctl = {.d32=0}; 
    496                 DWC_DEBUGPL(DBG_PCD, "DSTS=0x%0x\n", 
    497                             dwc_read_reg32(&core_if->dev_if->dev_global_regs->dsts)); 
     442                DWC_DEBUGPL(DBG_PCD, "DSTS=0x%0x\n",  
     443                            dwc_read_reg32( &_core_if->dev_if->dev_global_regs->dsts)); 
    498444#ifdef PARTIAL_POWER_DOWN 
    499                 if (core_if->hwcfg4.b.power_optimiz) { 
     445                if (_core_if->hwcfg4.b.power_optimiz) { 
    500446                        pcgcctl_data_t power = {.d32=0}; 
    501447 
    502                         power.d32 = dwc_read_reg32(core_if->pcgcctl); 
     448                        power.d32 = dwc_read_reg32( _core_if->pcgcctl ); 
    503449                        DWC_DEBUGPL(DBG_CIL, "PCGCCTL=%0x\n", power.d32); 
    504450 
    505451                        power.b.stoppclk = 0; 
    506                         dwc_write_reg32(core_if->pcgcctl, power.d32); 
     452                        dwc_write_reg32( _core_if->pcgcctl, power.d32); 
    507453 
    508454                        power.b.pwrclmp = 0; 
    509                         dwc_write_reg32(core_if->pcgcctl, power.d32); 
     455                        dwc_write_reg32( _core_if->pcgcctl, power.d32); 
    510456 
    511457                        power.b.rstpdwnmodule = 0; 
    512                         dwc_write_reg32(core_if->pcgcctl, power.d32); 
     458                        dwc_write_reg32( _core_if->pcgcctl, power.d32); 
    513459                } 
    514460#endif 
    515461                /* Clear the Remote Wakeup Signalling */ 
    516462                dctl.b.rmtwkupsig = 1; 
    517                 dwc_modify_reg32(&core_if->dev_if->dev_global_regs->dctl, 
    518                                   dctl.d32, 0); 
    519  
    520                 if (core_if->pcd_cb && core_if->pcd_cb->resume_wakeup) { 
    521                         core_if->pcd_cb->resume_wakeup(core_if->pcd_cb->p); 
    522                 } 
    523  
     463                dwc_modify_reg32( &_core_if->dev_if->dev_global_regs->dctl,  
     464                                  dctl.d32, 0 ); 
     465 
     466                if (_core_if->pcd_cb && _core_if->pcd_cb->resume_wakeup) { 
     467                        _core_if->pcd_cb->resume_wakeup( _core_if->pcd_cb->p ); 
     468                } 
     469         
    524470        } else { 
    525                 pcgcctl_data_t pcgcctl = {.d32=0}; 
    526  
    527                 /* Restart the Phy Clock */ 
    528                 pcgcctl.b.stoppclk = 1; 
    529                 dwc_modify_reg32(core_if->pcgcctl, pcgcctl.d32, 0); 
    530  
    531                 queue_delayed_work(core_if->wq_otg, &core_if->w_wkp, ((70 * HZ / 1000) + 1)); 
    532         } 
     471                /* 
     472                 * Clear the Resume after 70ms. (Need 20 ms minimum. Use 70 ms 
     473                 * so that OPT tests pass with all PHYs). 
     474                 */ 
     475                hprt0_data_t hprt0 = {.d32=0}; 
     476                pcgcctl_data_t pcgcctl = {.d32=0}; 
     477                /* Restart the Phy Clock */ 
     478                pcgcctl.b.stoppclk = 1; 
     479                dwc_modify_reg32(_core_if->pcgcctl, pcgcctl.d32, 0); 
     480                UDELAY(10); 
     481                 
     482                /* Now wait for 70 ms. */ 
     483                hprt0.d32 = dwc_otg_read_hprt0( _core_if ); 
     484                DWC_DEBUGPL(DBG_ANY,"Resume: HPRT0=%0x\n", hprt0.d32); 
     485                MDELAY(70); 
     486                hprt0.b.prtres = 0; /* Resume */ 
     487                dwc_write_reg32(_core_if->host_if->hprt0, hprt0.d32);                 
     488                DWC_DEBUGPL(DBG_ANY,"Clear Resume: HPRT0=%0x\n", dwc_read_reg32(_core_if->host_if->hprt0)); 
     489        }         
    533490 
    534491        /* Clear interrupt */ 
    535492        gintsts.d32 = 0; 
    536493        gintsts.b.wkupintr = 1; 
    537         dwc_write_reg32 (&core_if->core_global_regs->gintsts, gintsts.d32); 
     494        dwc_write_reg32 (&_core_if->core_global_regs->gintsts, gintsts.d32); 
    538495 
    539496        return 1; 
    540497} 
    541498 
    542 /** 
     499/**  
    543500 * This interrupt indicates that a device has been disconnected from 
    544  * the root port. 
    545  */ 
    546 int32_t dwc_otg_handle_disconnect_intr(dwc_otg_core_if_t *core_if) 
     501 * the root port.  
     502 */ 
     503int32_t dwc_otg_handle_disconnect_intr( dwc_otg_core_if_t *_core_if) 
    547504{ 
    548505        gintsts_data_t gintsts; 
    549506 
    550         DWC_DEBUGPL(DBG_ANY, "++Disconnect Detected Interrupt++ (%s) %s\n", 
    551                     (dwc_otg_is_host_mode(core_if)?"Host":"Device"), 
    552                     op_state_str(core_if)); 
     507        DWC_DEBUGPL(DBG_ANY, "++Disconnect Detected Interrupt++ (%s) %s\n",  
     508                    (dwc_otg_is_host_mode(_core_if)?"Host":"Device"),  
     509                    op_state_str(_core_if)); 
    553510 
    554511/** @todo Consolidate this if statement. */ 
    555512#ifndef DWC_HOST_ONLY 
    556         if (core_if->op_state == B_HOST) { 
     513        if (_core_if->op_state == B_HOST) { 
    557514                /* If in device mode Disconnect and stop the HCD, then 
    558515                 * start the PCD. */ 
    559                 hcd_disconnect(core_if); 
    560                 pcd_start(core_if); 
    561                 core_if->op_state = B_PERIPHERAL; 
    562         } else if (dwc_otg_is_device_mode(core_if)) { 
    563                 gotgctl_data_t gotgctl = { .d32 = 0 }; 
    564                 gotgctl.d32 = dwc_read_reg32(&core_if->core_global_regs->gotgctl); 
     516                hcd_disconnect( _core_if ); 
     517                pcd_start( _core_if ); 
     518                _core_if->op_state = B_PERIPHERAL; 
     519        } else if (dwc_otg_is_device_mode(_core_if)) { 
     520                gotgctl_data_t gotgctl = { .d32 = 0 };  
     521                gotgctl.d32 = dwc_read_reg32(&_core_if->core_global_regs->gotgctl); 
    565522                if (gotgctl.b.hstsethnpen==1) { 
    566523                        /* Do nothing, if HNP in process the OTG 
     
    571528                        /* If in device mode Disconnect and stop the HCD, then 
    572529                         * start the PCD. */ 
    573                         hcd_disconnect(core_if); 
    574                         pcd_start(core_if); 
    575                         core_if->op_state = B_PERIPHERAL; 
     530                        hcd_disconnect( _core_if ); 
     531                        pcd_start( _core_if ); 
     532                        _core_if->op_state = B_PERIPHERAL; 
    576533                } else { 
    577534                        DWC_DEBUGPL(DBG_ANY,"!a_peripheral && !devhnpen\n"); 
    578535                } 
    579536        } else { 
    580                 if (core_if->op_state == A_HOST) { 
     537                if (_core_if->op_state == A_HOST) { 
    581538                        /* A-Cable still connected but device disconnected. */ 
    582                         hcd_disconnect(core_if); 
     539                        hcd_disconnect( _core_if ); 
    583540                } 
    584541        } 
    585542#endif 
    586  
     543/* Without OTG, we should use the disconnect function!? winder added.*/ 
     544#if 1 // NO OTG, so host only!! 
     545        hcd_disconnect( _core_if ); 
     546#endif 
     547    
    587548        gintsts.d32 = 0; 
    588549        gintsts.b.disconnect = 1; 
    589         dwc_write_reg32 (&core_if->core_global_regs->gintsts, gintsts.d32); 
     550        dwc_write_reg32 (&_core_if->core_global_regs->gintsts, gintsts.d32); 
    590551        return 1; 
    591552} 
     
    593554 * This interrupt indicates that SUSPEND state has been detected on 
    594555 * the USB. 
    595  * 
     556 *  
    596557 * For HNP the USB Suspend interrupt signals the change from 
    597558 * "a_peripheral" to "a_host". 
     
    600561 * mode. 
    601562 */ 
    602 int32_t dwc_otg_handle_usb_suspend_intr(dwc_otg_core_if_t *core_if) 
     563int32_t dwc_otg_handle_usb_suspend_intr(dwc_otg_core_if_t *_core_if ) 
    603564{ 
    604565        dsts_data_t dsts; 
    605566        gintsts_data_t gintsts; 
    606567 
    607         DWC_DEBUGPL(DBG_ANY,"USB SUSPEND\n"); 
    608  
    609         if (dwc_otg_is_device_mode(core_if)) { 
     568         //805141:<IFTW-fchang>.removed DWC_DEBUGPL(DBG_ANY,"USB SUSPEND\n"); 
     569 
     570        if (dwc_otg_is_device_mode( _core_if ) ) {              
    610571                /* Check the Device status register to determine if the Suspend 
    611572                 * state is active. */ 
    612                 dsts.d32 = dwc_read_reg32(&core_if->dev_if->dev_global_regs->dsts); 
     573                dsts.d32 = dwc_read_reg32( &_core_if->dev_if->dev_global_regs->dsts); 
    613574                DWC_DEBUGPL(DBG_PCD, "DSTS=0x%0x\n", dsts.d32); 
    614575                DWC_DEBUGPL(DBG_PCD, "DSTS.Suspend Status=%d " 
    615                             "HWCFG4.power Optimize=%d\n", 
    616                             dsts.b.suspsts, core_if->hwcfg4.b.power_optimiz); 
     576                            "HWCFG4.power Optimize=%d\n",  
     577                            dsts.b.suspsts, _core_if->hwcfg4.b.power_optimiz); 
    617578 
    618579 
    619580#ifdef PARTIAL_POWER_DOWN 
    620581/** @todo Add a module parameter for power management. */ 
    621  
    622                 if (dsts.b.suspsts && core_if->hwcfg4.b.power_optimiz) { 
     582         
     583                if (dsts.b.suspsts && _core_if->hwcfg4.b.power_optimiz) { 
    623584                        pcgcctl_data_t power = {.d32=0}; 
    624585                        DWC_DEBUGPL(DBG_CIL, "suspend\n"); 
    625586 
    626587                        power.b.pwrclmp = 1; 
    627                         dwc_write_reg32(core_if->pcgcctl, power.d32); 
     588                        dwc_write_reg32( _core_if->pcgcctl, power.d32); 
    628589 
    629590                        power.b.rstpdwnmodule = 1; 
    630                         dwc_modify_reg32(core_if->pcgcctl, 0, power.d32); 
     591                        dwc_modify_reg32( _core_if->pcgcctl, 0, power.d32); 
    631592 
    632593                        power.b.stoppclk = 1; 
    633                         dwc_modify_reg32(core_if->pcgcctl, 0, power.d32); 
    634  
     594                        dwc_modify_reg32( _core_if->pcgcctl, 0, power.d32); 
     595                 
    635596                } else { 
    636597                        DWC_DEBUGPL(DBG_ANY,"disconnect?\n"); 
     
    638599#endif 
    639600                /* PCD callback for suspend. */ 
    640                 pcd_suspend(core_if); 
     601                pcd_suspend(_core_if); 
    641602        } else { 
    642                 if (core_if->op_state == A_PERIPHERAL) { 
     603                if (_core_if->op_state == A_PERIPHERAL) { 
    643604                        DWC_DEBUGPL(DBG_ANY,"a_peripheral->a_host\n"); 
    644605                        /* Clear the a_peripheral flag, back to a_host. */ 
    645                         pcd_stop(core_if); 
    646                         hcd_start(core_if); 
    647                         core_if->op_state = A_HOST; 
    648                 } 
    649         } 
    650  
     606                        pcd_stop( _core_if ); 
     607                        hcd_start( _core_if ); 
     608                        _core_if->op_state = A_HOST; 
     609                }                 
     610        } 
     611         
    651612        /* Clear interrupt */ 
    652613        gintsts.d32 = 0; 
    653614        gintsts.b.usbsuspend = 1; 
    654         dwc_write_reg32(&core_if->core_global_regs->gintsts, gintsts.d32); 
     615        dwc_write_reg32( &_core_if->core_global_regs->gintsts, gintsts.d32); 
    655616 
    656617        return 1; 
     
    661622 * This function returns the Core Interrupt register. 
    662623 */ 
    663 static inline uint32_t dwc_otg_read_common_intr(dwc_otg_core_if_t *core_if) 
     624static inline uint32_t dwc_otg_read_common_intr(dwc_otg_core_if_t *_core_if)  
    664625{ 
    665626        gintsts_data_t gintsts; 
     
    673634        gintmsk_common.b.disconnect = 1; 
    674635        gintmsk_common.b.usbsuspend = 1; 
    675         /** @todo: The port interrupt occurs while in device 
    676          * mode. Added code to CIL to clear the interrupt for now! 
     636        /** @todo: The port interrupt occurs while in device  
     637         * mode. Added code to CIL to clear the interrupt for now!  
    677638         */ 
    678639        gintmsk_common.b.portintr = 1; 
    679640 
    680         gintsts.d32 = dwc_read_reg32(&core_if->core_global_regs->gintsts); 
    681         gintmsk.d32 = dwc_read_reg32(&core_if->core_global_regs->gintmsk); 
     641        gintsts.d32 = dwc_read_reg32(&_core_if->core_global_regs->gintsts); 
     642        gintmsk.d32 = dwc_read_reg32(&_core_if->core_global_regs->gintmsk); 
    682643#ifdef DEBUG 
    683644        /* if any common interrupts set */ 
    684645        if (gintsts.d32 & gintmsk_common.d32) { 
    685                 DWC_DEBUGPL(DBG_ANY, "gintsts=%08x  gintmsk=%08x\n", 
     646                DWC_DEBUGPL(DBG_ANY, "gintsts=%08x  gintmsk=%08x\n",  
    686647                            gintsts.d32, gintmsk.d32); 
    687648        } 
    688 #endif 
    689  
    690         return ((gintsts.d32 & gintmsk.d32) & gintmsk_common.d32); 
     649#endif         
     650         
     651        return ((gintsts.d32 & gintmsk.d32 ) & gintmsk_common.d32); 
    691652 
    692653} 
     
    695656 * Common interrupt handler. 
    696657 * 
    697  * The common interrupts are those that occur in both Host and Device mode. 
     658 * The common interrupts are those that occur in both Host and Device mode.  
    698659 * This handler handles the following interrupts: 
    699660 * - Mode Mismatch Interrupt 
     
    703664 * - Session Request Interrupt. 
    704665 * - Resume / Remote Wakeup Detected Interrupt. 
    705  * 
    706  */ 
    707 int32_t dwc_otg_handle_common_intr(dwc_otg_core_if_t *core_if) 
     666 *  
     667 */ 
     668extern int32_t dwc_otg_handle_common_intr( dwc_otg_core_if_t *_core_if ) 
    708669{ 
    709670        int retval = 0; 
    710671        gintsts_data_t gintsts; 
    711672 
    712         gintsts.d32 = dwc_otg_read_common_intr(core_if); 
     673        gintsts.d32 = dwc_otg_read_common_intr(_core_if); 
    713674 
    714675        if (gintsts.b.modemismatch) { 
    715                 retval |= dwc_otg_handle_mode_mismatch_intr(core_if); 
     676                retval |= dwc_otg_handle_mode_mismatch_intr( _core_if ); 
    716677        } 
    717678        if (gintsts.b.otgintr) { 
    718                 retval |= dwc_otg_handle_otg_intr(core_if); 
     679                retval |= dwc_otg_handle_otg_intr( _core_if ); 
    719680        } 
    720681        if (gintsts.b.conidstschng) { 
    721                 retval |= dwc_otg_handle_conn_id_status_change_intr(core_if); 
     682                retval |= dwc_otg_handle_conn_id_status_change_intr( _core_if ); 
    722683        } 
    723684        if (gintsts.b.disconnect) { 
    724                 retval |= dwc_otg_handle_disconnect_intr(core_if); 
     685                retval |= dwc_otg_handle_disconnect_intr( _core_if ); 
    725686        } 
    726687        if (gintsts.b.sessreqintr) { 
    727                 retval |= dwc_otg_handle_session_req_intr(core_if); 
     688                retval |= dwc_otg_handle_session_req_intr( _core_if ); 
    728689        } 
    729690        if (gintsts.b.wkupintr) { 
    730                 retval |= dwc_otg_handle_wakeup_detected_intr(core_if); 
     691                retval |= dwc_otg_handle_wakeup_detected_intr( _core_if ); 
    731692        } 
    732693        if (gintsts.b.usbsuspend) { 
    733                 retval |= dwc_otg_handle_usb_suspend_intr(core_if); 
    734         } 
    735         if (gintsts.b.portintr && dwc_otg_is_device_mode(core_if)) { 
     694                retval |= dwc_otg_handle_usb_suspend_intr( _core_if ); 
     695        } 
     696        if (gintsts.b.portintr && dwc_otg_is_device_mode(_core_if)) { 
    736697                /* The port interrupt occurs while in device mode with HPRT0 
    737698                 * Port Enable/Disable. 
     
    739700                gintsts.d32 = 0; 
    740701                gintsts.b.portintr = 1; 
    741                 dwc_write_reg32(&core_if->core_global_regs->gintsts, 
     702                dwc_write_reg32(&_core_if->core_global_regs->gintsts,  
    742703                                gintsts.d32); 
    743704                retval |= 1; 
    744  
    745         } 
    746  
    747         S3C2410X_CLEAR_EINTPEND(); 
    748  
     705                 
     706        } 
    749707        return retval; 
    750708} 
  • trunk/target/linux/lantiq/files/drivers/usb/dwc_otg/dwc_otg_driver.c

    r32951 r32953  
    11/* ========================================================================== 
    22 * $File: //dwh/usb_iip/dev/software/otg_ipmate/linux/drivers/dwc_otg_driver.c $ 
    3  * $Revision: 1.7 $ 
    4  * $Date: 2008-11-21 05:39:15 $ 
    5  * $Change: 791271 $ 
     3 * $Revision: 1.1.1.1 $ 
     4 * $Date: 2009-04-17 06:15:34 $ 
     5 * $Change: 631780 $ 
    66 * 
    77 * Synopsys HS OTG Linux Software Driver and documentation (hereinafter, 
    88 * "Software") is an Unsupported proprietary work of Synopsys, Inc. unless 
    99 * otherwise expressly agreed to in writing between Synopsys and you. 
    10  * 
     10 *  
    1111 * The Software IS NOT an item of Licensed Software or Licensed Product under 
    1212 * any End User Software License Agreement or Agreement for Licensed Product 
     
    1818 * Synopsys. If you do not agree with this notice, including the disclaimer 
    1919 * below, then you are not authorized to use the Software. 
    20  * 
     20 *  
    2121 * THIS SOFTWARE IS BEING DISTRIBUTED BY SYNOPSYS SOLELY ON AN "AS IS" BASIS 
    2222 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
     
    3636 * points for the DWC_otg driver. This module will be dynamically installed 
    3737 * after Linux is booted using the insmod command. When the module is 
    38  * installed, the dwc_otg_driver_init function is called. When the module is 
    39  * removed (using rmmod), the dwc_otg_driver_cleanup function is called. 
    40  * 
     38 * installed, the dwc_otg_init function is called. When the module is 
     39 * removed (using rmmod), the dwc_otg_cleanup function is called. 
     40 *  
    4141 * This module also defines a data structure for the dwc_otg_driver, which is 
    42  * used in conjunction with the standard ARM platform_device structure. These 
     42 * used in conjunction with the standard ARM lm_device structure. These 
    4343 * structures allow the OTG driver to comply with the standard Linux driver 
    4444 * model in which devices and drivers are registered with a bus driver. This 
     
    5353#include <linux/moduleparam.h> 
    5454#include <linux/init.h> 
     55#include <linux/gpio.h> 
     56 
    5557#include <linux/device.h> 
     58#include <linux/platform_device.h> 
     59 
    5660#include <linux/errno.h> 
    5761#include <linux/types.h> 
    58 #include <linux/stat.h>  /* permission constants */ 
    59 #include <linux/version.h> 
    60 #include <linux/platform_device.h> 
    61  
    62 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20) 
    63 # include <linux/irq.h> 
    64 #endif 
    65  
     62#include <linux/stat.h>  /* permission constants */ 
     63#include <linux/irq.h> 
    6664#include <asm/io.h> 
    6765 
    68 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,20) 
    69 # include <asm/irq.h> 
    70 #endif 
    71  
    72 #include "linux/dwc_otg_plat.h" 
     66#include "dwc_otg_plat.h" 
    7367#include "dwc_otg_attr.h" 
    7468#include "dwc_otg_driver.h" 
    7569#include "dwc_otg_cil.h" 
    76 #include "dwc_otg_pcd.h" 
    77 #include "dwc_otg_hcd.h" 
    78  
    79 #define DWC_DRIVER_VERSION      "2.72a 24-JUN-2008" 
    80 #define DWC_DRIVER_DESC         "HS OTG USB Controller driver" 
    81  
    82 static const char dwc_driver_name[] = "dwc_otg"; 
     70#include "dwc_otg_cil_ifx.h" 
     71 
     72// #include "dwc_otg_pcd.h" // device 
     73#include "dwc_otg_hcd.h"   // host 
     74 
     75#include "dwc_otg_ifx.h" // for Infineon platform specific. 
     76 
     77#define DWC_DRIVER_VERSION      "2.60a 22-NOV-2006" 
     78#define DWC_DRIVER_DESC         "HS OTG USB Controller driver" 
     79 
     80const char dwc_driver_name[] = "dwc_otg"; 
     81 
     82static unsigned long dwc_iomem_base = IFX_USB_IOMEM_BASE; 
     83int dwc_irq = LTQ_USB_INT; 
     84//int dwc_irq = 54; 
     85//int dwc_irq = IFXMIPS_USB_OC_INT; 
     86 
     87extern int ifx_usb_hc_init(unsigned long base_addr, int irq); 
     88extern void ifx_usb_hc_remove(void); 
    8389 
    8490/*-------------------------------------------------------------------------*/ 
     
    8692 
    8793static dwc_otg_core_params_t dwc_otg_module_params = { 
    88         .opt = -1, 
    89         .otg_cap = -1, 
    90         .dma_enable = -1, 
    91         .dma_desc_enable = -1, 
     94        .opt = -1, 
     95        .otg_cap = -1, 
     96        .dma_enable = -1, 
    9297        .dma_burst_size = -1, 
    9398        .speed = -1, 
     
    98103        .dev_rx_fifo_size = -1, 
    99104        .dev_nperio_tx_fifo_size = -1, 
    100         .dev_perio_tx_fifo_size = { 
    101                 /* dev_perio_tx_fifo_size_1 */ 
    102                 -1, 
    103                 -1, 
    104                 -1, 
    105                 -1, 
    106                 -1, 
    107                 -1, 
    108                 -1, 
    109                 -1, 
    110                 -1, 
    111                 -1, 
    112                 -1, 
    113                 -1, 
    114                 -1, 
    115                 -1, 
    116                 -1 
    117                 /* 15 */ 
    118         }, 
     105        .dev_perio_tx_fifo_size = /* dev_perio_tx_fifo_size_1 */ {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},  /* 15 */ 
    119106        .host_rx_fifo_size = -1, 
    120107        .host_nperio_tx_fifo_size = -1, 
     
    125112        .dev_endpoints = -1, 
    126113        .phy_type = -1, 
    127         .phy_utmi_width = -1, 
    128         .phy_ulpi_ddr = -1, 
    129         .phy_ulpi_ext_vbus = -1, 
     114        .phy_utmi_width = -1, 
     115        .phy_ulpi_ddr = -1, 
     116        .phy_ulpi_ext_vbus = -1, 
    130117        .i2c_enable = -1, 
    131118        .ulpi_fs_ls = -1, 
    132119        .ts_dline = -1, 
    133120        .en_multiple_tx_fifo = -1, 
    134         .dev_tx_fifo_size = { 
    135                 /* dev_tx_fifo_size */ 
    136                 -1, 
    137                 -1, 
    138                 -1, 
    139                 -1, 
    140                 -1, 
    141                 -1, 
    142                 -1, 
    143                 -1, 
    144                 -1, 
    145                 -1, 
    146                 -1, 
    147                 -1, 
    148                 -1, 
    149                 -1, 
    150                 -1 
    151                 /* 15 */ 
    152         }, 
     121        .dev_tx_fifo_size = { /* dev_tx_fifo_size */ 
     122     -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 
     123        }, /* 15 */ 
    153124        .thr_ctl = -1, 
    154125        .tx_thr_length = -1, 
    155126        .rx_thr_length = -1, 
    156         .pti_enable = -1, 
    157         .mpi_enable = -1, 
    158127}; 
    159128 
     
    163132static ssize_t version_show(struct device_driver *dev, char *buf) 
    164133{ 
    165         return snprintf(buf, sizeof(DWC_DRIVER_VERSION)+2, "%s\n", 
    166                         DWC_DRIVER_VERSION); 
     134        return snprintf(buf, sizeof(DWC_DRIVER_VERSION)+2,"%s\n",  
     135                        DWC_DRIVER_VERSION); 
    167136} 
    168137static DRIVER_ATTR(version, S_IRUGO, version_show, NULL); 
     
    171140 * Global Debug Level Mask. 
    172141 */ 
    173 uint32_t g_dbg_lvl = 0; /* OFF */ 
     142uint32_t g_dbg_lvl = 0xff; /* OFF */ 
    174143 
    175144/** 
    176145 * This function shows the driver Debug Level. 
    177146 */ 
    178 static ssize_t dbg_level_show(struct device_driver *drv, char *buf) 
     147static ssize_t dbg_level_show(struct device_driver *_drv, char *_buf) 
    179148{ 
    180         return sprintf(buf, "0x%0x\n", g_dbg_lvl); 
     149        return sprintf(_buf, "0x%0x\n", g_dbg_lvl); 
    181150} 
    182  
    183151/** 
    184152 * This function stores the driver Debug Level. 
    185153 */ 
    186 static ssize_t dbg_level_store(struct device_driver *drv, const char *buf, 
    187                                size_t count) 
     154static ssize_t dbg_level_store(struct device_driver *_drv, const char *_buf,  
     155                               size_t _count) 
    188156{ 
    189         g_dbg_lvl = simple_strtoul(buf, NULL, 16); 
    190                 return count; 
     157        g_dbg_lvl = simple_strtoul(_buf, NULL, 16); 
     158        return _count; 
    191159} 
    192160static DRIVER_ATTR(debuglevel, S_IRUGO|S_IWUSR, dbg_level_show, dbg_level_store); 
     
    202170 
    203171/* Checks if the parameter is outside of its valid range of values */ 
    204 #define DWC_OTG_PARAM_TEST(_param_, _low_, _high_) \ 
    205                 ((dwc_otg_module_params._param_ < (_low_)) || \ 
    206                 (dwc_otg_module_params._param_ > (_high_))) 
     172#define DWC_OTG_PARAM_TEST(_param_,_low_,_high_) \ 
     173        ((dwc_otg_module_params._param_ < (_low_)) || \ 
     174         (dwc_otg_module_params._param_ > (_high_))) 
    207175 
    208176/* If the parameter has been set by the user, check that the parameter value is 
    209177 * within the value range of values.  If not, report a module error. */ 
    210 #define DWC_OTG_PARAM_ERR(_param_, _low_, _high_, _string_) \ 
    211                 do { \ 
    212                         if (dwc_otg_module_params._param_ != -1) { \ 
    213                                 if (DWC_OTG_PARAM_TEST(_param_, (_low_), (_high_))) { \ 
    214                                         DWC_ERROR("`%d' invalid for parameter `%s'\n", \ 
    215                                                   dwc_otg_module_params._param_, _string_); \ 
    216                                         dwc_otg_module_params._param_ = dwc_param_##_param_##_default; \ 
    217                                         retval++; \ 
    218                                 } \ 
     178#define DWC_OTG_PARAM_ERR(_param_,_low_,_high_,_string_) \ 
     179        do { \ 
     180                if (dwc_otg_module_params._param_ != -1) { \ 
     181                        if (DWC_OTG_PARAM_TEST(_param_,(_low_),(_high_))) { \ 
     182                                DWC_ERROR("`%d' invalid for parameter `%s'\n", \ 
     183                                          dwc_otg_module_params._param_, _string_); \ 
     184                                dwc_otg_module_params._param_ = dwc_param_##_param_##_default; \ 
     185                                retval ++; \ 
    219186                        } \ 
    220                 } while (0) 
     187                } \ 
     188        } while (0) 
    221189 
    222190        DWC_OTG_PARAM_ERR(opt,0,1,"opt"); 
    223191        DWC_OTG_PARAM_ERR(otg_cap,0,2,"otg_cap"); 
    224         DWC_OTG_PARAM_ERR(dma_enable,0,1,"dma_enable"); 
    225         DWC_OTG_PARAM_ERR(dma_desc_enable,0,1,"dma_desc_enable"); 
     192        DWC_OTG_PARAM_ERR(dma_enable,0,1,"dma_enable"); 
    226193        DWC_OTG_PARAM_ERR(speed,0,1,"speed"); 
    227194        DWC_OTG_PARAM_ERR(host_support_fs_ls_low_power,0,1,"host_support_fs_ls_low_power"); 
     
    239206        DWC_OTG_PARAM_ERR(dev_endpoints,1,15,"dev_endpoints"); 
    240207        DWC_OTG_PARAM_ERR(phy_type,0,2,"phy_type"); 
    241         DWC_OTG_PARAM_ERR(phy_ulpi_ddr,0,1,"phy_ulpi_ddr"); 
    242         DWC_OTG_PARAM_ERR(phy_ulpi_ext_vbus,0,1,"phy_ulpi_ext_vbus"); 
     208        DWC_OTG_PARAM_ERR(phy_ulpi_ddr,0,1,"phy_ulpi_ddr"); 
     209        DWC_OTG_PARAM_ERR(phy_ulpi_ext_vbus,0,1,"phy_ulpi_ext_vbus"); 
    243210        DWC_OTG_PARAM_ERR(i2c_enable,0,1,"i2c_enable"); 
    244211        DWC_OTG_PARAM_ERR(ulpi_fs_ls,0,1,"ulpi_fs_ls"); 
     
    253220                    DWC_OTG_PARAM_TEST(dma_burst_size,64,64) && 
    254221                    DWC_OTG_PARAM_TEST(dma_burst_size,128,128) && 
    255                     DWC_OTG_PARAM_TEST(dma_burst_size,256,256)) { 
    256                         DWC_ERROR("`%d' invalid for parameter `dma_burst_size'\n", 
     222                    DWC_OTG_PARAM_TEST(dma_burst_size,256,256)) 
     223                { 
     224                        DWC_ERROR("`%d' invalid for parameter `dma_burst_size'\n",  
    257225                                  dwc_otg_module_params.dma_burst_size); 
    258226                        dwc_otg_module_params.dma_burst_size = 32; 
    259                         retval++; 
    260                 } 
    261  
    262                 { 
    263                         uint8_t brst_sz = 0; 
    264                         while(dwc_otg_module_params.dma_burst_size > 1) { 
    265                                 brst_sz ++; 
    266                                 dwc_otg_module_params.dma_burst_size >>= 1; 
    267                         } 
    268                         dwc_otg_module_params.dma_burst_size = brst_sz; 
     227                        retval ++; 
    269228                } 
    270229        } 
    271230 
    272231        if (dwc_otg_module_params.phy_utmi_width != -1) { 
    273                 if (DWC_OTG_PARAM_TEST(phy_utmi_width, 8, 8) && 
    274                     DWC_OTG_PARAM_TEST(phy_utmi_width, 16, 16)) { 
    275                         DWC_ERROR("`%d' invalid for parameter `phy_utmi_width'\n", 
     232                if (DWC_OTG_PARAM_TEST(phy_utmi_width,8,8) && 
     233                    DWC_OTG_PARAM_TEST(phy_utmi_width,16,16))  
     234                { 
     235                        DWC_ERROR("`%d' invalid for parameter `phy_utmi_width'\n",  
    276236                                  dwc_otg_module_params.phy_utmi_width); 
    277                         dwc_otg_module_params.phy_utmi_width = 16; 
    278                         retval++; 
     237                        //dwc_otg_module_params.phy_utmi_width = 16; 
     238                        dwc_otg_module_params.phy_utmi_width = 8; 
     239                        retval ++; 
    279240                } 
    280241        } 
    281242 
    282         for (i = 0; i < 15; i++) { 
     243        for (i=0; i<15; i++) { 
    283244                /** @todo should be like above */ 
    284                 //DWC_OTG_PARAM_ERR(dev_perio_tx_fifo_size[i], 4, 768, "dev_perio_tx_fifo_size"); 
     245                //DWC_OTG_PARAM_ERR(dev_perio_tx_fifo_size[i],4,768,"dev_perio_tx_fifo_size"); 
    285246                if (dwc_otg_module_params.dev_perio_tx_fifo_size[i] != -1) { 
    286                         if (DWC_OTG_PARAM_TEST(dev_perio_tx_fifo_size[i], 4, 768)) { 
     247                        if (DWC_OTG_PARAM_TEST(dev_perio_tx_fifo_size[i],4,768)) { 
    287248                                DWC_ERROR("`%d' invalid for parameter `%s_%d'\n", 
    288249                                          dwc_otg_module_params.dev_perio_tx_fifo_size[i], "dev_perio_tx_fifo_size", i); 
    289250                                dwc_otg_module_params.dev_perio_tx_fifo_size[i] = dwc_param_dev_perio_tx_fifo_size_default; 
     251                                retval ++; 
     252                        } 
     253                } 
     254        } 
     255 
     256        DWC_OTG_PARAM_ERR(en_multiple_tx_fifo, 0, 1, "en_multiple_tx_fifo"); 
     257        for (i = 0; i < 15; i++) { 
     258                /** @todo should be like above */ 
     259                    //DWC_OTG_PARAM_ERR(dev_tx_fifo_size[i],4,768,"dev_tx_fifo_size"); 
     260                    if (dwc_otg_module_params.dev_tx_fifo_size[i] != -1) { 
     261                        if (DWC_OTG_PARAM_TEST(dev_tx_fifo_size[i], 4, 768)) { 
     262                                DWC_ERROR("`%d' invalid for parameter `%s_%d'\n", 
     263                                        dwc_otg_module_params.dev_tx_fifo_size[i], 
     264                                     "dev_tx_fifo_size", i); 
     265                                dwc_otg_module_params.dev_tx_fifo_size[i] = 
     266                                    dwc_param_dev_tx_fifo_size_default; 
    290267                                retval++; 
    291268                        } 
    292269                } 
    293270        } 
    294  
    295         DWC_OTG_PARAM_ERR(en_multiple_tx_fifo, 0, 1, "en_multiple_tx_fifo"); 
    296  
    297         for (i = 0; i < 15; i++) { 
    298                 /** @todo should be like above */ 
    299                 //DWC_OTG_PARAM_ERR(dev_tx_fifo_size[i], 4, 768, "dev_tx_fifo_size"); 
    300                 if (dwc_otg_module_params.dev_tx_fifo_size[i] != -1) { 
    301                         if (DWC_OTG_PARAM_TEST(dev_tx_fifo_size[i], 4, 768)) { 
    302                                 DWC_ERROR("`%d' invalid for parameter `%s_%d'\n", 
    303                                           dwc_otg_module_params.dev_tx_fifo_size[i], "dev_tx_fifo_size", i); 
    304                                 dwc_otg_module_params.dev_tx_fifo_size[i] = dwc_param_dev_tx_fifo_size_default; 
    305                                 retval++; 
    306                         } 
    307                 } 
    308         } 
    309  
    310271        DWC_OTG_PARAM_ERR(thr_ctl, 0, 7, "thr_ctl"); 
    311272        DWC_OTG_PARAM_ERR(tx_thr_length, 8, 128, "tx_thr_length"); 
    312273        DWC_OTG_PARAM_ERR(rx_thr_length, 8, 128, "rx_thr_length"); 
    313  
    314         DWC_OTG_PARAM_ERR(pti_enable,0,1,"pti_enable"); 
    315         DWC_OTG_PARAM_ERR(mpi_enable,0,1,"mpi_enable"); 
    316274 
    317275        /* At this point, all module parameters that have been set by the user 
     
    319277         * default values and/or check the parameters against the hardware 
    320278         * configurations of the OTG core. */ 
     279 
     280 
    321281 
    322282/* This sets the parameter to the default value if it has not been set by the 
     
    333293 
    334294/* This checks the macro agains the hardware configuration to see if it is 
    335  * valid.  It is possible that the default value could be invalid. In this 
     295 * valid.  It is possible that the default value could be invalid.  In this 
    336296 * case, it will report a module error if the user touched the parameter. 
    337297 * Otherwise it will adjust the value without any error. */ 
    338 #define DWC_OTG_PARAM_CHECK_VALID(_param_, _str_, _is_valid_, _set_valid_) \ 
     298#define DWC_OTG_PARAM_CHECK_VALID(_param_,_str_,_is_valid_,_set_valid_) \ 
    339299        ({ \ 
    340                 int changed = DWC_OTG_PARAM_SET_DEFAULT(_param_); \ 
     300                int changed = DWC_OTG_PARAM_SET_DEFAULT(_param_); \ 
    341301                int error = 0; \ 
    342302                if (!(_is_valid_)) { \ 
    343303                        if (changed) { \ 
    344                                 DWC_ERROR("`%d' invalid for parameter `%s'. Check HW configuration.\n", dwc_otg_module_params._param_, _str_); \ 
     304                                DWC_ERROR("`%d' invalid for parameter `%s'.  Check HW configuration.\n", dwc_otg_module_params._param_,_str_); \ 
    345305                                error = 1; \ 
    346306                        } \ 
     
    351311 
    352312        /* OTG Cap */ 
    353         retval += DWC_OTG_PARAM_CHECK_VALID(otg_cap, "otg_cap", 
    354                                 ({ 
    355                                         int valid; 
    356                                         valid = 1; 
    357                                         switch (dwc_otg_module_params.otg_cap) { 
    358                                         case DWC_OTG_CAP_PARAM_HNP_SRP_CAPABLE: 
    359                                                 if (core_if->hwcfg2.b.op_mode != DWC_HWCFG2_OP_MODE_HNP_SRP_CAPABLE_OTG) 
    360                                                         valid = 0; 
    361                                                 break; 
    362                                         case DWC_OTG_CAP_PARAM_SRP_ONLY_CAPABLE: 
    363                                                 if ((core_if->hwcfg2.b.op_mode != DWC_HWCFG2_OP_MODE_HNP_SRP_CAPABLE_OTG) && 
    364                                                     (core_if->hwcfg2.b.op_mode != DWC_HWCFG2_OP_MODE_SRP_ONLY_CAPABLE_OTG) && 
    365                                                     (core_if->hwcfg2.b.op_mode != DWC_HWCFG2_OP_MODE_SRP_CAPABLE_DEVICE) && 
    366                                                     (core_if->hwcfg2.b.op_mode != DWC_HWCFG2_OP_MODE_SRP_CAPABLE_HOST)) { 
    367                                                         valid = 0; 
    368                                                 } 
    369                                                 break; 
    370                                         case DWC_OTG_CAP_PARAM_NO_HNP_SRP_CAPABLE: 
    371                                                 /* always valid */ 
    372                                                 break; 
    373                                         } 
    374                                         valid; 
    375                                 }), 
    376                                 (((core_if->hwcfg2.b.op_mode == DWC_HWCFG2_OP_MODE_HNP_SRP_CAPABLE_OTG) || 
    377                                   (core_if->hwcfg2.b.op_mode == DWC_HWCFG2_OP_MODE_SRP_ONLY_CAPABLE_OTG) || 
    378                                   (core_if->hwcfg2.b.op_mode == DWC_HWCFG2_OP_MODE_SRP_CAPABLE_DEVICE) || 
    379                                   (core_if->hwcfg2.b.op_mode == DWC_HWCFG2_OP_MODE_SRP_CAPABLE_HOST)) ? 
    380                                  DWC_OTG_CAP_PARAM_SRP_ONLY_CAPABLE : 
    381                                  DWC_OTG_CAP_PARAM_NO_HNP_SRP_CAPABLE)); 
    382  
    383         retval += DWC_OTG_PARAM_CHECK_VALID(dma_enable, "dma_enable", 
    384                                 ((dwc_otg_module_params.dma_enable == 1) && (core_if->hwcfg2.b.architecture == 0)) ? 0 : 1, 
    385                                 0); 
    386  
    387         retval += DWC_OTG_PARAM_CHECK_VALID(dma_desc_enable, "dma_desc_enable", 
    388                                 ((dwc_otg_module_params.dma_desc_enable == 1) && 
    389                                  ((dwc_otg_module_params.dma_enable == 0) || (core_if->hwcfg4.b.desc_dma == 0))) ? 0 : 1, 
    390                                 0); 
    391  
    392         retval += DWC_OTG_PARAM_CHECK_VALID(opt, "opt", 1, 0); 
     313        retval += DWC_OTG_PARAM_CHECK_VALID(otg_cap,"otg_cap", 
     314                  ({ 
     315                          int valid; 
     316                          valid = 1; 
     317                          switch (dwc_otg_module_params.otg_cap) { 
     318                          case DWC_OTG_CAP_PARAM_HNP_SRP_CAPABLE: 
     319                                  if (core_if->hwcfg2.b.op_mode != DWC_HWCFG2_OP_MODE_HNP_SRP_CAPABLE_OTG) valid = 0; 
     320                                  break; 
     321                          case DWC_OTG_CAP_PARAM_SRP_ONLY_CAPABLE: 
     322                                  if ((core_if->hwcfg2.b.op_mode != DWC_HWCFG2_OP_MODE_HNP_SRP_CAPABLE_OTG) && 
     323                                      (core_if->hwcfg2.b.op_mode != DWC_HWCFG2_OP_MODE_SRP_ONLY_CAPABLE_OTG) && 
     324                                      (core_if->hwcfg2.b.op_mode != DWC_HWCFG2_OP_MODE_SRP_CAPABLE_DEVICE) && 
     325                                      (core_if->hwcfg2.b.op_mode != DWC_HWCFG2_OP_MODE_SRP_CAPABLE_HOST)) 
     326                                  { 
     327                                          valid = 0; 
     328                                  } 
     329                                  break; 
     330                          case DWC_OTG_CAP_PARAM_NO_HNP_SRP_CAPABLE: 
     331                                  /* always valid */ 
     332                                  break; 
     333                          }  
     334                          valid; 
     335                  }), 
     336                  (((core_if->hwcfg2.b.op_mode == DWC_HWCFG2_OP_MODE_HNP_SRP_CAPABLE_OTG) || 
     337                    (core_if->hwcfg2.b.op_mode == DWC_HWCFG2_OP_MODE_SRP_ONLY_CAPABLE_OTG) || 
     338                    (core_if->hwcfg2.b.op_mode == DWC_HWCFG2_OP_MODE_SRP_CAPABLE_DEVICE) || 
     339                    (core_if->hwcfg2.b.op_mode == DWC_HWCFG2_OP_MODE_SRP_CAPABLE_HOST)) ? 
     340                   DWC_OTG_CAP_PARAM_SRP_ONLY_CAPABLE : 
     341                   DWC_OTG_CAP_PARAM_NO_HNP_SRP_CAPABLE)); 
     342         
     343        retval += DWC_OTG_PARAM_CHECK_VALID(dma_enable,"dma_enable", 
     344                                            ((dwc_otg_module_params.dma_enable == 1) && (core_if->hwcfg2.b.architecture == 0)) ? 0 : 1,  
     345                                            0); 
     346 
     347        retval += DWC_OTG_PARAM_CHECK_VALID(opt,"opt", 
     348                                            1, 
     349                                            0); 
    393350 
    394351        DWC_OTG_PARAM_SET_DEFAULT(dma_burst_size); 
    395352 
    396353        retval += DWC_OTG_PARAM_CHECK_VALID(host_support_fs_ls_low_power, 
    397                                 "host_support_fs_ls_low_power", 
    398                                 1, 0); 
     354                                            "host_support_fs_ls_low_power", 
     355                                            1, 0); 
    399356 
    400357        retval += DWC_OTG_PARAM_CHECK_VALID(enable_dynamic_fifo, 
    401                                         "enable_dynamic_fifo", 
    402                                         ((dwc_otg_module_params.enable_dynamic_fifo == 0) || 
    403                                         (core_if->hwcfg2.b.dynamic_fifo == 1)), 0); 
     358                                  "enable_dynamic_fifo", 
     359                                  ((dwc_otg_module_params.enable_dynamic_fifo == 0) || 
     360                                   (core_if->hwcfg2.b.dynamic_fifo == 1)), 0); 
     361 
    404362 
    405363        retval += DWC_OTG_PARAM_CHECK_VALID(data_fifo_size, 
    406                                         "data_fifo_size", 
    407                                         (dwc_otg_module_params.data_fifo_size <= core_if->hwcfg3.b.dfifo_depth), 
    408                                         core_if->hwcfg3.b.dfifo_depth); 
     364                                  "data_fifo_size", 
     365                                  (dwc_otg_module_params.data_fifo_size <= core_if->hwcfg3.b.dfifo_depth), 
     366                                  core_if->hwcfg3.b.dfifo_depth); 
    409367 
    410368        retval += DWC_OTG_PARAM_CHECK_VALID(dev_rx_fifo_size, 
    411                                         "dev_rx_fifo_size", 
    412                                         (dwc_otg_module_params.dev_rx_fifo_size <= dwc_read_reg32(&core_if->core_global_regs->grxfsiz)), 
    413                                         dwc_read_reg32(&core_if->core_global_regs->grxfsiz)); 
     369                                  "dev_rx_fifo_size", 
     370                                  (dwc_otg_module_params.dev_rx_fifo_size <= dwc_read_reg32(&core_if->core_global_regs->grxfsiz)), 
     371                                  dwc_read_reg32(&core_if->core_global_regs->grxfsiz)); 
    414372 
    415373        retval += DWC_OTG_PARAM_CHECK_VALID(dev_nperio_tx_fifo_size, 
    416                                         "dev_nperio_tx_fifo_size", 
    417                                         (dwc_otg_module_params.dev_nperio_tx_fifo_size <= (dwc_read_reg32(&core_if->core_global_regs->gnptxfsiz) >> 16)), 
    418                                         (dwc_read_reg32(&core_if->core_global_regs->gnptxfsiz) >> 16)); 
     374                                  "dev_nperio_tx_fifo_size", 
     375                                  (dwc_otg_module_params.dev_nperio_tx_fifo_size <= (dwc_read_reg32(&core_if->core_global_regs->gnptxfsiz) >> 16)), 
     376                                  (dwc_read_reg32(&core_if->core_global_regs->gnptxfsiz) >> 16)); 
    419377 
    420378        retval += DWC_OTG_PARAM_CHECK_VALID(host_rx_fifo_size, 
    421                                         "host_rx_fifo_size", 
    422                                         (dwc_otg_module_params.host_rx_fifo_size <= dwc_read_reg32(&core_if->core_global_regs->grxfsiz)), 
    423                                         dwc_read_reg32(&core_if->core_global_regs->grxfsiz)); 
     379                                            "host_rx_fifo_size", 
     380                                            (dwc_otg_module_params.host_rx_fifo_size <= dwc_read_reg32(&core_if->core_global_regs->grxfsiz)), 
     381                                            dwc_read_reg32(&core_if->core_global_regs->grxfsiz)); 
     382 
    424383 
    425384        retval += DWC_OTG_PARAM_CHECK_VALID(host_nperio_tx_fifo_size, 
    426                                         "host_nperio_tx_fifo_size", 
    427                                         (dwc_otg_module_params.host_nperio_tx_fifo_size <= (dwc_read_reg32(&core_if->core_global_regs->gnptxfsiz) >> 16)), 
    428                                         (dwc_read_reg32(&core_if->core_global_regs->gnptxfsiz) >> 16)); 
     385                                  "host_nperio_tx_fifo_size", 
     386                                  (dwc_otg_module_params.host_nperio_tx_fifo_size <= (dwc_read_reg32(&core_if->core_global_regs->gnptxfsiz) >> 16)), 
     387                                  (dwc_read_reg32(&core_if->core_global_regs->gnptxfsiz) >> 16)); 
    429388 
    430389        retval += DWC_OTG_PARAM_CHECK_VALID(host_perio_tx_fifo_size, 
    431                                         "host_perio_tx_fifo_size", 
    432                                         (dwc_otg_module_params.host_perio_tx_fifo_size <= ((dwc_read_reg32(&core_if->core_global_regs->hptxfsiz) >> 16))), 
    433                                         ((dwc_read_reg32(&core_if->core_global_regs->hptxfsiz) >> 16))); 
     390                                            "host_perio_tx_fifo_size", 
     391                                            (dwc_otg_module_params.host_perio_tx_fifo_size <= ((dwc_read_reg32(&core_if->core_global_regs->hptxfsiz) >> 16))), 
     392                                            ((dwc_read_reg32(&core_if->core_global_regs->hptxfsiz) >> 16))); 
    434393 
    435394        retval += DWC_OTG_PARAM_CHECK_VALID(max_transfer_size, 
    436                                         "max_transfer_size", 
    437                                         (dwc_otg_module_params.max_transfer_size < (1 << (core_if->hwcfg3.b.xfer_size_cntr_width + 11))), 
    438                                         ((1 << (core_if->hwcfg3.b.xfer_size_cntr_width + 11)) - 1)); 
     395                                  "max_transfer_size", 
     396                                  (dwc_otg_module_params.max_transfer_size < (1 << (core_if->hwcfg3.b.xfer_size_cntr_width + 11))), 
     397                                  ((1 << (core_if->hwcfg3.b.xfer_size_cntr_width + 11)) - 1)); 
    439398 
    440399        retval += DWC_OTG_PARAM_CHECK_VALID(max_packet_count, 
    441                                         "max_packet_count", 
    442                                         (dwc_otg_module_params.max_packet_count < (1 << (core_if->hwcfg3.b.packet_size_cntr_width + 4))), 
    443                                         ((1 << (core_if->hwcfg3.b.packet_size_cntr_width + 4)) - 1)); 
     400                                  "max_packet_count", 
     401                                  (dwc_otg_module_params.max_packet_count < (1 << (core_if->hwcfg3.b.packet_size_cntr_width + 4))), 
     402                                  ((1 << (core_if->hwcfg3.b.packet_size_cntr_width + 4)) - 1)); 
    444403 
    445404        retval += DWC_OTG_PARAM_CHECK_VALID(host_channels, 
    446                                         "host_channels", 
    447                                         (dwc_otg_module_params.host_channels <= (core_if->hwcfg2.b.num_host_chan + 1)), 
    448                                         (core_if->hwcfg2.b.num_host_chan + 1)); 
     405                                  "host_channels", 
     406                                  (dwc_otg_module_params.host_channels <= (core_if->hwcfg2.b.num_host_chan + 1)), 
     407                                  (core_if->hwcfg2.b.num_host_chan + 1)); 
    449408 
    450409        retval += DWC_OTG_PARAM_CHECK_VALID(dev_endpoints, 
    451                                         "dev_endpoints", 
    452                                         (dwc_otg_module_params.dev_endpoints <= (core_if->hwcfg2.b.num_dev_ep)), 
    453                                         core_if->hwcfg2.b.num_dev_ep); 
     410                                  "dev_endpoints", 
     411                                  (dwc_otg_module_params.dev_endpoints <= (core_if->hwcfg2.b.num_dev_ep)), 
     412                                  core_if->hwcfg2.b.num_dev_ep); 
    454413 
    455414/* 
     
    457416 * internal testing only. 
    458417 * 
    459  * #define NO_FS_PHY_HW_CHECKS 
     418 * #define NO_FS_PHY_HW_CHECKS  
    460419 */ 
    461420 
    462421#ifdef NO_FS_PHY_HW_CHECKS 
    463422        retval += DWC_OTG_PARAM_CHECK_VALID(phy_type, 
    464                                 "phy_type", 1, 0); 
     423                                            "phy_type", 1, 0); 
    465424#else 
    466425        retval += DWC_OTG_PARAM_CHECK_VALID(phy_type, 
    467                                 "phy_type", 
    468                                 ({ 
    469                                         int valid = 0; 
    470                                         if ((dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_UTMI) && 
    471                                         ((core_if->hwcfg2.b.hs_phy_type == 1) || 
    472                                          (core_if->hwcfg2.b.hs_phy_type == 3))) { 
    473                                                 valid = 1; 
    474                                         } 
    475                                         else if ((dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_ULPI) && 
    476                                                  ((core_if->hwcfg2.b.hs_phy_type == 2) || 
    477                                                   (core_if->hwcfg2.b.hs_phy_type == 3))) { 
    478                                                 valid = 1; 
    479                                         } 
    480                                         else if ((dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_FS) && 
    481                                                  (core_if->hwcfg2.b.fs_phy_type == 1)) { 
    482                                                 valid = 1; 
    483                                         } 
    484                                         valid; 
    485                                 }), 
    486                                 ({ 
    487                                         int set = DWC_PHY_TYPE_PARAM_FS; 
    488                                         if (core_if->hwcfg2.b.hs_phy_type) { 
    489                                                 if ((core_if->hwcfg2.b.hs_phy_type == 3) || 
    490                                                 (core_if->hwcfg2.b.hs_phy_type == 1)) { 
    491                                                         set = DWC_PHY_TYPE_PARAM_UTMI; 
    492                                                 } 
    493                                                 else { 
    494                                                         set = DWC_PHY_TYPE_PARAM_ULPI; 
    495                                                 } 
    496                                         } 
    497                                         set; 
    498                                 })); 
     426                                            "phy_type", 
     427                                            ({ 
     428                                                    int valid = 0; 
     429                                                    if ((dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_UTMI) && 
     430                                                        ((core_if->hwcfg2.b.hs_phy_type == 1) ||  
     431                                                         (core_if->hwcfg2.b.hs_phy_type == 3))) 
     432                                                    { 
     433                                                            valid = 1; 
     434                                                    } 
     435                                                    else if ((dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_ULPI) && 
     436                                                             ((core_if->hwcfg2.b.hs_phy_type == 2) ||  
     437                                                              (core_if->hwcfg2.b.hs_phy_type == 3))) 
     438                                                    { 
     439                                                            valid = 1; 
     440                                                    } 
     441                                                    else if ((dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_FS) && 
     442                                                             (core_if->hwcfg2.b.fs_phy_type == 1)) 
     443                                                    { 
     444                                                            valid = 1; 
     445                                                    } 
     446                                                    valid; 
     447                                            }), 
     448                                            ({ 
     449                                                    int set = DWC_PHY_TYPE_PARAM_FS; 
     450                                                    if (core_if->hwcfg2.b.hs_phy_type) {  
     451                                                            if ((core_if->hwcfg2.b.hs_phy_type == 3) ||  
     452                                                                (core_if->hwcfg2.b.hs_phy_type == 1)) { 
     453                                                                    set = DWC_PHY_TYPE_PARAM_UTMI; 
     454                                                            } 
     455                                                            else { 
     456                                                                    set = DWC_PHY_TYPE_PARAM_ULPI; 
     457                                                            } 
     458                                                    } 
     459                                                    set; 
     460                                            })); 
    499461#endif 
    500462 
    501         retval += DWC_OTG_PARAM_CHECK_VALID(speed, "speed", 
    502                                 (dwc_otg_module_params.speed == 0) && (dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_FS) ? 0 : 1, 
    503                                 dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_FS ? 1 : 0); 
     463        retval += DWC_OTG_PARAM_CHECK_VALID(speed,"speed", 
     464                                            (dwc_otg_module_params.speed == 0) && (dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_FS) ? 0 : 1, 
     465                                            dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_FS ? 1 : 0); 
    504466 
    505467        retval += DWC_OTG_PARAM_CHECK_VALID(host_ls_low_power_phy_clk, 
    506                                 "host_ls_low_power_phy_clk", 
    507                                 ((dwc_otg_module_params.host_ls_low_power_phy_clk == DWC_HOST_LS_LOW_POWER_PHY_CLK_PARAM_48MHZ) && (dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_FS) ? 0 : 1), 
    508                                 ((dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_FS) ? DWC_HOST_LS_LOW_POWER_PHY_CLK_PARAM_6MHZ : DWC_HOST_LS_LOW_POWER_PHY_CLK_PARAM_48MHZ)); 
    509  
    510         DWC_OTG_PARAM_SET_DEFAULT(phy_ulpi_ddr); 
    511         DWC_OTG_PARAM_SET_DEFAULT(phy_ulpi_ext_vbus); 
    512         DWC_OTG_PARAM_SET_DEFAULT(phy_utmi_width); 
    513         DWC_OTG_PARAM_SET_DEFAULT(ulpi_fs_ls); 
    514         DWC_OTG_PARAM_SET_DEFAULT(ts_dline); 
     468                                            "host_ls_low_power_phy_clk", 
     469                                            ((dwc_otg_module_params.host_ls_low_power_phy_clk == DWC_HOST_LS_LOW_POWER_PHY_CLK_PARAM_48MHZ) && (dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_FS) ? 0 : 1), 
     470                                            ((dwc_otg_module_params.phy_type == DWC_PHY_TYPE_PARAM_FS) ? DWC_HOST_LS_LOW_POWER_PHY_CLK_PARAM_6MHZ : DWC_HOST_LS_LOW_POWER_PHY_CLK_PARAM_48MHZ)); 
     471 
     472        DWC_OTG_PARAM_SET_DEFAULT(phy_ulpi_ddr); 
     473        DWC_OTG_PARAM_SET_DEFAULT(phy_ulpi_ext_vbus); 
     474        DWC_OTG_PARAM_SET_DEFAULT(phy_utmi_width); 
     475        DWC_OTG_PARAM_SET_DEFAULT(ulpi_fs_ls); 
     476        DWC_OTG_PARAM_SET_DEFAULT(ts_dline); 
    515477 
    516478#ifdef NO_FS_PHY_HW_CHECKS 
    517         retval += DWC_OTG_PARAM_CHECK_VALID(i2c_enable, "i2c_enable", 1, 0); 
     479        retval += DWC_OTG_PARAM_CHECK_VALID(i2c_enable, 
     480                                            "i2c_enable", 1, 0); 
    518481#else 
    519482        retval += DWC_OTG_PARAM_CHECK_VALID(i2c_enable, 
    520                                 "i2c_enable", 
    521                                 (dwc_otg_module_params.i2c_enable == 1) && (core_if->hwcfg3.b.i2c == 0) ? 0 : 1, 
    522                                 0); 
     483                                            "i2c_enable", 
     484                                            (dwc_otg_module_params.i2c_enable == 1) && (core_if->hwcfg3.b.i2c == 0) ? 0 : 1, 
     485                                            0); 
    523486#endif 
    524487 
    525         for (i = 0; i < 15; i++) { 
     488        for (i=0; i<16; i++) { 
     489 
    526490                int changed = 1; 
    527491                int error = 0; 
     
    533497                if (!(dwc_otg_module_params.dev_perio_tx_fifo_size[i] <= (dwc_read_reg32(&core_if->core_global_regs->dptxfsiz_dieptxf[i])))) { 
    534498                        if (changed) { 
    535                                 DWC_ERROR("`%d' invalid for parameter `dev_perio_fifo_size_%d'. Check HW configuration.\n", dwc_otg_module_params.dev_perio_tx_fifo_size[i], i); 
     499                                DWC_ERROR("`%d' invalid for parameter `dev_perio_fifo_size_%d'.  Check HW configuration.\n", dwc_otg_module_params.dev_perio_tx_fifo_size[i],i); 
    536500                                error = 1; 
    537501                        } 
     
    541505        } 
    542506 
    543         retval += DWC_OTG_PARAM_CHECK_VALID(en_multiple_tx_fifo, "en_multiple_tx_fifo", 
    544                                                 ((dwc_otg_module_params.en_multiple_tx_fifo == 1) && (core_if->hwcfg4.b.ded_fifo_en == 0)) ? 0 : 1, 
    545                                                 0); 
    546  
    547         for (i = 0; i < 15; i++) { 
     507        retval += DWC_OTG_PARAM_CHECK_VALID(en_multiple_tx_fifo, 
     508                                "en_multiple_tx_fifo", 
     509                                ((dwc_otg_module_params.en_multiple_tx_fifo == 1) && 
     510                                (core_if->hwcfg4.b.ded_fifo_en == 0)) ? 0 : 1, 0); 
     511 
     512        for (i = 0; i < 16; i++) { 
    548513                int changed = 1; 
    549514                int error = 0; 
    550  
    551515                if (dwc_otg_module_params.dev_tx_fifo_size[i] == -1) { 
    552516                        changed = 0; 
    553                         dwc_otg_module_params.dev_tx_fifo_size[i] = dwc_param_dev_tx_fifo_size_default; 
     517                        dwc_otg_module_params.dev_tx_fifo_size[i] = 
     518                            dwc_param_dev_tx_fifo_size_default; 
    554519                } 
    555                 if (!(dwc_otg_module_params.dev_tx_fifo_size[i] <= (dwc_read_reg32(&core_if->core_global_regs->dptxfsiz_dieptxf[i])))) { 
     520                if (!(dwc_otg_module_params.dev_tx_fifo_size[i] <= 
     521                     (dwc_read_reg32(&core_if->core_global_regs->dptxfsiz_dieptxf[i])))) { 
    556522                        if (changed) { 
    557                                 DWC_ERROR("%d' invalid for parameter `dev_perio_fifo_size_%d'. Check HW configuration.\n", dwc_otg_module_params.dev_tx_fifo_size[i], i); 
     523                                DWC_ERROR("%d' invalid for parameter `dev_perio_fifo_size_%d'." 
     524                                        "Check HW configuration.\n",dwc_otg_module_params.dev_tx_fifo_size[i],i); 
    558525                                error = 1; 
    559526                        } 
    560                         dwc_otg_module_params.dev_tx_fifo_size[i] = dwc_read_reg32(&core_if->core_global_regs->dptxfsiz_dieptxf[i]); 
     527                        dwc_otg_module_params.dev_tx_fifo_size[i] = 
     528                            dwc_read_reg32(&core_if->core_global_regs->dptxfsiz_dieptxf[i]); 
    561529                } 
    562530                retval += error; 
    563531        } 
    564  
    565         retval += DWC_OTG_PARAM_CHECK_VALID(thr_ctl, "thr_ctl", 
    566                                 ((dwc_otg_module_params.thr_ctl != 0) && ((dwc_otg_module_params.dma_enable == 0) || (core_if->hwcfg4.b.ded_fifo_en == 0))) ? 0 : 1, 
    567                                 0); 
    568  
     532        DWC_OTG_PARAM_SET_DEFAULT(thr_ctl); 
    569533        DWC_OTG_PARAM_SET_DEFAULT(tx_thr_length); 
    570534        DWC_OTG_PARAM_SET_DEFAULT(rx_thr_length); 
    571  
    572         retval += DWC_OTG_PARAM_CHECK_VALID(pti_enable, "pti_enable", 
    573                 ((dwc_otg_module_params.pti_enable == 0) || ((dwc_otg_module_params.pti_enable == 1) && (core_if->snpsid >= 0x4F54272A))) ? 1 : 0, 
    574                         0); 
    575  
    576         retval += DWC_OTG_PARAM_CHECK_VALID(mpi_enable, "mpi_enable", 
    577                         ((dwc_otg_module_params.mpi_enable == 0) || ((dwc_otg_module_params.mpi_enable == 1) && (core_if->hwcfg2.b.multi_proc_int == 1))) ? 1 : 0, 
    578                         0); 
    579535        return retval; 
    580 } 
    581  
    582 /** 
     536} // check_parameters  
     537 
     538 
     539/**  
    583540 * This function is the top level interrupt handler for the Common 
    584541 * (Device and host modes) interrupts. 
    585542 */ 
    586 static irqreturn_t dwc_otg_common_irq(int irq, void *dev 
    587 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,19) 
    588                                       , struct pt_regs *r 
    589 #endif 
    590                                      ) 
     543static irqreturn_t dwc_otg_common_irq(int _irq, void *_dev) 
    591544{ 
    592         dwc_otg_device_t *otg_dev = dev; 
     545        dwc_otg_device_t *otg_dev = _dev; 
    593546        int32_t retval = IRQ_NONE; 
    594547 
    595         retval = dwc_otg_handle_common_intr(otg_dev->core_if); 
     548        retval = dwc_otg_handle_common_intr( otg_dev->core_if ); 
     549 
     550        mask_and_ack_ifx_irq (_irq); 
     551     
    596552        return IRQ_RETVAL(retval); 
    597553} 
    598554 
     555 
    599556/** 
    600  * This function is called when a platform_device is unregistered with the 
     557 * This function is called when a DWC_OTG device is unregistered with the 
    601558 * dwc_otg_driver. This happens, for example, when the rmmod command is 
    602559 * executed. The device may or may not be electrically present. If it is 
     
    604561 * of this device are freed. 
    605562 * 
    606  * @param[in] pdev 
     563