xref: /titanic_50/usr/src/uts/sun4/io/rootnex.c (revision b56bf881a9655cb27b53cba1468312f7c6dfb0a2)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 
28 /*
29  * sun4 root nexus driver
30  */
31 
32 #include <sys/conf.h>
33 #include <sys/modctl.h>
34 #include <sys/ddi_subrdefs.h>
35 #include <sys/sunndi.h>
36 #include <sys/vmsystm.h>
37 #include <sys/async.h>
38 #include <sys/intr.h>
39 #include <sys/ndifm.h>
40 #include <vm/seg_dev.h>
41 #include <vm/seg_kmem.h>
42 #include <sys/ontrap.h>
43 
44 /* Useful debugging Stuff */
45 #include <sys/nexusdebug.h>
46 #define	ROOTNEX_MAP_DEBUG		0x1
47 #define	ROOTNEX_INTR_DEBUG		0x2
48 
49 /*
50  * config information
51  */
52 
53 static int
54 rootnex_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
55     off_t offset, off_t len, caddr_t *vaddrp);
56 
57 static int
58 rootnex_intr_ops(dev_info_t *, dev_info_t *, ddi_intr_op_t,
59     ddi_intr_handle_impl_t *, void *);
60 
61 static int
62 rootnex_map_fault(dev_info_t *dip, dev_info_t *rdip,
63     struct hat *hat, struct seg *seg, caddr_t addr,
64     struct devpage *dp, pfn_t pfn, uint_t prot, uint_t lock);
65 
66 static int
67 rootnex_ctlops(dev_info_t *, dev_info_t *, ddi_ctl_enum_t, void *, void *);
68 
69 static int
70 rootnex_busop_fminit(dev_info_t *dip, dev_info_t *tdip, int tcap,
71     ddi_iblock_cookie_t *ibc);
72 
73 static void
74 rootnex_fm_init(dev_info_t *);
75 
76 static int
77 rootnex_ctlops_peekpoke(ddi_ctl_enum_t, peekpoke_ctlops_t *, void *result);
78 
79 /*
80  * Defined in $KARCH/io/mach_rootnex.c
81  */
82 int rootnex_add_intr_impl(dev_info_t *dip, dev_info_t *rdip,
83     ddi_intr_handle_impl_t *hdlp);
84 #pragma weak rootnex_add_intr_impl
85 
86 int rootnex_remove_intr_impl(dev_info_t *dip, dev_info_t *rdip,
87     ddi_intr_handle_impl_t *hdlp);
88 #pragma weak rootnex_remove_intr_impl
89 
90 int rootnex_get_intr_pri(dev_info_t *dip, dev_info_t *rdip,
91     ddi_intr_handle_impl_t *hdlp);
92 #pragma weak rootnex_get_intr_pri
93 
94 int rootnex_name_child_impl(dev_info_t *child, char *name, int namelen);
95 #pragma weak rootnex_name_child_impl
96 
97 int rootnex_ctl_initchild_impl(dev_info_t *dip);
98 #pragma weak rootnex_initchild_impl
99 
100 void rootnex_ctl_uninitchild_impl(dev_info_t *dip);
101 #pragma weak rootnex_uninitchild_impl
102 
103 int rootnex_ctl_reportdev_impl(dev_info_t *dev);
104 #pragma weak rootnex_reportdev_impl
105 
106 static struct cb_ops rootnex_cb_ops = {
107 	nodev,		/* open */
108 	nodev,		/* close */
109 	nodev,		/* strategy */
110 	nodev,		/* print */
111 	nodev,		/* dump */
112 	nodev,		/* read */
113 	nodev,		/* write */
114 	nodev,		/* ioctl */
115 	nodev,		/* devmap */
116 	nodev,		/* mmap */
117 	nodev,		/* segmap */
118 	nochpoll,	/* chpoll */
119 	ddi_prop_op,	/* cb_prop_op */
120 	NULL,		/* struct streamtab */
121 	D_NEW | D_MP | D_HOTPLUG,	/* compatibility flags */
122 	CB_REV,		/* Rev */
123 	nodev,		/* cb_aread */
124 	nodev		/* cb_awrite */
125 };
126 
127 static struct bus_ops rootnex_bus_ops = {
128 	BUSO_REV,
129 	rootnex_map,
130 	NULL,
131 	NULL,
132 	NULL,
133 	rootnex_map_fault,
134 	ddi_no_dma_map,		/* no rootnex_dma_map- now in sysio nexus */
135 	ddi_no_dma_allochdl,
136 	ddi_no_dma_freehdl,
137 	ddi_no_dma_bindhdl,
138 	ddi_no_dma_unbindhdl,
139 	ddi_no_dma_flush,
140 	ddi_no_dma_win,
141 	ddi_no_dma_mctl,	/* no rootnex_dma_mctl- now in sysio nexus */
142 	rootnex_ctlops,
143 	ddi_bus_prop_op,
144 	i_ddi_rootnex_get_eventcookie,
145 	i_ddi_rootnex_add_eventcall,
146 	i_ddi_rootnex_remove_eventcall,
147 	i_ddi_rootnex_post_event,
148 	NULL,			/* bus_intr_ctl */
149 	NULL,			/* bus_config */
150 	NULL,			/* bus_unconfig */
151 	rootnex_busop_fminit,	/* bus_fm_init */
152 	NULL,			/* bus_fm_fini */
153 	NULL,			/* bus_fm_access_enter */
154 	NULL,			/* bus_fm_access_fini */
155 	NULL,			/* bus_power */
156 	rootnex_intr_ops	/* bus_intr_op */
157 };
158 
159 static int rootnex_attach(dev_info_t *devi, ddi_attach_cmd_t cmd);
160 static int rootnex_detach(dev_info_t *devi, ddi_detach_cmd_t cmd);
161 
162 static struct dev_ops rootnex_ops = {
163 	DEVO_REV,
164 	0,			/* refcnt */
165 	ddi_no_info,		/* info */
166 	nulldev,
167 	nulldev,		/* probe */
168 	rootnex_attach,
169 	rootnex_detach,
170 	nodev,			/* reset */
171 	&rootnex_cb_ops,
172 	&rootnex_bus_ops,
173 	NULL,			/* power */
174 	ddi_quiesce_not_needed,		/* quiesce */
175 };
176 
177 
178 extern uint_t	root_phys_addr_lo_mask;
179 extern uint_t	root_phys_addr_hi_mask;
180 extern struct mod_ops mod_driverops;
181 extern struct dev_ops rootnex_ops;
182 extern struct cpu cpu0;
183 extern ddi_iblock_cookie_t rootnex_err_ibc;
184 
185 
186 /*
187  * Add statically defined root properties to this list...
188  */
189 static const int pagesize = PAGESIZE;
190 static const int mmu_pagesize = MMU_PAGESIZE;
191 static const int mmu_pageoffset = MMU_PAGEOFFSET;
192 
193 struct prop_def {
194 	char *prop_name;
195 	caddr_t prop_value;
196 };
197 
198 static struct prop_def root_props[] = {
199 	{ "PAGESIZE",		(caddr_t)&pagesize },
200 	{ "MMU_PAGESIZE",	(caddr_t)&mmu_pagesize},
201 	{ "MMU_PAGEOFFSET",	(caddr_t)&mmu_pageoffset},
202 };
203 
204 static vmem_t	*rootnex_regspec_arena;
205 
206 #define	NROOT_PROPS	(sizeof (root_props) / sizeof (struct prop_def))
207 
208 
209 
210 /*
211  * Module linkage information for the kernel.
212  */
213 
214 static struct modldrv modldrv = {
215 	&mod_driverops,	/* Type of module.  This one is a nexus driver */
216 	"sun4 root nexus",
217 	&rootnex_ops,	/* Driver ops */
218 };
219 
220 static struct modlinkage modlinkage = {
221 	MODREV_1, (void *)&modldrv, NULL
222 };
223 
224 int
225 _init(void)
226 {
227 	return (mod_install(&modlinkage));
228 }
229 
230 int
231 _fini(void)
232 {
233 	return (EBUSY);
234 }
235 
236 int
237 _info(struct modinfo *modinfop)
238 {
239 	return (mod_info(&modlinkage, modinfop));
240 }
241 
242 /*
243  * rootnex_attach:
244  *
245  *	attach the root nexus.
246  */
247 static void add_root_props(dev_info_t *);
248 
249 /*ARGSUSED*/
250 static int
251 rootnex_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
252 {
253 	int length;
254 	char *valuep = NULL;
255 
256 	/*
257 	 * Only do these functions when the driver is acting as the
258 	 * root nexus, not when it is driving a memory controller.
259 	 */
260 	if (ddi_root_node() == devi) {
261 		rootnex_fm_init(devi);
262 		add_root_props(devi);
263 		i_ddi_rootnex_init_events(devi);
264 		rootnex_regspec_arena = vmem_create("regspec",
265 		    (void *)PIOMAPBASE, PIOMAPSIZE, MMU_PAGESIZE, NULL, NULL,
266 		    NULL, 0, VM_SLEEP);
267 	}
268 
269 	if (ddi_prop_op(DDI_DEV_T_ANY, devi, PROP_LEN_AND_VAL_ALLOC,
270 	    DDI_PROP_DONTPASS, "banner-name", (caddr_t)&valuep,
271 	    &length) == DDI_PROP_SUCCESS) {
272 		cmn_err(CE_CONT, "?root nexus = %s\n", valuep);
273 		kmem_free(valuep, length);
274 	}
275 	/*
276 	 * Add a no-suspend-resume property so that NDI
277 	 * does not attempt to suspend/resume the rootnex
278 	 * (or any of its aliases) node.
279 	 */
280 	(void) ddi_prop_update_string(DDI_DEV_T_NONE, devi,
281 	    "pm-hardware-state", "no-suspend-resume");
282 
283 	return (DDI_SUCCESS);
284 }
285 
286 /*ARGSUSED*/
287 static int
288 rootnex_detach(dev_info_t *devi, ddi_detach_cmd_t cmd)
289 {
290 	return (DDI_SUCCESS);
291 }
292 
293 static void
294 add_root_props(dev_info_t *devi)
295 {
296 	int i;
297 	struct prop_def *rpp;
298 
299 	/*
300 	 * Note that this for loop works because all of the
301 	 * properties in root_prop are integers
302 	 */
303 	for (i = 0, rpp = root_props; i < NROOT_PROPS; ++i, ++rpp) {
304 		(void) e_ddi_prop_update_int(DDI_DEV_T_NONE, devi,
305 		    rpp->prop_name, *((int *)rpp->prop_value));
306 	}
307 
308 	/*
309 	 * Create the root node "boolean" property
310 	 * corresponding to addressing type supported in the root node:
311 	 *
312 	 * Choices are:
313 	 *	"relative-addressing" (OBP PROMS)
314 	 *	"generic-addressing"  (SunMon -- pseudo OBP/DDI)
315 	 */
316 
317 	(void) e_ddi_prop_update_int(DDI_DEV_T_NONE, devi,
318 	    DDI_RELATIVE_ADDRESSING, 1);
319 
320 	/*
321 	 * Create fault management capability property
322 	 */
323 	(void) e_ddi_prop_update_int(DDI_DEV_T_NONE, devi, "fm-capable",
324 	    ddi_fm_capable(devi));
325 }
326 
327 static int
328 rootnex_map_regspec(ddi_map_req_t *mp, caddr_t *vaddrp, uint_t mapping_attr)
329 {
330 	uint64_t base;
331 	caddr_t kaddr;
332 	pgcnt_t npages;
333 	pfn_t 	pfn;
334 	uint_t 	pgoffset;
335 	struct regspec *rp = mp->map_obj.rp;
336 	ddi_acc_hdl_t *hp;
337 
338 	base = (uint64_t)rp->regspec_addr & (~MMU_PAGEOFFSET); /* base addr */
339 
340 	/*
341 	 * Take the bustype and addr and convert it to a
342 	 * page frame number.
343 	 */
344 	pfn =  mmu_btop(((uint64_t)(rp->regspec_bustype &
345 	    root_phys_addr_hi_mask) << 32) | base);
346 
347 	/*
348 	 * Do a quick sanity check to make sure we are in I/O space.
349 	 */
350 	if (pf_is_memory(pfn))
351 		return (DDI_ME_INVAL);
352 
353 	if (rp->regspec_size == 0) {
354 		DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map_regspec: zero "
355 		    "regspec_size\n"));
356 		return (DDI_ME_INVAL);
357 	}
358 
359 	if (mp->map_flags & DDI_MF_DEVICE_MAPPING)
360 		*vaddrp = (caddr_t)pfn;
361 	else {
362 		pgoffset = (ulong_t)rp->regspec_addr & MMU_PAGEOFFSET;
363 		npages = mmu_btopr(rp->regspec_size + pgoffset);
364 
365 		DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map_regspec: Mapping "
366 		    "%lu pages physical %x.%lx ", npages, rp->regspec_bustype,
367 		    base));
368 
369 		if ((kaddr = vmem_alloc(rootnex_regspec_arena,
370 		    ptob(npages), VM_NOSLEEP)) == NULL)
371 			return (DDI_ME_NORESOURCES);
372 
373 		/*
374 		 * Now map in the pages we've allocated...
375 		 */
376 		hat_devload(kas.a_hat, kaddr, ptob(npages), pfn,
377 		    mp->map_prot | mapping_attr, HAT_LOAD_LOCK);
378 
379 		*vaddrp = kaddr + pgoffset;
380 
381 		hp = mp->map_handlep;
382 		if (hp) {
383 			hp->ah_pfn = pfn;
384 			hp->ah_pnum = npages;
385 		}
386 	}
387 
388 	DPRINTF(ROOTNEX_MAP_DEBUG, ("at virtual 0x%p\n", (void *)*vaddrp));
389 	return (0);
390 }
391 
392 static int
393 rootnex_unmap_regspec(ddi_map_req_t *mp, caddr_t *vaddrp)
394 {
395 	caddr_t addr = *vaddrp;
396 	pgcnt_t npages;
397 	uint_t  pgoffset;
398 	caddr_t base;
399 	struct regspec *rp;
400 
401 	if (mp->map_flags & DDI_MF_DEVICE_MAPPING)
402 		return (0);
403 
404 	rp = mp->map_obj.rp;
405 	pgoffset = (uintptr_t)addr & MMU_PAGEOFFSET;
406 
407 	if (rp->regspec_size == 0) {
408 		DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_unmap_regspec: "
409 		    "zero regspec_size\n"));
410 		return (DDI_ME_INVAL);
411 	}
412 
413 	base = addr - pgoffset;
414 	npages = mmu_btopr(rp->regspec_size + pgoffset);
415 	hat_unload(kas.a_hat, base, ptob(npages), HAT_UNLOAD_UNLOCK);
416 	vmem_free(rootnex_regspec_arena, base, ptob(npages));
417 
418 	/*
419 	 * Destroy the pointer - the mapping has logically gone
420 	 */
421 	*vaddrp = (caddr_t)0;
422 
423 	return (0);
424 }
425 
426 static int
427 rootnex_map_handle(ddi_map_req_t *mp)
428 {
429 	ddi_acc_hdl_t *hp;
430 	uint_t hat_flags;
431 	register struct regspec *rp;
432 
433 	/*
434 	 * Set up the hat_flags for the mapping.
435 	 */
436 	hp = mp->map_handlep;
437 
438 	switch (hp->ah_acc.devacc_attr_endian_flags) {
439 	case DDI_NEVERSWAP_ACC:
440 		hat_flags = HAT_NEVERSWAP | HAT_STRICTORDER;
441 		break;
442 	case DDI_STRUCTURE_BE_ACC:
443 		hat_flags = HAT_STRUCTURE_BE;
444 		break;
445 	case DDI_STRUCTURE_LE_ACC:
446 		hat_flags = HAT_STRUCTURE_LE;
447 		break;
448 	default:
449 		return (DDI_REGS_ACC_CONFLICT);
450 	}
451 
452 	switch (hp->ah_acc.devacc_attr_dataorder) {
453 	case DDI_STRICTORDER_ACC:
454 		break;
455 	case DDI_UNORDERED_OK_ACC:
456 		hat_flags |= HAT_UNORDERED_OK;
457 		break;
458 	case DDI_MERGING_OK_ACC:
459 		hat_flags |= HAT_MERGING_OK;
460 		break;
461 	case DDI_LOADCACHING_OK_ACC:
462 		hat_flags |= HAT_LOADCACHING_OK;
463 		break;
464 	case DDI_STORECACHING_OK_ACC:
465 		hat_flags |= HAT_STORECACHING_OK;
466 		break;
467 	default:
468 		return (DDI_FAILURE);
469 	}
470 
471 	rp = mp->map_obj.rp;
472 	if (rp->regspec_size == 0)
473 		return (DDI_ME_INVAL);
474 
475 	hp->ah_hat_flags = hat_flags;
476 	hp->ah_pfn = mmu_btop((ulong_t)rp->regspec_addr & (~MMU_PAGEOFFSET));
477 	hp->ah_pnum = mmu_btopr(rp->regspec_size +
478 	    (ulong_t)rp->regspec_addr & MMU_PAGEOFFSET);
479 	return (DDI_SUCCESS);
480 }
481 
482 static int
483 rootnex_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
484     off_t offset, off_t len, caddr_t *vaddrp)
485 {
486 	struct regspec *rp, tmp_reg;
487 	ddi_map_req_t mr = *mp;		/* Get private copy of request */
488 	int error;
489 	uint_t mapping_attr;
490 	ddi_acc_hdl_t *hp = NULL;
491 
492 	mp = &mr;
493 
494 	switch (mp->map_op)  {
495 	case DDI_MO_MAP_LOCKED:
496 	case DDI_MO_UNMAP:
497 	case DDI_MO_MAP_HANDLE:
498 		break;
499 	default:
500 		DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map: unimplemented map "
501 		    "op %d.", mp->map_op));
502 		return (DDI_ME_UNIMPLEMENTED);
503 	}
504 
505 	if (mp->map_flags & DDI_MF_USER_MAPPING)  {
506 		DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map: unimplemented map "
507 		    "type: user."));
508 		return (DDI_ME_UNIMPLEMENTED);
509 	}
510 
511 	/*
512 	 * First, if given an rnumber, convert it to a regspec...
513 	 * (Presumably, this is on behalf of a child of the root node?)
514 	 */
515 
516 	if (mp->map_type == DDI_MT_RNUMBER)  {
517 
518 		int rnumber = mp->map_obj.rnumber;
519 
520 		rp = i_ddi_rnumber_to_regspec(rdip, rnumber);
521 		if (rp == (struct regspec *)0)  {
522 			DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map: Out of "
523 			    "range rnumber <%d>, device <%s>", rnumber,
524 			    ddi_get_name(rdip)));
525 			return (DDI_ME_RNUMBER_RANGE);
526 		}
527 
528 		/*
529 		 * Convert the given ddi_map_req_t from rnumber to regspec...
530 		 */
531 
532 		mp->map_type = DDI_MT_REGSPEC;
533 		mp->map_obj.rp = rp;
534 	}
535 
536 	/*
537 	 * Adjust offset and length corresponding to called values...
538 	 * XXX: A non-zero length means override the one in the regspec
539 	 * XXX: regardless of what's in the parent's range?.
540 	 */
541 
542 	tmp_reg = *(mp->map_obj.rp);		/* Preserve underlying data */
543 	rp = mp->map_obj.rp = &tmp_reg;		/* Use tmp_reg in request */
544 
545 	rp->regspec_addr += (uint_t)offset;
546 	if (len != 0)
547 		rp->regspec_size = (uint_t)len;
548 
549 	/*
550 	 * Apply any parent ranges at this level, if applicable.
551 	 * (This is where nexus specific regspec translation takes place.
552 	 * Use of this function is implicit agreement that translation is
553 	 * provided via ddi_apply_range.)
554 	 */
555 
556 	DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map: applying range of parent "
557 	    "<%s> to child <%s>...\n", ddi_get_name(dip), ddi_get_name(rdip)));
558 
559 	if ((error = i_ddi_apply_range(dip, rdip, mp->map_obj.rp)) != 0)
560 		return (error);
561 
562 	switch (mp->map_op)  {
563 	case DDI_MO_MAP_LOCKED:
564 
565 		/*
566 		 * Set up the locked down kernel mapping to the regspec...
567 		 */
568 
569 		/*
570 		 * If we were passed an access handle we need to determine
571 		 * the "endian-ness" of the mapping and fill in the handle.
572 		 */
573 		if (mp->map_handlep) {
574 			hp = mp->map_handlep;
575 			switch (hp->ah_acc.devacc_attr_endian_flags) {
576 			case DDI_NEVERSWAP_ACC:
577 				mapping_attr = HAT_NEVERSWAP | HAT_STRICTORDER;
578 				break;
579 			case DDI_STRUCTURE_BE_ACC:
580 				mapping_attr = HAT_STRUCTURE_BE;
581 				break;
582 			case DDI_STRUCTURE_LE_ACC:
583 				mapping_attr = HAT_STRUCTURE_LE;
584 				break;
585 			default:
586 				return (DDI_REGS_ACC_CONFLICT);
587 			}
588 
589 			switch (hp->ah_acc.devacc_attr_dataorder) {
590 			case DDI_STRICTORDER_ACC:
591 				break;
592 			case DDI_UNORDERED_OK_ACC:
593 				mapping_attr |= HAT_UNORDERED_OK;
594 				break;
595 			case DDI_MERGING_OK_ACC:
596 				mapping_attr |= HAT_MERGING_OK;
597 				break;
598 			case DDI_LOADCACHING_OK_ACC:
599 				mapping_attr |= HAT_LOADCACHING_OK;
600 				break;
601 			case DDI_STORECACHING_OK_ACC:
602 				mapping_attr |= HAT_STORECACHING_OK;
603 				break;
604 			default:
605 				return (DDI_REGS_ACC_CONFLICT);
606 			}
607 		} else {
608 			mapping_attr = HAT_NEVERSWAP | HAT_STRICTORDER;
609 		}
610 
611 		/*
612 		 * Set up the mapping.
613 		 */
614 		error = rootnex_map_regspec(mp, vaddrp, mapping_attr);
615 
616 		/*
617 		 * Fill in the access handle if needed.
618 		 */
619 		if (hp) {
620 			hp->ah_addr = *vaddrp;
621 			hp->ah_hat_flags = mapping_attr;
622 			if (error == 0)
623 				impl_acc_hdl_init(hp);
624 		}
625 		return (error);
626 
627 	case DDI_MO_UNMAP:
628 
629 		/*
630 		 * Release mapping...
631 		 */
632 
633 		return (rootnex_unmap_regspec(mp, vaddrp));
634 
635 	case DDI_MO_MAP_HANDLE:
636 		return (rootnex_map_handle(mp));
637 
638 	}
639 
640 	return (DDI_ME_UNIMPLEMENTED);
641 }
642 
643 static int
644 rootnex_intr_ops(dev_info_t *dip, dev_info_t *rdip, ddi_intr_op_t intr_op,
645     ddi_intr_handle_impl_t *hdlp, void *result)
646 {
647 	int	ret = DDI_SUCCESS;
648 
649 	DPRINTF(ROOTNEX_INTR_DEBUG, ("rootnex_intr_ops: rdip=%s%d "
650 	    "intr_op 0x%x hdlp 0x%p\n", ddi_driver_name(rdip),
651 	    ddi_get_instance(rdip), intr_op, (void *)hdlp));
652 
653 	switch (intr_op) {
654 	case DDI_INTROP_GETCAP:
655 		*(int *)result = DDI_INTR_FLAG_LEVEL;
656 		break;
657 	case DDI_INTROP_SETCAP:
658 		ret = DDI_ENOTSUP;
659 		break;
660 	case DDI_INTROP_ALLOC:
661 		*(int *)result = hdlp->ih_scratch1;
662 		break;
663 	case DDI_INTROP_FREE:
664 		break;
665 	case DDI_INTROP_GETPRI:
666 		*(int *)result = rootnex_get_intr_pri(dip, rdip, hdlp);
667 		break;
668 	case DDI_INTROP_SETPRI:
669 		break;
670 	case DDI_INTROP_ADDISR:
671 		ret = rootnex_add_intr_impl(dip, rdip, hdlp);
672 		break;
673 	case DDI_INTROP_REMISR:
674 		ret = rootnex_remove_intr_impl(dip, rdip, hdlp);
675 		break;
676 	case DDI_INTROP_ENABLE:
677 	case DDI_INTROP_DISABLE:
678 		break;
679 	case DDI_INTROP_NINTRS:
680 	case DDI_INTROP_NAVAIL:
681 		*(int *)result = i_ddi_get_intx_nintrs(rdip);
682 		break;
683 	case DDI_INTROP_SUPPORTED_TYPES:
684 		/* Root nexus driver supports only fixed interrupts */
685 		*(int *)result = i_ddi_get_intx_nintrs(rdip) ?
686 		    DDI_INTR_TYPE_FIXED : 0;
687 		break;
688 	default:
689 		ret = DDI_ENOTSUP;
690 		break;
691 	}
692 
693 	return (ret);
694 }
695 
696 
697 /*
698  * Shorthand defines
699  */
700 
701 #define	DMAOBJ_PP_PP	dmao_obj.pp_obj.pp_pp
702 #define	DMAOBJ_PP_OFF	dmao_ogj.pp_obj.pp_offset
703 #define	ALO		dma_lim->dlim_addr_lo
704 #define	AHI		dma_lim->dlim_addr_hi
705 #define	OBJSIZE		dmareq->dmar_object.dmao_size
706 #define	ORIGVADDR	dmareq->dmar_object.dmao_obj.virt_obj.v_addr
707 #define	RED		((mp->dmai_rflags & DDI_DMA_REDZONE)? 1 : 0)
708 #define	DIRECTION	(mp->dmai_rflags & DDI_DMA_RDWR)
709 
710 /*
711  * rootnex_map_fault:
712  *
713  *	fault in mappings for requestors
714  */
715 
716 /*ARGSUSED*/
717 static int
718 rootnex_map_fault(dev_info_t *dip, dev_info_t *rdip,
719     struct hat *hat, struct seg *seg, caddr_t addr,
720     struct devpage *dp, pfn_t pfn, uint_t prot, uint_t lock)
721 {
722 	extern struct seg_ops segdev_ops;
723 
724 	DPRINTF(ROOTNEX_MAP_DEBUG, ("rootnex_map_fault: address <%p> "
725 	    "pfn <%lx>", (void *)addr, pfn));
726 	DPRINTF(ROOTNEX_MAP_DEBUG, (" Seg <%s>\n",
727 	    seg->s_ops == &segdev_ops ? "segdev" :
728 	    seg == &kvseg ? "segkmem" : "NONE!"));
729 
730 	/*
731 	 * This is all terribly broken, but it is a start
732 	 *
733 	 * XXX	Note that this test means that segdev_ops
734 	 *	must be exported from seg_dev.c.
735 	 * XXX	What about devices with their own segment drivers?
736 	 */
737 	if (seg->s_ops == &segdev_ops) {
738 		register struct segdev_data *sdp =
739 		    (struct segdev_data *)seg->s_data;
740 
741 		if (hat == NULL) {
742 			/*
743 			 * This is one plausible interpretation of
744 			 * a null hat i.e. use the first hat on the
745 			 * address space hat list which by convention is
746 			 * the hat of the system MMU.  At alternative
747 			 * would be to panic .. this might well be better ..
748 			 */
749 			ASSERT(AS_READ_HELD(seg->s_as, &seg->s_as->a_lock));
750 			hat = seg->s_as->a_hat;
751 			cmn_err(CE_NOTE, "rootnex_map_fault: nil hat");
752 		}
753 		hat_devload(hat, addr, MMU_PAGESIZE, pfn, prot | sdp->hat_attr,
754 		    (lock ? HAT_LOAD_LOCK : HAT_LOAD));
755 	} else if (seg == &kvseg && dp == (struct devpage *)0) {
756 		hat_devload(kas.a_hat, addr, MMU_PAGESIZE, pfn, prot,
757 		    HAT_LOAD_LOCK);
758 	} else
759 		return (DDI_FAILURE);
760 	return (DDI_SUCCESS);
761 }
762 
763 /*
764  * Name a child of rootnex
765  *
766  * This may be called multiple times, independent of initchild calls.
767  */
768 int
769 rootnex_name_child(dev_info_t *child, char *name, int namelen)
770 {
771 	return (rootnex_name_child_impl(child, name, namelen));
772 }
773 
774 
775 static int
776 rootnex_ctl_initchild(dev_info_t *dip)
777 {
778 	return (rootnex_ctl_initchild_impl(dip));
779 }
780 
781 
782 int
783 rootnex_ctl_uninitchild(dev_info_t *dip)
784 {
785 	extern void impl_free_ddi_ppd(dev_info_t *);
786 
787 	rootnex_ctl_uninitchild_impl(dip);
788 
789 	/*
790 	 * strip properties and convert node to prototype form
791 	 */
792 	impl_free_ddi_ppd(dip);
793 	ddi_set_name_addr(dip, NULL);
794 	impl_rem_dev_props(dip);
795 	return (DDI_SUCCESS);
796 }
797 
798 
799 static int
800 rootnex_ctl_reportdev(dev_info_t *dev)
801 {
802 	return (rootnex_ctl_reportdev_impl(dev));
803 }
804 
805 
806 static int
807 rootnex_ctlops_peekpoke(ddi_ctl_enum_t cmd, peekpoke_ctlops_t *in_args,
808     void *result)
809 {
810 	int err = DDI_SUCCESS;
811 	on_trap_data_t otd;
812 
813 	/* No safe access except for peek/poke is supported. */
814 	if (in_args->handle != NULL)
815 		return (DDI_FAILURE);
816 
817 	/* Set up protected environment. */
818 	if (!on_trap(&otd, OT_DATA_ACCESS)) {
819 		uintptr_t tramp = otd.ot_trampoline;
820 
821 		if (cmd == DDI_CTLOPS_POKE) {
822 			otd.ot_trampoline = (uintptr_t)&poke_fault;
823 			err = do_poke(in_args->size, (void *)in_args->dev_addr,
824 			    (void *)in_args->host_addr);
825 		} else {
826 			otd.ot_trampoline = (uintptr_t)&peek_fault;
827 			err = do_peek(in_args->size, (void *)in_args->dev_addr,
828 			    (void *)in_args->host_addr);
829 			result = (void *)in_args->host_addr;
830 		}
831 		otd.ot_trampoline = tramp;
832 	} else
833 		err = DDI_FAILURE;
834 
835 	/* Take down protected environment. */
836 	no_trap();
837 
838 	return (err);
839 }
840 
841 /*ARGSUSED*/
842 static int
843 rootnex_ctlops(dev_info_t *dip, dev_info_t *rdip,
844     ddi_ctl_enum_t ctlop, void *arg, void *result)
845 {
846 	register int n, *ptr;
847 	register struct ddi_parent_private_data *pdp;
848 
849 	static boolean_t reserved_msg_printed = B_FALSE;
850 
851 	switch (ctlop) {
852 	case DDI_CTLOPS_DMAPMAPC:
853 		return (DDI_FAILURE);
854 
855 	case DDI_CTLOPS_BTOP:
856 		/*
857 		 * Convert byte count input to physical page units.
858 		 * (byte counts that are not a page-size multiple
859 		 * are rounded down)
860 		 */
861 		*(ulong_t *)result = btop(*(ulong_t *)arg);
862 		return (DDI_SUCCESS);
863 
864 	case DDI_CTLOPS_PTOB:
865 		/*
866 		 * Convert size in physical pages to bytes
867 		 */
868 		*(ulong_t *)result = ptob(*(ulong_t *)arg);
869 		return (DDI_SUCCESS);
870 
871 	case DDI_CTLOPS_BTOPR:
872 		/*
873 		 * Convert byte count input to physical page units
874 		 * (byte counts that are not a page-size multiple
875 		 * are rounded up)
876 		 */
877 		*(ulong_t *)result = btopr(*(ulong_t *)arg);
878 		return (DDI_SUCCESS);
879 
880 	case DDI_CTLOPS_INITCHILD:
881 		return (rootnex_ctl_initchild((dev_info_t *)arg));
882 
883 	case DDI_CTLOPS_UNINITCHILD:
884 		return (rootnex_ctl_uninitchild((dev_info_t *)arg));
885 
886 	case DDI_CTLOPS_REPORTDEV:
887 		return (rootnex_ctl_reportdev(rdip));
888 
889 	case DDI_CTLOPS_IOMIN:
890 		/*
891 		 * Nothing to do here but reflect back..
892 		 */
893 		return (DDI_SUCCESS);
894 
895 	case DDI_CTLOPS_REGSIZE:
896 	case DDI_CTLOPS_NREGS:
897 		break;
898 
899 	case DDI_CTLOPS_SIDDEV:
900 		if (ndi_dev_is_prom_node(rdip))
901 			return (DDI_SUCCESS);
902 		if (ndi_dev_is_persistent_node(rdip))
903 			return (DDI_SUCCESS);
904 		return (DDI_FAILURE);
905 
906 	case DDI_CTLOPS_POWER: {
907 		return ((*pm_platform_power)((power_req_t *)arg));
908 	}
909 
910 	case DDI_CTLOPS_RESERVED0: /* Was DDI_CTLOPS_NINTRS, obsolete */
911 	case DDI_CTLOPS_RESERVED1: /* Was DDI_CTLOPS_POKE_INIT, obsolete */
912 	case DDI_CTLOPS_RESERVED2: /* Was DDI_CTLOPS_POKE_FLUSH, obsolete */
913 	case DDI_CTLOPS_RESERVED3: /* Was DDI_CTLOPS_POKE_FINI, obsolete */
914 	case DDI_CTLOPS_RESERVED4: /* Was DDI_CTLOPS_INTR_HILEVEL, obsolete */
915 	case DDI_CTLOPS_RESERVED5: /* Was DDI_CTLOPS_XLATE_INTRS, obsolete */
916 		if (!reserved_msg_printed) {
917 			reserved_msg_printed = B_TRUE;
918 			cmn_err(CE_WARN, "Failing ddi_ctlops call(s) for "
919 			    "1 or more reserved/obsolete operations.");
920 		}
921 		return (DDI_FAILURE);
922 
923 	case DDI_CTLOPS_POKE:
924 	case DDI_CTLOPS_PEEK:
925 		return (rootnex_ctlops_peekpoke(ctlop, (peekpoke_ctlops_t *)arg,
926 		    result));
927 
928 	default:
929 		return (DDI_FAILURE);
930 	}
931 
932 	/*
933 	 * The rest are for "hardware" properties
934 	 */
935 	if ((pdp = ddi_get_parent_data(rdip)) == NULL)
936 		return (DDI_FAILURE);
937 
938 	if (ctlop == DDI_CTLOPS_NREGS) {
939 		ptr = (int *)result;
940 		*ptr = pdp->par_nreg;
941 	} else {	/* ctlop == DDI_CTLOPS_REGSIZE */
942 		off_t *size = (off_t *)result;
943 
944 		ptr = (int *)arg;
945 		n = *ptr;
946 		if (n >= pdp->par_nreg) {
947 			return (DDI_FAILURE);
948 		}
949 		*size = (off_t)pdp->par_reg[n].regspec_size;
950 	}
951 	return (DDI_SUCCESS);
952 }
953 
954 /* ARGSUSED */
955 int
956 rootnex_busop_fminit(dev_info_t *dip, dev_info_t *tdip, int cap,
957     ddi_iblock_cookie_t *ibc)
958 {
959 	*ibc = rootnex_err_ibc;
960 	return (ddi_system_fmcap | DDI_FM_ACCCHK_CAPABLE |
961 	    DDI_FM_DMACHK_CAPABLE);
962 }
963 
964 static void
965 rootnex_fm_init(dev_info_t *dip)
966 {
967 	int fmcap;
968 
969 	/* Minimum fm capability level for sun4u platforms */
970 	ddi_system_fmcap = DDI_FM_EREPORT_CAPABLE | DDI_FM_ERRCB_CAPABLE;
971 
972 	fmcap = ddi_system_fmcap;
973 
974 	/*
975 	 * Initialize ECC error handling
976 	 */
977 	rootnex_err_ibc = (ddi_iblock_cookie_t)PIL_15;
978 	ddi_fm_init(dip, &fmcap, &rootnex_err_ibc);
979 }
980