drivers/usb/musb-new/omap2430.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2005-2007 by Texas Instruments
   4  * Some code has been taken from tusb6010.c
   5  * Copyrights for that are attributable to:
   6  * Copyright (C) 2006 Nokia Corporation
   7  * Tony Lindgren <tony@atomide.com>
   8  *
   9  * This file is part of the Inventra Controller Driver for Linux.
  10  */
  11 #include <common.h>
  12 #include <dm.h>
  13 #include <dm/device-internal.h>
  14 #include <dm/lists.h>
  15 #include <linux/usb/otg.h>
  16 #include <asm/omap_common.h>
  17 #include <asm/omap_musb.h>
  18 #include <twl4030.h>
  19 #include <twl6030.h>
  20 #include "linux-compat.h"
  21 #include "musb_core.h"
  22 #include "omap2430.h"
  23 #include "musb_uboot.h"
  24
  25 static inline void omap2430_low_level_exit(struct musb *musb)
  26 {
  27         u32 l;
  28
  29         /* in any role */
  30         l = musb_readl(musb->mregs, OTG_FORCESTDBY);
  31         l |= ENABLEFORCE;       /* enable MSTANDBY */
  32         musb_writel(musb->mregs, OTG_FORCESTDBY, l);
  33 }
  34
  35 static inline void omap2430_low_level_init(struct musb *musb)
  36 {
  37         u32 l;
  38
  39         l = musb_readl(musb->mregs, OTG_FORCESTDBY);
  40         l &= ~ENABLEFORCE;      /* disable MSTANDBY */
  41         musb_writel(musb->mregs, OTG_FORCESTDBY, l);
  42 }
  43
  44
  45 static int omap2430_musb_init(struct musb *musb)
  46 {
  47         u32 l;
  48         int status = 0;
  49         unsigned long int start;
  50
  51         struct omap_musb_board_data *data =
  52                 (struct omap_musb_board_data *)musb->controller;
  53
  54         /* Reset the controller */
  55         musb_writel(musb->mregs, OTG_SYSCONFIG, SOFTRST);
  56
  57         start = get_timer(0);
  58
  59         while (1) {
  60                 l = musb_readl(musb->mregs, OTG_SYSCONFIG);
  61                 if ((l & SOFTRST) == 0)
  62                         break;
  63
  64                 if (get_timer(start) > (CONFIG_SYS_HZ / 1000)) {
  65                         dev_err(musb->controller, "MUSB reset is taking too long\n");
  66                         return -ENODEV;
  67                 }
  68         }
  69
  70         l = musb_readl(musb->mregs, OTG_INTERFSEL);
  71
  72         if (data->interface_type == MUSB_INTERFACE_UTMI) {
  73                 /* OMAP4 uses Internal PHY GS70 which uses UTMI interface */
  74                 l &= ~ULPI_12PIN;       /* Disable ULPI */
  75                 l |= UTMI_8BIT;         /* Enable UTMI  */
  76         } else {
  77                 l |= ULPI_12PIN;
  78         }
  79
  80         musb_writel(musb->mregs, OTG_INTERFSEL, l);
  81
  82         pr_debug("HS USB OTG: revision 0x%x, sysconfig 0x%02x, "
  83                         "sysstatus 0x%x, intrfsel 0x%x, simenable  0x%x\n",
  84                         musb_readl(musb->mregs, OTG_REVISION),
  85                         musb_readl(musb->mregs, OTG_SYSCONFIG),
  86                         musb_readl(musb->mregs, OTG_SYSSTATUS),
  87                         musb_readl(musb->mregs, OTG_INTERFSEL),
  88                         musb_readl(musb->mregs, OTG_SIMENABLE));
  89         return 0;
  90
  91 err1:
  92         return status;
  93 }
  94
  95 static int omap2430_musb_enable(struct musb *musb)
  96 {
  97 #ifdef CONFIG_TWL4030_USB
  98         if (twl4030_usb_ulpi_init()) {
  99                 serial_printf("ERROR: %s Could not initialize PHY\n",
 100                                 __PRETTY_FUNCTION__);
 101         }
 102 #endif
 103
 104 #ifdef CONFIG_TWL6030_POWER
 105         twl6030_usb_device_settings();
 106 #endif
 107
 108 #ifdef CONFIG_OMAP44XX
 109         u32 *usbotghs_control = (u32 *)((*ctrl)->control_usbotghs_ctrl);
 110         *usbotghs_control = USBOTGHS_CONTROL_AVALID |
 111                 USBOTGHS_CONTROL_VBUSVALID | USBOTGHS_CONTROL_IDDIG;
 112 #endif
 113
 114         return 0;
 115 }
 116
 117 static void omap2430_musb_disable(struct musb *musb)
 118 {
 119
 120 }
 121
 122 static int omap2430_musb_exit(struct musb *musb)
 123 {
 124         del_timer_sync(&musb_idle_timer);
 125
 126         omap2430_low_level_exit(musb);
 127
 128         return 0;
 129 }
 130
 131 const struct musb_platform_ops omap2430_ops = {
 132         .init           = omap2430_musb_init,
 133         .exit           = omap2430_musb_exit,
 134         .enable         = omap2430_musb_enable,
 135         .disable        = omap2430_musb_disable,
 136 };
 137
 138 #if defined(CONFIG_DM_USB)
 139
 140 struct omap2430_musb_platdata {
 141         void *base;
 142         void *ctrl_mod_base;
 143         struct musb_hdrc_platform_data plat;
 144         struct musb_hdrc_config musb_config;
 145         struct omap_musb_board_data otg_board_data;
 146 };
 147
 148 static int omap2430_musb_ofdata_to_platdata(struct udevice *dev)
 149 {
 150         struct omap2430_musb_platdata *platdata = dev_get_platdata(dev);
 151         const void *fdt = gd->fdt_blob;
 152         int node = dev_of_offset(dev);
 153
 154         platdata->base = (void *)dev_read_addr_ptr(dev);
 155
 156         platdata->musb_config.multipoint = fdtdec_get_int(fdt, node,
 157                                                           "multipoint",
 158                                                           -1);
 159         if (platdata->musb_config.multipoint < 0) {
 160                 pr_err("MUSB multipoint DT entry missing\n");
 161                 return -ENOENT;
 162         }
 163
 164         platdata->musb_config.dyn_fifo = 1;
 165         platdata->musb_config.num_eps = fdtdec_get_int(fdt, node,
 166                                                        "num-eps", -1);
 167         if (platdata->musb_config.num_eps < 0) {
 168                 pr_err("MUSB num-eps DT entry missing\n");
 169                 return -ENOENT;
 170         }
 171
 172         platdata->musb_config.ram_bits = fdtdec_get_int(fdt, node,
 173                                                         "ram-bits", -1);
 174         if (platdata->musb_config.ram_bits < 0) {
 175                 pr_err("MUSB ram-bits DT entry missing\n");
 176                 return -ENOENT;
 177         }
 178
 179         platdata->plat.power = fdtdec_get_int(fdt, node,
 180                                                                 "power", -1);
 181         if (platdata->plat.power < 0) {
 182                 pr_err("MUSB power DT entry missing\n");
 183                 return -ENOENT;
 184         }
 185
 186         platdata->otg_board_data.interface_type = fdtdec_get_int(fdt, node,
 187                                                                         "interface-type", -1);
 188         if (platdata->otg_board_data.interface_type < 0) {
 189                 pr_err("MUSB interface-type DT entry missing\n");
 190                 return -ENOENT;
 191         }
 192
 193 #if 0 /* In a perfect world, mode would be set to OTG, mode 3 from DT */
 194         platdata->plat.mode = fdtdec_get_int(fdt, node,
 195                                                                                 "mode", -1);
 196         if (platdata->plat.mode < 0) {
 197                 pr_err("MUSB mode DT entry missing\n");
 198                 return -ENOENT;
 199         }
 200 #else /* MUSB_OTG, it doesn't work */
 201 #ifdef CONFIG_USB_MUSB_HOST /* Host seems to be the only option that works */
 202         platdata->plat.mode = MUSB_HOST;
 203 #else /* For that matter, MUSB_PERIPHERAL doesn't either */
 204         platdata->plat.mode = MUSB_PERIPHERAL;
 205 #endif
 206 #endif
 207         platdata->otg_board_data.dev = dev;
 208         platdata->plat.config = &platdata->musb_config;
 209         platdata->plat.platform_ops = &omap2430_ops;
 210         platdata->plat.board_data = &platdata->otg_board_data;
 211         return 0;
 212 }
 213
 214 static int omap2430_musb_probe(struct udevice *dev)
 215 {
 216 #ifdef CONFIG_USB_MUSB_HOST
 217         struct musb_host_data *host = dev_get_priv(dev);
 218 #endif
 219         struct omap2430_musb_platdata *platdata = dev_get_platdata(dev);
 220         struct usb_bus_priv *priv = dev_get_uclass_priv(dev);
 221         struct omap_musb_board_data *otg_board_data;
 222         int ret;
 223         void *base = dev_read_addr_ptr(dev);
 224
 225         priv->desc_before_addr = true;
 226
 227         otg_board_data = &platdata->otg_board_data;
 228
 229 #ifdef CONFIG_USB_MUSB_HOST
 230         host->host = musb_init_controller(&platdata->plat,
 231                                           (struct device *)otg_board_data,
 232                                           platdata->base);
 233         if (!host->host) {
 234                 return -EIO;
 235         }
 236
 237         ret = musb_lowlevel_init(host);
 238 #else
 239         ret = musb_register(&platdata->plat,
 240                           (struct device *)otg_board_data,
 241                           platdata->base);
 242 #endif
 243         return ret;
 244 }
 245
 246 static int omap2430_musb_remove(struct udevice *dev)
 247 {
 248         struct musb_host_data *host = dev_get_priv(dev);
 249
 250         musb_stop(host->host);
 251
 252         return 0;
 253 }
 254
 255 static const struct udevice_id omap2430_musb_ids[] = {
 256         { .compatible = "ti,omap3-musb" },
 257         { .compatible = "ti,omap4-musb" },
 258         { }
 259 };
 260
 261 U_BOOT_DRIVER(omap2430_musb) = {
 262         .name   = "omap2430-musb",
 263 #ifdef CONFIG_USB_MUSB_HOST
 264         .id             = UCLASS_USB,
 265 #else
 266         .id             = UCLASS_USB_DEV_GENERIC,
 267 #endif
 268         .of_match = omap2430_musb_ids,
 269         .ofdata_to_platdata = omap2430_musb_ofdata_to_platdata,
 270         .probe = omap2430_musb_probe,
 271         .remove = omap2430_musb_remove,
 272 #ifdef CONFIG_USB_MUSB_HOST
 273         .ops = &musb_usb_ops,
 274 #endif
 275         .platdata_auto_alloc_size = sizeof(struct omap2430_musb_platdata),
 276         .priv_auto_alloc_size = sizeof(struct musb_host_data),
 277 };
 278
 279 #endif /* CONFIG_DM_USB */