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 const 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 }