sys/dev/bhnd/bhnd.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2015-2016 Landon Fuller <landonf@FreeBSD.org>
   5  * Copyright (c) 2017 The FreeBSD Foundation
   6  * All rights reserved.
   7  *
   8  * Portions of this software were developed by Landon Fuller
   9  * under sponsorship from the FreeBSD Foundation.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
  19  *    redistribution must be conditioned upon including a substantially
  20  *    similar Disclaimer requirement for further binary redistribution.
  21  *
  22  * NO WARRANTY
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  * LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTIBILITY
  26  * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  27  * THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
  28  * OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
  31  * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  33  * THE POSSIBILITY OF SUCH DAMAGES.
  34  */
  35
  36 #include <sys/cdefs.h>
  37 __FBSDID("$FreeBSD$");
  38
  39 /*
  40  * Broadcom Home Networking Division (HND) Bus Driver.
  41  *
  42  * The Broadcom HND family of devices consists of both SoCs and host-connected
  43  * networking chipsets containing a common family of Broadcom IP cores,
  44  * including an integrated MIPS and/or ARM cores.
  45  *
  46  * HND devices expose a nearly identical interface whether accessible over a
  47  * native SoC interconnect, or when connected via a host interface such as
  48  * PCIe. As a result, the majority of hardware support code should be re-usable
  49  * across host drivers for HND networking chipsets, as well as FreeBSD support
  50  * for Broadcom MIPS/ARM HND SoCs.
  51  *
  52  * Earlier HND models used the siba(4) on-chip interconnect, while later models
  53  * use bcma(4); the programming model is almost entirely independent
  54  * of the actual underlying interconect.
  55  */
  56
  57 #include <sys/param.h>
  58 #include <sys/kernel.h>
  59 #include <sys/bus.h>
  60 #include <sys/module.h>
  61 #include <sys/sbuf.h>
  62 #include <sys/systm.h>
  63
  64 #include <machine/bus.h>
  65 #include <sys/rman.h>
  66 #include <machine/resource.h>
  67
  68 #include <dev/bhnd/cores/pmu/bhnd_pmu.h>
  69
  70 #include "bhnd_chipc_if.h"
  71 #include "bhnd_nvram_if.h"
  72
  73 #include "bhnd.h"
  74 #include "bhndreg.h"
  75 #include "bhndvar.h"
  76
  77 #include "bhnd_private.h"
  78
  79 MALLOC_DEFINE(M_BHND, "bhnd", "bhnd bus data structures");
  80
  81 /**
  82  * bhnd_generic_probe_nomatch() reporting configuration.
  83  */
  84 static const struct bhnd_nomatch {
  85         uint16_t        vendor;         /**< core designer */
  86         uint16_t        device;         /**< core id */
  87         bool            if_verbose;     /**< print when bootverbose is set. */
  88 } bhnd_nomatch_table[] = {
  89         { BHND_MFGID_ARM,       BHND_COREID_OOB_ROUTER,         true    },
  90         { BHND_MFGID_ARM,       BHND_COREID_EROM,               true    },
  91         { BHND_MFGID_ARM,       BHND_COREID_PL301,              true    },
  92         { BHND_MFGID_ARM,       BHND_COREID_APB_BRIDGE,         true    },
  93         { BHND_MFGID_ARM,       BHND_COREID_AXI_UNMAPPED,       false   },
  94         { BHND_MFGID_INVALID,   BHND_COREID_INVALID,            false   }
  95 };
  96
  97 static int                       bhnd_delete_children(struct bhnd_softc *sc);
  98
  99 /**
 100  * Default bhnd(4) bus driver implementation of DEVICE_ATTACH().
 101  *
 102  * This implementation calls device_probe_and_attach() for each of the device's
 103  * children, in bhnd probe order.
 104  */
 105 int
 106 bhnd_generic_attach(device_t dev)
 107 {
 108         struct bhnd_softc       *sc;
 109         int                      error;
 110
 111         if (device_is_attached(dev))
 112                 return (EBUSY);
 113
 114         sc = device_get_softc(dev);
 115         sc->dev = dev;
 116
 117         /* Probe and attach all children */
 118         if ((error = bhnd_bus_probe_children(dev))) {
 119                 bhnd_delete_children(sc);
 120                 return (error);
 121         }
 122
 123         return (0);
 124 }
 125
 126 /**
 127  * Detach and delete all children, in reverse of their attach order.
 128  */
 129 static int
 130 bhnd_delete_children(struct bhnd_softc *sc)
 131 {
 132         device_t                *devs;
 133         int                      ndevs;
 134         int                      error;
 135
 136         /* Fetch children in detach order */
 137         error = bhnd_bus_get_children(sc->dev, &devs, &ndevs,
 138             BHND_DEVICE_ORDER_DETACH);
 139         if (error)
 140                 return (error);
 141
 142         /* Perform detach */
 143         for (int i = 0; i < ndevs; i++) {
 144                 device_t child = devs[i];
 145
 146                 /* Terminate on first error */
 147                 if ((error = device_delete_child(sc->dev, child)))
 148                         goto cleanup;
 149         }
 150
 151 cleanup:
 152         bhnd_bus_free_children(devs);
 153         return (error);
 154 }
 155
 156 /**
 157  * Default bhnd(4) bus driver implementation of DEVICE_DETACH().
 158  *
 159  * This implementation calls device_detach() for each of the device's
 160  * children, in reverse bhnd probe order, terminating if any call to
 161  * device_detach() fails.
 162  */
 163 int
 164 bhnd_generic_detach(device_t dev)
 165 {
 166         struct bhnd_softc       *sc;
 167         int                      error;
 168
 169         if (!device_is_attached(dev))
 170                 return (EBUSY);
 171
 172         sc = device_get_softc(dev);
 173
 174         if ((error = bhnd_delete_children(sc)))
 175                 return (error);
 176
 177         return (0);
 178 }
 179
 180 /**
 181  * Default bhnd(4) bus driver implementation of DEVICE_SHUTDOWN().
 182  *
 183  * This implementation calls device_shutdown() for each of the device's
 184  * children, in reverse bhnd probe order, terminating if any call to
 185  * device_shutdown() fails.
 186  */
 187 int
 188 bhnd_generic_shutdown(device_t dev)
 189 {
 190         device_t        *devs;
 191         int              ndevs;
 192         int              error;
 193
 194         if (!device_is_attached(dev))
 195                 return (EBUSY);
 196
 197         /* Fetch children in detach order */
 198         error = bhnd_bus_get_children(dev, &devs, &ndevs,
 199             BHND_DEVICE_ORDER_DETACH);
 200         if (error)
 201                 return (error);
 202
 203         /* Perform shutdown */
 204         for (int i = 0; i < ndevs; i++) {
 205                 device_t child = devs[i];
 206
 207                 /* Terminate on first error */
 208                 if ((error = device_shutdown(child)))
 209                         goto cleanup;
 210         }
 211
 212 cleanup:
 213         bhnd_bus_free_children(devs);
 214         return (error);
 215 }
 216
 217 /**
 218  * Default bhnd(4) bus driver implementation of DEVICE_RESUME().
 219  *
 220  * This implementation calls BUS_RESUME_CHILD() for each of the device's
 221  * children in bhnd probe order, terminating if any call to BUS_RESUME_CHILD()
 222  * fails.
 223  */
 224 int
 225 bhnd_generic_resume(device_t dev)
 226 {
 227         device_t        *devs;
 228         int              ndevs;
 229         int              error;
 230
 231         if (!device_is_attached(dev))
 232                 return (EBUSY);
 233
 234         /* Fetch children in attach order */
 235         error = bhnd_bus_get_children(dev, &devs, &ndevs,
 236             BHND_DEVICE_ORDER_ATTACH);
 237         if (error)
 238                 return (error);
 239
 240         /* Perform resume */
 241         for (int i = 0; i < ndevs; i++) {
 242                 device_t child = devs[i];
 243
 244                 /* Terminate on first error */
 245                 if ((error = BUS_RESUME_CHILD(device_get_parent(child), child)))
 246                         goto cleanup;
 247         }
 248
 249 cleanup:
 250         bhnd_bus_free_children(devs);
 251         return (error);
 252 }
 253
 254 /**
 255  * Default bhnd(4) bus driver implementation of DEVICE_SUSPEND().
 256  *
 257  * This implementation calls BUS_SUSPEND_CHILD() for each of the device's
 258  * children in reverse bhnd probe order. If any call to BUS_SUSPEND_CHILD()
 259  * fails, the suspend operation is terminated and any devices that were
 260  * suspended are resumed immediately by calling their BUS_RESUME_CHILD()
 261  * methods.
 262  */
 263 int
 264 bhnd_generic_suspend(device_t dev)
 265 {
 266         device_t        *devs;
 267         int              ndevs;
 268         int              error;
 269
 270         if (!device_is_attached(dev))
 271                 return (EBUSY);
 272
 273         /* Fetch children in detach order */
 274         error = bhnd_bus_get_children(dev, &devs, &ndevs,
 275             BHND_DEVICE_ORDER_DETACH);
 276         if (error)
 277                 return (error);
 278
 279         /* Perform suspend */
 280         for (int i = 0; i < ndevs; i++) {
 281                 device_t child = devs[i];
 282                 error = BUS_SUSPEND_CHILD(device_get_parent(child), child);
 283
 284                 /* On error, resume suspended devices and then terminate */
 285                 if (error) {
 286                         for (int j = 0; j < i; j++) {
 287                                 BUS_RESUME_CHILD(device_get_parent(devs[j]),
 288                                     devs[j]);
 289                         }
 290
 291                         goto cleanup;
 292                 }
 293         }
 294
 295 cleanup:
 296         bhnd_bus_free_children(devs);
 297         return (error);
 298 }
 299
 300 /**
 301  * Default bhnd(4) bus driver implementation of BHND_BUS_GET_PROBE_ORDER().
 302  *
 303  * This implementation determines probe ordering based on the device's class
 304  * and other properties, including whether the device is serving as a host
 305  * bridge.
 306  */
 307 int
 308 bhnd_generic_get_probe_order(device_t dev, device_t child)
 309 {
 310         switch (bhnd_get_class(child)) {
 311         case BHND_DEVCLASS_CC:
 312                 /* Must be early enough to provide NVRAM access to the
 313                  * host bridge */
 314                 return (BHND_PROBE_ROOT + BHND_PROBE_ORDER_FIRST);
 315
 316         case BHND_DEVCLASS_CC_B:
 317                 /* fall through */
 318         case BHND_DEVCLASS_PMU:
 319                 return (BHND_PROBE_BUS + BHND_PROBE_ORDER_EARLY);
 320
 321         case BHND_DEVCLASS_SOC_ROUTER:
 322                 return (BHND_PROBE_BUS + BHND_PROBE_ORDER_LATE);
 323
 324         case BHND_DEVCLASS_SOC_BRIDGE:
 325                 return (BHND_PROBE_BUS + BHND_PROBE_ORDER_LAST);
 326
 327         case BHND_DEVCLASS_CPU:
 328                 return (BHND_PROBE_CPU + BHND_PROBE_ORDER_FIRST);
 329
 330         case BHND_DEVCLASS_RAM:
 331                 /* fall through */
 332         case BHND_DEVCLASS_MEMC:
 333                 return (BHND_PROBE_CPU + BHND_PROBE_ORDER_EARLY);
 334
 335         case BHND_DEVCLASS_NVRAM:
 336                 return (BHND_PROBE_RESOURCE + BHND_PROBE_ORDER_EARLY);
 337
 338         case BHND_DEVCLASS_PCI:
 339         case BHND_DEVCLASS_PCIE:
 340         case BHND_DEVCLASS_PCCARD:
 341         case BHND_DEVCLASS_ENET:
 342         case BHND_DEVCLASS_ENET_MAC:
 343         case BHND_DEVCLASS_ENET_PHY:
 344         case BHND_DEVCLASS_WLAN:
 345         case BHND_DEVCLASS_WLAN_MAC:
 346         case BHND_DEVCLASS_WLAN_PHY:
 347         case BHND_DEVCLASS_EROM:
 348         case BHND_DEVCLASS_OTHER:
 349         case BHND_DEVCLASS_INVALID:
 350                 if (bhnd_bus_find_hostb_device(dev) == child)
 351                         return (BHND_PROBE_ROOT + BHND_PROBE_ORDER_EARLY);
 352
 353                 return (BHND_PROBE_DEFAULT);
 354         default:
 355                 return (BHND_PROBE_DEFAULT);
 356         }
 357 }
 358
 359 /**
 360  * Default bhnd(4) bus driver implementation of BHND_BUS_ALLOC_PMU().
 361  */
 362 int
 363 bhnd_generic_alloc_pmu(device_t dev, device_t child)
 364 {
 365         struct bhnd_softc               *sc;
 366         struct bhnd_resource            *r;
 367         struct bhnd_core_clkctl         *clkctl;
 368         struct resource_list            *rl;
 369         struct resource_list_entry      *rle;
 370         device_t                         pmu_dev;
 371         bhnd_addr_t                      r_addr;
 372         bhnd_size_t                      r_size;
 373         bus_size_t                       pmu_regs;
 374         u_int                            max_latency;
 375         int                              error;
 376
 377         GIANT_REQUIRED; /* for newbus */
 378
 379         if (device_get_parent(child) != dev)
 380                 return (EINVAL);
 381
 382         sc = device_get_softc(dev);
 383         clkctl = bhnd_get_pmu_info(child);
 384         pmu_regs = BHND_CLK_CTL_ST;
 385
 386         /* already allocated? */
 387         if (clkctl != NULL) {
 388                 panic("duplicate PMU allocation for %s",
 389                     device_get_nameunit(child));
 390         }
 391
 392         /* Determine address+size of the core's PMU register block */
 393         error = bhnd_get_region_addr(child, BHND_PORT_DEVICE, 0, 0, &r_addr,
 394             &r_size);
 395         if (error) {
 396                 device_printf(sc->dev, "error fetching register block info for "
 397                     "%s: %d\n", device_get_nameunit(child), error);
 398                 return (error);
 399         }
 400
 401         if (r_size < (pmu_regs + sizeof(uint32_t))) {
 402                 device_printf(sc->dev, "pmu offset %#jx would overrun %s "
 403                     "register block\n", (uintmax_t)pmu_regs,
 404                     device_get_nameunit(child));
 405                 return (ENODEV);
 406         }
 407
 408         /* Locate actual resource containing the core's register block */
 409         if ((rl = BUS_GET_RESOURCE_LIST(dev, child)) == NULL) {
 410                 device_printf(dev, "NULL resource list returned for %s\n",
 411                     device_get_nameunit(child));
 412                 return (ENXIO);
 413         }
 414
 415         if ((rle = resource_list_find(rl, SYS_RES_MEMORY, 0)) == NULL) {
 416                 device_printf(dev, "cannot locate core register resource "
 417                     "for %s\n", device_get_nameunit(child));
 418                 return (ENXIO);
 419         }
 420
 421         if (rle->res == NULL) {
 422                 device_printf(dev, "core register resource unallocated for "
 423                     "%s\n", device_get_nameunit(child));
 424                 return (ENXIO);
 425         }
 426
 427         if (r_addr+pmu_regs < rman_get_start(rle->res) ||
 428             r_addr+pmu_regs >= rman_get_end(rle->res))
 429         {
 430                 device_printf(dev, "core register resource does not map PMU "
 431                     "registers at %#jx\n for %s\n", r_addr+pmu_regs,
 432                     device_get_nameunit(child));
 433                 return (ENXIO);
 434         }
 435
 436         /* Adjust PMU register offset relative to the actual start address
 437          * of the core's register block allocation.
 438          *
 439          * XXX: The saved offset will be invalid if bus_adjust_resource is
 440          * used to modify the resource's start address.
 441          */
 442         if (rman_get_start(rle->res) > r_addr)
 443                 pmu_regs -= rman_get_start(rle->res) - r_addr;
 444         else
 445                 pmu_regs -= r_addr - rman_get_start(rle->res);
 446
 447         /* Retain a PMU reference for the clkctl instance state */
 448         pmu_dev = bhnd_retain_provider(child, BHND_SERVICE_PMU);
 449         if (pmu_dev == NULL) {
 450                 device_printf(sc->dev, "PMU not found\n");
 451                 return (ENXIO);
 452         }
 453
 454         /* Fetch the maximum transition latency from our PMU */
 455         max_latency = bhnd_pmu_get_max_transition_latency(pmu_dev);
 456
 457         /* Allocate a new bhnd_resource wrapping the standard resource we
 458          * fetched from the resource list; we'll free this in
 459          * bhnd_generic_release_pmu() */
 460         r = malloc(sizeof(struct bhnd_resource), M_BHND, M_NOWAIT);
 461         if (r == NULL) {
 462                 bhnd_release_provider(child, pmu_dev, BHND_SERVICE_PMU);
 463                 return (ENOMEM);
 464         }
 465
 466         r->res = rle->res;
 467         r->direct = ((rman_get_flags(rle->res) & RF_ACTIVE) != 0);
 468
 469         /* Allocate the clkctl instance */
 470         clkctl = bhnd_alloc_core_clkctl(child, pmu_dev, r, pmu_regs,
 471             max_latency);
 472         if (clkctl == NULL) {
 473                 free(r, M_BHND);
 474                 bhnd_release_provider(child, pmu_dev, BHND_SERVICE_PMU);
 475                 return (ENOMEM);
 476         }
 477
 478         bhnd_set_pmu_info(child, clkctl);
 479         return (0);
 480 }
 481
 482 /**
 483  * Default bhnd(4) bus driver implementation of BHND_BUS_RELEASE_PMU().
 484  */
 485 int
 486 bhnd_generic_release_pmu(device_t dev, device_t child)
 487 {
 488         struct bhnd_softc       *sc;
 489         struct bhnd_core_clkctl *clkctl;
 490         struct bhnd_resource    *r;
 491         device_t                 pmu_dev;
 492
 493         GIANT_REQUIRED; /* for newbus */
 494
 495         sc = device_get_softc(dev);
 496
 497         if (device_get_parent(child) != dev)
 498                 return (EINVAL);
 499
 500         clkctl = bhnd_get_pmu_info(child);
 501         if (clkctl == NULL)
 502                 panic("pmu over-release for %s", device_get_nameunit(child));
 503
 504         /* Clear all FORCE, AREQ, and ERSRC flags, unless we're already in
 505          * RESET. Suspending a core clears clkctl automatically (and attempting
 506          * to access the PMU registers in a suspended core will trigger a
 507          * system livelock). */
 508         if (!bhnd_is_hw_suspended(clkctl->cc_dev)) {
 509                 BHND_CLKCTL_LOCK(clkctl);
 510
 511                 /* Clear all FORCE, AREQ, and ERSRC flags */
 512                 BHND_CLKCTL_SET_4(clkctl, 0x0, BHND_CCS_FORCE_MASK |
 513                     BHND_CCS_AREQ_MASK | BHND_CCS_ERSRC_REQ_MASK);
 514
 515                 BHND_CLKCTL_UNLOCK(clkctl);
 516         }
 517
 518         /* Clear child's PMU info reference */
 519         bhnd_set_pmu_info(child, NULL);
 520
 521         /* Before freeing the clkctl instance, save a pointer to resources we
 522          * need to clean up manually */
 523         r = clkctl->cc_res;
 524         pmu_dev = clkctl->cc_pmu_dev;
 525
 526         /* Free the clkctl instance */
 527         bhnd_free_core_clkctl(clkctl);
 528
 529         /* Free the child's bhnd resource wrapper */
 530         free(r, M_BHND);
 531
 532         /* Release the child's PMU provider reference */
 533         bhnd_release_provider(child, pmu_dev, BHND_SERVICE_PMU);
 534
 535         return (0);
 536 }
 537
 538 /**
 539  * Default bhnd(4) bus driver implementation of BHND_BUS_GET_CLOCK_LATENCY().
 540  */
 541 int
 542 bhnd_generic_get_clock_latency(device_t dev, device_t child, bhnd_clock clock,
 543     u_int *latency)
 544 {
 545         struct bhnd_core_clkctl *clkctl;
 546
 547         if (device_get_parent(child) != dev)
 548                 return (EINVAL);
 549
 550         if ((clkctl = bhnd_get_pmu_info(child)) == NULL)
 551                 panic("no active PMU allocation");
 552
 553         return (bhnd_pmu_get_clock_latency(clkctl->cc_pmu_dev, clock, latency));
 554 }
 555
 556 /**
 557  * Default bhnd(4) bus driver implementation of BHND_BUS_GET_CLOCK_FREQ().
 558  */
 559 int
 560 bhnd_generic_get_clock_freq(device_t dev, device_t child, bhnd_clock clock,
 561     u_int *freq)
 562 {
 563         struct bhnd_core_clkctl *clkctl;
 564
 565         if (device_get_parent(child) != dev)
 566                 return (EINVAL);
 567
 568         if ((clkctl = bhnd_get_pmu_info(child)) == NULL)
 569                 panic("no active PMU allocation");
 570
 571         return (bhnd_pmu_get_clock_freq(clkctl->cc_pmu_dev, clock, freq));
 572 }
 573
 574 /**
 575  * Default bhnd(4) bus driver implementation of BHND_BUS_REQUEST_CLOCK().
 576  */
 577 int
 578 bhnd_generic_request_clock(device_t dev, device_t child, bhnd_clock clock)
 579 {
 580         struct bhnd_softc       *sc;
 581         struct bhnd_core_clkctl *clkctl;
 582         uint32_t                 avail;
 583         uint32_t                 req;
 584         int                      error;
 585
 586         sc = device_get_softc(dev);
 587
 588         if (device_get_parent(child) != dev)
 589                 return (EINVAL);
 590
 591         if ((clkctl = bhnd_get_pmu_info(child)) == NULL)
 592                 panic("no active PMU allocation");
 593
 594         BHND_ASSERT_CLKCTL_AVAIL(clkctl);
 595
 596         avail = 0x0;
 597         req = 0x0;
 598
 599         switch (clock) {
 600         case BHND_CLOCK_DYN:
 601                 break;
 602         case BHND_CLOCK_ILP:
 603                 req |= BHND_CCS_FORCEILP;
 604                 break;
 605         case BHND_CLOCK_ALP:
 606                 req |= BHND_CCS_FORCEALP;
 607                 avail |= BHND_CCS_ALPAVAIL;
 608                 break;
 609         case BHND_CLOCK_HT:
 610                 req |= BHND_CCS_FORCEHT;
 611                 avail |= BHND_CCS_HTAVAIL;
 612                 break;
 613         default:
 614                 device_printf(dev, "%s requested unknown clock: %#x\n",
 615                     device_get_nameunit(clkctl->cc_dev), clock);
 616                 return (ENODEV);
 617         }
 618
 619         BHND_CLKCTL_LOCK(clkctl);
 620
 621         /* Issue request */
 622         BHND_CLKCTL_SET_4(clkctl, req, BHND_CCS_FORCE_MASK);
 623
 624         /* Wait for clock availability */
 625         error = bhnd_core_clkctl_wait(clkctl, avail, avail);
 626
 627         BHND_CLKCTL_UNLOCK(clkctl);
 628
 629         return (error);
 630 }
 631
 632 /**
 633  * Default bhnd(4) bus driver implementation of BHND_BUS_ENABLE_CLOCKS().
 634  */
 635 int
 636 bhnd_generic_enable_clocks(device_t dev, device_t child, uint32_t clocks)
 637 {
 638         struct bhnd_core_clkctl *clkctl;
 639         uint32_t                 avail;
 640         uint32_t                 req;
 641         int                      error;
 642
 643         if (device_get_parent(child) != dev)
 644                 return (EINVAL);
 645
 646         if ((clkctl = bhnd_get_pmu_info(child)) == NULL)
 647                 panic("no active PMU allocation");
 648
 649         BHND_ASSERT_CLKCTL_AVAIL(clkctl);
 650
 651         avail = 0x0;
 652         req = 0x0;
 653
 654         /* Build clock request flags */
 655         if (clocks & BHND_CLOCK_DYN)            /* nothing to enable */
 656                 clocks &= ~BHND_CLOCK_DYN;
 657
 658         if (clocks & BHND_CLOCK_ILP)            /* nothing to enable */
 659                 clocks &= ~BHND_CLOCK_ILP;
 660
 661         if (clocks & BHND_CLOCK_ALP) {
 662                 req |= BHND_CCS_ALPAREQ;
 663                 avail |= BHND_CCS_ALPAVAIL;
 664                 clocks &= ~BHND_CLOCK_ALP;
 665         }
 666
 667         if (clocks & BHND_CLOCK_HT) {
 668                 req |= BHND_CCS_HTAREQ;
 669                 avail |= BHND_CCS_HTAVAIL;
 670                 clocks &= ~BHND_CLOCK_HT;
 671         }
 672
 673         /* Check for unknown clock values */
 674         if (clocks != 0x0) {
 675                 device_printf(dev, "%s requested unknown clocks: %#x\n",
 676                     device_get_nameunit(clkctl->cc_dev), clocks);
 677                 return (ENODEV);
 678         }
 679
 680         BHND_CLKCTL_LOCK(clkctl);
 681
 682         /* Issue request */
 683         BHND_CLKCTL_SET_4(clkctl, req, BHND_CCS_AREQ_MASK);
 684
 685         /* Wait for clock availability */
 686         error = bhnd_core_clkctl_wait(clkctl, avail, avail);
 687
 688         BHND_CLKCTL_UNLOCK(clkctl);
 689
 690         return (error);
 691 }
 692
 693 /**
 694  * Default bhnd(4) bus driver implementation of BHND_BUS_REQUEST_EXT_RSRC().
 695  */
 696 int
 697 bhnd_generic_request_ext_rsrc(device_t dev, device_t child, u_int rsrc)
 698 {
 699         struct bhnd_softc       *sc;
 700         struct bhnd_core_clkctl *clkctl;
 701         uint32_t                 req;
 702         uint32_t                 avail;
 703         int                      error;
 704
 705         sc = device_get_softc(dev);
 706
 707         if (device_get_parent(child) != dev)
 708                 return (EINVAL);
 709
 710         if ((clkctl = bhnd_get_pmu_info(child)) == NULL)
 711                 panic("no active PMU allocation");
 712
 713         BHND_ASSERT_CLKCTL_AVAIL(clkctl);
 714
 715         sc = device_get_softc(dev);
 716
 717         if (rsrc > BHND_CCS_ERSRC_MAX)
 718                 return (EINVAL);
 719
 720         req = BHND_CCS_SET_BITS((1<<rsrc), BHND_CCS_ERSRC_REQ);
 721         avail = BHND_CCS_SET_BITS((1<<rsrc), BHND_CCS_ERSRC_STS);
 722
 723         BHND_CLKCTL_LOCK(clkctl);
 724
 725         /* Write request */
 726         BHND_CLKCTL_SET_4(clkctl, req, req);
 727
 728         /* Wait for resource availability */
 729         error = bhnd_core_clkctl_wait(clkctl, avail, avail);
 730
 731         BHND_CLKCTL_UNLOCK(clkctl);
 732
 733         return (error);
 734 }
 735
 736 /**
 737  * Default bhnd(4) bus driver implementation of BHND_BUS_RELEASE_EXT_RSRC().
 738  */
 739 int
 740 bhnd_generic_release_ext_rsrc(device_t dev, device_t child, u_int rsrc)
 741 {
 742         struct bhnd_softc       *sc;
 743         struct bhnd_core_clkctl *clkctl;
 744         uint32_t                 mask;
 745
 746         sc = device_get_softc(dev);
 747
 748         if (device_get_parent(child) != dev)
 749                 return (EINVAL);
 750
 751         if ((clkctl = bhnd_get_pmu_info(child)) == NULL)
 752                 panic("no active PMU allocation");
 753
 754         BHND_ASSERT_CLKCTL_AVAIL(clkctl);
 755
 756         sc = device_get_softc(dev);
 757
 758         if (rsrc > BHND_CCS_ERSRC_MAX)
 759                 return (EINVAL);
 760
 761         mask = BHND_CCS_SET_BITS((1<<rsrc), BHND_CCS_ERSRC_REQ);
 762
 763         /* Clear request */
 764         BHND_CLKCTL_LOCK(clkctl);
 765         BHND_CLKCTL_SET_4(clkctl, 0x0, mask);
 766         BHND_CLKCTL_UNLOCK(clkctl);
 767
 768         return (0);
 769 }
 770
 771 /**
 772  * Default bhnd(4) bus driver implementation of BHND_BUS_IS_REGION_VALID().
 773  *
 774  * This implementation assumes that port and region numbers are 0-indexed and
 775  * are allocated non-sparsely, using BHND_BUS_GET_PORT_COUNT() and
 776  * BHND_BUS_GET_REGION_COUNT() to determine if @p port and @p region fall
 777  * within the defined range.
 778  */
 779 static bool
 780 bhnd_generic_is_region_valid(device_t dev, device_t child,
 781     bhnd_port_type type, u_int port, u_int region)
 782 {
 783         if (port >= bhnd_get_port_count(child, type))
 784                 return (false);
 785
 786         if (region >= bhnd_get_region_count(child, type, port))
 787                 return (false);
 788
 789         return (true);
 790 }
 791
 792 /**
 793  * Default bhnd(4) bus driver implementation of BHND_BUS_GET_NVRAM_VAR().
 794  *
 795  * This implementation searches @p dev for a registered NVRAM child device.
 796  *
 797  * If no NVRAM device is registered with @p dev, the request is delegated to
 798  * the BHND_BUS_GET_NVRAM_VAR() method on the parent of @p dev.
 799  */
 800 int
 801 bhnd_generic_get_nvram_var(device_t dev, device_t child, const char *name,
 802     void *buf, size_t *size, bhnd_nvram_type type)
 803 {
 804         struct bhnd_softc       *sc;
 805         device_t                 nvram, parent;
 806         int                      error;
 807
 808         sc = device_get_softc(dev);
 809
 810         /* If a NVRAM device is available, consult it first */
 811         nvram = bhnd_retain_provider(child, BHND_SERVICE_NVRAM);
 812         if (nvram != NULL) {
 813                 error = BHND_NVRAM_GETVAR(nvram, name, buf, size, type);
 814                 bhnd_release_provider(child, nvram, BHND_SERVICE_NVRAM);
 815                 return (error);
 816         }
 817
 818         /* Otherwise, try to delegate to parent */
 819         if ((parent = device_get_parent(dev)) == NULL)
 820                 return (ENODEV);
 821
 822         return (BHND_BUS_GET_NVRAM_VAR(device_get_parent(dev), child,
 823             name, buf, size, type));
 824 }
 825
 826 /**
 827  * Default bhnd(4) bus driver implementation of BUS_PRINT_CHILD().
 828  *
 829  * This implementation requests the device's struct resource_list via
 830  * BUS_GET_RESOURCE_LIST.
 831  */
 832 int
 833 bhnd_generic_print_child(device_t dev, device_t child)
 834 {
 835         struct resource_list    *rl;
 836         int                     retval = 0;
 837
 838         retval += bus_print_child_header(dev, child);
 839
 840         rl = BUS_GET_RESOURCE_LIST(dev, child);
 841
 842         if (rl != NULL) {
 843                 retval += resource_list_print_type(rl, "mem", SYS_RES_MEMORY,
 844                     "%#jx");
 845
 846                 retval += resource_list_print_type(rl, "irq", SYS_RES_IRQ,
 847                     "%#jd");
 848         }
 849
 850         retval += printf(" at core %u", bhnd_get_core_index(child));
 851
 852         retval += bus_print_child_domain(dev, child);
 853         retval += bus_print_child_footer(dev, child);
 854
 855         return (retval);
 856 }
 857
 858 /**
 859  * Default bhnd(4) bus driver implementation of BUS_PROBE_NOMATCH().
 860  *
 861  * This implementation requests the device's struct resource_list via
 862  * BUS_GET_RESOURCE_LIST.
 863  */
 864 void
 865 bhnd_generic_probe_nomatch(device_t dev, device_t child)
 866 {
 867         struct resource_list            *rl;
 868         const struct bhnd_nomatch       *nm;
 869         bool                             report;
 870
 871         /* Fetch reporting configuration for this device */
 872         report = true;
 873         for (nm = bhnd_nomatch_table; nm->device != BHND_COREID_INVALID; nm++) {
 874                 if (nm->vendor != bhnd_get_vendor(child))
 875                         continue;
 876
 877                 if (nm->device != bhnd_get_device(child))
 878                         continue;
 879
 880                 report = false;
 881                 if (bootverbose && nm->if_verbose)
 882                         report = true;
 883                 break;
 884         }
 885
 886         if (!report)
 887                 return;
 888
 889         /* Print the non-matched device info */
 890         device_printf(dev, "<%s %s, rev %hhu>", bhnd_get_vendor_name(child),
 891                 bhnd_get_device_name(child), bhnd_get_hwrev(child));
 892
 893         rl = BUS_GET_RESOURCE_LIST(dev, child);
 894         if (rl != NULL) {
 895                 resource_list_print_type(rl, "mem", SYS_RES_MEMORY, "%#jx");
 896                 resource_list_print_type(rl, "irq", SYS_RES_IRQ, "%#jd");
 897         }
 898
 899         printf(" at core %u (no driver attached)\n",
 900             bhnd_get_core_index(child));
 901 }
 902
 903 static int
 904 bhnd_child_pnpinfo(device_t dev, device_t child, struct sbuf *sb)
 905 {
 906         if (device_get_parent(child) != dev)
 907                 return (BUS_CHILD_PNPINFO(device_get_parent(dev), child, sb));
 908
 909         sbuf_printf(sb, "vendor=0x%hx device=0x%hx rev=0x%hhx",
 910             bhnd_get_vendor(child), bhnd_get_device(child),
 911             bhnd_get_hwrev(child));
 912
 913         return (0);
 914 }
 915
 916 static int
 917 bhnd_child_location(device_t dev, device_t child, struct sbuf *sb)
 918 {
 919         bhnd_addr_t     addr;
 920         bhnd_size_t     size;
 921
 922         if (device_get_parent(child) != dev)
 923                 return (BUS_CHILD_LOCATION(device_get_parent(dev), child, sb));
 924
 925         if (bhnd_get_region_addr(child, BHND_PORT_DEVICE, 0, 0, &addr, &size))
 926                 return (0);
 927
 928         sbuf_printf(sb, "port0.0=0x%llx", (unsigned long long) addr);
 929         return (0);
 930 }
 931
 932 /**
 933  * Default bhnd(4) bus driver implementation of BUS_CHILD_DELETED().
 934  *
 935  * This implementation manages internal bhnd(4) state, and must be called
 936  * by subclassing drivers.
 937  */
 938 void
 939 bhnd_generic_child_deleted(device_t dev, device_t child)
 940 {
 941         struct bhnd_softc       *sc;
 942
 943         sc = device_get_softc(dev);
 944
 945         /* Free device info */
 946         if (bhnd_get_pmu_info(child) != NULL) {
 947                 /* Releasing PMU requests automatically would be nice,
 948                  * but we can't reference per-core PMU register
 949                  * resource after driver detach */
 950                 panic("%s leaked device pmu state\n",
 951                     device_get_nameunit(child));
 952         }
 953 }
 954
 955 /**
 956  * Helper function for implementing BUS_SUSPEND_CHILD().
 957  *
 958  * TODO: Power management
 959  *
 960  * If @p child is not a direct child of @p dev, suspension is delegated to
 961  * the @p dev parent.
 962  */
 963 int
 964 bhnd_generic_suspend_child(device_t dev, device_t child)
 965 {
 966         if (device_get_parent(child) != dev)
 967                 BUS_SUSPEND_CHILD(device_get_parent(dev), child);
 968
 969         return bus_generic_suspend_child(dev, child);
 970 }
 971
 972 /**
 973  * Helper function for implementing BUS_RESUME_CHILD().
 974  *
 975  * TODO: Power management
 976  *
 977  * If @p child is not a direct child of @p dev, suspension is delegated to
 978  * the @p dev parent.
 979  */
 980 int
 981 bhnd_generic_resume_child(device_t dev, device_t child)
 982 {
 983         if (device_get_parent(child) != dev)
 984                 BUS_RESUME_CHILD(device_get_parent(dev), child);
 985
 986         return bus_generic_resume_child(dev, child);
 987 }
 988
 989 /**
 990  * Default bhnd(4) bus driver implementation of BUS_SETUP_INTR().
 991  *
 992  * This implementation of BUS_SETUP_INTR() will delegate interrupt setup
 993  * to the parent of @p dev, if any.
 994  */
 995 int
 996 bhnd_generic_setup_intr(device_t dev, device_t child, struct resource *irq,
 997     int flags, driver_filter_t *filter, driver_intr_t *intr, void *arg,
 998     void **cookiep)
 999 {
1000         return (bus_generic_setup_intr(dev, child, irq, flags, filter, intr,
1001             arg, cookiep));
1002 }
1003
1004 /*
1005  * Delegate all indirect I/O to the parent device. When inherited by
1006  * non-bridged bus implementations, resources will never be marked as
1007  * indirect, and these methods will never be called.
1008  */
1009 #define BHND_IO_READ(_type, _name, _method)                             \
1010 static _type                                                            \
1011 bhnd_read_ ## _name (device_t dev, device_t child,                      \
1012     struct bhnd_resource *r, bus_size_t offset)                         \
1013 {                                                                       \
1014         return (BHND_BUS_READ_ ## _method(                              \
1015                     device_get_parent(dev), child, r, offset));         \
1016 }
1017
1018 #define BHND_IO_WRITE(_type, _name, _method)                            \
1019 static void                                                             \
1020 bhnd_write_ ## _name (device_t dev, device_t child,                     \
1021     struct bhnd_resource *r, bus_size_t offset, _type value)            \
1022 {                                                                       \
1023         return (BHND_BUS_WRITE_ ## _method(                             \
1024                     device_get_parent(dev), child, r, offset,           \
1025                     value));    \
1026 }
1027
1028 #define BHND_IO_MISC(_type, _op, _method)                               \
1029 static void                                                             \
1030 bhnd_ ## _op (device_t dev, device_t child,                             \
1031     struct bhnd_resource *r, bus_size_t offset, _type datap,            \
1032     bus_size_t count)                                                   \
1033 {                                                                       \
1034         BHND_BUS_ ## _method(device_get_parent(dev), child, r,          \
1035             offset, datap, count);                                      \
1036 }
1037
1038 #define BHND_IO_METHODS(_type, _size)                                   \
1039         BHND_IO_READ(_type, _size, _size)                               \
1040         BHND_IO_WRITE(_type, _size, _size)                              \
1041                                                                         \
1042         BHND_IO_READ(_type, stream_ ## _size, STREAM_ ## _size)         \
1043         BHND_IO_WRITE(_type, stream_ ## _size, STREAM_ ## _size)        \
1044                                                                         \
1045         BHND_IO_MISC(_type*, read_multi_ ## _size,                      \
1046             READ_MULTI_ ## _size)                                       \
1047         BHND_IO_MISC(_type*, write_multi_ ## _size,                     \
1048             WRITE_MULTI_ ## _size)                                      \
1049                                                                         \
1050         BHND_IO_MISC(_type*, read_multi_stream_ ## _size,               \
1051            READ_MULTI_STREAM_ ## _size)                                 \
1052         BHND_IO_MISC(_type*, write_multi_stream_ ## _size,              \
1053            WRITE_MULTI_STREAM_ ## _size)                                \
1054                                                                         \
1055         BHND_IO_MISC(_type, set_multi_ ## _size, SET_MULTI_ ## _size)   \
1056         BHND_IO_MISC(_type, set_region_ ## _size, SET_REGION_ ## _size) \
1057                                                                         \
1058         BHND_IO_MISC(_type*, read_region_ ## _size,                     \
1059             READ_REGION_ ## _size)                                      \
1060         BHND_IO_MISC(_type*, write_region_ ## _size,                    \
1061             WRITE_REGION_ ## _size)                                     \
1062                                                                         \
1063         BHND_IO_MISC(_type*, read_region_stream_ ## _size,              \
1064             READ_REGION_STREAM_ ## _size)                               \
1065         BHND_IO_MISC(_type*, write_region_stream_ ## _size,             \
1066             WRITE_REGION_STREAM_ ## _size)                              \
1067
1068 BHND_IO_METHODS(uint8_t, 1);
1069 BHND_IO_METHODS(uint16_t, 2);
1070 BHND_IO_METHODS(uint32_t, 4);
1071
1072 static void
1073 bhnd_barrier(device_t dev, device_t child, struct bhnd_resource *r,
1074     bus_size_t offset, bus_size_t length, int flags)
1075 {
1076         BHND_BUS_BARRIER(device_get_parent(dev), child, r, offset, length,
1077             flags);
1078 }
1079
1080 static device_method_t bhnd_methods[] = {
1081         /* Device interface */ \
1082         DEVMETHOD(device_attach,                bhnd_generic_attach),
1083         DEVMETHOD(device_detach,                bhnd_generic_detach),
1084         DEVMETHOD(device_shutdown,              bhnd_generic_shutdown),
1085         DEVMETHOD(device_suspend,               bhnd_generic_suspend),
1086         DEVMETHOD(device_resume,                bhnd_generic_resume),
1087
1088         /* Bus interface */
1089         DEVMETHOD(bus_child_deleted,            bhnd_generic_child_deleted),
1090         DEVMETHOD(bus_probe_nomatch,            bhnd_generic_probe_nomatch),
1091         DEVMETHOD(bus_print_child,              bhnd_generic_print_child),
1092         DEVMETHOD(bus_child_pnpinfo,            bhnd_child_pnpinfo),
1093         DEVMETHOD(bus_child_location,           bhnd_child_location),
1094
1095         DEVMETHOD(bus_suspend_child,            bhnd_generic_suspend_child),
1096         DEVMETHOD(bus_resume_child,             bhnd_generic_resume_child),
1097
1098         DEVMETHOD(bus_set_resource,             bus_generic_rl_set_resource),
1099         DEVMETHOD(bus_get_resource,             bus_generic_rl_get_resource),
1100         DEVMETHOD(bus_delete_resource,          bus_generic_rl_delete_resource),
1101         DEVMETHOD(bus_alloc_resource,           bus_generic_rl_alloc_resource),
1102         DEVMETHOD(bus_adjust_resource,          bus_generic_adjust_resource),
1103         DEVMETHOD(bus_release_resource,         bus_generic_rl_release_resource),
1104         DEVMETHOD(bus_activate_resource,        bus_generic_activate_resource),
1105         DEVMETHOD(bus_deactivate_resource,      bus_generic_deactivate_resource),
1106
1107         DEVMETHOD(bus_setup_intr,               bhnd_generic_setup_intr),
1108         DEVMETHOD(bus_teardown_intr,            bus_generic_teardown_intr),
1109         DEVMETHOD(bus_config_intr,              bus_generic_config_intr),
1110         DEVMETHOD(bus_bind_intr,                bus_generic_bind_intr),
1111         DEVMETHOD(bus_describe_intr,            bus_generic_describe_intr),
1112
1113         DEVMETHOD(bus_get_dma_tag,              bus_generic_get_dma_tag),
1114
1115         /* BHND interface */
1116         DEVMETHOD(bhnd_bus_get_chipid,          bhnd_bus_generic_get_chipid),
1117         DEVMETHOD(bhnd_bus_is_hw_disabled,      bhnd_bus_generic_is_hw_disabled),
1118
1119         DEVMETHOD(bhnd_bus_get_probe_order,     bhnd_generic_get_probe_order),
1120
1121         DEVMETHOD(bhnd_bus_alloc_pmu,           bhnd_generic_alloc_pmu),
1122         DEVMETHOD(bhnd_bus_release_pmu,         bhnd_generic_release_pmu),
1123         DEVMETHOD(bhnd_bus_request_clock,       bhnd_generic_request_clock),
1124         DEVMETHOD(bhnd_bus_enable_clocks,       bhnd_generic_enable_clocks),
1125         DEVMETHOD(bhnd_bus_request_ext_rsrc,    bhnd_generic_request_ext_rsrc),
1126         DEVMETHOD(bhnd_bus_release_ext_rsrc,    bhnd_generic_release_ext_rsrc),
1127         DEVMETHOD(bhnd_bus_get_clock_latency,   bhnd_generic_get_clock_latency),
1128         DEVMETHOD(bhnd_bus_get_clock_freq,      bhnd_generic_get_clock_freq),
1129
1130         DEVMETHOD(bhnd_bus_is_region_valid,     bhnd_generic_is_region_valid),
1131         DEVMETHOD(bhnd_bus_get_nvram_var,       bhnd_generic_get_nvram_var),
1132
1133         /* BHND interface (bus I/O) */
1134         DEVMETHOD(bhnd_bus_read_1,              bhnd_read_1),
1135         DEVMETHOD(bhnd_bus_read_2,              bhnd_read_2),
1136         DEVMETHOD(bhnd_bus_read_4,              bhnd_read_4),
1137         DEVMETHOD(bhnd_bus_write_1,             bhnd_write_1),
1138         DEVMETHOD(bhnd_bus_write_2,             bhnd_write_2),
1139         DEVMETHOD(bhnd_bus_write_4,             bhnd_write_4),
1140
1141         DEVMETHOD(bhnd_bus_read_stream_1,       bhnd_read_stream_1),
1142         DEVMETHOD(bhnd_bus_read_stream_2,       bhnd_read_stream_2),
1143         DEVMETHOD(bhnd_bus_read_stream_4,       bhnd_read_stream_4),
1144         DEVMETHOD(bhnd_bus_write_stream_1,      bhnd_write_stream_1),
1145         DEVMETHOD(bhnd_bus_write_stream_2,      bhnd_write_stream_2),
1146         DEVMETHOD(bhnd_bus_write_stream_4,      bhnd_write_stream_4),
1147
1148         DEVMETHOD(bhnd_bus_read_multi_1,        bhnd_read_multi_1),
1149         DEVMETHOD(bhnd_bus_read_multi_2,        bhnd_read_multi_2),
1150         DEVMETHOD(bhnd_bus_read_multi_4,        bhnd_read_multi_4),
1151         DEVMETHOD(bhnd_bus_write_multi_1,       bhnd_write_multi_1),
1152         DEVMETHOD(bhnd_bus_write_multi_2,       bhnd_write_multi_2),
1153         DEVMETHOD(bhnd_bus_write_multi_4,       bhnd_write_multi_4),
1154
1155         DEVMETHOD(bhnd_bus_read_multi_stream_1, bhnd_read_multi_stream_1),
1156         DEVMETHOD(bhnd_bus_read_multi_stream_2, bhnd_read_multi_stream_2),
1157         DEVMETHOD(bhnd_bus_read_multi_stream_4, bhnd_read_multi_stream_4),
1158         DEVMETHOD(bhnd_bus_write_multi_stream_1,bhnd_write_multi_stream_1),
1159         DEVMETHOD(bhnd_bus_write_multi_stream_2,bhnd_write_multi_stream_2),
1160         DEVMETHOD(bhnd_bus_write_multi_stream_4,bhnd_write_multi_stream_4),
1161
1162         DEVMETHOD(bhnd_bus_set_multi_1,         bhnd_set_multi_1),
1163         DEVMETHOD(bhnd_bus_set_multi_2,         bhnd_set_multi_2),
1164         DEVMETHOD(bhnd_bus_set_multi_4,         bhnd_set_multi_4),
1165
1166         DEVMETHOD(bhnd_bus_set_region_1,        bhnd_set_region_1),
1167         DEVMETHOD(bhnd_bus_set_region_2,        bhnd_set_region_2),
1168         DEVMETHOD(bhnd_bus_set_region_4,        bhnd_set_region_4),
1169
1170         DEVMETHOD(bhnd_bus_read_region_1,       bhnd_read_region_1),
1171         DEVMETHOD(bhnd_bus_read_region_2,       bhnd_read_region_2),
1172         DEVMETHOD(bhnd_bus_read_region_4,       bhnd_read_region_4),
1173         DEVMETHOD(bhnd_bus_write_region_1,      bhnd_write_region_1),
1174         DEVMETHOD(bhnd_bus_write_region_2,      bhnd_write_region_2),
1175         DEVMETHOD(bhnd_bus_write_region_4,      bhnd_write_region_4),
1176
1177         DEVMETHOD(bhnd_bus_read_region_stream_1,bhnd_read_region_stream_1),
1178         DEVMETHOD(bhnd_bus_read_region_stream_2,bhnd_read_region_stream_2),
1179         DEVMETHOD(bhnd_bus_read_region_stream_4,bhnd_read_region_stream_4),
1180         DEVMETHOD(bhnd_bus_write_region_stream_1, bhnd_write_region_stream_1),
1181         DEVMETHOD(bhnd_bus_write_region_stream_2, bhnd_write_region_stream_2),
1182         DEVMETHOD(bhnd_bus_write_region_stream_4, bhnd_write_region_stream_4),
1183
1184         DEVMETHOD(bhnd_bus_barrier,                     bhnd_barrier),
1185
1186         DEVMETHOD_END
1187 };
1188
1189 devclass_t bhnd_devclass;       /**< bhnd bus. */
1190 devclass_t bhnd_hostb_devclass; /**< bhnd bus host bridge. */
1191 devclass_t bhnd_nvram_devclass; /**< bhnd NVRAM device */
1192
1193 DEFINE_CLASS_0(bhnd, bhnd_driver, bhnd_methods, sizeof(struct bhnd_softc));
1194 MODULE_VERSION(bhnd, 1);