drivers/usb/host/ehci-generic.c

   1 /*
   2  * Copyright (C) 2015 Alexey Brodkin <abrodkin@synopsys.com>
   3  *
   4  * SPDX-License-Identifier:     GPL-2.0+
   5  */
   6
   7 #include <common.h>
   8 #include <clk.h>
   9 #include <dm/ofnode.h>
  10 #include <generic-phy.h>
  11 #include <reset.h>
  12 #include <asm/io.h>
  13 #include <dm.h>
  14 #include "ehci.h"
  15
  16 /*
  17  * Even though here we don't explicitly use "struct ehci_ctrl"
  18  * ehci_register() expects it to be the first thing that resides in
  19  * device's private data.
  20  */
  21 struct generic_ehci {
  22         struct ehci_ctrl ctrl;
  23         struct clk *clocks;
  24         struct reset_ctl *resets;
  25         struct phy phy;
  26         int clock_count;
  27         int reset_count;
  28 };
  29
  30 static int ehci_usb_probe(struct udevice *dev)
  31 {
  32         struct generic_ehci *priv = dev_get_priv(dev);
  33         struct ehci_hccr *hccr;
  34         struct ehci_hcor *hcor;
  35         int i, err, ret, clock_nb, reset_nb;
  36
  37         err = 0;
  38         priv->clock_count = 0;
  39         clock_nb = ofnode_count_phandle_with_args(dev_ofnode(dev), "clocks",
  40                                                   "#clock-cells");
  41         if (clock_nb > 0) {
  42                 priv->clocks = devm_kcalloc(dev, clock_nb, sizeof(struct clk),
  43                                             GFP_KERNEL);
  44                 if (!priv->clocks)
  45                         return -ENOMEM;
  46
  47                 for (i = 0; i < clock_nb; i++) {
  48                         err = clk_get_by_index(dev, i, &priv->clocks[i]);
  49
  50                         if (err < 0)
  51                                 break;
  52                         err = clk_enable(&priv->clocks[i]);
  53                         if (err) {
  54                                 error("failed to enable clock %d\n", i);
  55                                 clk_free(&priv->clocks[i]);
  56                                 goto clk_err;
  57                         }
  58                         priv->clock_count++;
  59                 }
  60         } else {
  61                 if (clock_nb != -ENOENT) {
  62                         error("failed to get clock phandle(%d)\n", clock_nb);
  63                         return clock_nb;
  64                 }
  65         }
  66
  67         priv->reset_count = 0;
  68         reset_nb = ofnode_count_phandle_with_args(dev_ofnode(dev), "resets",
  69                                                   "#reset-cells");
  70         if (reset_nb > 0) {
  71                 priv->resets = devm_kcalloc(dev, reset_nb,
  72                                             sizeof(struct reset_ctl),
  73                                             GFP_KERNEL);
  74                 if (!priv->resets)
  75                         return -ENOMEM;
  76
  77                 for (i = 0; i < reset_nb; i++) {
  78                         err = reset_get_by_index(dev, i, &priv->resets[i]);
  79                         if (err < 0)
  80                                 break;
  81
  82                         if (reset_deassert(&priv->resets[i])) {
  83                                 error("failed to deassert reset %d\n", i);
  84                                 reset_free(&priv->resets[i]);
  85                                 goto reset_err;
  86                         }
  87                         priv->reset_count++;
  88                 }
  89         } else {
  90                 if (reset_nb != -ENOENT) {
  91                         error("failed to get reset phandle(%d)\n", reset_nb);
  92                         goto clk_err;
  93                 }
  94         }
  95
  96         err = generic_phy_get_by_index(dev, 0, &priv->phy);
  97         if (err) {
  98                 if (err != -ENOENT) {
  99                         error("failed to get usb phy\n");
 100                         goto reset_err;
 101                 }
 102         }
 103
 104         err = generic_phy_init(&priv->phy);
 105         if (err) {
 106                 error("failed to init usb phy\n");
 107                 goto reset_err;
 108         }
 109
 110         hccr = map_physmem(devfdt_get_addr(dev), 0x100, MAP_NOCACHE);
 111         hcor = (struct ehci_hcor *)((uintptr_t)hccr +
 112                                     HC_LENGTH(ehci_readl(&hccr->cr_capbase)));
 113
 114         err = ehci_register(dev, hccr, hcor, NULL, 0, USB_INIT_HOST);
 115         if (err)
 116                 goto phy_err;
 117
 118         return 0;
 119
 120 phy_err:
 121         if (generic_phy_valid(&priv->phy)) {
 122                 ret = generic_phy_exit(&priv->phy);
 123                 if (ret)
 124                         error("failed to release phy\n");
 125         }
 126
 127 reset_err:
 128         ret = reset_release_all(priv->resets, priv->reset_count);
 129         if (ret)
 130                 error("failed to assert all resets\n");
 131 clk_err:
 132         ret = clk_release_all(priv->clocks, priv->clock_count);
 133         if (ret)
 134                 error("failed to disable all clocks\n");
 135
 136         return err;
 137 }
 138
 139 static int ehci_usb_remove(struct udevice *dev)
 140 {
 141         struct generic_ehci *priv = dev_get_priv(dev);
 142         int ret;
 143
 144         ret = ehci_deregister(dev);
 145         if (ret)
 146                 return ret;
 147
 148         if (generic_phy_valid(&priv->phy)) {
 149                 ret = generic_phy_exit(&priv->phy);
 150                 if (ret)
 151                         return ret;
 152         }
 153
 154         ret =  reset_release_all(priv->resets, priv->reset_count);
 155         if (ret)
 156                 return ret;
 157
 158         return clk_release_all(priv->clocks, priv->clock_count);
 159 }
 160
 161 static const struct udevice_id ehci_usb_ids[] = {
 162         { .compatible = "generic-ehci" },
 163         { }
 164 };
 165
 166 U_BOOT_DRIVER(ehci_generic) = {
 167         .name   = "ehci_generic",
 168         .id     = UCLASS_USB,
 169         .of_match = ehci_usb_ids,
 170         .probe = ehci_usb_probe,
 171         .remove = ehci_usb_remove,
 172         .ops    = &ehci_usb_ops,
 173         .priv_auto_alloc_size = sizeof(struct generic_ehci),
 174         .flags  = DM_FLAG_ALLOC_PRIV_DMA,
 175 };