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