drivers/usb/host/dwc3-sti-glue.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * STiH407 family DWC3 specific Glue layer
   4  *
   5  * Copyright (C) 2017, STMicroelectronics - All Rights Reserved
   6  * Author(s): Patrice Chotard, <patrice.chotard@foss.st.com> for STMicroelectronics.
   7  */
   8
   9 #include <common.h>
  10 #include <log.h>
  11 #include <asm/io.h>
  12 #include <dm.h>
  13 #include <errno.h>
  14 #include <dm/lists.h>
  15 #include <regmap.h>
  16 #include <reset-uclass.h>
  17 #include <syscon.h>
  18 #include <usb.h>
  19
  20 #include <linux/usb/dwc3.h>
  21 #include <linux/usb/otg.h>
  22 #include <dwc3-sti-glue.h>
  23
  24 DECLARE_GLOBAL_DATA_PTR;
  25
  26 /*
  27  * struct sti_dwc3_glue_plat - dwc3 STi glue driver private structure
  28  * @syscfg_base:        addr for the glue syscfg
  29  * @glue_base:          addr for the glue registers
  30  * @syscfg_offset:      usb syscfg control offset
  31  * @powerdown_ctl:      rest controller for powerdown signal
  32  * @softreset_ctl:      reset controller for softreset signal
  33  * @mode:               drd static host/device config
  34  */
  35 struct sti_dwc3_glue_plat {
  36         phys_addr_t syscfg_base;
  37         phys_addr_t glue_base;
  38         phys_addr_t syscfg_offset;
  39         struct reset_ctl powerdown_ctl;
  40         struct reset_ctl softreset_ctl;
  41         enum usb_dr_mode mode;
  42 };
  43
  44 static int sti_dwc3_glue_drd_init(struct sti_dwc3_glue_plat *plat)
  45 {
  46         unsigned long val;
  47
  48         val = readl(plat->syscfg_base + plat->syscfg_offset);
  49
  50         val &= USB3_CONTROL_MASK;
  51
  52         switch (plat->mode) {
  53         case USB_DR_MODE_PERIPHERAL:
  54                 val &= ~(USB3_DELAY_VBUSVALID
  55                         | USB3_SEL_FORCE_OPMODE | USB3_FORCE_OPMODE(0x3)
  56                         | USB3_SEL_FORCE_DPPULLDOWN2 | USB3_FORCE_DPPULLDOWN2
  57                         | USB3_SEL_FORCE_DMPULLDOWN2 | USB3_FORCE_DMPULLDOWN2);
  58
  59                 val |= USB3_DEVICE_NOT_HOST | USB3_FORCE_VBUSVALID;
  60                 break;
  61
  62         case USB_DR_MODE_HOST:
  63                 val &= ~(USB3_DEVICE_NOT_HOST | USB3_FORCE_VBUSVALID
  64                         | USB3_SEL_FORCE_OPMODE | USB3_FORCE_OPMODE(0x3)
  65                         | USB3_SEL_FORCE_DPPULLDOWN2 | USB3_FORCE_DPPULLDOWN2
  66                         | USB3_SEL_FORCE_DMPULLDOWN2 | USB3_FORCE_DMPULLDOWN2);
  67
  68                 val |= USB3_DELAY_VBUSVALID;
  69                 break;
  70
  71         default:
  72                 pr_err("Unsupported mode of operation %d\n", plat->mode);
  73                 return -EINVAL;
  74         }
  75         writel(val, plat->syscfg_base + plat->syscfg_offset);
  76
  77         return 0;
  78 }
  79
  80 static void sti_dwc3_glue_init(struct sti_dwc3_glue_plat *plat)
  81 {
  82         unsigned long reg;
  83
  84         reg = readl(plat->glue_base + CLKRST_CTRL);
  85
  86         reg |= AUX_CLK_EN | EXT_CFG_RESET_N | XHCI_REVISION;
  87         reg &= ~SW_PIPEW_RESET_N;
  88
  89         writel(reg, plat->glue_base + CLKRST_CTRL);
  90
  91         /* configure mux for vbus, powerpresent and bvalid signals */
  92         reg = readl(plat->glue_base + USB2_VBUS_MNGMNT_SEL1);
  93
  94         reg |= SEL_OVERRIDE_VBUSVALID(USB2_VBUS_UTMIOTG) |
  95                SEL_OVERRIDE_POWERPRESENT(USB2_VBUS_UTMIOTG) |
  96                SEL_OVERRIDE_BVALID(USB2_VBUS_UTMIOTG);
  97
  98         writel(reg, plat->glue_base + USB2_VBUS_MNGMNT_SEL1);
  99
 100         setbits_le32(plat->glue_base + CLKRST_CTRL, SW_PIPEW_RESET_N);
 101 }
 102
 103 static int sti_dwc3_glue_of_to_plat(struct udevice *dev)
 104 {
 105         struct sti_dwc3_glue_plat *plat = dev_get_plat(dev);
 106         struct udevice *syscon;
 107         struct regmap *regmap;
 108         int ret;
 109         u32 reg[4];
 110
 111         ret = ofnode_read_u32_array(dev_ofnode(dev), "reg", reg,
 112                                     ARRAY_SIZE(reg));
 113         if (ret) {
 114                 pr_err("unable to find st,stih407-dwc3 reg property(%d)\n", ret);
 115                 return ret;
 116         }
 117
 118         plat->glue_base = reg[0];
 119         plat->syscfg_offset = reg[2];
 120
 121         /* get corresponding syscon phandle */
 122         ret = uclass_get_device_by_phandle(UCLASS_SYSCON, dev, "st,syscfg",
 123                                            &syscon);
 124         if (ret) {
 125                 pr_err("unable to find syscon device (%d)\n", ret);
 126                 return ret;
 127         }
 128
 129         /* get syscfg-reg base address */
 130         regmap = syscon_get_regmap(syscon);
 131         if (!regmap) {
 132                 pr_err("unable to find regmap\n");
 133                 return -ENODEV;
 134         }
 135         plat->syscfg_base = regmap->ranges[0].start;
 136
 137         /* get powerdown reset */
 138         ret = reset_get_by_name(dev, "powerdown", &plat->powerdown_ctl);
 139         if (ret) {
 140                 pr_err("can't get powerdown reset for %s (%d)", dev->name, ret);
 141                 return ret;
 142         }
 143
 144         /* get softreset reset */
 145         ret = reset_get_by_name(dev, "softreset", &plat->softreset_ctl);
 146         if (ret)
 147                 pr_err("can't get soft reset for %s (%d)", dev->name, ret);
 148
 149         return ret;
 150 };
 151
 152 static int sti_dwc3_glue_bind(struct udevice *dev)
 153 {
 154         struct sti_dwc3_glue_plat *plat = dev_get_plat(dev);
 155         ofnode node, dwc3_node;
 156
 157         /* Find snps,dwc3 node from subnode */
 158         ofnode_for_each_subnode(node, dev_ofnode(dev)) {
 159                 if (ofnode_device_is_compatible(node, "snps,dwc3"))
 160                         dwc3_node = node;
 161         }
 162
 163         if (!ofnode_valid(dwc3_node)) {
 164                 pr_err("Can't find dwc3 subnode for %s\n", dev->name);
 165                 return -ENODEV;
 166         }
 167
 168         /* retrieve the DWC3 dual role mode */
 169         plat->mode = usb_get_dr_mode(dwc3_node);
 170         if (plat->mode == USB_DR_MODE_UNKNOWN)
 171                 /* by default set dual role mode to HOST */
 172                 plat->mode = USB_DR_MODE_HOST;
 173
 174         return dm_scan_fdt_dev(dev);
 175 }
 176
 177 static int sti_dwc3_glue_probe(struct udevice *dev)
 178 {
 179         struct sti_dwc3_glue_plat *plat = dev_get_plat(dev);
 180         int ret;
 181
 182         /* deassert both powerdown and softreset */
 183         ret = reset_deassert(&plat->powerdown_ctl);
 184         if (ret < 0) {
 185                 pr_err("DWC3 powerdown reset deassert failed: %d", ret);
 186                 return ret;
 187         }
 188
 189         ret = reset_deassert(&plat->softreset_ctl);
 190         if (ret < 0) {
 191                 pr_err("DWC3 soft reset deassert failed: %d", ret);
 192                 goto softreset_err;
 193         }
 194
 195         ret = sti_dwc3_glue_drd_init(plat);
 196         if (ret)
 197                 goto init_err;
 198
 199         sti_dwc3_glue_init(plat);
 200
 201         return 0;
 202
 203 init_err:
 204         ret = reset_assert(&plat->softreset_ctl);
 205         if (ret < 0) {
 206                 pr_err("DWC3 soft reset deassert failed: %d", ret);
 207                 return ret;
 208         }
 209
 210 softreset_err:
 211         ret = reset_assert(&plat->powerdown_ctl);
 212         if (ret < 0)
 213                 pr_err("DWC3 powerdown reset deassert failed: %d", ret);
 214
 215         return ret;
 216 }
 217
 218 static int sti_dwc3_glue_remove(struct udevice *dev)
 219 {
 220         struct sti_dwc3_glue_plat *plat = dev_get_plat(dev);
 221         int ret;
 222
 223         /* assert both powerdown and softreset */
 224         ret = reset_assert(&plat->powerdown_ctl);
 225         if (ret < 0) {
 226                 pr_err("DWC3 powerdown reset deassert failed: %d", ret);
 227                 return ret;
 228         }
 229
 230         ret = reset_assert(&plat->softreset_ctl);
 231         if (ret < 0)
 232                 pr_err("DWC3 soft reset deassert failed: %d", ret);
 233
 234         return ret;
 235 }
 236
 237 static const struct udevice_id sti_dwc3_glue_ids[] = {
 238         { .compatible = "st,stih407-dwc3" },
 239         { }
 240 };
 241
 242 U_BOOT_DRIVER(dwc3_sti_glue) = {
 243         .name = "dwc3_sti_glue",
 244         .id = UCLASS_NOP,
 245         .of_match = sti_dwc3_glue_ids,
 246         .of_to_plat = sti_dwc3_glue_of_to_plat,
 247         .probe = sti_dwc3_glue_probe,
 248         .remove = sti_dwc3_glue_remove,
 249         .bind = sti_dwc3_glue_bind,
 250         .plat_auto      = sizeof(struct sti_dwc3_glue_plat),
 251         .flags = DM_FLAG_ALLOC_PRIV_DMA,
 252 };