Author: mizhka
Date: Mon Sep  5 16:06:52 2016
New Revision: 305426
URL: https://svnweb.freebsd.org/changeset/base/305426

Log:
  [BHND/USB] Port of EHCI/OHCI support from ZRouter
  
  This patch adds driver implementation for BHND USB core. Driver has been
  imported from ZRouter project with small adaptions for FreeBSD 11.
  
  Also it's enabled for BroadCom MIPS74k boards by default. It's fully tested
  on Asus boards (RT-N16: external USB, RT-N53: USB bus between SoC and WiFi
  chips).
  
  Reviewed by:    adrian (mentor), ray
  Approved by:  adrian (mentor)
  Obtained from:        ZRouter
  Differential Revision:  https://reviews.freebsd.org/D7781

Added:
  head/sys/dev/bhnd/cores/usb/
  head/sys/dev/bhnd/cores/usb/bhnd_ehci.c   (contents, props changed)
  head/sys/dev/bhnd/cores/usb/bhnd_ohci.c   (contents, props changed)
  head/sys/dev/bhnd/cores/usb/bhnd_usb.c   (contents, props changed)
  head/sys/dev/bhnd/cores/usb/bhnd_usbvar.h   (contents, props changed)
Modified:
  head/sys/mips/broadcom/files.broadcom
  head/sys/mips/conf/BCM

Added: head/sys/dev/bhnd/cores/usb/bhnd_ehci.c
==============================================================================
--- /dev/null   00:00:00 1970   (empty, because file is newly added)
+++ head/sys/dev/bhnd/cores/usb/bhnd_ehci.c     Mon Sep  5 16:06:52 2016        
(r305426)
@@ -0,0 +1,267 @@
+/*-
+ * Copyright (C) 2008 MARVELL INTERNATIONAL LTD.
+ * Copyright (c) 2010, Aleksandr Rybalko <r...@ddteam.net>
+ * All rights reserved.
+ *
+ * Developed by Semihalf.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of MARVELL nor the names of contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * BHND attachment driver for the USB Enhanced Host Controller.
+ * Ported from ZRouter with insignificant adaptations for FreeBSD11.
+ */
+
+#include "opt_bus.h"
+
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/rman.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
+#include <dev/usb/usb.h>
+#include <dev/usb/usbdi.h>
+
+#include <dev/usb/usb_core.h>
+#include <dev/usb/usb_busdma.h>
+#include <dev/usb/usb_process.h>
+#include <dev/usb/usb_util.h>
+
+#include <dev/usb/usb_controller.h>
+#include <dev/usb/usb_bus.h>
+#include <dev/usb/controller/ehci.h>
+#include <dev/usb/controller/ehcireg.h>
+
+#include <dev/bhnd/bhnd.h>
+
+#define        EHCI_HC_DEVSTR          "Broadcom EHCI"
+
+#define        USB_BRIDGE_INTR_CAUSE   0x210
+#define        USB_BRIDGE_INTR_MASK    0x214
+
+static device_attach_t bhnd_ehci_attach;
+static device_detach_t bhnd_ehci_detach;
+
+static int             bhnd_ehci_probe(device_t self);
+static void            bhnd_ehci_post_reset(struct ehci_softc *ehci_softc);
+
+static int
+bhnd_ehci_probe(device_t self)
+{
+
+       device_set_desc(self, EHCI_HC_DEVSTR);
+
+       return (BUS_PROBE_DEFAULT);
+}
+
+static void
+bhnd_ehci_post_reset(struct ehci_softc *ehci_softc)
+{
+        uint32_t       usbmode;
+
+        /* Force HOST mode */
+        usbmode = EOREAD4(ehci_softc, EHCI_USBMODE_NOLPM);
+        usbmode &= ~EHCI_UM_CM;
+        usbmode |= EHCI_UM_CM_HOST;
+        EOWRITE4(ehci_softc, EHCI_USBMODE_NOLPM, usbmode);
+}
+
+static int
+bhnd_ehci_attach(device_t self)
+{
+       ehci_softc_t    *sc;
+       int              err;
+       int              rid;
+
+       sc = device_get_softc(self);
+       /* initialise some bus fields */
+       sc->sc_bus.parent = self;
+       sc->sc_bus.devices = sc->sc_devices;
+       sc->sc_bus.devices_max = EHCI_MAX_DEVICES;
+       sc->sc_bus.usbrev = USB_REV_2_0;
+       sc->sc_bus.dma_bits = 32;
+
+       /* get all DMA memory */
+       if ((err = usb_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self),
+           &ehci_iterate_hw_softc)) != 0) {
+               BHND_ERROR_DEV(self, "can't allocate DMA memory: %d", err);
+               return (ENOMEM);
+       }
+
+       rid = 0;
+       sc->sc_io_res = bus_alloc_resource_any(self, SYS_RES_MEMORY, &rid, 
+           RF_ACTIVE);
+       if (!sc->sc_io_res) {
+               BHND_ERROR_DEV(self, "Could not map memory");
+               goto error;
+       }
+       sc->sc_io_tag = rman_get_bustag(sc->sc_io_res);
+       sc->sc_io_hdl = rman_get_bushandle(sc->sc_io_res);
+       sc->sc_io_size = rman_get_size(sc->sc_io_res);
+
+       rid = 0;
+       sc->sc_irq_res = bus_alloc_resource_any(self, SYS_RES_IRQ, &rid,
+           RF_SHAREABLE | RF_ACTIVE);
+
+       if (sc->sc_irq_res == NULL) {
+               BHND_ERROR_DEV(self, "Could not allocate error irq");
+               bhnd_ehci_detach(self);
+               return (ENXIO);
+       }
+
+       sc->sc_bus.bdev = device_add_child(self, "usbus", -1);
+       if (!sc->sc_bus.bdev) {
+               BHND_ERROR_DEV(self, "Could not add USB device");
+               goto error;
+       }
+       device_set_ivars(sc->sc_bus.bdev, &sc->sc_bus);
+       device_set_desc(sc->sc_bus.bdev, EHCI_HC_DEVSTR);
+
+       sprintf(sc->sc_vendor, "Broadcom");
+
+       err = bus_setup_intr(self, sc->sc_irq_res, INTR_TYPE_BIO | INTR_MPSAFE,
+           NULL, (driver_intr_t *)ehci_interrupt, sc, &sc->sc_intr_hdl);
+       if (err) {
+               BHND_ERROR_DEV(self, "Could not setup irq, %d", err);
+               sc->sc_intr_hdl = NULL;
+               goto error;
+       }
+
+       sc->sc_flags |= EHCI_SCFLG_LOSTINTRBUG;
+       sc->sc_vendor_post_reset = bhnd_ehci_post_reset;
+
+       err = ehci_init(sc);
+       if (!err) {
+               err = device_probe_and_attach(sc->sc_bus.bdev);
+       }
+       if (err) {
+               BHND_ERROR_DEV(self, "USB init failed err=%d", err);
+               goto error;
+       }
+       return (0);
+
+error:
+       bhnd_ehci_detach(self);
+       return (ENXIO);
+}
+
+static int
+bhnd_ehci_detach(device_t self)
+{
+       ehci_softc_t    *sc;
+       device_t         bdev;
+       int              err;
+
+       sc = device_get_softc(self);
+
+       if (sc->sc_bus.bdev) {
+               bdev = sc->sc_bus.bdev;
+               device_detach(bdev);
+               device_delete_child(self, bdev);
+       }
+       /* during module unload there are lots of children leftover */
+       device_delete_children(self);
+
+       /*
+        * disable interrupts that might have been switched on in ehci_init
+        */
+#ifdef notyet
+       if (sc->sc_io_res) {
+               EWRITE4(sc, EHCI_USBINTR, 0);
+               EWRITE4(sc, USB_BRIDGE_INTR_MASK, 0);
+       }
+#endif
+       if (sc->sc_irq_res && sc->sc_intr_hdl) {
+               /*
+                * only call ehci_detach() after ehci_init()
+                */
+               ehci_detach(sc);
+
+               err = bus_teardown_intr(self, sc->sc_irq_res, sc->sc_intr_hdl);
+
+               if (err)
+                       /* XXX or should we panic? */
+                       BHND_ERROR_DEV(self, "Could not tear down irq, %d", 
err);
+
+               sc->sc_intr_hdl = NULL;
+       }
+       if (sc->sc_irq_res) {
+               bus_release_resource(self, SYS_RES_IRQ, 0, sc->sc_irq_res);
+               sc->sc_irq_res = NULL;
+       }
+       if (sc->sc_io_res) {
+               bus_release_resource(self, SYS_RES_MEMORY, 0, sc->sc_io_res);
+               sc->sc_io_res = NULL;
+       }
+       usb_bus_mem_free_all(&sc->sc_bus, &ehci_iterate_hw_softc);
+
+       return (0);
+}
+
+static device_method_t ehci_methods[] = {
+       /* Device interface */
+       DEVMETHOD(device_probe,         bhnd_ehci_probe),
+       DEVMETHOD(device_attach,        bhnd_ehci_attach),
+       DEVMETHOD(device_detach,        bhnd_ehci_detach),
+       DEVMETHOD(device_suspend,       bus_generic_suspend),
+       DEVMETHOD(device_resume,        bus_generic_resume),
+       DEVMETHOD(device_shutdown,      bus_generic_shutdown),
+
+       /* Bus interface */
+       DEVMETHOD(bus_print_child,      bus_generic_print_child),
+
+       {0, 0}
+};
+
+static driver_t ehci_driver = {
+       "ehci",
+       ehci_methods,
+       sizeof(ehci_softc_t),
+};
+
+static devclass_t ehci_devclass;
+
+DRIVER_MODULE(ehci, bhnd_usb, ehci_driver, ehci_devclass, 0, 0);
+MODULE_DEPEND(ehci, usb, 1, 1, 1);

Added: head/sys/dev/bhnd/cores/usb/bhnd_ohci.c
==============================================================================
--- /dev/null   00:00:00 1970   (empty, because file is newly added)
+++ head/sys/dev/bhnd/cores/usb/bhnd_ohci.c     Mon Sep  5 16:06:52 2016        
(r305426)
@@ -0,0 +1,228 @@
+/*-
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * Copyright (c) 2010, Aleksandr Rybalko <r...@ddteam.net>
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Lennart Augustsson (augus...@carlstedt.se) at
+ * Carlstedt Research & Technology.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
+ * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * USB Open Host Controller driver.
+ *
+ * OHCI spec: http://www.intel.com/design/usb/ohci11d.pdf
+ */
+
+/* The low level controller code for OHCI has been split into
+ * SIBA probes and OHCI specific code. This was done to facilitate the
+ * sharing of code between *BSD's
+ */
+
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/rman.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/linker_set.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
+#include <dev/usb/usb.h>
+#include <dev/usb/usbdi.h>
+
+#include <dev/usb/usb_core.h>
+#include <dev/usb/usb_busdma.h>
+#include <dev/usb/usb_process.h>
+#include <dev/usb/usb_util.h>
+
+#include <dev/usb/usb_controller.h>
+#include <dev/usb/usb_bus.h>
+#include <dev/usb/controller/ohci.h>
+#include <dev/usb/controller/ohcireg.h>
+
+static device_probe_t bhnd_ohci_probe;
+static device_attach_t bhnd_ohci_attach;
+static device_detach_t bhnd_ohci_detach;
+
+static int
+bhnd_ohci_probe(device_t self)
+{
+       device_set_desc(self, "Broadcom OHCI");
+       return (0);
+}
+
+static int
+bhnd_ohci_attach(device_t self)
+{
+       ohci_softc_t    *sc;
+       int              rid;
+       int              err;
+
+       sc = device_get_softc(self);
+       /* initialise some bus fields */
+       sc->sc_bus.parent = self;
+       sc->sc_bus.devices = sc->sc_devices;
+       sc->sc_bus.devices_max = OHCI_MAX_DEVICES;
+       sc->sc_bus.dma_bits = 32;
+
+       /* get all DMA memory */
+       if (usb_bus_mem_alloc_all(&sc->sc_bus, USB_GET_DMA_TAG(self),
+           &ohci_iterate_hw_softc)) {
+               return (ENOMEM);
+       }
+       sc->sc_dev = self;
+
+       rid = 0;
+       sc->sc_io_res = bus_alloc_resource_any(self, SYS_RES_MEMORY, &rid,
+           RF_ACTIVE);
+       if (!sc->sc_io_res) {
+               device_printf(self, "Could not map memory\n");
+               goto error;
+       }
+       sc->sc_io_tag = rman_get_bustag(sc->sc_io_res);
+       sc->sc_io_hdl = rman_get_bushandle(sc->sc_io_res);
+       sc->sc_io_size = rman_get_size(sc->sc_io_res);
+
+       rid = 0;
+       sc->sc_irq_res = bus_alloc_resource_any(self, SYS_RES_IRQ, &rid,
+           RF_SHAREABLE | RF_ACTIVE);
+       if (sc->sc_irq_res == NULL) {
+               device_printf(self, "Could not allocate irq\n");
+               goto error;
+       }
+       sc->sc_bus.bdev = device_add_child(self, "usbus", -1);
+       if (!sc->sc_bus.bdev) {
+               device_printf(self, "Could not add USB device\n");
+               goto error;
+       }
+       device_set_ivars(sc->sc_bus.bdev, &sc->sc_bus);
+
+       strlcpy(sc->sc_vendor, "Broadcom", sizeof(sc->sc_vendor));
+
+       err = bus_setup_intr(self, sc->sc_irq_res, INTR_TYPE_BIO | INTR_MPSAFE,
+           NULL, (driver_intr_t *)ohci_interrupt, sc, &sc->sc_intr_hdl);
+
+       if (err) {
+               device_printf(self, "Could not setup irq, %d\n", err);
+               sc->sc_intr_hdl = NULL;
+               goto error;
+       }
+       err = ohci_init(sc);
+       if (!err) {
+               err = device_probe_and_attach(sc->sc_bus.bdev);
+       }
+       if (err) {
+               device_printf(self, "USB init failed\n");
+               goto error;
+       }
+       return (0);
+
+error:
+       bhnd_ohci_detach(self);
+       return (ENXIO);
+}
+
+static int
+bhnd_ohci_detach(device_t self)
+{
+       ohci_softc_t    *sc;
+       device_t         bdev;
+
+       sc = device_get_softc(self);
+
+       if (sc->sc_bus.bdev) {
+               bdev = sc->sc_bus.bdev;
+               device_detach(bdev);
+               device_delete_child(self, bdev);
+       }
+       /* during module unload there are lots of children leftover */
+       device_delete_children(self);
+
+       if (sc->sc_irq_res && sc->sc_intr_hdl) {
+               /*
+                * only call ohci_detach() after ohci_init()
+                */
+               ohci_detach(sc);
+
+               int err = bus_teardown_intr(self, sc->sc_irq_res, 
sc->sc_intr_hdl);
+
+               if (err) {
+                       /* XXX or should we panic? */
+                       device_printf(self, "Could not tear down irq, %d\n",
+                           err);
+               }
+               sc->sc_intr_hdl = NULL;
+       }
+       if (sc->sc_irq_res) {
+               bus_release_resource(self, SYS_RES_IRQ, 0, sc->sc_irq_res);
+               sc->sc_irq_res = NULL;
+       }
+       if (sc->sc_io_res) {
+               bus_release_resource(self, SYS_RES_MEMORY, 0,
+                   sc->sc_io_res);
+               sc->sc_io_res = NULL;
+       }
+       usb_bus_mem_free_all(&sc->sc_bus, &ohci_iterate_hw_softc);
+
+       return (0);
+}
+
+static device_method_t bhnd_ohci_methods[] = {
+       /* Device interface */
+       DEVMETHOD(device_probe,         bhnd_ohci_probe),
+       DEVMETHOD(device_attach,        bhnd_ohci_attach),
+       DEVMETHOD(device_detach,        bhnd_ohci_detach),
+       DEVMETHOD(device_suspend,       bus_generic_suspend),
+       DEVMETHOD(device_resume,        bus_generic_resume),
+       DEVMETHOD(device_shutdown,      bus_generic_shutdown),
+
+       DEVMETHOD_END
+};
+
+static driver_t ohci_driver = {
+       .name = "ohci",
+       .methods = bhnd_ohci_methods,
+       .size = sizeof(struct ohci_softc),
+};
+
+static devclass_t ohci_devclass;
+
+DRIVER_MODULE(ohci, bhnd_usb, ohci_driver, ohci_devclass, 0, 0);
+MODULE_DEPEND(ohci, usb, 1, 1, 1);

Added: head/sys/dev/bhnd/cores/usb/bhnd_usb.c
==============================================================================
--- /dev/null   00:00:00 1970   (empty, because file is newly added)
+++ head/sys/dev/bhnd/cores/usb/bhnd_usb.c      Mon Sep  5 16:06:52 2016        
(r305426)
@@ -0,0 +1,487 @@
+/*-
+ * Copyright (c) 2010, Aleksandr Rybalko <r...@ddteam.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * Ported version of BroadCom USB core driver from ZRouter project
+ */
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/module.h>
+#include <sys/errno.h>
+#include <sys/bus.h>
+#include <sys/rman.h>
+#include <sys/malloc.h>
+
+#include <machine/bus.h>
+#include <machine/resource.h>
+
+#include <dev/bhnd/bhnd.h>
+#include <dev/bhnd/bhnd_core.h>
+
+#include <dev/bhnd/cores/pmu/bhnd_pmureg.h>
+
+#include "bhnd_usbvar.h"
+
+/****************************** Variables ************************************/
+static const struct bhnd_device bhnd_usb_devs[] = {
+       BHND_DEVICE(BCM,        USB,    "USB1.1 Host/Device core",      NULL),
+       BHND_DEVICE(BCM,        USB20H, "USB2.0 Host core",             NULL),
+       BHND_DEVICE(BCM,        USB20D, "USB2.0 Device core",           NULL),
+       BHND_DEVICE(BCM,        USB11H, "USB1.1 Host core",             NULL),
+       BHND_DEVICE(BCM,        USB11D, "USB1.1 Device core",           NULL),
+       BHND_DEVICE_END
+};
+
+/****************************** Prototypes ***********************************/
+
+static int     bhnd_usb_attach(device_t);
+static int     bhnd_usb_probe(device_t);
+static device_t        bhnd_usb_add_child(device_t dev, u_int order, const 
char *name, 
+                   int unit);
+static int     bhnd_usb_print_all_resources(device_t dev);
+static int     bhnd_usb_print_child(device_t bus, device_t child);
+
+static struct resource *       bhnd_usb_alloc_resource(device_t bus,
+                                   device_t child, int type, int *rid,
+                                   rman_res_t start, rman_res_t end,
+                                   rman_res_t count, u_int flags);
+static int                     bhnd_usb_release_resource(device_t dev,
+                                   device_t child, int type, int rid,
+                                   struct resource *r);
+
+static struct resource_list *  bhnd_usb_get_reslist(device_t dev,
+                                   device_t child);
+
+static int
+bhnd_usb_probe(device_t dev)
+{
+       const struct bhnd_device        *id;
+
+       id = bhnd_device_lookup(dev, bhnd_usb_devs, sizeof(bhnd_usb_devs[0]));
+       if (id == NULL)
+               return (ENXIO);
+
+       device_set_desc(dev, id->desc);
+       return (BUS_PROBE_DEFAULT);
+}
+
+static int
+bhnd_usb_attach(device_t dev)
+{
+       struct bhnd_usb_softc   *sc;
+       int                      rid;
+       uint32_t                 tmp;
+       int                      tries, err;
+
+       sc = device_get_softc(dev);
+
+       BHND_BUS_RESET_CORE(device_get_parent(dev), dev, 0);
+
+       /*
+        * Allocate the resources which the parent bus has already
+        * determined for us.
+        * XXX: There are few windows (usually 2), RID should be chip-specific
+        */
+       rid = 0;
+       sc->sc_mem = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &rid, 
RF_ACTIVE);
+       if (sc->sc_mem == NULL) {
+               BHND_ERROR_DEV(dev, "unable to allocate memory");
+               return (ENXIO);
+       }
+
+       sc->sc_bt = rman_get_bustag(sc->sc_mem);
+       sc->sc_bh = rman_get_bushandle(sc->sc_mem);
+       sc->sc_maddr = rman_get_start(sc->sc_mem);
+       sc->sc_msize = rman_get_size(sc->sc_mem);
+
+       rid = 0;
+       sc->sc_irq = bus_alloc_resource_any(dev, SYS_RES_IRQ, &rid, 
+               RF_SHAREABLE | RF_ACTIVE);
+       if (sc->sc_irq == NULL) {
+               BHND_ERROR_DEV(dev, "unable to allocate IRQ");
+               return (ENXIO);
+       }
+
+       sc->sc_irqn = rman_get_start(sc->sc_irq);
+
+       sc->mem_rman.rm_start = sc->sc_maddr;
+       sc->mem_rman.rm_end = sc->sc_maddr + sc->sc_msize - 1;
+       sc->mem_rman.rm_type = RMAN_ARRAY;
+       sc->mem_rman.rm_descr = "BHND USB core I/O memory addresses";
+       if (rman_init(&sc->mem_rman) != 0 ||
+           rman_manage_region(&sc->mem_rman, sc->mem_rman.rm_start,
+           sc->mem_rman.rm_end) != 0) {
+               panic("%s: sc->mem_rman", __func__);
+       }
+
+       sc->irq_rman.rm_start = sc->sc_irqn;
+       sc->irq_rman.rm_end = sc->sc_irqn;
+       sc->irq_rman.rm_type = RMAN_ARRAY;
+       sc->irq_rman.rm_descr = "BHND USB core IRQ";
+       /* 
+        * BHND USB share same IRQ between OHCI and EHCI
+        */
+       if (rman_init(&sc->irq_rman) != 0 ||
+           rman_manage_region(&sc->irq_rman, sc->irq_rman.rm_start,
+           sc->irq_rman.rm_end) != 0)
+               panic("%s: failed to set up IRQ rman", __func__);
+
+       /* TODO: macros for registers */
+       bus_write_4(sc->sc_mem, 0x200, 0x7ff); 
+       DELAY(100); 
+
+#define        OHCI_CONTROL            0x04
+       bus_write_4(sc->sc_mem, OHCI_CONTROL, 0);
+
+       if ( bhnd_get_device(dev) == BHND_COREID_USB20H) {
+
+               uint32_t rev;
+               BHND_INFO_DEV(dev, "USB HOST 2.0 setup for rev %d", rev);
+               rev = bhnd_get_hwrev(dev);
+               if (rev == 1/* ? == 2 */) {
+                       /* SiBa code */
+
+                       /* Change Flush control reg */
+                       tmp = bus_read_4(sc->sc_mem, 0x400) & ~0x8;
+                       bus_write_4(sc->sc_mem, 0x400, tmp);
+                       tmp = bus_read_4(sc->sc_mem, 0x400);
+                       BHND_DEBUG_DEV(dev, "USB20H fcr: 0x%x", tmp);
+
+                       /* Change Shim control reg */
+                       tmp = bus_read_4(sc->sc_mem, 0x304) & ~0x100;
+                       bus_write_4(sc->sc_mem, 0x304, tmp);
+                       tmp = bus_read_4(sc->sc_mem, 0x304);
+                       BHND_DEBUG_DEV(dev, "USB20H shim: 0x%x", tmp);
+               } else if (rev >= 5) {
+                       /* BCMA code */
+                       err = bhnd_alloc_pmu(dev);
+                       if(err) {
+                               BHND_ERROR_DEV(dev, "can't alloc pmu: %d", err);
+                               return (err);
+                       }
+
+                       err = bhnd_request_ext_rsrc(dev, 1);
+                       if(err) {
+                               BHND_ERROR_DEV(dev, "can't req ext: %d", err);
+                               return (err);
+                       }
+                       /* Take out of resets */
+                       bus_write_4(sc->sc_mem, 0x200, 0x4ff);
+                       DELAY(25);
+                       bus_write_4(sc->sc_mem, 0x200, 0x6ff);
+                       DELAY(25);
+
+                       /* Make sure digital and AFE are locked in USB PHY */
+                       bus_write_4(sc->sc_mem, 0x524, 0x6b);
+                       DELAY(50);
+                       bus_read_4(sc->sc_mem, 0x524);
+                       DELAY(50);
+                       bus_write_4(sc->sc_mem, 0x524, 0xab);
+                       DELAY(50);
+                       bus_read_4(sc->sc_mem, 0x524);
+                       DELAY(50);
+                       bus_write_4(sc->sc_mem, 0x524, 0x2b);
+                       DELAY(50);
+                       bus_read_4(sc->sc_mem, 0x524);
+                       DELAY(50);
+                       bus_write_4(sc->sc_mem, 0x524, 0x10ab);
+                       DELAY(50);
+                       bus_read_4(sc->sc_mem, 0x524);
+
+                       tries = 10000;
+                       for (;;) {
+                               DELAY(10);
+                               tmp = bus_read_4(sc->sc_mem, 0x528);
+                               if (tmp & 0xc000)
+                                       break;
+                               if (--tries != 0)
+                                       continue;
+
+                               tmp = bus_read_4(sc->sc_mem, 0x528);
+                               BHND_ERROR_DEV(dev, "USB20H mdio_rddata 
0x%08x", tmp);
+                       }
+
+                       /* XXX: Puzzle code */
+                       bus_write_4(sc->sc_mem, 0x528, 0x80000000);
+                       bus_read_4(sc->sc_mem, 0x314);
+                       DELAY(265);
+                       bus_write_4(sc->sc_mem, 0x200, 0x7ff);
+                       DELAY(10);
+
+                       /* Take USB and HSIC out of non-driving modes */
+                       bus_write_4(sc->sc_mem, 0x510, 0);
+               }
+       }
+
+       bus_generic_probe(dev);
+
+       if (bhnd_get_device(dev) == BHND_COREID_USB20H &&
+           ( bhnd_get_hwrev(dev) > 0))
+               bhnd_usb_add_child(dev, 0, "ehci", -1);
+       bhnd_usb_add_child(dev, 1, "ohci", -1);
+
+       bus_generic_attach(dev);
+
+       return (0);
+}
+
+static struct resource *
+bhnd_usb_alloc_resource(device_t bus, device_t child, int type, int *rid,
+    rman_res_t start, rman_res_t end, rman_res_t count, u_int flags)
+{
+       struct resource                 *rv;
+       struct resource_list            *rl;
+       struct resource_list_entry      *rle;
+       int                              isdefault, needactivate;
+       struct bhnd_usb_softc           *sc = device_get_softc(bus);
+
+       isdefault = RMAN_IS_DEFAULT_RANGE(start,end);
+       needactivate = flags & RF_ACTIVE;
+       rl = BUS_GET_RESOURCE_LIST(bus, child);
+       rle = NULL;
+
+       if (isdefault) {
+               BHND_INFO_DEV(bus, "trying allocate def %d - %d for %s", type,
+                   *rid, device_get_nameunit(child) );
+               rle = resource_list_find(rl, type, *rid);
+               if (rle == NULL)
+                       return (NULL);
+               if (rle->res != NULL)
+                       panic("%s: resource entry is busy", __func__);
+               start = rle->start;
+               end = rle->end;
+               count = rle->count;
+       } else {
+               BHND_INFO_DEV(bus, "trying allocate %d - %d (%jx-%jx) for %s", 
type,
+                  *rid, start, end, device_get_nameunit(child) );
+       }
+
+       /*
+        * If the request is for a resource which we manage,
+        * attempt to satisfy the allocation ourselves.
+        */
+       if (type == SYS_RES_MEMORY) {
+
+               rv = rman_reserve_resource(&sc->mem_rman, start, end, count,
+                   flags, child);
+               if (rv == 0) {
+                       BHND_ERROR_DEV(bus, "could not reserve resource");
+                       return (0);
+               }
+
+               rman_set_rid(rv, *rid);
+
+               if (needactivate &&
+                   bus_activate_resource(child, type, *rid, rv)) {
+                       BHND_ERROR_DEV(bus, "could not activate resource");
+                       rman_release_resource(rv);
+                       return (0);
+               }
+
+               return (rv);
+       }
+
+       if (type == SYS_RES_IRQ) {
+
+               rv = rman_reserve_resource(&sc->irq_rman, start, end, count,
+                   flags, child);
+               if (rv == 0) {
+                       BHND_ERROR_DEV(bus, "could not reserve resource");
+                       return (0);
+               }
+
+               rman_set_rid(rv, *rid);
+
+               if (needactivate &&
+                   bus_activate_resource(child, type, *rid, rv)) {
+                       BHND_ERROR_DEV(bus, "could not activate resource");
+                       rman_release_resource(rv);
+                       return (0);
+               }
+
+               return (rv);
+       }
+
+       /*
+        * Pass the request to the parent.
+        */
+       return (resource_list_alloc(rl, bus, child, type, rid,
+           start, end, count, flags));
+}
+
+static struct resource_list *
+bhnd_usb_get_reslist(device_t dev, device_t child)
+{
+       struct bhnd_usb_devinfo *sdi;
+
+       sdi = device_get_ivars(child);
+
+       return (&sdi->sdi_rl);
+}
+
+static int
+bhnd_usb_release_resource(device_t dev, device_t child, int type,
+    int rid, struct resource *r)
+{
+       struct resource_list            *rl;
+       struct resource_list_entry      *rle;
+
+       rl = bhnd_usb_get_reslist(dev, child);
+       if (rl == NULL)
+               return (EINVAL);
+       rle = resource_list_find(rl, type, rid);
+       if (rle == NULL)
+               return (EINVAL);
+       rman_release_resource(r);
+       rle->res = NULL;
+
+       return (0);
+}
+
+static int
+bhnd_usb_print_all_resources(device_t dev)
+{
+       struct bhnd_usb_devinfo *sdi;
+       struct resource_list    *rl;
+       int                      retval;
+
+       retval = 0;
+       sdi = device_get_ivars(dev);
+       rl = &sdi->sdi_rl;
+
+       if (STAILQ_FIRST(rl))
+               retval += printf(" at");
+
+       retval += resource_list_print_type(rl, "mem", SYS_RES_MEMORY, "%jx");
+       retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%ld");
+
+       return (retval);
+}
+
+static int
+bhnd_usb_print_child(device_t bus, device_t child)
+{
+       int retval = 0;
+
+       retval += bus_print_child_header(bus, child);
+       retval += bhnd_usb_print_all_resources(child);
+       if (device_get_flags(child))
+               retval += printf(" flags %#x", device_get_flags(child));
+       retval += printf(" on %s\n", device_get_nameunit(bus));
+
+       return (retval);
+}
+
+static device_t
+bhnd_usb_add_child(device_t dev, u_int order, const char *name, int unit)
+{
+       struct bhnd_usb_softc           *sc;
+       struct bhnd_usb_devinfo         *sdi;
+       device_t                         child;
+
+       sc = device_get_softc(dev);
+       child = device_add_child_ordered(dev, order, name, unit);
+
+       if (child == NULL)
+               return (NULL);
+
+       sdi = malloc(sizeof(struct bhnd_usb_devinfo), M_DEVBUF, 
M_NOWAIT|M_ZERO);
+       if (sdi == NULL)
+               return (NULL);
+
+       if (strncmp(name, "ohci", 4) == 0) 
+       {
+               sdi->sdi_maddr = sc->sc_maddr + 0x000;
+               sdi->sdi_msize = 0x200;
+               sdi->sdi_irq   = sc->sc_irqn;
+               BHND_INFO_DEV(dev, "ohci: irq=%d maddr=0x%jx", sdi->sdi_irq,
+                   sdi->sdi_maddr);
+       }
+       else if (strncmp(name, "ehci", 4) == 0) 
+       {
+               sdi->sdi_maddr = sc->sc_maddr + 0x000;
+               sdi->sdi_msize = 0x1000;
+               sdi->sdi_irq   = sc->sc_irqn;
+               BHND_INFO_DEV(dev, "ehci: irq=%d maddr=0x%jx", sdi->sdi_irq,
+                   sdi->sdi_maddr);
+       }
+       else
+       {
+               panic("Unknown subdevice");
+               /* Unknown subdevice */
+               sdi->sdi_maddr = 1;
+               sdi->sdi_msize = 1;
+               sdi->sdi_irq   = 1;
+       }
+
+       resource_list_init(&sdi->sdi_rl);
+
+       /*
+        * Determine memory window on bus and irq if one is needed.
+        */
+       resource_list_add(&sdi->sdi_rl, SYS_RES_MEMORY, 0,
+           sdi->sdi_maddr, sdi->sdi_maddr + sdi->sdi_msize - 1, 
sdi->sdi_msize);
+
+       resource_list_add(&sdi->sdi_rl, SYS_RES_IRQ, 0,
+           sdi->sdi_irq, sdi->sdi_irq, 1);
+
+       device_set_ivars(child, sdi);
+       return (child);
+
+}
+
+static device_method_t bhnd_usb_methods[] = {
+       /* Device interface */
+       DEVMETHOD(device_attach,                bhnd_usb_attach),
+       DEVMETHOD(device_probe,                 bhnd_usb_probe),
+
+       /* Bus interface */
+       DEVMETHOD(bus_add_child,                bhnd_usb_add_child),
+       DEVMETHOD(bus_alloc_resource,           bhnd_usb_alloc_resource),
+       DEVMETHOD(bus_get_resource_list,        bhnd_usb_get_reslist),
+       DEVMETHOD(bus_print_child,              bhnd_usb_print_child),
+       DEVMETHOD(bus_release_resource,         bhnd_usb_release_resource),
+       /* Bus interface: generic part */
+       DEVMETHOD(bus_activate_resource,        bus_generic_activate_resource),
+       DEVMETHOD(bus_deactivate_resource,      
bus_generic_deactivate_resource),
+       DEVMETHOD(bus_setup_intr,               bus_generic_setup_intr),
+       DEVMETHOD(bus_teardown_intr,            bus_generic_teardown_intr),
+
+       DEVMETHOD_END
+};
+
+static devclass_t bhnd_usb_devclass;
+
+DEFINE_CLASS_0(bhnd_usb, bhnd_usb_driver, bhnd_usb_methods,
+    sizeof(struct bhnd_usb_softc));
+DRIVER_MODULE(bhnd_usb, bhnd, bhnd_usb_driver, bhnd_usb_devclass, 0, 0);
+
+MODULE_VERSION(bhnd_usb, 1);

Added: head/sys/dev/bhnd/cores/usb/bhnd_usbvar.h
==============================================================================
--- /dev/null   00:00:00 1970   (empty, because file is newly added)
+++ head/sys/dev/bhnd/cores/usb/bhnd_usbvar.h   Mon Sep  5 16:06:52 2016        
(r305426)
@@ -0,0 +1,59 @@
+/*-
+ * Copyright (c) 2010, Aleksandr Rybalko <r...@ddteam.net>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***
_______________________________________________
svn-src-all@freebsd.org mailing list
https://lists.freebsd.org/mailman/listinfo/svn-src-all
To unsubscribe, send any mail to "svn-src-all-unsubscr...@freebsd.org"

Reply via email to