arch/arm/plat-mxc/ehci.c

   1 /*
   2  * Copyright (c) 2009 Daniel Mack <daniel@caiaq.de>
   3  * Copyright (C) 2010 Freescale Semiconductor, Inc.
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License as published by the
   7  * Free Software Foundation; either version 2 of the License, or (at your
   8  * option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  12  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software Foundation,
  17  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  */
  19
  20 #include <linux/platform_device.h>
  21 #include <linux/io.h>
  22
  23 #include <mach/hardware.h>
  24 #include <mach/mxc_ehci.h>
  25
  26 #define USBCTRL_OTGBASE_OFFSET  0x600
  27
  28 #define MX31_OTG_SIC_SHIFT      29
  29 #define MX31_OTG_SIC_MASK       (0x3 << MX31_OTG_SIC_SHIFT)
  30 #define MX31_OTG_PM_BIT         (1 << 24)
  31
  32 #define MX31_H2_SIC_SHIFT       21
  33 #define MX31_H2_SIC_MASK        (0x3 << MX31_H2_SIC_SHIFT)
  34 #define MX31_H2_PM_BIT          (1 << 16)
  35 #define MX31_H2_DT_BIT          (1 << 5)
  36
  37 #define MX31_H1_SIC_SHIFT       13
  38 #define MX31_H1_SIC_MASK        (0x3 << MX31_H1_SIC_SHIFT)
  39 #define MX31_H1_PM_BIT          (1 << 8)
  40 #define MX31_H1_DT_BIT          (1 << 4)
  41
  42 #define MX35_OTG_SIC_SHIFT      29
  43 #define MX35_OTG_SIC_MASK       (0x3 << MX35_OTG_SIC_SHIFT)
  44 #define MX35_OTG_PM_BIT         (1 << 24)
  45
  46 #define MX35_H1_SIC_SHIFT       21
  47 #define MX35_H1_SIC_MASK        (0x3 << MX35_H1_SIC_SHIFT)
  48 #define MX35_H1_PM_BIT          (1 << 8)
  49 #define MX35_H1_IPPUE_UP_BIT    (1 << 7)
  50 #define MX35_H1_IPPUE_DOWN_BIT  (1 << 6)
  51 #define MX35_H1_TLL_BIT         (1 << 5)
  52 #define MX35_H1_USBTE_BIT       (1 << 4)
  53
  54 #define MXC_OTG_OFFSET          0
  55 #define MXC_H1_OFFSET           0x200
  56
  57 /* USB_CTRL */
  58 #define MXC_OTG_UCTRL_OWIE_BIT          (1 << 27)       /* OTG wakeup intr enable */
  59 #define MXC_OTG_UCTRL_OPM_BIT           (1 << 24)       /* OTG power mask */
  60 #define MXC_H1_UCTRL_H1UIE_BIT          (1 << 12)       /* Host1 ULPI interrupt enable */
  61 #define MXC_H1_UCTRL_H1WIE_BIT          (1 << 11)       /* HOST1 wakeup intr enable */
  62 #define MXC_H1_UCTRL_H1PM_BIT           (1 <<  8)               /* HOST1 power mask */
  63
  64 /* USB_PHY_CTRL_FUNC */
  65 #define MXC_OTG_PHYCTRL_OC_DIS_BIT      (1 << 8)        /* OTG Disable Overcurrent Event */
  66 #define MXC_H1_OC_DIS_BIT                       (1 << 5)        /* UH1 Disable Overcurrent Event */
  67
  68 #define MXC_USBCMD_OFFSET                       0x140
  69
  70 /* USBCMD */
  71 #define MXC_UCMD_ITC_NO_THRESHOLD_MASK  (~(0xff << 16)) /* Interrupt Threshold Control */
  72
  73 int mxc_initialize_usb_hw(int port, unsigned int flags)
  74 {
  75         unsigned int v;
  76 #if defined(CONFIG_ARCH_MX25)
  77         if (cpu_is_mx25()) {
  78                 v = readl(MX25_IO_ADDRESS(MX25_OTG_BASE_ADDR +
  79                                      USBCTRL_OTGBASE_OFFSET));
  80
  81                 switch (port) {
  82                 case 0: /* OTG port */
  83                         v &= ~(MX35_OTG_SIC_MASK | MX35_OTG_PM_BIT);
  84                         v |= (flags & MXC_EHCI_INTERFACE_MASK)
  85                                         << MX35_OTG_SIC_SHIFT;
  86                         if (!(flags & MXC_EHCI_POWER_PINS_ENABLED))
  87                                 v |= MX35_OTG_PM_BIT;
  88
  89                         break;
  90                 case 1: /* H1 port */
  91                         v &= ~(MX35_H1_SIC_MASK | MX35_H1_PM_BIT | MX35_H1_TLL_BIT |
  92                                 MX35_H1_USBTE_BIT | MX35_H1_IPPUE_DOWN_BIT | MX35_H1_IPPUE_UP_BIT);
  93                         v |= (flags & MXC_EHCI_INTERFACE_MASK)
  94                                                 << MX35_H1_SIC_SHIFT;
  95                         if (!(flags & MXC_EHCI_POWER_PINS_ENABLED))
  96                                 v |= MX35_H1_PM_BIT;
  97
  98                         if (!(flags & MXC_EHCI_TTL_ENABLED))
  99                                 v |= MX35_H1_TLL_BIT;
 100
 101                         if (flags & MXC_EHCI_INTERNAL_PHY)
 102                                 v |= MX35_H1_USBTE_BIT;
 103
 104                         if (flags & MXC_EHCI_IPPUE_DOWN)
 105                                 v |= MX35_H1_IPPUE_DOWN_BIT;
 106
 107                         if (flags & MXC_EHCI_IPPUE_UP)
 108                                 v |= MX35_H1_IPPUE_UP_BIT;
 109
 110                         break;
 111                 default:
 112                         return -EINVAL;
 113                 }
 114
 115                 writel(v, MX25_IO_ADDRESS(MX25_OTG_BASE_ADDR +
 116                                      USBCTRL_OTGBASE_OFFSET));
 117                 return 0;
 118         }
 119 #endif /* CONFIG_ARCH_MX25 */
 120 #if defined(CONFIG_ARCH_MX3)
 121         if (cpu_is_mx31()) {
 122                 v = readl(MX31_IO_ADDRESS(MX31_OTG_BASE_ADDR +
 123                                      USBCTRL_OTGBASE_OFFSET));
 124
 125                 switch (port) {
 126                 case 0: /* OTG port */
 127                         v &= ~(MX31_OTG_SIC_MASK | MX31_OTG_PM_BIT);
 128                         v |= (flags & MXC_EHCI_INTERFACE_MASK)
 129                                         << MX31_OTG_SIC_SHIFT;
 130                         if (!(flags & MXC_EHCI_POWER_PINS_ENABLED))
 131                                 v |= MX31_OTG_PM_BIT;
 132
 133                         break;
 134                 case 1: /* H1 port */
 135                         v &= ~(MX31_H1_SIC_MASK | MX31_H1_PM_BIT | MX31_H1_DT_BIT);
 136                         v |= (flags & MXC_EHCI_INTERFACE_MASK)
 137                                                 << MX31_H1_SIC_SHIFT;
 138                         if (!(flags & MXC_EHCI_POWER_PINS_ENABLED))
 139                                 v |= MX31_H1_PM_BIT;
 140
 141                         if (!(flags & MXC_EHCI_TTL_ENABLED))
 142                                 v |= MX31_H1_DT_BIT;
 143
 144                         break;
 145                 case 2: /* H2 port */
 146                         v &= ~(MX31_H2_SIC_MASK | MX31_H2_PM_BIT | MX31_H2_DT_BIT);
 147                         v |= (flags & MXC_EHCI_INTERFACE_MASK)
 148                                                 << MX31_H2_SIC_SHIFT;
 149                         if (!(flags & MXC_EHCI_POWER_PINS_ENABLED))
 150                                 v |= MX31_H2_PM_BIT;
 151
 152                         if (!(flags & MXC_EHCI_TTL_ENABLED))
 153                                 v |= MX31_H2_DT_BIT;
 154
 155                         break;
 156                 default:
 157                         return -EINVAL;
 158                 }
 159
 160                 writel(v, MX31_IO_ADDRESS(MX31_OTG_BASE_ADDR +
 161                                      USBCTRL_OTGBASE_OFFSET));
 162                 return 0;
 163         }
 164
 165         if (cpu_is_mx35()) {
 166                 v = readl(MX35_IO_ADDRESS(MX35_OTG_BASE_ADDR +
 167                                      USBCTRL_OTGBASE_OFFSET));
 168
 169                 switch (port) {
 170                 case 0: /* OTG port */
 171                         v &= ~(MX35_OTG_SIC_MASK | MX35_OTG_PM_BIT);
 172                         v |= (flags & MXC_EHCI_INTERFACE_MASK)
 173                                         << MX35_OTG_SIC_SHIFT;
 174                         if (!(flags & MXC_EHCI_POWER_PINS_ENABLED))
 175                                 v |= MX35_OTG_PM_BIT;
 176
 177                         break;
 178                 case 1: /* H1 port */
 179                         v &= ~(MX35_H1_SIC_MASK | MX35_H1_PM_BIT | MX35_H1_TLL_BIT |
 180                                 MX35_H1_USBTE_BIT | MX35_H1_IPPUE_DOWN_BIT | MX35_H1_IPPUE_UP_BIT);
 181                         v |= (flags & MXC_EHCI_INTERFACE_MASK)
 182                                                 << MX35_H1_SIC_SHIFT;
 183                         if (!(flags & MXC_EHCI_POWER_PINS_ENABLED))
 184                                 v |= MX35_H1_PM_BIT;
 185
 186                         if (!(flags & MXC_EHCI_TTL_ENABLED))
 187                                 v |= MX35_H1_TLL_BIT;
 188
 189                         if (flags & MXC_EHCI_INTERNAL_PHY)
 190                                 v |= MX35_H1_USBTE_BIT;
 191
 192                         if (flags & MXC_EHCI_IPPUE_DOWN)
 193                                 v |= MX35_H1_IPPUE_DOWN_BIT;
 194
 195                         if (flags & MXC_EHCI_IPPUE_UP)
 196                                 v |= MX35_H1_IPPUE_UP_BIT;
 197
 198                         break;
 199                 default:
 200                         return -EINVAL;
 201                 }
 202
 203                 writel(v, MX35_IO_ADDRESS(MX35_OTG_BASE_ADDR +
 204                                      USBCTRL_OTGBASE_OFFSET));
 205                 return 0;
 206         }
 207 #endif /* CONFIG_ARCH_MX3 */
 208 #ifdef CONFIG_MACH_MX27
 209         if (cpu_is_mx27()) {
 210                 /* On i.MX27 we can use the i.MX31 USBCTRL bits, they
 211                  * are identical
 212                  */
 213                 v = readl(MX27_IO_ADDRESS(MX27_OTG_BASE_ADDR +
 214                                      USBCTRL_OTGBASE_OFFSET));
 215                 switch (port) {
 216                 case 0: /* OTG port */
 217                         v &= ~(MX31_OTG_SIC_MASK | MX31_OTG_PM_BIT);
 218                         v |= (flags & MXC_EHCI_INTERFACE_MASK)
 219                                         << MX31_OTG_SIC_SHIFT;
 220                         if (!(flags & MXC_EHCI_POWER_PINS_ENABLED))
 221                                 v |= MX31_OTG_PM_BIT;
 222                         break;
 223                 case 1: /* H1 port */
 224                         v &= ~(MX31_H1_SIC_MASK | MX31_H1_PM_BIT | MX31_H1_DT_BIT);
 225                         v |= (flags & MXC_EHCI_INTERFACE_MASK)
 226                                                 << MX31_H1_SIC_SHIFT;
 227                         if (!(flags & MXC_EHCI_POWER_PINS_ENABLED))
 228                                 v |= MX31_H1_PM_BIT;
 229
 230                         if (!(flags & MXC_EHCI_TTL_ENABLED))
 231                                 v |= MX31_H1_DT_BIT;
 232
 233                         break;
 234                 case 2: /* H2 port */
 235                         v &= ~(MX31_H2_SIC_MASK | MX31_H2_PM_BIT | MX31_H2_DT_BIT);
 236                         v |= (flags & MXC_EHCI_INTERFACE_MASK)
 237                                                 << MX31_H2_SIC_SHIFT;
 238                         if (!(flags & MXC_EHCI_POWER_PINS_ENABLED))
 239                                 v |= MX31_H2_PM_BIT;
 240
 241                         if (!(flags & MXC_EHCI_TTL_ENABLED))
 242                                 v |= MX31_H2_DT_BIT;
 243
 244                         break;
 245                 default:
 246                         return -EINVAL;
 247                 }
 248                 writel(v, MX27_IO_ADDRESS(MX27_OTG_BASE_ADDR +
 249                                      USBCTRL_OTGBASE_OFFSET));
 250                 return 0;
 251         }
 252 #endif /* CONFIG_MACH_MX27 */
 253 #ifdef CONFIG_ARCH_MX51
 254         if (cpu_is_mx51()) {
 255                 void __iomem *usb_base;
 256                 u32 usbotg_base;
 257                 u32 usbother_base;
 258                 int ret = 0;
 259
 260                 usb_base = ioremap(MX51_OTG_BASE_ADDR, SZ_4K);
 261
 262                 switch (port) {
 263                 case 0: /* OTG port */
 264                         usbotg_base = usb_base + MXC_OTG_OFFSET;
 265                         break;
 266                 case 1: /* Host 1 port */
 267                         usbotg_base = usb_base + MXC_H1_OFFSET;
 268                         break;
 269                 default:
 270                         printk(KERN_ERR"%s no such port %d\n", __func__, port);
 271                         ret = -ENOENT;
 272                         goto error;
 273                 }
 274                 usbother_base = usb_base + MX5_USBOTHER_REGS_OFFSET;
 275
 276                 switch (port) {
 277                 case 0: /*OTG port */
 278                         if (flags & MXC_EHCI_INTERNAL_PHY) {
 279                                 v = __raw_readl(usbother_base + MXC_USB_PHY_CTR_FUNC_OFFSET);
 280
 281                                 if (flags & MXC_EHCI_POWER_PINS_ENABLED)
 282                                         v |= (MXC_OTG_PHYCTRL_OC_DIS_BIT | MXC_OTG_UCTRL_OPM_BIT); /* OC/USBPWR is not used */
 283                                 else
 284                                         v &= ~(MXC_OTG_PHYCTRL_OC_DIS_BIT | MXC_OTG_UCTRL_OPM_BIT); /* OC/USBPWR is used */
 285                                 __raw_writel(v, usbother_base + MXC_USB_PHY_CTR_FUNC_OFFSET);
 286
 287                                 v = __raw_readl(usbother_base + MXC_USBCTRL_OFFSET);
 288                                 if (flags & MXC_EHCI_WAKEUP_ENABLED)
 289                                         v |= MXC_OTG_UCTRL_OWIE_BIT;/* OTG wakeup enable */
 290                                 else
 291                                         v &= ~MXC_OTG_UCTRL_OWIE_BIT;/* OTG wakeup disable */
 292                                 __raw_writel(v, usbother_base + MXC_USBCTRL_OFFSET);
 293                         }
 294                         break;
 295                 case 1: /* Host 1 */
 296                         /*Host ULPI */
 297                         v = __raw_readl(usbother_base + MXC_USBCTRL_OFFSET);
 298                         if (flags & MXC_EHCI_WAKEUP_ENABLED)
 299                                 v &= ~(MXC_H1_UCTRL_H1WIE_BIT | MXC_H1_UCTRL_H1UIE_BIT);/* HOST1 wakeup/ULPI intr disable */
 300                         else
 301                                 v &= ~(MXC_H1_UCTRL_H1WIE_BIT | MXC_H1_UCTRL_H1UIE_BIT);/* HOST1 wakeup/ULPI intr disable */
 302
 303                         if (flags & MXC_EHCI_POWER_PINS_ENABLED)
 304                                 v &= ~MXC_H1_UCTRL_H1PM_BIT; /* HOST1 power mask used*/
 305                         else
 306                                 v |= MXC_H1_UCTRL_H1PM_BIT; /* HOST1 power mask used*/
 307                         __raw_writel(v, usbother_base + MXC_USBCTRL_OFFSET);
 308
 309                         v = __raw_readl(usbother_base + MXC_USB_PHY_CTR_FUNC_OFFSET);
 310                         if (flags & MXC_EHCI_POWER_PINS_ENABLED)
 311                                 v &= ~MXC_H1_OC_DIS_BIT; /* OC is used */
 312                         else
 313                                 v |= MXC_H1_OC_DIS_BIT; /* OC is not used */
 314                         __raw_writel(v, usbother_base + MXC_USB_PHY_CTR_FUNC_OFFSET);
 315
 316                         v = __raw_readl(usbotg_base + MXC_USBCMD_OFFSET);
 317                         if (flags & MXC_EHCI_ITC_NO_THRESHOLD)
 318                                 /* Interrupt Threshold Control:Immediate (no threshold) */
 319                                 v &= MXC_UCMD_ITC_NO_THRESHOLD_MASK;
 320                         __raw_writel(v, usbotg_base + MXC_USBCMD_OFFSET);
 321                         break;
 322                 }
 323
 324 error:
 325                 iounmap(usb_base);
 326                 return ret;
 327         }
 328 #endif
 329         printk(KERN_WARNING
 330                 "%s() unable to setup USBCONTROL for this CPU\n", __func__);
 331         return -EINVAL;
 332 }
 333 EXPORT_SYMBOL(mxc_initialize_usb_hw);
 334