sys/dev/usb/controller/generic_ohci.c

   1 /*-
   2  * Copyright (c) 2006 M. Warner Losh.  All rights reserved.
   3  * Copyright (c) 2016 Emmanuel Vadot <manu@freebsd.org>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 /*
  29  * Generic OHCI driver based on AT91 OHCI
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/bus.h>
  38 #include <sys/rman.h>
  39 #include <sys/condvar.h>
  40 #include <sys/kernel.h>
  41 #include <sys/module.h>
  42
  43 #include <machine/bus.h>
  44 #include <dev/ofw/ofw_bus.h>
  45 #include <dev/ofw/ofw_bus_subr.h>
  46
  47 #include <dev/usb/usb.h>
  48 #include <dev/usb/usbdi.h>
  49
  50 #include <dev/usb/usb_core.h>
  51 #include <dev/usb/usb_busdma.h>
  52 #include <dev/usb/usb_process.h>
  53 #include <dev/usb/usb_util.h>
  54
  55 #include <dev/usb/usb_controller.h>
  56 #include <dev/usb/usb_bus.h>
  57 #include <dev/usb/controller/ohci.h>
  58 #include <dev/usb/controller/ohcireg.h>
  59
  60 #ifdef EXT_RESOURCES
  61 #include <dev/extres/clk/clk.h>
  62 #include <dev/extres/hwreset/hwreset.h>
  63 #include <dev/extres/phy/phy.h>
  64 #endif
  65
  66 #include "generic_usb_if.h"
  67
  68 #ifdef EXT_RESOURCES
  69 struct clk_list {
  70         TAILQ_ENTRY(clk_list)   next;
  71         clk_t                   clk;
  72 };
  73 #endif
  74
  75 struct generic_ohci_softc {
  76         ohci_softc_t    ohci_sc;
  77
  78 #ifdef EXT_RESOURCES
  79         hwreset_t       rst;
  80         phy_t           phy;
  81         TAILQ_HEAD(, clk_list)  clk_list;
  82 #endif
  83 };
  84
  85 static int generic_ohci_detach(device_t);
  86
  87 static int
  88 generic_ohci_probe(device_t dev)
  89 {
  90
  91         if (!ofw_bus_status_okay(dev))
  92                 return (ENXIO);
  93
  94         if (!ofw_bus_is_compatible(dev, "generic-ohci"))
  95                 return (ENXIO);
  96
  97         device_set_desc(dev, "Generic OHCI Controller");
  98
  99         return (BUS_PROBE_DEFAULT);
 100 }
 101
 102 static int
 103 generic_ohci_attach(device_t dev)
 104 {
 105         struct generic_ohci_softc *sc = device_get_softc(dev);
 106         int err, rid;
 107 #ifdef EXT_RESOURCES
 108         int off;
 109         struct clk_list *clkp;
 110         clk_t clk;
 111 #endif
 112
 113         sc->ohci_sc.sc_bus.parent = dev;
 114         sc->ohci_sc.sc_bus.devices = sc->ohci_sc.sc_devices;
 115         sc->ohci_sc.sc_bus.devices_max = OHCI_MAX_DEVICES;
 116         sc->ohci_sc.sc_bus.dma_bits = 32;
 117
 118         /* get all DMA memory */
 119         if (usb_bus_mem_alloc_all(&sc->ohci_sc.sc_bus,
 120             USB_GET_DMA_TAG(dev), &ohci_iterate_hw_softc)) {
 121                 return (ENOMEM);
 122         }
 123
 124         rid = 0;
 125         sc->ohci_sc.sc_io_res = bus_alloc_resource_any(dev, SYS_RES_MEMORY,
 126             &rid, RF_ACTIVE);
 127         if (sc->ohci_sc.sc_io_res == 0) {
 128                 err = ENOMEM;
 129                 goto error;
 130         }
 131
 132         sc->ohci_sc.sc_io_tag = rman_get_bustag(sc->ohci_sc.sc_io_res);
 133         sc->ohci_sc.sc_io_hdl = rman_get_bushandle(sc->ohci_sc.sc_io_res);
 134         sc->ohci_sc.sc_io_size = rman_get_size(sc->ohci_sc.sc_io_res);
 135
 136         rid = 0;
 137         sc->ohci_sc.sc_irq_res = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid,
 138             RF_ACTIVE);
 139         if (sc->ohci_sc.sc_irq_res == 0) {
 140                 err = ENXIO;
 141                 goto error;
 142         }
 143         sc->ohci_sc.sc_bus.bdev = device_add_child(dev, "usbus", -1);
 144         if (sc->ohci_sc.sc_bus.bdev == 0) {
 145                 err = ENXIO;
 146                 goto error;
 147         }
 148         device_set_ivars(sc->ohci_sc.sc_bus.bdev, &sc->ohci_sc.sc_bus);
 149
 150         strlcpy(sc->ohci_sc.sc_vendor, "Generic",
 151             sizeof(sc->ohci_sc.sc_vendor));
 152
 153         err = bus_setup_intr(dev, sc->ohci_sc.sc_irq_res,
 154             INTR_TYPE_BIO | INTR_MPSAFE, NULL,
 155             (driver_intr_t *)ohci_interrupt, sc, &sc->ohci_sc.sc_intr_hdl);
 156         if (err) {
 157                 sc->ohci_sc.sc_intr_hdl = NULL;
 158                 goto error;
 159         }
 160
 161 #ifdef EXT_RESOURCES
 162         TAILQ_INIT(&sc->clk_list);
 163         /* Enable clock */
 164         for (off = 0; clk_get_by_ofw_index(dev, 0, off, &clk) == 0; off++) {
 165                 err = clk_enable(clk);
 166                 if (err != 0) {
 167                         device_printf(dev, "Could not enable clock %s\n",
 168                             clk_get_name(clk));
 169                         goto error;
 170                 }
 171                 clkp = malloc(sizeof(*clkp), M_DEVBUF, M_WAITOK | M_ZERO);
 172                 clkp->clk = clk;
 173                 TAILQ_INSERT_TAIL(&sc->clk_list, clkp, next);
 174         }
 175
 176         /* De-assert reset */
 177         if (hwreset_get_by_ofw_idx(dev, 0, 0, &sc->rst) == 0) {
 178                 err = hwreset_deassert(sc->rst);
 179                 if (err != 0) {
 180                         device_printf(dev, "Could not de-assert reset %d\n",
 181                             off);
 182                         goto error;
 183                 }
 184         }
 185
 186         /* Enable phy */
 187         if (phy_get_by_ofw_name(dev, 0, "usb", &sc->phy) == 0) {
 188                 err = phy_enable(sc->phy);
 189                 if (err != 0) {
 190                         device_printf(dev, "Could not enable phy\n");
 191                         goto error;
 192                 }
 193         }
 194 #endif
 195
 196         if (GENERIC_USB_INIT(dev) != 0) {
 197                 err = ENXIO;
 198                 goto error;
 199         }
 200
 201         err = ohci_init(&sc->ohci_sc);
 202         if (err == 0)
 203                 err = device_probe_and_attach(sc->ohci_sc.sc_bus.bdev);
 204         if (err)
 205                 goto error;
 206
 207         return (0);
 208 error:
 209         generic_ohci_detach(dev);
 210         return (err);
 211 }
 212
 213 static int
 214 generic_ohci_detach(device_t dev)
 215 {
 216         struct generic_ohci_softc *sc = device_get_softc(dev);
 217         int err;
 218 #ifdef EXT_RESOURCES
 219         struct clk_list *clk, *clk_tmp;
 220 #endif
 221
 222         /* during module unload there are lots of children leftover */
 223         device_delete_children(dev);
 224
 225         /*
 226          * Put the controller into reset, then disable clocks and do
 227          * the MI tear down.  We have to disable the clocks/hardware
 228          * after we do the rest of the teardown.  We also disable the
 229          * clocks in the opposite order we acquire them, but that
 230          * doesn't seem to be absolutely necessary.  We free up the
 231          * clocks after we disable them, so the system could, in
 232          * theory, reuse them.
 233          */
 234         bus_space_write_4(sc->ohci_sc.sc_io_tag, sc->ohci_sc.sc_io_hdl,
 235             OHCI_CONTROL, 0);
 236
 237         if (sc->ohci_sc.sc_irq_res && sc->ohci_sc.sc_intr_hdl) {
 238                 /*
 239                  * only call ohci_detach() after ohci_init()
 240                  */
 241                 ohci_detach(&sc->ohci_sc);
 242
 243                 err = bus_teardown_intr(dev, sc->ohci_sc.sc_irq_res,
 244                     sc->ohci_sc.sc_intr_hdl);
 245                 sc->ohci_sc.sc_intr_hdl = NULL;
 246         }
 247         if (sc->ohci_sc.sc_irq_res) {
 248                 bus_release_resource(dev, SYS_RES_IRQ, 0,
 249                     sc->ohci_sc.sc_irq_res);
 250                 sc->ohci_sc.sc_irq_res = NULL;
 251         }
 252         if (sc->ohci_sc.sc_io_res) {
 253                 bus_release_resource(dev, SYS_RES_MEMORY, 0,
 254                     sc->ohci_sc.sc_io_res);
 255                 sc->ohci_sc.sc_io_res = NULL;
 256         }
 257         usb_bus_mem_free_all(&sc->ohci_sc.sc_bus, &ohci_iterate_hw_softc);
 258
 259 #ifdef EXT_RESOURCES
 260         /* Disable phy */
 261         if (sc->phy) {
 262                 err = phy_disable(sc->phy);
 263                 if (err != 0)
 264                         device_printf(dev, "Could not disable phy\n");
 265                 phy_release(sc->phy);
 266         }
 267
 268         /* Disable clock */
 269         TAILQ_FOREACH_SAFE(clk, &sc->clk_list, next, clk_tmp) {
 270                 err = clk_disable(clk->clk);
 271                 if (err != 0)
 272                         device_printf(dev, "Could not disable clock %s\n",
 273                             clk_get_name(clk->clk));
 274                 err = clk_release(clk->clk);
 275                 if (err != 0)
 276                         device_printf(dev, "Could not release clock %s\n",
 277                             clk_get_name(clk->clk));
 278                 TAILQ_REMOVE(&sc->clk_list, clk, next);
 279                 free(clk, M_DEVBUF);
 280         }
 281
 282         /* De-assert reset */
 283         if (sc->rst) {
 284                 err = hwreset_assert(sc->rst);
 285                 if (err != 0)
 286                         device_printf(dev, "Could not assert reset\n");
 287                 hwreset_release(sc->rst);
 288         }
 289 #endif
 290
 291         if (GENERIC_USB_DEINIT(dev) != 0)
 292                 return (ENXIO);
 293
 294         return (0);
 295 }
 296
 297 static device_method_t generic_ohci_methods[] = {
 298         /* Device interface */
 299         DEVMETHOD(device_probe, generic_ohci_probe),
 300         DEVMETHOD(device_attach, generic_ohci_attach),
 301         DEVMETHOD(device_detach, generic_ohci_detach),
 302
 303         DEVMETHOD(device_suspend, bus_generic_suspend),
 304         DEVMETHOD(device_resume, bus_generic_resume),
 305         DEVMETHOD(device_shutdown, bus_generic_shutdown),
 306
 307         DEVMETHOD_END
 308 };
 309
 310 driver_t generic_ohci_driver = {
 311         .name = "ohci",
 312         .methods = generic_ohci_methods,
 313         .size = sizeof(struct generic_ohci_softc),
 314 };
 315
 316 static devclass_t generic_ohci_devclass;
 317
 318 DRIVER_MODULE(ohci, simplebus, generic_ohci_driver,
 319     generic_ohci_devclass, 0, 0);
 320 MODULE_DEPEND(ohci, usb, 1, 1, 1);