?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
6514 AS_* lock macros simplification
[illumos-gate.git] / usr / src / uts / sun4 / io / rootnex.c
blobc7f504437b71342cd642f6901e774dc4632ba158
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));
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 }
Community developed and maintained version of the OS/Net consolidation