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  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 /*
  26  * Copyright (c) 2010, Intel Corporation.
  27  * All rights reserved.
  28  */
  29 
  30 #include <sys/types.h>
  31 #include <sys/cmn_err.h>
  32 #include <sys/conf.h>
  33 #include <sys/debug.h>
  34 #include <sys/errno.h>
  35 #include <sys/note.h>
  36 #include <sys/dditypes.h>
  37 #include <sys/ddi.h>
  38 #include <sys/sunddi.h>
  39 #include <sys/sunndi.h>
  40 #include <sys/ddi_impldefs.h>
  41 #include <sys/ndi_impldefs.h>
  42 #include <sys/varargs.h>
  43 #include <sys/modctl.h>
  44 #include <sys/kmem.h>
  45 #include <sys/cpuvar.h>
  46 #include <sys/cpupart.h>
  47 #include <sys/mem_config.h>
  48 #include <sys/mem_cage.h>
  49 #include <sys/memnode.h>
  50 #include <sys/callb.h>
  51 #include <sys/ontrap.h>
  52 #include <sys/obpdefs.h>
  53 #include <sys/promif.h>
  54 #include <sys/synch.h>
  55 #include <sys/systm.h>
  56 #include <sys/sysmacros.h>
  57 #include <sys/archsystm.h>
  58 #include <sys/machsystm.h>
  59 #include <sys/x_call.h>
  60 #include <sys/x86_archext.h>
  61 #include <sys/fastboot_impl.h>
  62 #include <sys/sysevent.h>
  63 #include <sys/sysevent/dr.h>
  64 #include <sys/sysevent/eventdefs.h>
  65 #include <acpica/include/acpi.h>
  66 #include <sys/acpica.h>
  67 #include <sys/acpidev.h>
  68 #include <sys/acpidev_rsc.h>
  69 #include <sys/acpidev_dr.h>
  70 #include <sys/dr.h>
  71 #include <sys/dr_util.h>
  72 #include <sys/drmach.h>
  73 #include "drmach_acpi.h"
  74 
  75 /* utility */
  76 #define MBYTE           (1048576ull)
  77 #define _ptob64(p)      ((uint64_t)(p) << PAGESHIFT)
  78 #define _b64top(b)      ((pgcnt_t)((b) >> PAGESHIFT))
  79 
  80 static int              drmach_init(void);
  81 static void             drmach_fini(void);
  82 static int              drmach_name2type_idx(char *);
  83 static sbd_error_t      *drmach_mem_update_lgrp(drmachid_t);
  84 
  85 static void drmach_board_dispose(drmachid_t id);
  86 static sbd_error_t *drmach_board_release(drmachid_t);
  87 static sbd_error_t *drmach_board_status(drmachid_t, drmach_status_t *);
  88 
  89 static void drmach_io_dispose(drmachid_t);
  90 static sbd_error_t *drmach_io_release(drmachid_t);
  91 static sbd_error_t *drmach_io_status(drmachid_t, drmach_status_t *);
  92 
  93 static void drmach_cpu_dispose(drmachid_t);
  94 static sbd_error_t *drmach_cpu_release(drmachid_t);
  95 static sbd_error_t *drmach_cpu_status(drmachid_t, drmach_status_t *);
  96 
  97 static void drmach_mem_dispose(drmachid_t);
  98 static sbd_error_t *drmach_mem_release(drmachid_t);
  99 static sbd_error_t *drmach_mem_status(drmachid_t, drmach_status_t *);
 100 
 101 #ifdef DEBUG
 102 int drmach_debug = 1;            /* set to non-zero to enable debug messages */
 103 #endif /* DEBUG */
 104 
 105 drmach_domain_info_t     drmach_domain;
 106 
 107 static char             *drmach_ie_fmt = "drmach_acpi.c %d";
 108 static drmach_array_t   *drmach_boards;
 109 
 110 /* rwlock to protect drmach_boards. */
 111 static krwlock_t         drmach_boards_rwlock;
 112 
 113 /* rwlock to block out CPR thread. */
 114 static krwlock_t         drmach_cpr_rwlock;
 115 
 116 /* CPR callb id. */
 117 static callb_id_t        drmach_cpr_cid;
 118 
 119 static struct {
 120         const char      *name;
 121         const char      *type;
 122         sbd_error_t     *(*new)(drmach_device_t *, drmachid_t *);
 123 } drmach_name2type[] = {
 124         { ACPIDEV_NODE_NAME_CPU,        DRMACH_DEVTYPE_CPU, drmach_cpu_new },
 125         { ACPIDEV_NODE_NAME_MEMORY,     DRMACH_DEVTYPE_MEM, drmach_mem_new },
 126         { ACPIDEV_NODE_NAME_PCI,        DRMACH_DEVTYPE_PCI, drmach_io_new  },
 127 };
 128 
 129 /*
 130  * drmach autoconfiguration data structures and interfaces
 131  */
 132 static struct modlmisc modlmisc = {
 133         &mod_miscops,
 134         "ACPI based DR v1.0"
 135 };
 136 
 137 static struct modlinkage modlinkage = {
 138         MODREV_1,
 139         (void *)&modlmisc,
 140         NULL
 141 };
 142 
 143 int
 144 _init(void)
 145 {
 146         int err;
 147 
 148         if ((err = drmach_init()) != 0) {
 149                 return (err);
 150         }
 151 
 152         if ((err = mod_install(&modlinkage)) != 0) {
 153                 drmach_fini();
 154         }
 155 
 156         return (err);
 157 }
 158 
 159 int
 160 _fini(void)
 161 {
 162         int     err;
 163 
 164         if ((err = mod_remove(&modlinkage)) == 0) {
 165                 drmach_fini();
 166         }
 167 
 168         return (err);
 169 }
 170 
 171 int
 172 _info(struct modinfo *modinfop)
 173 {
 174         return (mod_info(&modlinkage, modinfop));
 175 }
 176 
 177 /*
 178  * Internal support functions.
 179  */
 180 static DRMACH_HANDLE
 181 drmach_node_acpi_get_dnode(drmach_node_t *np)
 182 {
 183         return ((DRMACH_HANDLE)(uintptr_t)np->here);
 184 }
 185 
 186 static dev_info_t *
 187 drmach_node_acpi_get_dip(drmach_node_t *np)
 188 {
 189         dev_info_t *dip = NULL;
 190 
 191         if (ACPI_FAILURE(acpica_get_devinfo((DRMACH_HANDLE)(np->here), &dip))) {
 192                 return (NULL);
 193         }
 194 
 195         return (dip);
 196 }
 197 
 198 static int
 199 drmach_node_acpi_get_prop(drmach_node_t *np, char *name, void *buf, int len)
 200 {
 201         int             rv = 0;
 202         DRMACH_HANDLE   hdl;
 203 
 204         hdl = np->get_dnode(np);
 205         if (hdl == NULL) {
 206                 DRMACH_PR("!drmach_node_acpi_get_prop: NULL handle");
 207                 rv = -1;
 208         } else {
 209                 rv = acpidev_dr_device_getprop(hdl, name, buf, len);
 210                 if (rv >= 0) {
 211                         ASSERT(rv <= len);
 212                         rv = 0;
 213                 }
 214         }
 215 
 216         return (rv);
 217 }
 218 
 219 static int
 220 drmach_node_acpi_get_proplen(drmach_node_t *np, char *name, int *len)
 221 {
 222         int             rv = 0;
 223         DRMACH_HANDLE   hdl;
 224 
 225         hdl = np->get_dnode(np);
 226         if (hdl == NULL) {
 227                 DRMACH_PR("!drmach_node_acpi_get_proplen: NULL handle");
 228                 rv = -1;
 229         } else {
 230                 rv = acpidev_dr_device_getprop(hdl, name, NULL, 0);
 231                 if (rv >= 0) {
 232                         *len = rv;
 233                         return (0);
 234                 }
 235         }
 236 
 237         return (-1);
 238 }
 239 
 240 static ACPI_STATUS
 241 drmach_node_acpi_callback(ACPI_HANDLE hdl, uint_t lvl, void *ctx, void **retval)
 242 {
 243         _NOTE(ARGUNUSED(lvl));
 244 
 245         int rv;
 246         dev_info_t *dip;
 247         drmach_node_walk_args_t *argp = ctx;
 248         int (*cb)(drmach_node_walk_args_t *args);
 249         acpidev_class_id_t clsid;
 250 
 251         ASSERT(hdl != NULL);
 252         ASSERT(ctx != NULL);
 253         ASSERT(retval != NULL);
 254 
 255         /* Skip subtree if the device is not powered. */
 256         if (!acpidev_dr_device_is_powered(hdl)) {
 257                 return (AE_CTRL_DEPTH);
 258         }
 259 
 260         /*
 261          * Keep scanning subtree if it fails to lookup device node.
 262          * There may be some ACPI objects without device nodes created.
 263          */
 264         if (ACPI_FAILURE(acpica_get_devinfo(hdl, &dip))) {
 265                 return (AE_OK);
 266         }
 267 
 268         argp->node->here = hdl;
 269         cb = (int (*)(drmach_node_walk_args_t *args))argp->func;
 270         rv = (*cb)(argp);
 271         argp->node->here = NULL;
 272         if (rv) {
 273                 *(int *)retval = rv;
 274                 return (AE_CTRL_TERMINATE);
 275         }
 276 
 277         /*
 278          * Skip descendants of PCI/PCIex host bridges.
 279          * PCI/PCIex devices will be handled by pcihp.
 280          */
 281         clsid = acpidev_dr_device_get_class(hdl);
 282         if (clsid == ACPIDEV_CLASS_ID_PCI || clsid == ACPIDEV_CLASS_ID_PCIEX) {
 283                 return (AE_CTRL_DEPTH);
 284         }
 285 
 286         return (AE_OK);
 287 }
 288 
 289 static int
 290 drmach_node_acpi_walk(drmach_node_t *np, void *data,
 291     int (*cb)(drmach_node_walk_args_t *args))
 292 {
 293         DRMACH_HANDLE           hdl;
 294         int                     rv = 0;
 295         drmach_node_walk_args_t args;
 296 
 297         /* initialize the args structure for callback */
 298         args.node = np;
 299         args.data = data;
 300         args.func = (void *)cb;
 301 
 302         /* save the handle, it will be modified when walking the tree. */
 303         hdl = np->get_dnode(np);
 304         if (hdl == NULL) {
 305                 DRMACH_PR("!drmach_node_acpi_walk: failed to get device node.");
 306                 return (EX86_INAPPROP);
 307         }
 308 
 309         if (ACPI_FAILURE(acpidev_dr_device_walk_device(hdl,
 310             ACPIDEV_MAX_ENUM_LEVELS, drmach_node_acpi_callback,
 311             &args, (void *)&rv))) {
 312                 /*
 313                  * If acpidev_dr_device_walk_device() itself fails, rv won't
 314                  * be set to suitable error code. Set it here.
 315                  */
 316                 if (rv == 0) {
 317                         cmn_err(CE_WARN, "!drmach_node_acpi_walk: failed to "
 318                             "walk ACPI namespace.");
 319                         rv = EX86_ACPIWALK;
 320                 }
 321         }
 322 
 323         /* restore the handle to original value after walking the tree. */
 324         np->here = (void *)hdl;
 325 
 326         return ((int)rv);
 327 }
 328 
 329 static drmach_node_t *
 330 drmach_node_new(void)
 331 {
 332         drmach_node_t *np;
 333 
 334         np = kmem_zalloc(sizeof (drmach_node_t), KM_SLEEP);
 335 
 336         np->get_dnode = drmach_node_acpi_get_dnode;
 337         np->getdip = drmach_node_acpi_get_dip;
 338         np->getproplen = drmach_node_acpi_get_proplen;
 339         np->getprop = drmach_node_acpi_get_prop;
 340         np->walk = drmach_node_acpi_walk;
 341 
 342         return (np);
 343 }
 344 
 345 static drmachid_t
 346 drmach_node_dup(drmach_node_t *np)
 347 {
 348         drmach_node_t *dup;
 349 
 350         dup = drmach_node_new();
 351         dup->here = np->here;
 352         dup->get_dnode = np->get_dnode;
 353         dup->getdip = np->getdip;
 354         dup->getproplen = np->getproplen;
 355         dup->getprop = np->getprop;
 356         dup->walk = np->walk;
 357 
 358         return (dup);
 359 }
 360 
 361 static void
 362 drmach_node_dispose(drmach_node_t *np)
 363 {
 364         kmem_free(np, sizeof (*np));
 365 }
 366 
 367 static int
 368 drmach_node_walk(drmach_node_t *np, void *param,
 369         int (*cb)(drmach_node_walk_args_t *args))
 370 {
 371         return (np->walk(np, param, cb));
 372 }
 373 
 374 static DRMACH_HANDLE
 375 drmach_node_get_dnode(drmach_node_t *np)
 376 {
 377         return (np->get_dnode(np));
 378 }
 379 
 380 /*
 381  * drmach_array provides convenient array construction, access,
 382  * bounds checking and array destruction logic.
 383  */
 384 static drmach_array_t *
 385 drmach_array_new(uint_t min_index, uint_t max_index)
 386 {
 387         drmach_array_t *arr;
 388 
 389         arr = kmem_zalloc(sizeof (drmach_array_t), KM_SLEEP);
 390 
 391         arr->arr_sz = (max_index - min_index + 1) * sizeof (void *);
 392         if (arr->arr_sz > 0) {
 393                 arr->min_index = min_index;
 394                 arr->max_index = max_index;
 395 
 396                 arr->arr = kmem_zalloc(arr->arr_sz, KM_SLEEP);
 397                 return (arr);
 398         } else {
 399                 kmem_free(arr, sizeof (*arr));
 400                 return (0);
 401         }
 402 }
 403 
 404 static int
 405 drmach_array_set(drmach_array_t *arr, uint_t idx, drmachid_t val)
 406 {
 407         if (idx < arr->min_index || idx > arr->max_index)
 408                 return (-1);
 409         arr->arr[idx - arr->min_index] = val;
 410         return (0);
 411 }
 412 
 413 /*
 414  * Get the item with index idx.
 415  * Return 0 with the value stored in val if succeeds, otherwise return -1.
 416  */
 417 static int
 418 drmach_array_get(drmach_array_t *arr, uint_t idx, drmachid_t *val)
 419 {
 420         if (idx < arr->min_index || idx > arr->max_index)
 421                 return (-1);
 422         *val = arr->arr[idx - arr->min_index];
 423         return (0);
 424 }
 425 
 426 static int
 427 drmach_array_first(drmach_array_t *arr, uint_t *idx, drmachid_t *val)
 428 {
 429         int rv;
 430 
 431         *idx = arr->min_index;
 432         while ((rv = drmach_array_get(arr, *idx, val)) == 0 && *val == NULL)
 433                 *idx += 1;
 434 
 435         return (rv);
 436 }
 437 
 438 static int
 439 drmach_array_next(drmach_array_t *arr, uint_t *idx, drmachid_t *val)
 440 {
 441         int rv;
 442 
 443         *idx += 1;
 444         while ((rv = drmach_array_get(arr, *idx, val)) == 0 && *val == NULL)
 445                 *idx += 1;
 446 
 447         return (rv);
 448 }
 449 
 450 static void
 451 drmach_array_dispose(drmach_array_t *arr, void (*disposer)(drmachid_t))
 452 {
 453         drmachid_t      val;
 454         uint_t          idx;
 455         int             rv;
 456 
 457         rv = drmach_array_first(arr, &idx, &val);
 458         while (rv == 0) {
 459                 (*disposer)(val);
 460                 rv = drmach_array_next(arr, &idx, &val);
 461         }
 462 
 463         kmem_free(arr->arr, arr->arr_sz);
 464         kmem_free(arr, sizeof (*arr));
 465 }
 466 
 467 static drmach_board_t *
 468 drmach_get_board_by_bnum(uint_t bnum)
 469 {
 470         drmachid_t id;
 471 
 472         if (drmach_array_get(drmach_boards, bnum, &id) == 0)
 473                 return ((drmach_board_t *)id);
 474         else
 475                 return (NULL);
 476 }
 477 
 478 sbd_error_t *
 479 drmach_device_new(drmach_node_t *node,
 480         drmach_board_t *bp, int portid, drmachid_t *idp)
 481 {
 482         int              i;
 483         int              rv;
 484         drmach_device_t  proto;
 485         sbd_error_t     *err;
 486         char             name[OBP_MAXDRVNAME];
 487 
 488         rv = node->getprop(node, ACPIDEV_DR_PROP_DEVNAME, name, OBP_MAXDRVNAME);
 489         if (rv) {
 490                 /* every node is expected to have a name */
 491                 err = drerr_new(1, EX86_GETPROP, "device node %s: property %s",
 492                     ddi_node_name(node->getdip(node)),
 493                     ACPIDEV_DR_PROP_DEVNAME);
 494                 return (err);
 495         }
 496 
 497         /*
 498          * The node currently being examined is not listed in the name2type[]
 499          * array.  In this case, the node is no interest to drmach.  Both
 500          * dp and err are initialized here to yield nothing (no device or
 501          * error structure) for this case.
 502          */
 503         i = drmach_name2type_idx(name);
 504         if (i < 0) {
 505                 *idp = (drmachid_t)0;
 506                 return (NULL);
 507         }
 508 
 509         /* device specific new function will set unum */
 510         bzero(&proto, sizeof (proto));
 511         proto.type = drmach_name2type[i].type;
 512         proto.bp = bp;
 513         proto.node = node;
 514         proto.portid = portid;
 515 
 516         return (drmach_name2type[i].new(&proto, idp));
 517 }
 518 
 519 static void
 520 drmach_device_dispose(drmachid_t id)
 521 {
 522         drmach_device_t *self = id;
 523 
 524         self->cm.dispose(id);
 525 }
 526 
 527 static sbd_error_t *
 528 drmach_device_status(drmachid_t id, drmach_status_t *stat)
 529 {
 530         drmach_common_t *cp;
 531 
 532         if (!DRMACH_IS_ID(id))
 533                 return (drerr_new(0, EX86_NOTID, NULL));
 534         cp = id;
 535 
 536         return (cp->status(id, stat));
 537 }
 538 
 539 drmach_board_t *
 540 drmach_board_new(uint_t bnum, int boot_board)
 541 {
 542         sbd_error_t *err;
 543         drmach_board_t  *bp;
 544         dev_info_t *dip = NULL;
 545 
 546         bp = kmem_zalloc(sizeof (drmach_board_t), KM_SLEEP);
 547         bp->cm.isa = (void *)drmach_board_new;
 548         bp->cm.release = drmach_board_release;
 549         bp->cm.status = drmach_board_status;
 550 
 551         bp->bnum = bnum;
 552         bp->devices = NULL;
 553         bp->tree = drmach_node_new();
 554 
 555         acpidev_dr_lock_all();
 556         if (ACPI_FAILURE(acpidev_dr_get_board_handle(bnum, &bp->tree->here))) {
 557                 acpidev_dr_unlock_all();
 558                 drmach_board_dispose(bp);
 559                 return (NULL);
 560         }
 561         acpidev_dr_unlock_all();
 562         ASSERT(bp->tree->here != NULL);
 563 
 564         err = drmach_board_name(bnum, bp->cm.name, sizeof (bp->cm.name));
 565         if (err != NULL) {
 566                 sbd_err_clear(&err);
 567                 drmach_board_dispose(bp);
 568                 return (NULL);
 569         }
 570 
 571         if (acpidev_dr_device_is_powered(bp->tree->here)) {
 572                 bp->boot_board = boot_board;
 573                 bp->powered = 1;
 574         } else {
 575                 bp->boot_board = 0;
 576                 bp->powered = 0;
 577         }
 578         bp->assigned = boot_board;
 579         if (ACPI_SUCCESS(acpica_get_devinfo(bp->tree->here, &dip))) {
 580                 bp->connected = 1;
 581         } else {
 582                 bp->connected = 0;
 583         }
 584 
 585         (void) drmach_array_set(drmach_boards, bnum, bp);
 586 
 587         return (bp);
 588 }
 589 
 590 static void
 591 drmach_board_dispose(drmachid_t id)
 592 {
 593         drmach_board_t *bp;
 594 
 595         ASSERT(DRMACH_IS_BOARD_ID(id));
 596         bp = id;
 597 
 598         if (bp->tree)
 599                 drmach_node_dispose(bp->tree);
 600 
 601         if (bp->devices)
 602                 drmach_array_dispose(bp->devices, drmach_device_dispose);
 603 
 604         kmem_free(bp, sizeof (drmach_board_t));
 605 }
 606 
 607 static sbd_error_t *
 608 drmach_board_release(drmachid_t id)
 609 {
 610         if (!DRMACH_IS_BOARD_ID(id))
 611                 return (drerr_new(0, EX86_INAPPROP, NULL));
 612 
 613         return (NULL);
 614 }
 615 
 616 static int
 617 drmach_board_check_power(drmach_board_t *bp)
 618 {
 619         DRMACH_HANDLE   hdl;
 620 
 621         hdl = drmach_node_get_dnode(bp->tree);
 622 
 623         return (acpidev_dr_device_is_powered(hdl));
 624 }
 625 
 626 struct drmach_board_list_dep_arg {
 627         int     count;
 628         size_t  len;
 629         ssize_t off;
 630         char    *buf;
 631         char    temp[MAXPATHLEN];
 632 };
 633 
 634 static ACPI_STATUS
 635 drmach_board_generate_name(ACPI_HANDLE hdl, UINT32 lvl, void *ctx,
 636     void **retval)
 637 {
 638         _NOTE(ARGUNUSED(retval));
 639 
 640         struct drmach_board_list_dep_arg *argp = ctx;
 641 
 642         ASSERT(hdl != NULL);
 643         ASSERT(lvl == UINT32_MAX);
 644         ASSERT(ctx != NULL);
 645 
 646         /* Skip non-board devices. */
 647         if (!acpidev_dr_device_is_board(hdl)) {
 648                 return (AE_OK);
 649         }
 650 
 651         if (ACPI_FAILURE(acpidev_dr_get_board_name(hdl, argp->temp,
 652             sizeof (argp->temp)))) {
 653                 DRMACH_PR("!drmach_board_generate_name: failed to "
 654                     "generate board name for handle %p.", hdl);
 655                 /* Keep on walking. */
 656                 return (AE_OK);
 657         }
 658         argp->count++;
 659         argp->off += snprintf(argp->buf + argp->off, argp->len - argp->off,
 660             " %s", argp->temp);
 661         if (argp->off >= argp->len) {
 662                 return (AE_CTRL_TERMINATE);
 663         }
 664 
 665         return (AE_OK);
 666 }
 667 
 668 static ssize_t
 669 drmach_board_list_dependency(ACPI_HANDLE hdl, boolean_t edl, char *prefix,
 670     char *buf, size_t len)
 671 {
 672         ACPI_STATUS rc;
 673         ssize_t off;
 674         struct drmach_board_list_dep_arg *ap;
 675 
 676         ASSERT(buf != NULL && len != 0);
 677         if (buf == NULL || len == 0) {
 678                 return (-1);
 679         }
 680 
 681         ap = kmem_zalloc(sizeof (*ap), KM_SLEEP);
 682         ap->buf = buf;
 683         ap->len = len;
 684         ap->off = snprintf(buf, len, "%s", prefix);
 685         if (ap->off >= len) {
 686                 *buf = '\0';
 687                 kmem_free(ap, sizeof (*ap));
 688                 return (-1);
 689         }
 690 
 691         /* Generate the device dependency list. */
 692         if (edl) {
 693                 rc = acpidev_dr_device_walk_edl(hdl,
 694                     drmach_board_generate_name, ap, NULL);
 695         } else {
 696                 rc = acpidev_dr_device_walk_ejd(hdl,
 697                     drmach_board_generate_name, ap, NULL);
 698         }
 699         if (ACPI_FAILURE(rc)) {
 700                 *buf = '\0';
 701                 ap->off = -1;
 702         /* No device has dependency on this board. */
 703         } else if (ap->count == 0) {
 704                 *buf = '\0';
 705                 ap->off = 0;
 706         }
 707 
 708         off = ap->off;
 709         kmem_free(ap, sizeof (*ap));
 710 
 711         return (off);
 712 }
 713 
 714 static sbd_error_t *
 715 drmach_board_status(drmachid_t id, drmach_status_t *stat)
 716 {
 717         sbd_error_t     *err = NULL;
 718         drmach_board_t  *bp;
 719         DRMACH_HANDLE   hdl;
 720         size_t          off;
 721 
 722         if (!DRMACH_IS_BOARD_ID(id))
 723                 return (drerr_new(0, EX86_INAPPROP, NULL));
 724         bp = id;
 725 
 726         if (bp->tree == NULL)
 727                 return (drerr_new(0, EX86_INAPPROP, NULL));
 728         hdl = drmach_node_get_dnode(bp->tree);
 729         if (hdl == NULL)
 730                 return (drerr_new(0, EX86_INAPPROP, NULL));
 731 
 732         stat->busy = 0;                      /* assume not busy */
 733         stat->configured = 0;                /* assume not configured */
 734         stat->assigned = bp->assigned;
 735         stat->powered = bp->powered = acpidev_dr_device_is_powered(hdl);
 736         stat->empty = !acpidev_dr_device_is_present(hdl);
 737         if (ACPI_SUCCESS(acpidev_dr_device_check_status(hdl))) {
 738                 stat->cond = bp->cond = SBD_COND_OK;
 739         } else {
 740                 stat->cond = bp->cond = SBD_COND_FAILED;
 741         }
 742         stat->info[0] = '\0';
 743 
 744         /* Generate the eject device list. */
 745         if (drmach_board_list_dependency(hdl, B_TRUE, "EDL:",
 746             stat->info, sizeof (stat->info)) < 0) {
 747                 DRMACH_PR("!drmach_board_status: failed to generate "
 748                     "eject device list for board %d.", bp->bnum);
 749                 stat->info[0] = '\0';
 750         }
 751         off = strlen(stat->info);
 752         if (off < sizeof (stat->info)) {
 753                 if (drmach_board_list_dependency(hdl, B_FALSE,
 754                     off ? ", EJD:" : "EJD:",
 755                     stat->info + off, sizeof (stat->info) - off) < 0) {
 756                         DRMACH_PR("!drmach_board_status: failed to generate "
 757                             "eject dependent device for board %d.", bp->bnum);
 758                         stat->info[off] = '\0';
 759                 }
 760         }
 761 
 762         switch (acpidev_dr_get_board_type(bp->tree->get_dnode(bp->tree))) {
 763         case ACPIDEV_CPU_BOARD:
 764                 (void) strlcpy(stat->type, "CPU Board", sizeof (stat->type));
 765                 break;
 766         case ACPIDEV_MEMORY_BOARD:
 767                 (void) strlcpy(stat->type, "MemoryBoard", sizeof (stat->type));
 768                 break;
 769         case ACPIDEV_IO_BOARD:
 770                 (void) strlcpy(stat->type, "IO Board", sizeof (stat->type));
 771                 break;
 772         case ACPIDEV_SYSTEM_BOARD:
 773                 /*FALLTHROUGH*/
 774         default:
 775                 (void) strlcpy(stat->type, "SystemBoard", sizeof (stat->type));
 776                 break;
 777         }
 778 
 779         if (bp->devices) {
 780                 int              rv;
 781                 uint_t           d_idx;
 782                 drmachid_t       d_id;
 783 
 784                 rv = drmach_array_first(bp->devices, &d_idx, &d_id);
 785                 while (rv == 0) {
 786                         drmach_status_t d_stat;
 787 
 788                         err = drmach_device_status(d_id, &d_stat);
 789                         if (err)
 790                                 break;
 791 
 792                         stat->busy |= d_stat.busy;
 793                         stat->configured |= d_stat.configured;
 794 
 795                         rv = drmach_array_next(bp->devices, &d_idx, &d_id);
 796                 }
 797         }
 798 
 799         return (err);
 800 }
 801 
 802 /*
 803  * When DR is initialized, we walk the device tree and acquire a hold on
 804  * all the nodes that are interesting to DR. This is so that the corresponding
 805  * branches cannot be deleted.
 806  */
 807 static int
 808 drmach_hold_rele_devtree(dev_info_t *rdip, void *arg)
 809 {
 810         int *holdp = (int *)arg;
 811         ACPI_HANDLE hdl = NULL;
 812         acpidev_data_handle_t dhdl;
 813 
 814         /* Skip nodes and subtrees which are not created by acpidev. */
 815         if (ACPI_FAILURE(acpica_get_handle(rdip, &hdl))) {
 816                 return (DDI_WALK_PRUNECHILD);
 817         }
 818         ASSERT(hdl != NULL);
 819         dhdl = acpidev_data_get_handle(hdl);
 820         if (dhdl == NULL) {
 821                 return (DDI_WALK_PRUNECHILD);
 822         }
 823 
 824         /* Hold/release devices which are interesting to DR operations. */
 825         if (acpidev_data_dr_ready(dhdl)) {
 826                 if (*holdp) {
 827                         ASSERT(!e_ddi_branch_held(rdip));
 828                         e_ddi_branch_hold(rdip);
 829                 } else {
 830                         ASSERT(e_ddi_branch_held(rdip));
 831                         e_ddi_branch_rele(rdip);
 832                 }
 833         }
 834 
 835         return (DDI_WALK_CONTINUE);
 836 }
 837 
 838 static void
 839 drmach_hold_devtree(void)
 840 {
 841         dev_info_t *dip;
 842         int circ;
 843         int hold = 1;
 844 
 845         dip = ddi_root_node();
 846         ndi_devi_enter(dip, &circ);
 847         ddi_walk_devs(ddi_get_child(dip), drmach_hold_rele_devtree, &hold);
 848         ndi_devi_exit(dip, circ);
 849 }
 850 
 851 static void
 852 drmach_release_devtree(void)
 853 {
 854         dev_info_t *dip;
 855         int circ;
 856         int hold = 0;
 857 
 858         dip = ddi_root_node();
 859         ndi_devi_enter(dip, &circ);
 860         ddi_walk_devs(ddi_get_child(dip), drmach_hold_rele_devtree, &hold);
 861         ndi_devi_exit(dip, circ);
 862 }
 863 
 864 static boolean_t
 865 drmach_cpr_callb(void *arg, int code)
 866 {
 867         _NOTE(ARGUNUSED(arg));
 868 
 869         if (code == CB_CODE_CPR_CHKPT) {
 870                 /*
 871                  * Temporarily block CPR operations if there are DR operations
 872                  * ongoing.
 873                  */
 874                 rw_enter(&drmach_cpr_rwlock, RW_WRITER);
 875         } else {
 876                 rw_exit(&drmach_cpr_rwlock);
 877         }
 878 
 879         return (B_TRUE);
 880 }
 881 
 882 static int
 883 drmach_init(void)
 884 {
 885         DRMACH_HANDLE   hdl;
 886         drmachid_t      id;
 887         uint_t          bnum;
 888 
 889         if (MAX_BOARDS > SHRT_MAX) {
 890                 cmn_err(CE_WARN, "!drmach_init: system has too many (%d) "
 891                     "hotplug capable boards.", MAX_BOARDS);
 892                 return (ENXIO);
 893         } else if (MAX_CMP_UNITS_PER_BOARD > 1) {
 894                 cmn_err(CE_WARN, "!drmach_init: DR doesn't support multiple "
 895                     "(%d) physical processors on one board.",
 896                     MAX_CMP_UNITS_PER_BOARD);
 897                 return (ENXIO);
 898         } else if (MAX_CORES_PER_CMP & (MAX_CORES_PER_CMP - 1)) {
 899                 cmn_err(CE_WARN, "!drmach_init: number of logical CPUs (%d) in "
 900                     "physical processor is not power of 2.",
 901                     MAX_CORES_PER_CMP);
 902                 return (ENXIO);
 903         } else if (MAX_CPU_UNITS_PER_BOARD > DEVSET_CPU_NUMBER ||
 904             MAX_MEM_UNITS_PER_BOARD > DEVSET_MEM_NUMBER ||
 905             MAX_IO_UNITS_PER_BOARD > DEVSET_IO_NUMBER) {
 906                 cmn_err(CE_WARN, "!drmach_init: system has more CPU/memory/IO "
 907                     "units than the DR driver can handle.");
 908                 return (ENXIO);
 909         }
 910 
 911         rw_init(&drmach_cpr_rwlock, NULL, RW_DEFAULT, NULL);
 912         drmach_cpr_cid = callb_add(drmach_cpr_callb, NULL,
 913             CB_CL_CPR_PM, "drmach");
 914 
 915         rw_init(&drmach_boards_rwlock, NULL, RW_DEFAULT, NULL);
 916         drmach_boards = drmach_array_new(0, MAX_BOARDS - 1);
 917         drmach_domain.allow_dr = acpidev_dr_capable();
 918 
 919         for (bnum = 0; bnum < MAX_BOARDS; bnum++) {
 920                 hdl = NULL;
 921                 if (ACPI_FAILURE(acpidev_dr_get_board_handle(bnum, &hdl)) ||
 922                     hdl == NULL) {
 923                         cmn_err(CE_WARN, "!drmach_init: failed to lookup ACPI "
 924                             "handle for board %d.", bnum);
 925                         continue;
 926                 }
 927                 if (drmach_array_get(drmach_boards, bnum, &id) == -1) {
 928                         DRMACH_PR("!drmach_init: failed to get handle "
 929                             "for board %d.", bnum);
 930                         ASSERT(0);
 931                         goto error;
 932                 } else if (id == NULL) {
 933                         (void) drmach_board_new(bnum, 1);
 934                 }
 935         }
 936 
 937         /*
 938          * Walk descendants of the devinfo root node and hold
 939          * all devinfo branches of interest.
 940          */
 941         drmach_hold_devtree();
 942 
 943         return (0);
 944 
 945 error:
 946         drmach_array_dispose(drmach_boards, drmach_board_dispose);
 947         rw_destroy(&drmach_boards_rwlock);
 948         rw_destroy(&drmach_cpr_rwlock);
 949         return (ENXIO);
 950 }
 951 
 952 static void
 953 drmach_fini(void)
 954 {
 955         rw_enter(&drmach_boards_rwlock, RW_WRITER);
 956         if (drmach_boards != NULL) {
 957                 drmach_array_dispose(drmach_boards, drmach_board_dispose);
 958                 drmach_boards = NULL;
 959         }
 960         rw_exit(&drmach_boards_rwlock);
 961 
 962         /*
 963          * Walk descendants of the root devinfo node
 964          * release holds acquired on branches in drmach_init()
 965          */
 966         drmach_release_devtree();
 967 
 968         (void) callb_delete(drmach_cpr_cid);
 969         rw_destroy(&drmach_cpr_rwlock);
 970         rw_destroy(&drmach_boards_rwlock);
 971 }
 972 
 973 sbd_error_t *
 974 drmach_io_new(drmach_device_t *proto, drmachid_t *idp)
 975 {
 976         drmach_io_t     *ip;
 977         int             portid;
 978 
 979         portid = proto->portid;
 980         ASSERT(portid != -1);
 981         proto->unum = portid;
 982 
 983         ip = kmem_zalloc(sizeof (drmach_io_t), KM_SLEEP);
 984         bcopy(proto, &ip->dev, sizeof (ip->dev));
 985         ip->dev.node = drmach_node_dup(proto->node);
 986         ip->dev.cm.isa = (void *)drmach_io_new;
 987         ip->dev.cm.dispose = drmach_io_dispose;
 988         ip->dev.cm.release = drmach_io_release;
 989         ip->dev.cm.status = drmach_io_status;
 990         (void) snprintf(ip->dev.cm.name, sizeof (ip->dev.cm.name), "%s%d",
 991             ip->dev.type, ip->dev.unum);
 992 
 993         *idp = (drmachid_t)ip;
 994 
 995         return (NULL);
 996 }
 997 
 998 static void
 999 drmach_io_dispose(drmachid_t id)
1000 {
1001         drmach_io_t *self;
1002 
1003         ASSERT(DRMACH_IS_IO_ID(id));
1004 
1005         self = id;
1006         if (self->dev.node)
1007                 drmach_node_dispose(self->dev.node);
1008 
1009         kmem_free(self, sizeof (*self));
1010 }
1011 
1012 static sbd_error_t *
1013 drmach_io_release(drmachid_t id)
1014 {
1015         if (!DRMACH_IS_IO_ID(id))
1016                 return (drerr_new(0, EX86_INAPPROP, NULL));
1017 
1018         return (NULL);
1019 }
1020 
1021 static sbd_error_t *
1022 drmach_io_status(drmachid_t id, drmach_status_t *stat)
1023 {
1024         drmach_device_t *dp;
1025         sbd_error_t     *err;
1026         int              configured;
1027 
1028         ASSERT(DRMACH_IS_IO_ID(id));
1029         dp = id;
1030 
1031         err = drmach_io_is_attached(id, &configured);
1032         if (err)
1033                 return (err);
1034 
1035         stat->assigned = dp->bp->assigned;
1036         stat->powered = dp->bp->powered;
1037         stat->configured = (configured != 0);
1038         stat->busy = dp->busy;
1039         (void) strlcpy(stat->type, dp->type, sizeof (stat->type));
1040         stat->info[0] = '\0';
1041 
1042         return (NULL);
1043 }
1044 
1045 sbd_error_t *
1046 drmach_cpu_new(drmach_device_t *proto, drmachid_t *idp)
1047 {
1048         int              portid;
1049         processorid_t    cpuid;
1050         drmach_cpu_t    *cp = NULL;
1051 
1052         /* the portid is APIC ID of the node */
1053         portid = proto->portid;
1054         ASSERT(portid != -1);
1055 
1056         /*
1057          * Assume all CPUs are homogeneous and have the same number of
1058          * cores/threads.
1059          */
1060         proto->unum = portid % MAX_CPU_UNITS_PER_BOARD;
1061 
1062         cp = kmem_zalloc(sizeof (drmach_cpu_t), KM_SLEEP);
1063         bcopy(proto, &cp->dev, sizeof (cp->dev));
1064         cp->dev.node = drmach_node_dup(proto->node);
1065         cp->dev.cm.isa = (void *)drmach_cpu_new;
1066         cp->dev.cm.dispose = drmach_cpu_dispose;
1067         cp->dev.cm.release = drmach_cpu_release;
1068         cp->dev.cm.status = drmach_cpu_status;
1069         (void) snprintf(cp->dev.cm.name, sizeof (cp->dev.cm.name), "%s%d",
1070             cp->dev.type, cp->dev.unum);
1071 
1072         cp->apicid = portid;
1073         if (ACPI_SUCCESS(acpica_get_cpu_id_by_object(
1074             drmach_node_get_dnode(proto->node), &cpuid))) {
1075                 cp->cpuid = cpuid;
1076         } else {
1077                 cp->cpuid = -1;
1078         }
1079 
1080         /* Mark CPU0 as busy, many other components have dependency on it. */
1081         if (cp->cpuid == 0) {
1082                 cp->dev.busy = 1;
1083         }
1084 
1085         *idp = (drmachid_t)cp;
1086 
1087         return (NULL);
1088 }
1089 
1090 static void
1091 drmach_cpu_dispose(drmachid_t id)
1092 {
1093         drmach_cpu_t    *self;
1094 
1095         ASSERT(DRMACH_IS_CPU_ID(id));
1096 
1097         self = id;
1098         if (self->dev.node)
1099                 drmach_node_dispose(self->dev.node);
1100 
1101         kmem_free(self, sizeof (*self));
1102 }
1103 
1104 static sbd_error_t *
1105 drmach_cpu_release(drmachid_t id)
1106 {
1107         if (!DRMACH_IS_CPU_ID(id))
1108                 return (drerr_new(0, EX86_INAPPROP, NULL));
1109 
1110         return (NULL);
1111 }
1112 
1113 static sbd_error_t *
1114 drmach_cpu_status(drmachid_t id, drmach_status_t *stat)
1115 {
1116         drmach_cpu_t *cp;
1117         drmach_device_t *dp;
1118 
1119         ASSERT(DRMACH_IS_CPU_ID(id));
1120         cp = (drmach_cpu_t *)id;
1121         dp = &cp->dev;
1122 
1123         stat->assigned = dp->bp->assigned;
1124         stat->powered = dp->bp->powered;
1125         mutex_enter(&cpu_lock);
1126         stat->configured = (cpu_get(cp->cpuid) != NULL);
1127         mutex_exit(&cpu_lock);
1128         stat->busy = dp->busy;
1129         (void) strlcpy(stat->type, dp->type, sizeof (stat->type));
1130         stat->info[0] = '\0';
1131 
1132         return (NULL);
1133 }
1134 
1135 static int
1136 drmach_setup_mc_info(DRMACH_HANDLE hdl, drmach_mem_t *mp)
1137 {
1138         uint_t i, j, count;
1139         struct memlist  *ml = NULL, *ml2 = NULL;
1140         acpidev_regspec_t *regp;
1141         uint64_t align, addr_min, addr_max, total_size, skipped_size;
1142 
1143         if (hdl == NULL) {
1144                 return (-1);
1145         } else if (ACPI_FAILURE(acpidev_dr_get_mem_alignment(hdl, &align))) {
1146                 return (-1);
1147         } else {
1148                 ASSERT((align & (align - 1)) == 0);
1149                 mp->mem_alignment = align;
1150         }
1151 
1152         addr_min = UINT64_MAX;
1153         addr_max = 0;
1154         total_size = 0;
1155         skipped_size = 0;
1156         /*
1157          * There's a memory hole just below 4G on x86, which needs special
1158          * handling. All other addresses assigned to a specific memory device
1159          * should be contiguous.
1160          */
1161         if (ACPI_FAILURE(acpidev_dr_device_get_regspec(hdl, TRUE, &regp,
1162             &count))) {
1163                 return (-1);
1164         }
1165         for (i = 0, j = 0; i < count; i++) {
1166                 uint64_t        addr, size;
1167 
1168                 addr  = (uint64_t)regp[i].phys_mid << 32;
1169                 addr |= (uint64_t)regp[i].phys_low;
1170                 size  = (uint64_t)regp[i].size_hi << 32;
1171                 size |= (uint64_t)regp[i].size_low;
1172                 if (size == 0)
1173                         continue;
1174                 else
1175                         j++;
1176 
1177                 total_size += size;
1178                 if (addr < addr_min)
1179                         addr_min = addr;
1180                 if (addr + size > addr_max)
1181                         addr_max = addr + size;
1182                 if (mp->dev.bp->boot_board ||
1183                     j <= acpidev_dr_max_segments_per_mem_device()) {
1184                         ml = memlist_add_span(ml, addr, size);
1185                 } else {
1186                         skipped_size += size;
1187                 }
1188         }
1189         acpidev_dr_device_free_regspec(regp, count);
1190 
1191         if (skipped_size != 0) {
1192                 cmn_err(CE_WARN, "!drmach: too many (%d) segments on memory "
1193                     "device, max (%d) segments supported, 0x%" PRIx64 " bytes "
1194                     "of memory skipped.",
1195                     j, acpidev_dr_max_segments_per_mem_device(), skipped_size);
1196         }
1197 
1198         mp->slice_base = addr_min;
1199         mp->slice_top = addr_max;
1200         mp->slice_size = total_size;
1201 
1202         if (mp->dev.bp->boot_board) {
1203                 uint64_t endpa = _ptob64(physmax + 1);
1204 
1205                 /*
1206                  * we intersect phys_install to get base_pa.
1207                  * This only works at boot-up time.
1208                  */
1209                 memlist_read_lock();
1210                 ml2 = memlist_dup(phys_install);
1211                 memlist_read_unlock();
1212 
1213                 ml2 = memlist_del_span(ml2, 0ull, mp->slice_base);
1214                 if (ml2 && endpa > addr_max) {
1215                         ml2 = memlist_del_span(ml2, addr_max, endpa - addr_max);
1216                 }
1217         }
1218 
1219         /*
1220          * Create a memlist for the memory board.
1221          * The created memlist only contains configured memory if there's
1222          * configured memory on the board, otherwise it contains all memory
1223          * on the board.
1224          */
1225         if (ml2) {
1226                 uint64_t nbytes = 0;
1227                 struct memlist *p;
1228 
1229                 for (p = ml2; p; p = p->ml_next) {
1230                         nbytes += p->ml_size;
1231                 }
1232                 if (nbytes == 0) {
1233                         memlist_delete(ml2);
1234                         ml2 = NULL;
1235                 } else {
1236                         /* Node has configured memory at boot time. */
1237                         mp->base_pa = ml2->ml_address;
1238                         mp->nbytes = nbytes;
1239                         mp->memlist = ml2;
1240                         if (ml)
1241                                 memlist_delete(ml);
1242                 }
1243         }
1244         if (ml2 == NULL) {
1245                 /* Not configured at boot time. */
1246                 mp->base_pa = UINT64_MAX;
1247                 mp->nbytes = 0;
1248                 mp->memlist = ml;
1249         }
1250 
1251         return (0);
1252 }
1253 
1254 sbd_error_t *
1255 drmach_mem_new(drmach_device_t *proto, drmachid_t *idp)
1256 {
1257         DRMACH_HANDLE   hdl;
1258         drmach_mem_t    *mp;
1259         int             portid;
1260 
1261         mp = kmem_zalloc(sizeof (drmach_mem_t), KM_SLEEP);
1262         portid = proto->portid;
1263         ASSERT(portid != -1);
1264         proto->unum = portid;
1265 
1266         bcopy(proto, &mp->dev, sizeof (mp->dev));
1267         mp->dev.node = drmach_node_dup(proto->node);
1268         mp->dev.cm.isa = (void *)drmach_mem_new;
1269         mp->dev.cm.dispose = drmach_mem_dispose;
1270         mp->dev.cm.release = drmach_mem_release;
1271         mp->dev.cm.status = drmach_mem_status;
1272 
1273         (void) snprintf(mp->dev.cm.name, sizeof (mp->dev.cm.name), "%s%d",
1274             mp->dev.type, proto->unum);
1275         hdl = mp->dev.node->get_dnode(mp->dev.node);
1276         ASSERT(hdl != NULL);
1277         if (drmach_setup_mc_info(hdl, mp) != 0) {
1278                 kmem_free(mp, sizeof (drmach_mem_t));
1279                 *idp = (drmachid_t)NULL;
1280                 return (drerr_new(1, EX86_MC_SETUP, NULL));
1281         }
1282 
1283         /* make sure we do not create memoryless nodes */
1284         if (mp->nbytes == 0 && mp->slice_size == 0) {
1285                 kmem_free(mp, sizeof (drmach_mem_t));
1286                 *idp = (drmachid_t)NULL;
1287         } else
1288                 *idp = (drmachid_t)mp;
1289 
1290         return (NULL);
1291 }
1292 
1293 static void
1294 drmach_mem_dispose(drmachid_t id)
1295 {
1296         drmach_mem_t *mp;
1297 
1298         ASSERT(DRMACH_IS_MEM_ID(id));
1299 
1300         mp = id;
1301 
1302         if (mp->dev.node)
1303                 drmach_node_dispose(mp->dev.node);
1304 
1305         if (mp->memlist) {
1306                 memlist_delete(mp->memlist);
1307                 mp->memlist = NULL;
1308         }
1309 
1310         kmem_free(mp, sizeof (*mp));
1311 }
1312 
1313 static sbd_error_t *
1314 drmach_mem_release(drmachid_t id)
1315 {
1316         if (!DRMACH_IS_MEM_ID(id))
1317                 return (drerr_new(0, EX86_INAPPROP, NULL));
1318 
1319         return (NULL);
1320 }
1321 
1322 static sbd_error_t *
1323 drmach_mem_status(drmachid_t id, drmach_status_t *stat)
1324 {
1325         uint64_t         pa;
1326         drmach_mem_t    *dp;
1327         struct memlist  *ml = NULL;
1328 
1329         ASSERT(DRMACH_IS_MEM_ID(id));
1330         dp = id;
1331 
1332         /* get starting physical address of target memory */
1333         pa = dp->base_pa;
1334         /* round down to slice boundary */
1335         pa &= ~(dp->mem_alignment - 1);
1336 
1337         /* stop at first span that is in slice */
1338         memlist_read_lock();
1339         for (ml = phys_install; ml; ml = ml->ml_next)
1340                 if (ml->ml_address >= pa && ml->ml_address < dp->slice_top)
1341                         break;
1342         memlist_read_unlock();
1343 
1344         stat->assigned = dp->dev.bp->assigned;
1345         stat->powered = dp->dev.bp->powered;
1346         stat->configured = (ml != NULL);
1347         stat->busy = dp->dev.busy;
1348         (void) strlcpy(stat->type, dp->dev.type, sizeof (stat->type));
1349         stat->info[0] = '\0';
1350 
1351         return (NULL);
1352 }
1353 
1354 /*
1355  * Public interfaces exported to support platform independent dr driver.
1356  */
1357 uint_t
1358 drmach_max_boards(void)
1359 {
1360         return (acpidev_dr_max_boards());
1361 }
1362 
1363 uint_t
1364 drmach_max_io_units_per_board(void)
1365 {
1366         return (acpidev_dr_max_io_units_per_board());
1367 }
1368 
1369 uint_t
1370 drmach_max_cmp_units_per_board(void)
1371 {
1372         return (acpidev_dr_max_cmp_units_per_board());
1373 }
1374 
1375 uint_t
1376 drmach_max_mem_units_per_board(void)
1377 {
1378         return (acpidev_dr_max_mem_units_per_board());
1379 }
1380 
1381 uint_t
1382 drmach_max_core_per_cmp(void)
1383 {
1384         return (acpidev_dr_max_cpu_units_per_cmp());
1385 }
1386 
1387 sbd_error_t *
1388 drmach_pre_op(int cmd, drmachid_t id, drmach_opts_t *opts, void *argp)
1389 {
1390         drmach_board_t  *bp = (drmach_board_t *)id;
1391         sbd_error_t     *err = NULL;
1392 
1393         /* allow status and ncm operations to always succeed */
1394         if ((cmd == SBD_CMD_STATUS) || (cmd == SBD_CMD_GETNCM)) {
1395                 return (NULL);
1396         }
1397 
1398         switch (cmd) {
1399         case SBD_CMD_POWERON:
1400         case SBD_CMD_POWEROFF:
1401                 /*
1402                  * Disable fast reboot if CPU/MEM/IOH hotplug event happens.
1403                  * Note: this is a temporary solution and will be revised when
1404                  * fast reboot can support CPU/MEM/IOH DR operations in future.
1405                  *
1406                  * ACPI BIOS generates some static ACPI tables, such as MADT,
1407                  * SRAT and SLIT, to describe system hardware configuration on
1408                  * power-on. When CPU/MEM/IOH hotplug event happens, those
1409                  * static tables won't be updated and will become stale.
1410                  *
1411                  * If we reset system by fast reboot, BIOS will have no chance
1412                  * to regenerate those staled static tables. Fast reboot can't
1413                  * tolerate such inconsistency between staled ACPI tables and
1414                  * real hardware configuration yet.
1415                  *
1416                  * A temporary solution is introduced to disable fast reboot if
1417                  * CPU/MEM/IOH hotplug event happens. This solution should be
1418                  * revised when fast reboot is enhanced to support CPU/MEM/IOH
1419                  * DR operations.
1420                  */
1421                 fastreboot_disable(FBNS_HOTPLUG);
1422                 /*FALLTHROUGH*/
1423 
1424         default:
1425                 /* Block out the CPR thread. */
1426                 rw_enter(&drmach_cpr_rwlock, RW_READER);
1427                 break;
1428         }
1429 
1430         /* check all other commands for the required option string */
1431         if ((opts->size > 0) && (opts->copts != NULL)) {
1432                 if (strstr(opts->copts, ACPIDEV_CMD_OST_PREFIX) == NULL) {
1433                         err = drerr_new(1, EX86_SUPPORT, NULL);
1434                 }
1435         } else {
1436                 err = drerr_new(1, EX86_SUPPORT, NULL);
1437         }
1438 
1439         if (!err && id && DRMACH_IS_BOARD_ID(id)) {
1440                 switch (cmd) {
1441                 case SBD_CMD_TEST:
1442                         break;
1443                 case SBD_CMD_CONNECT:
1444                         if (bp->connected)
1445                                 err = drerr_new(0, ESBD_STATE, NULL);
1446                         else if (!drmach_domain.allow_dr)
1447                                 err = drerr_new(1, EX86_SUPPORT, NULL);
1448                         break;
1449                 case SBD_CMD_DISCONNECT:
1450                         if (!bp->connected)
1451                                 err = drerr_new(0, ESBD_STATE, NULL);
1452                         else if (!drmach_domain.allow_dr)
1453                                 err = drerr_new(1, EX86_SUPPORT, NULL);
1454                         break;
1455                 default:
1456                         if (!drmach_domain.allow_dr)
1457                                 err = drerr_new(1, EX86_SUPPORT, NULL);
1458                         break;
1459 
1460                 }
1461         }
1462 
1463         /*
1464          * CPU/memory/IO DR operations will be supported in stages on x86.
1465          * With early versions, some operations should be blocked here.
1466          * This temporary hook will be removed when all CPU/memory/IO DR
1467          * operations are supported on x86 systems.
1468          *
1469          * We only need to filter unsupported device types for
1470          * SBD_CMD_CONFIGURE/SBD_CMD_UNCONFIGURE commands, all other
1471          * commands are supported by all device types.
1472          */
1473         if (!err && (cmd == SBD_CMD_CONFIGURE || cmd == SBD_CMD_UNCONFIGURE)) {
1474                 int             i;
1475                 dr_devset_t     *devsetp = (dr_devset_t *)argp;
1476                 dr_devset_t     devset = *devsetp;
1477 
1478                 switch (cmd) {
1479                 case SBD_CMD_CONFIGURE:
1480                         if (!plat_dr_support_cpu()) {
1481                                 DEVSET_DEL(devset, SBD_COMP_CPU,
1482                                     DEVSET_ANYUNIT);
1483                         } else {
1484                                 for (i = MAX_CPU_UNITS_PER_BOARD;
1485                                     i < DEVSET_CPU_NUMBER; i++) {
1486                                         DEVSET_DEL(devset, SBD_COMP_CPU, i);
1487                                 }
1488                         }
1489 
1490                         if (!plat_dr_support_memory()) {
1491                                 DEVSET_DEL(devset, SBD_COMP_MEM,
1492                                     DEVSET_ANYUNIT);
1493                         } else {
1494                                 for (i = MAX_MEM_UNITS_PER_BOARD;
1495                                     i < DEVSET_MEM_NUMBER; i++) {
1496                                         DEVSET_DEL(devset, SBD_COMP_MEM, i);
1497                                 }
1498                         }
1499 
1500                         /* No support of configuring IOH devices yet. */
1501                         DEVSET_DEL(devset, SBD_COMP_IO, DEVSET_ANYUNIT);
1502                         break;
1503 
1504                 case SBD_CMD_UNCONFIGURE:
1505                         if (!plat_dr_support_cpu()) {
1506                                 DEVSET_DEL(devset, SBD_COMP_CPU,
1507                                     DEVSET_ANYUNIT);
1508                         } else {
1509                                 for (i = MAX_CPU_UNITS_PER_BOARD;
1510                                     i < DEVSET_CPU_NUMBER; i++) {
1511                                         DEVSET_DEL(devset, SBD_COMP_CPU, i);
1512                                 }
1513                         }
1514 
1515                         /* No support of unconfiguring MEM/IOH devices yet. */
1516                         DEVSET_DEL(devset, SBD_COMP_MEM, DEVSET_ANYUNIT);
1517                         DEVSET_DEL(devset, SBD_COMP_IO, DEVSET_ANYUNIT);
1518                         break;
1519                 }
1520 
1521                 *devsetp = devset;
1522                 if (DEVSET_IS_NULL(devset)) {
1523                         err = drerr_new(1, EX86_SUPPORT, NULL);
1524                 }
1525         }
1526 
1527         return (err);
1528 }
1529 
1530 sbd_error_t *
1531 drmach_post_op(int cmd, drmachid_t id, drmach_opts_t *opts, int rv)
1532 {
1533         _NOTE(ARGUNUSED(id, opts, rv));
1534 
1535         switch (cmd) {
1536         case SBD_CMD_STATUS:
1537         case SBD_CMD_GETNCM:
1538                 break;
1539 
1540         default:
1541                 rw_exit(&drmach_cpr_rwlock);
1542                 break;
1543         }
1544 
1545         return (NULL);
1546 }
1547 
1548 sbd_error_t *
1549 drmach_configure(drmachid_t id, int flags)
1550 {
1551         _NOTE(ARGUNUSED(flags));
1552 
1553         drmach_device_t         *dp;
1554         sbd_error_t             *err = NULL;
1555         dev_info_t              *rdip;
1556         dev_info_t              *fdip = NULL;
1557 
1558         if (!DRMACH_IS_DEVICE_ID(id))
1559                 return (drerr_new(0, EX86_INAPPROP, NULL));
1560         dp = id;
1561 
1562         rdip = dp->node->getdip(dp->node);
1563         ASSERT(rdip);
1564         ASSERT(e_ddi_branch_held(rdip));
1565 
1566         /* allocate cpu id for the CPU device. */
1567         if (DRMACH_IS_CPU_ID(id)) {
1568                 DRMACH_HANDLE hdl = drmach_node_get_dnode(dp->node);
1569                 ASSERT(hdl != NULL);
1570                 if (ACPI_FAILURE(acpidev_dr_allocate_cpuid(hdl, NULL))) {
1571                         err = drerr_new(1, EX86_ALLOC_CPUID, NULL);
1572                 }
1573                 return (err);
1574         }
1575 
1576         if (DRMACH_IS_MEM_ID(id)) {
1577                 err = drmach_mem_update_lgrp(id);
1578                 if (err)
1579                         return (err);
1580         }
1581 
1582         if (e_ddi_branch_configure(rdip, &fdip, 0) != 0) {
1583                 char *path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1584                 dev_info_t *dip = (fdip != NULL) ? fdip : rdip;
1585 
1586                 (void) ddi_pathname(dip, path);
1587                 err = drerr_new(1, EX86_DRVFAIL, path);
1588                 kmem_free(path, MAXPATHLEN);
1589 
1590                 /* If non-NULL, fdip is returned held and must be released */
1591                 if (fdip != NULL)
1592                         ddi_release_devi(fdip);
1593         }
1594 
1595         return (err);
1596 }
1597 
1598 sbd_error_t *
1599 drmach_unconfigure(drmachid_t id, int flags)
1600 {
1601         _NOTE(ARGUNUSED(flags));
1602 
1603         drmach_device_t *dp;
1604         sbd_error_t     *err = NULL;
1605         dev_info_t      *rdip, *fdip = NULL;
1606 
1607         if (!DRMACH_IS_DEVICE_ID(id))
1608                 return (drerr_new(0, EX86_INAPPROP, NULL));
1609         dp = id;
1610 
1611         rdip = dp->node->getdip(dp->node);
1612         ASSERT(rdip);
1613         ASSERT(e_ddi_branch_held(rdip));
1614 
1615         if (DRMACH_IS_CPU_ID(id)) {
1616                 DRMACH_HANDLE hdl = drmach_node_get_dnode(dp->node);
1617                 ASSERT(hdl != NULL);
1618                 if (ACPI_FAILURE(acpidev_dr_free_cpuid(hdl))) {
1619                         err = drerr_new(1, EX86_FREE_CPUID, NULL);
1620                 }
1621                 return (err);
1622         }
1623 
1624         /*
1625          * Note: FORCE flag is no longer necessary under devfs
1626          */
1627         if (e_ddi_branch_unconfigure(rdip, &fdip, 0)) {
1628                 char            *path = kmem_alloc(MAXPATHLEN, KM_SLEEP);
1629 
1630                 /*
1631                  * If non-NULL, fdip is returned held and must be released.
1632                  */
1633                 if (fdip != NULL) {
1634                         (void) ddi_pathname(fdip, path);
1635                         ndi_rele_devi(fdip);
1636                 } else {
1637                         (void) ddi_pathname(rdip, path);
1638                 }
1639 
1640                 err = drerr_new(1, EX86_DRVFAIL, path);
1641 
1642                 kmem_free(path, MAXPATHLEN);
1643         }
1644 
1645         return (err);
1646 }
1647 
1648 sbd_error_t *
1649 drmach_get_dip(drmachid_t id, dev_info_t **dip)
1650 {
1651         drmach_device_t *dp;
1652 
1653         if (!DRMACH_IS_DEVICE_ID(id))
1654                 return (drerr_new(0, EX86_INAPPROP, NULL));
1655         dp = id;
1656 
1657         *dip = dp->node->getdip(dp->node);
1658 
1659         return (NULL);
1660 }
1661 
1662 sbd_error_t *
1663 drmach_release(drmachid_t id)
1664 {
1665         drmach_common_t *cp;
1666 
1667         if (!DRMACH_IS_DEVICE_ID(id))
1668                 return (drerr_new(0, EX86_INAPPROP, NULL));
1669         cp = id;
1670 
1671         return (cp->release(id));
1672 }
1673 
1674 sbd_error_t *
1675 drmach_status(drmachid_t id, drmach_status_t *stat)
1676 {
1677         drmach_common_t *cp;
1678         sbd_error_t     *err;
1679 
1680         rw_enter(&drmach_boards_rwlock, RW_READER);
1681         if (!DRMACH_IS_ID(id)) {
1682                 rw_exit(&drmach_boards_rwlock);
1683                 return (drerr_new(0, EX86_NOTID, NULL));
1684         }
1685         cp = (drmach_common_t *)id;
1686         err = cp->status(id, stat);
1687         rw_exit(&drmach_boards_rwlock);
1688 
1689         return (err);
1690 }
1691 
1692 static sbd_error_t *
1693 drmach_update_acpi_status(drmachid_t id, drmach_opts_t *opts)
1694 {
1695         char            *copts;
1696         drmach_board_t  *bp;
1697         DRMACH_HANDLE   hdl;
1698         int             event, code;
1699         boolean_t       inprogress = B_FALSE;
1700 
1701         if (DRMACH_NULL_ID(id) || !DRMACH_IS_BOARD_ID(id))
1702                 return (drerr_new(0, EX86_INAPPROP, NULL));
1703         bp = (drmach_board_t *)id;
1704         hdl = drmach_node_get_dnode(bp->tree);
1705         ASSERT(hdl != NULL);
1706         if (hdl == NULL)
1707                 return (drerr_new(0, EX86_INAPPROP, NULL));
1708 
1709         /* Get the status code. */
1710         copts = opts->copts;
1711         if (strncmp(copts, ACPIDEV_CMD_OST_INPROGRESS,
1712             strlen(ACPIDEV_CMD_OST_INPROGRESS)) == 0) {
1713                 inprogress = B_TRUE;
1714                 code = ACPI_OST_STA_INSERT_IN_PROGRESS;
1715                 copts += strlen(ACPIDEV_CMD_OST_INPROGRESS);
1716         } else if (strncmp(copts, ACPIDEV_CMD_OST_SUCCESS,
1717             strlen(ACPIDEV_CMD_OST_SUCCESS)) == 0) {
1718                 code = ACPI_OST_STA_SUCCESS;
1719                 copts += strlen(ACPIDEV_CMD_OST_SUCCESS);
1720         } else if (strncmp(copts, ACPIDEV_CMD_OST_FAILURE,
1721             strlen(ACPIDEV_CMD_OST_FAILURE)) == 0) {
1722                 code = ACPI_OST_STA_FAILURE;
1723                 copts += strlen(ACPIDEV_CMD_OST_FAILURE);
1724         } else if (strncmp(copts, ACPIDEV_CMD_OST_NOOP,
1725             strlen(ACPIDEV_CMD_OST_NOOP)) == 0) {
1726                 return (NULL);
1727         } else {
1728                 return (drerr_new(0, EX86_UNKPTCMD, opts->copts));
1729         }
1730 
1731         /* Get the event type. */
1732         copts = strstr(copts, ACPIDEV_EVENT_TYPE_ATTR_NAME);
1733         if (copts == NULL) {
1734                 return (drerr_new(0, EX86_UNKPTCMD, opts->copts));
1735         }
1736         copts += strlen(ACPIDEV_EVENT_TYPE_ATTR_NAME);
1737         if (copts[0] != '=') {
1738                 return (drerr_new(0, EX86_UNKPTCMD, opts->copts));
1739         }
1740         copts += strlen("=");
1741         if (strncmp(copts, ACPIDEV_EVENT_TYPE_BUS_CHECK,
1742             strlen(ACPIDEV_EVENT_TYPE_BUS_CHECK)) == 0) {
1743                 event = ACPI_NOTIFY_BUS_CHECK;
1744         } else if (strncmp(copts, ACPIDEV_EVENT_TYPE_DEVICE_CHECK,
1745             strlen(ACPIDEV_EVENT_TYPE_DEVICE_CHECK)) == 0) {
1746                 event = ACPI_NOTIFY_DEVICE_CHECK;
1747         } else if (strncmp(copts, ACPIDEV_EVENT_TYPE_DEVICE_CHECK_LIGHT,
1748             strlen(ACPIDEV_EVENT_TYPE_DEVICE_CHECK_LIGHT)) == 0) {
1749                 event = ACPI_NOTIFY_DEVICE_CHECK_LIGHT;
1750         } else if (strncmp(copts, ACPIDEV_EVENT_TYPE_EJECT_REQUEST,
1751             strlen(ACPIDEV_EVENT_TYPE_EJECT_REQUEST)) == 0) {
1752                 event = ACPI_NOTIFY_EJECT_REQUEST;
1753                 if (inprogress) {
1754                         code = ACPI_OST_STA_EJECT_IN_PROGRESS;
1755                 }
1756         } else {
1757                 return (drerr_new(0, EX86_UNKPTCMD, opts->copts));
1758         }
1759 
1760         (void) acpidev_eval_ost(hdl, event, code, NULL, 0);
1761 
1762         return (NULL);
1763 }
1764 
1765 static struct {
1766         const char      *name;
1767         sbd_error_t     *(*handler)(drmachid_t id, drmach_opts_t *opts);
1768 } drmach_pt_arr[] = {
1769         { ACPIDEV_CMD_OST_PREFIX,       &drmach_update_acpi_status  },
1770         /* the following line must always be last */
1771         { NULL,                         NULL                            }
1772 };
1773 
1774 sbd_error_t *
1775 drmach_passthru(drmachid_t id, drmach_opts_t *opts)
1776 {
1777         int             i;
1778         sbd_error_t     *err;
1779 
1780         i = 0;
1781         while (drmach_pt_arr[i].name != NULL) {
1782                 int len = strlen(drmach_pt_arr[i].name);
1783 
1784                 if (strncmp(drmach_pt_arr[i].name, opts->copts, len) == 0)
1785                         break;
1786 
1787                 i += 1;
1788         }
1789 
1790         if (drmach_pt_arr[i].name == NULL)
1791                 err = drerr_new(0, EX86_UNKPTCMD, opts->copts);
1792         else
1793                 err = (*drmach_pt_arr[i].handler)(id, opts);
1794 
1795         return (err);
1796 }
1797 
1798 /*
1799  * Board specific interfaces to support dr driver
1800  */
1801 static int
1802 drmach_get_portid(drmach_node_t *np)
1803 {
1804         uint32_t        portid;
1805 
1806         if (np->getprop(np, ACPIDEV_DR_PROP_PORTID,
1807             &portid, sizeof (portid)) == 0) {
1808                 /*
1809                  * acpidev returns portid as uint32_t, validates it.
1810                  */
1811                 if (portid > INT_MAX) {
1812                         return (-1);
1813                 } else {
1814                         return (portid);
1815                 }
1816         }
1817 
1818         return (-1);
1819 }
1820 
1821 /*
1822  * This is a helper function to determine if a given
1823  * node should be considered for a dr operation according
1824  * to predefined dr type nodes and the node's name.
1825  * Formal Parameter : The name of a device node.
1826  * Return Value: -1, name does not map to a valid dr type.
1827  *               A value greater or equal to 0, name is a valid dr type.
1828  */
1829 static int
1830 drmach_name2type_idx(char *name)
1831 {
1832         int     index, ntypes;
1833 
1834         if (name == NULL)
1835                 return (-1);
1836 
1837         /*
1838          * Determine how many possible types are currently supported
1839          * for dr.
1840          */
1841         ntypes = sizeof (drmach_name2type) / sizeof (drmach_name2type[0]);
1842 
1843         /* Determine if the node's name correspond to a predefined type. */
1844         for (index = 0; index < ntypes; index++) {
1845                 if (strcmp(drmach_name2type[index].name, name) == 0)
1846                         /* The node is an allowed type for dr. */
1847                         return (index);
1848         }
1849 
1850         /*
1851          * If the name of the node does not map to any of the
1852          * types in the array drmach_name2type then the node is not of
1853          * interest to dr.
1854          */
1855         return (-1);
1856 }
1857 
1858 static int
1859 drmach_board_find_devices_cb(drmach_node_walk_args_t *args)
1860 {
1861         drmach_node_t                   *node = args->node;
1862         drmach_board_cb_data_t          *data = args->data;
1863         drmach_board_t                  *obj = data->obj;
1864 
1865         int             rv, portid;
1866         uint32_t        bnum;
1867         drmachid_t      id;
1868         drmach_device_t *device;
1869         char            name[OBP_MAXDRVNAME];
1870 
1871         portid = drmach_get_portid(node);
1872         rv = node->getprop(node, ACPIDEV_DR_PROP_DEVNAME,
1873             name, OBP_MAXDRVNAME);
1874         if (rv)
1875                 return (0);
1876 
1877         rv = node->getprop(node, ACPIDEV_DR_PROP_BOARDNUM,
1878             &bnum, sizeof (bnum));
1879         if (rv) {
1880                 return (0);
1881         }
1882         if (bnum > INT_MAX) {
1883                 return (0);
1884         }
1885 
1886         if (bnum != obj->bnum)
1887                 return (0);
1888 
1889         if (drmach_name2type_idx(name) < 0) {
1890                 return (0);
1891         }
1892 
1893         /*
1894          * Create a device data structure from this node data.
1895          * The call may yield nothing if the node is not of interest
1896          * to drmach.
1897          */
1898         data->err = drmach_device_new(node, obj, portid, &id);
1899         if (data->err)
1900                 return (-1);
1901         else if (!id) {
1902                 /*
1903                  * drmach_device_new examined the node we passed in
1904                  * and determined that it was one not of interest to
1905                  * drmach.  So, it is skipped.
1906                  */
1907                 return (0);
1908         }
1909 
1910         rv = drmach_array_set(obj->devices, data->ndevs++, id);
1911         if (rv) {
1912                 data->err = DRMACH_INTERNAL_ERROR();
1913                 return (-1);
1914         }
1915         device = id;
1916 
1917         data->err = (*data->found)(data->a, device->type, device->unum, id);
1918 
1919         return (data->err == NULL ? 0 : -1);
1920 }
1921 
1922 sbd_error_t *
1923 drmach_board_find_devices(drmachid_t id, void *a,
1924         sbd_error_t *(*found)(void *a, const char *, int, drmachid_t))
1925 {
1926         drmach_board_t          *bp = (drmach_board_t *)id;
1927         sbd_error_t             *err;
1928         int                      max_devices;
1929         int                      rv;
1930         drmach_board_cb_data_t  data;
1931 
1932         if (!DRMACH_IS_BOARD_ID(id))
1933                 return (drerr_new(0, EX86_INAPPROP, NULL));
1934 
1935         max_devices  = MAX_CPU_UNITS_PER_BOARD;
1936         max_devices += MAX_MEM_UNITS_PER_BOARD;
1937         max_devices += MAX_IO_UNITS_PER_BOARD;
1938 
1939         if (bp->devices == NULL)
1940                 bp->devices = drmach_array_new(0, max_devices);
1941         ASSERT(bp->tree != NULL);
1942 
1943         data.obj = bp;
1944         data.ndevs = 0;
1945         data.found = found;
1946         data.a = a;
1947         data.err = NULL;
1948 
1949         acpidev_dr_lock_all();
1950         rv = drmach_node_walk(bp->tree, &data, drmach_board_find_devices_cb);
1951         acpidev_dr_unlock_all();
1952         if (rv == 0) {
1953                 err = NULL;
1954         } else {
1955                 drmach_array_dispose(bp->devices, drmach_device_dispose);
1956                 bp->devices = NULL;
1957 
1958                 if (data.err)
1959                         err = data.err;
1960                 else
1961                         err = DRMACH_INTERNAL_ERROR();
1962         }
1963 
1964         return (err);
1965 }
1966 
1967 int
1968 drmach_board_lookup(int bnum, drmachid_t *id)
1969 {
1970         int     rv = 0;
1971 
1972         if (bnum < 0) {
1973                 *id = 0;
1974                 return (-1);
1975         }
1976 
1977         rw_enter(&drmach_boards_rwlock, RW_READER);
1978         if (drmach_array_get(drmach_boards, (uint_t)bnum, id)) {
1979                 *id = 0;
1980                 rv = -1;
1981         }
1982         rw_exit(&drmach_boards_rwlock);
1983 
1984         return (rv);
1985 }
1986 
1987 sbd_error_t *
1988 drmach_board_name(int bnum, char *buf, int buflen)
1989 {
1990         ACPI_HANDLE hdl;
1991         sbd_error_t *err = NULL;
1992 
1993         if (bnum < 0) {
1994                 return (drerr_new(1, EX86_BNUM, "%d", bnum));
1995         }
1996 
1997         acpidev_dr_lock_all();
1998         if (ACPI_FAILURE(acpidev_dr_get_board_handle(bnum, &hdl))) {
1999                 DRMACH_PR("!drmach_board_name: failed to lookup ACPI handle "
2000                     "for board %d.", bnum);
2001                 err = drerr_new(1, EX86_BNUM, "%d", bnum);
2002         } else if (ACPI_FAILURE(acpidev_dr_get_board_name(hdl, buf, buflen))) {
2003                 DRMACH_PR("!drmach_board_name: failed to generate board name "
2004                     "for board %d.", bnum);
2005                 err = drerr_new(0, EX86_INVALID_ARG,
2006                     ": buffer is too small for board name.");
2007         }
2008         acpidev_dr_unlock_all();
2009 
2010         return (err);
2011 }
2012 
2013 int
2014 drmach_board_is_floating(drmachid_t id)
2015 {
2016         drmach_board_t *bp;
2017 
2018         if (!DRMACH_IS_BOARD_ID(id))
2019                 return (0);
2020 
2021         bp = (drmach_board_t *)id;
2022 
2023         return ((drmach_domain.floating & (1ULL << bp->bnum)) ? 1 : 0);
2024 }
2025 
2026 static ACPI_STATUS
2027 drmach_board_check_dependent_cb(ACPI_HANDLE hdl, UINT32 lvl, void *ctx,
2028     void **retval)
2029 {
2030         uint32_t bdnum;
2031         drmach_board_t *bp;
2032         ACPI_STATUS rc = AE_OK;
2033         int cmd = (int)(intptr_t)ctx;
2034 
2035         ASSERT(hdl != NULL);
2036         ASSERT(lvl == UINT32_MAX);
2037         ASSERT(retval != NULL);
2038 
2039         /* Skip non-board devices. */
2040         if (!acpidev_dr_device_is_board(hdl)) {
2041                 return (AE_OK);
2042         } else if (ACPI_FAILURE(acpidev_dr_get_board_number(hdl, &bdnum))) {
2043                 DRMACH_PR("!drmach_board_check_dependent_cb: failed to get "
2044                     "board number for object %p.\n", hdl);
2045                 return (AE_ERROR);
2046         } else if (bdnum > MAX_BOARDS) {
2047                 DRMACH_PR("!drmach_board_check_dependent_cb: board number %u "
2048                     "is too big, max %u.", bdnum, MAX_BOARDS);
2049                 return (AE_ERROR);
2050         }
2051 
2052         bp = drmach_get_board_by_bnum(bdnum);
2053         switch (cmd) {
2054         case SBD_CMD_CONNECT:
2055                 /*
2056                  * Its parent board should be present, assigned, powered and
2057                  * connected when connecting the child board.
2058                  */
2059                 if (bp == NULL) {
2060                         *retval = hdl;
2061                         rc = AE_ERROR;
2062                 } else {
2063                         bp->powered = acpidev_dr_device_is_powered(hdl);
2064                         if (!bp->connected || !bp->powered || !bp->assigned) {
2065                                 *retval = hdl;
2066                                 rc = AE_ERROR;
2067                         }
2068                 }
2069                 break;
2070 
2071         case SBD_CMD_POWERON:
2072                 /*
2073                  * Its parent board should be present, assigned and powered when
2074                  * powering on the child board.
2075                  */
2076                 if (bp == NULL) {
2077                         *retval = hdl;
2078                         rc = AE_ERROR;
2079                 } else {
2080                         bp->powered = acpidev_dr_device_is_powered(hdl);
2081                         if (!bp->powered || !bp->assigned) {
2082                                 *retval = hdl;
2083                                 rc = AE_ERROR;
2084                         }
2085                 }
2086                 break;
2087 
2088         case SBD_CMD_ASSIGN:
2089                 /*
2090                  * Its parent board should be present and assigned when
2091                  * assigning the child board.
2092                  */
2093                 if (bp == NULL) {
2094                         *retval = hdl;
2095                         rc = AE_ERROR;
2096                 } else if (!bp->assigned) {
2097                         *retval = hdl;
2098                         rc = AE_ERROR;
2099                 }
2100                 break;
2101 
2102         case SBD_CMD_DISCONNECT:
2103                 /*
2104                  * The child board should be disconnected if present when
2105                  * disconnecting its parent board.
2106                  */
2107                 if (bp != NULL && bp->connected) {
2108                         *retval = hdl;
2109                         rc = AE_ERROR;
2110                 }
2111                 break;
2112 
2113         case SBD_CMD_POWEROFF:
2114                 /*
2115                  * The child board should be disconnected and powered off if
2116                  * present when powering off its parent board.
2117                  */
2118                 if (bp != NULL) {
2119                         bp->powered = acpidev_dr_device_is_powered(hdl);
2120                         if (bp->connected || bp->powered) {
2121                                 *retval = hdl;
2122                                 rc = AE_ERROR;
2123                         }
2124                 }
2125                 break;
2126 
2127         case SBD_CMD_UNASSIGN:
2128                 /*
2129                  * The child board should be disconnected, powered off and
2130                  * unassigned if present when unassigning its parent board.
2131                  */
2132                 if (bp != NULL) {
2133                         bp->powered = acpidev_dr_device_is_powered(hdl);
2134                         if (bp->connected || bp->powered || bp->assigned) {
2135                                 *retval = hdl;
2136                                 rc = AE_ERROR;
2137                         }
2138                 }
2139                 break;
2140 
2141         default:
2142                 /* Return success for all other commands. */
2143                 break;
2144         }
2145 
2146         return (rc);
2147 }
2148 
2149 sbd_error_t *
2150 drmach_board_check_dependent(int cmd, drmach_board_t *bp)
2151 {
2152         int reverse;
2153         char *name;
2154         sbd_error_t *err = NULL;
2155         DRMACH_HANDLE hdl;
2156         DRMACH_HANDLE dp = NULL;
2157 
2158         ASSERT(bp != NULL);
2159         ASSERT(DRMACH_IS_BOARD_ID(bp));
2160         ASSERT(RW_LOCK_HELD(&drmach_boards_rwlock));
2161 
2162         hdl = drmach_node_get_dnode(bp->tree);
2163         if (hdl == NULL)
2164                 return (drerr_new(0, EX86_INAPPROP, NULL));
2165 
2166         switch (cmd) {
2167         case SBD_CMD_ASSIGN:
2168         case SBD_CMD_POWERON:
2169         case SBD_CMD_CONNECT:
2170                 if (ACPI_SUCCESS(acpidev_dr_device_walk_ejd(hdl,
2171                     &drmach_board_check_dependent_cb,
2172                     (void *)(intptr_t)cmd, &dp))) {
2173                         return (NULL);
2174                 }
2175                 reverse = 0;
2176                 break;
2177 
2178         case SBD_CMD_UNASSIGN:
2179         case SBD_CMD_POWEROFF:
2180         case SBD_CMD_DISCONNECT:
2181                 if (ACPI_SUCCESS(acpidev_dr_device_walk_edl(hdl,
2182                     &drmach_board_check_dependent_cb,
2183                     (void *)(intptr_t)cmd, &dp))) {
2184                         return (NULL);
2185                 }
2186                 reverse = 1;
2187                 break;
2188 
2189         default:
2190                 return (drerr_new(0, EX86_INAPPROP, NULL));
2191         }
2192 
2193         if (dp == NULL) {
2194                 return (drerr_new(1, EX86_WALK_DEPENDENCY, "%s", bp->cm.name));
2195         }
2196         name = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
2197         if (ACPI_FAILURE(acpidev_dr_get_board_name(dp, name, MAXPATHLEN))) {
2198                 err = drerr_new(1, EX86_WALK_DEPENDENCY, "%s", bp->cm.name);
2199         } else if (reverse == 0) {
2200                 err = drerr_new(1, EX86_WALK_DEPENDENCY,
2201                     "%s, depends on board %s", bp->cm.name, name);
2202         } else {
2203                 err = drerr_new(1, EX86_WALK_DEPENDENCY,
2204                     "board %s depends on %s", name, bp->cm.name);
2205         }
2206         kmem_free(name, MAXPATHLEN);
2207 
2208         return (err);
2209 }
2210 
2211 sbd_error_t *
2212 drmach_board_assign(int bnum, drmachid_t *id)
2213 {
2214         sbd_error_t     *err = NULL;
2215 
2216         if (bnum < 0) {
2217                 return (drerr_new(1, EX86_BNUM, "%d", bnum));
2218         }
2219 
2220         rw_enter(&drmach_boards_rwlock, RW_WRITER);
2221 
2222         if (drmach_array_get(drmach_boards, bnum, id) == -1) {
2223                 err = drerr_new(1, EX86_BNUM, "%d", bnum);
2224         } else {
2225                 drmach_board_t  *bp;
2226 
2227                 /*
2228                  * Board has already been created, downgrade to reader.
2229                  */
2230                 if (*id)
2231                         rw_downgrade(&drmach_boards_rwlock);
2232 
2233                 bp = *id;
2234                 if (!(*id))
2235                         bp = *id  =
2236                             (drmachid_t)drmach_board_new(bnum, 0);
2237 
2238                 if (bp == NULL) {
2239                         DRMACH_PR("!drmach_board_assign: failed to create "
2240                             "object for board %d.", bnum);
2241                         err = drerr_new(1, EX86_BNUM, "%d", bnum);
2242                 } else {
2243                         err = drmach_board_check_dependent(SBD_CMD_ASSIGN, bp);
2244                         if (err == NULL)
2245                                 bp->assigned = 1;
2246                 }
2247         }
2248 
2249         rw_exit(&drmach_boards_rwlock);
2250 
2251         return (err);
2252 }
2253 
2254 sbd_error_t *
2255 drmach_board_unassign(drmachid_t id)
2256 {
2257         drmach_board_t  *bp;
2258         sbd_error_t     *err;
2259         drmach_status_t  stat;
2260 
2261         if (DRMACH_NULL_ID(id))
2262                 return (NULL);
2263 
2264         if (!DRMACH_IS_BOARD_ID(id)) {
2265                 return (drerr_new(0, EX86_INAPPROP, NULL));
2266         }
2267         bp = id;
2268 
2269         rw_enter(&drmach_boards_rwlock, RW_WRITER);
2270 
2271         err = drmach_board_status(id, &stat);
2272         if (err) {
2273                 rw_exit(&drmach_boards_rwlock);
2274                 return (err);
2275         }
2276 
2277         if (stat.configured || stat.busy) {
2278                 err = drerr_new(0, EX86_CONFIGBUSY, bp->cm.name);
2279         } else if (bp->connected) {
2280                 err = drerr_new(0, EX86_CONNECTBUSY, bp->cm.name);
2281         } else if (stat.powered) {
2282                 err = drerr_new(0, EX86_POWERBUSY, bp->cm.name);
2283         } else {
2284                 err = drmach_board_check_dependent(SBD_CMD_UNASSIGN, bp);
2285                 if (err == NULL) {
2286                         if (drmach_array_set(drmach_boards, bp->bnum, 0) != 0)
2287                                 err = DRMACH_INTERNAL_ERROR();
2288                         else
2289                                 drmach_board_dispose(bp);
2290                 }
2291         }
2292 
2293         rw_exit(&drmach_boards_rwlock);
2294 
2295         return (err);
2296 }
2297 
2298 sbd_error_t *
2299 drmach_board_poweron(drmachid_t id)
2300 {
2301         drmach_board_t  *bp;
2302         sbd_error_t *err = NULL;
2303         DRMACH_HANDLE hdl;
2304 
2305         if (!DRMACH_IS_BOARD_ID(id))
2306                 return (drerr_new(0, EX86_INAPPROP, NULL));
2307         bp = id;
2308 
2309         hdl = drmach_node_get_dnode(bp->tree);
2310         if (hdl == NULL)
2311                 return (drerr_new(0, EX86_INAPPROP, NULL));
2312 
2313         bp->powered = drmach_board_check_power(bp);
2314         if (bp->powered) {
2315                 return (NULL);
2316         }
2317 
2318         rw_enter(&drmach_boards_rwlock, RW_WRITER);
2319         err = drmach_board_check_dependent(SBD_CMD_POWERON, bp);
2320         if (err == NULL) {
2321                 acpidev_dr_lock_all();
2322                 if (ACPI_FAILURE(acpidev_dr_device_poweron(hdl)))
2323                         err = drerr_new(0, EX86_POWERON, NULL);
2324                 acpidev_dr_unlock_all();
2325 
2326                 /* Check whether the board is powered on. */
2327                 bp->powered = drmach_board_check_power(bp);
2328                 if (err == NULL && bp->powered == 0)
2329                         err = drerr_new(0, EX86_POWERON, NULL);
2330         }
2331         rw_exit(&drmach_boards_rwlock);
2332 
2333         return (err);
2334 }
2335 
2336 sbd_error_t *
2337 drmach_board_poweroff(drmachid_t id)
2338 {
2339         sbd_error_t     *err = NULL;
2340         drmach_board_t  *bp;
2341         drmach_status_t  stat;
2342         DRMACH_HANDLE    hdl;
2343 
2344         if (DRMACH_NULL_ID(id))
2345                 return (NULL);
2346 
2347         if (!DRMACH_IS_BOARD_ID(id))
2348                 return (drerr_new(0, EX86_INAPPROP, NULL));
2349         bp = id;
2350 
2351         hdl = drmach_node_get_dnode(bp->tree);
2352         if (hdl == NULL)
2353                 return (drerr_new(0, EX86_INAPPROP, NULL));
2354 
2355         /* Check whether the board is busy, configured or connected. */
2356         err = drmach_board_status(id, &stat);
2357         if (err != NULL)
2358                 return (err);
2359         if (stat.configured || stat.busy) {
2360                 return (drerr_new(0, EX86_CONFIGBUSY, bp->cm.name));
2361         } else if (bp->connected) {
2362                 return (drerr_new(0, EX86_CONNECTBUSY, bp->cm.name));
2363         }
2364 
2365         bp->powered = drmach_board_check_power(bp);
2366         if (bp->powered == 0) {
2367                 return (NULL);
2368         }
2369 
2370         rw_enter(&drmach_boards_rwlock, RW_WRITER);
2371         err = drmach_board_check_dependent(SBD_CMD_POWEROFF, bp);
2372         if (err == NULL) {
2373                 acpidev_dr_lock_all();
2374                 if (ACPI_FAILURE(acpidev_dr_device_poweroff(hdl)))
2375                         err = drerr_new(0, EX86_POWEROFF, NULL);
2376                 acpidev_dr_unlock_all();
2377 
2378                 bp->powered = drmach_board_check_power(bp);
2379                 if (err == NULL && bp->powered != 0)
2380                         err = drerr_new(0, EX86_POWEROFF, NULL);
2381         }
2382         rw_exit(&drmach_boards_rwlock);
2383 
2384         return (err);
2385 }
2386 
2387 sbd_error_t *
2388 drmach_board_test(drmachid_t id, drmach_opts_t *opts, int force)
2389 {
2390         _NOTE(ARGUNUSED(opts, force));
2391 
2392         drmach_board_t  *bp;
2393         DRMACH_HANDLE    hdl;
2394 
2395         if (DRMACH_NULL_ID(id))
2396                 return (NULL);
2397 
2398         if (!DRMACH_IS_BOARD_ID(id))
2399                 return (drerr_new(0, EX86_INAPPROP, NULL));
2400         bp = id;
2401 
2402         hdl = drmach_node_get_dnode(bp->tree);
2403         if (hdl == NULL)
2404                 return (drerr_new(0, EX86_INAPPROP, NULL));
2405 
2406         if (ACPI_FAILURE(acpidev_dr_device_check_status(hdl)))
2407                 return (drerr_new(0, EX86_IN_FAILURE, NULL));
2408 
2409         return (NULL);
2410 }
2411 
2412 sbd_error_t *
2413 drmach_board_connect(drmachid_t id, drmach_opts_t *opts)
2414 {
2415         _NOTE(ARGUNUSED(opts));
2416 
2417         sbd_error_t     *err = NULL;
2418         drmach_board_t  *bp = (drmach_board_t *)id;
2419         DRMACH_HANDLE   hdl;
2420 
2421         if (!DRMACH_IS_BOARD_ID(id))
2422                 return (drerr_new(0, EX86_INAPPROP, NULL));
2423         bp = (drmach_board_t *)id;
2424 
2425         hdl = drmach_node_get_dnode(bp->tree);
2426         if (hdl == NULL)
2427                 return (drerr_new(0, EX86_INAPPROP, NULL));
2428 
2429         rw_enter(&drmach_boards_rwlock, RW_WRITER);
2430         err = drmach_board_check_dependent(SBD_CMD_CONNECT, bp);
2431         if (err == NULL) {
2432                 acpidev_dr_lock_all();
2433                 if (ACPI_FAILURE(acpidev_dr_device_insert(hdl))) {
2434                         (void) acpidev_dr_device_remove(hdl);
2435                         err = drerr_new(1, EX86_PROBE, NULL);
2436                 } else {
2437                         bp->connected = 1;
2438                 }
2439                 acpidev_dr_unlock_all();
2440         }
2441         rw_exit(&drmach_boards_rwlock);
2442 
2443         return (err);
2444 }
2445 
2446 sbd_error_t *
2447 drmach_board_disconnect(drmachid_t id, drmach_opts_t *opts)
2448 {
2449         _NOTE(ARGUNUSED(opts));
2450 
2451         DRMACH_HANDLE hdl;
2452         drmach_board_t *bp;
2453         drmach_status_t stat;
2454         sbd_error_t *err = NULL;
2455 
2456         if (DRMACH_NULL_ID(id))
2457                 return (NULL);
2458         if (!DRMACH_IS_BOARD_ID(id))
2459                 return (drerr_new(0, EX86_INAPPROP, NULL));
2460         bp = (drmach_board_t *)id;
2461 
2462         hdl = drmach_node_get_dnode(bp->tree);
2463         if (hdl == NULL)
2464                 return (drerr_new(0, EX86_INAPPROP, NULL));
2465 
2466         /* Check whether the board is busy or configured. */
2467         err = drmach_board_status(id, &stat);
2468         if (err != NULL)
2469                 return (err);
2470         if (stat.configured || stat.busy)
2471                 return (drerr_new(0, EX86_CONFIGBUSY, bp->cm.name));
2472 
2473         rw_enter(&drmach_boards_rwlock, RW_WRITER);
2474         err = drmach_board_check_dependent(SBD_CMD_DISCONNECT, bp);
2475         if (err == NULL) {
2476                 acpidev_dr_lock_all();
2477                 if (ACPI_SUCCESS(acpidev_dr_device_remove(hdl))) {
2478                         bp->connected = 0;
2479                 } else {
2480                         err = drerr_new(1, EX86_DEPROBE, bp->cm.name);
2481                 }
2482                 acpidev_dr_unlock_all();
2483         }
2484         rw_exit(&drmach_boards_rwlock);
2485 
2486         return (err);
2487 }
2488 
2489 sbd_error_t *
2490 drmach_board_deprobe(drmachid_t id)
2491 {
2492         drmach_board_t  *bp;
2493 
2494         if (!DRMACH_IS_BOARD_ID(id))
2495                 return (drerr_new(0, EX86_INAPPROP, NULL));
2496         bp = id;
2497 
2498         cmn_err(CE_CONT, "DR: detach board %d\n", bp->bnum);
2499 
2500         if (bp->devices) {
2501                 drmach_array_dispose(bp->devices, drmach_device_dispose);
2502                 bp->devices = NULL;
2503         }
2504 
2505         bp->boot_board = 0;
2506 
2507         return (NULL);
2508 }
2509 
2510 /*
2511  * CPU specific interfaces to support dr driver
2512  */
2513 sbd_error_t *
2514 drmach_cpu_disconnect(drmachid_t id)
2515 {
2516         if (!DRMACH_IS_CPU_ID(id))
2517                 return (drerr_new(0, EX86_INAPPROP, NULL));
2518 
2519         return (NULL);
2520 }
2521 
2522 sbd_error_t *
2523 drmach_cpu_get_id(drmachid_t id, processorid_t *cpuid)
2524 {
2525         drmach_cpu_t *cpu;
2526 
2527         if (!DRMACH_IS_CPU_ID(id))
2528                 return (drerr_new(0, EX86_INAPPROP, NULL));
2529         cpu = (drmach_cpu_t *)id;
2530 
2531         if (cpu->cpuid == -1) {
2532                 if (ACPI_SUCCESS(acpica_get_cpu_id_by_object(
2533                     drmach_node_get_dnode(cpu->dev.node), cpuid))) {
2534                         cpu->cpuid = *cpuid;
2535                 } else {
2536                         *cpuid = -1;
2537                 }
2538         } else {
2539                 *cpuid = cpu->cpuid;
2540         }
2541 
2542         return (NULL);
2543 }
2544 
2545 sbd_error_t *
2546 drmach_cpu_get_impl(drmachid_t id, int *ip)
2547 {
2548         if (!DRMACH_IS_CPU_ID(id))
2549                 return (drerr_new(0, EX86_INAPPROP, NULL));
2550 
2551         /* Assume all CPUs in system are homogeneous. */
2552         *ip = X86_CPU_IMPL_UNKNOWN;
2553 
2554         kpreempt_disable();
2555         if (cpuid_getvendor(CPU) == X86_VENDOR_Intel) {
2556                 /* NHM-EX CPU */
2557                 if (cpuid_getfamily(CPU) == 0x6 &&
2558                     cpuid_getmodel(CPU) == 0x2e) {
2559                         *ip = X86_CPU_IMPL_NEHALEM_EX;
2560                 }
2561         }
2562         kpreempt_enable();
2563 
2564         return (NULL);
2565 }
2566 
2567 /*
2568  * Memory specific interfaces to support dr driver
2569  */
2570 
2571 /*
2572  * When drmach_mem_new() is called, the mp->base_pa field is set to the base
2573  * address of configured memory if there's configured memory on the board,
2574  * otherwise set to UINT64_MAX. For hot-added memory board, there's no
2575  * configured memory when drmach_mem_new() is called, so mp->base_pa is set
2576  * to UINT64_MAX and we need to set a correct value for it after memory
2577  * hot-add  operations.
2578  * A hot-added memory board may contain multiple memory segments,
2579  * drmach_mem_add_span() will be called once for each segment, so we can't
2580  * rely on the basepa argument. And it's possible that only part of a memory
2581  * segment is added into OS, so need to intersect with phys_installed list
2582  * to get the real base address of configured memory on the board.
2583  */
2584 sbd_error_t *
2585 drmach_mem_add_span(drmachid_t id, uint64_t basepa, uint64_t size)
2586 {
2587         _NOTE(ARGUNUSED(basepa));
2588 
2589         uint64_t        nbytes = 0;
2590         uint64_t        endpa;
2591         drmach_mem_t    *mp;
2592         struct memlist  *ml2;
2593         struct memlist  *p;
2594 
2595         ASSERT(size != 0);
2596 
2597         if (!DRMACH_IS_MEM_ID(id))
2598                 return (drerr_new(0, EX86_INAPPROP, NULL));
2599         mp = (drmach_mem_t *)id;
2600 
2601         /* Compute basepa and size of installed memory. */
2602         endpa = _ptob64(physmax + 1);
2603         memlist_read_lock();
2604         ml2 = memlist_dup(phys_install);
2605         memlist_read_unlock();
2606         ml2 = memlist_del_span(ml2, 0ull, mp->slice_base);
2607         if (ml2 && endpa > mp->slice_top) {
2608                 ml2 = memlist_del_span(ml2, mp->slice_top,
2609                     endpa - mp->slice_top);
2610         }
2611 
2612         ASSERT(ml2);
2613         if (ml2) {
2614                 for (p = ml2; p; p = p->ml_next) {
2615                         nbytes += p->ml_size;
2616                         if (mp->base_pa > p->ml_address)
2617                                 mp->base_pa = p->ml_address;
2618                 }
2619                 ASSERT(nbytes > 0);
2620                 mp->nbytes += nbytes;
2621                 memlist_delete(ml2);
2622         }
2623 
2624         return (NULL);
2625 }
2626 
2627 static sbd_error_t *
2628 drmach_mem_update_lgrp(drmachid_t id)
2629 {
2630         ACPI_STATUS     rc;
2631         DRMACH_HANDLE   hdl;
2632         void            *hdlp;
2633         drmach_mem_t    *mp;
2634         update_membounds_t umb;
2635 
2636         if (!DRMACH_IS_MEM_ID(id))
2637                 return (drerr_new(0, EX86_INAPPROP, NULL));
2638         mp = (drmach_mem_t *)id;
2639         /* No need to update lgrp if memory is already installed. */
2640         if (mp->nbytes != 0)
2641                 return (NULL);
2642         /* No need to update lgrp if lgrp is disabled. */
2643         if (max_mem_nodes == 1)
2644                 return (NULL);
2645 
2646         /* Add memory to lgroup */
2647         hdl = mp->dev.node->get_dnode(mp->dev.node);
2648         rc = acpidev_dr_device_get_memory_index(hdl, &umb.u_device_id);
2649         ASSERT(ACPI_SUCCESS(rc));
2650         if (ACPI_FAILURE(rc)) {
2651                 cmn_err(CE_WARN, "drmach: failed to get device id of memory, "
2652                     "can't update lgrp information.");
2653                 return (drerr_new(0, EX86_INTERNAL, NULL));
2654         }
2655         rc = acpidev_dr_get_mem_numa_info(hdl, mp->memlist, &hdlp,
2656             &umb.u_domain, &umb.u_sli_cnt, &umb.u_sli_ptr);
2657         ASSERT(ACPI_SUCCESS(rc));
2658         if (ACPI_FAILURE(rc)) {
2659                 cmn_err(CE_WARN, "drmach: failed to get lgrp info of memory, "
2660                     "can't update lgrp information.");
2661                 return (drerr_new(0, EX86_INTERNAL, NULL));
2662         }
2663         umb.u_base = (uint64_t)mp->slice_base;
2664         umb.u_length = (uint64_t)(mp->slice_top - mp->slice_base);
2665         lgrp_plat_config(LGRP_CONFIG_MEM_ADD, (uintptr_t)&umb);
2666         acpidev_dr_free_mem_numa_info(hdlp);
2667 
2668         return (NULL);
2669 }
2670 
2671 sbd_error_t *
2672 drmach_mem_enable(drmachid_t id)
2673 {
2674         if (!DRMACH_IS_MEM_ID(id))
2675                 return (drerr_new(0, EX86_INAPPROP, NULL));
2676         else
2677                 return (NULL);
2678 }
2679 
2680 sbd_error_t *
2681 drmach_mem_get_info(drmachid_t id, drmach_mem_info_t *mem)
2682 {
2683         drmach_mem_t *mp;
2684 
2685         if (!DRMACH_IS_MEM_ID(id))
2686                 return (drerr_new(0, EX86_INAPPROP, NULL));
2687         mp = (drmach_mem_t *)id;
2688 
2689         /*
2690          * This is only used by dr to round up/down the memory
2691          * for copying.
2692          */
2693         mem->mi_alignment_mask = mp->mem_alignment - 1;
2694         mem->mi_basepa = mp->base_pa;
2695         mem->mi_size = mp->nbytes;
2696         mem->mi_slice_base = mp->slice_base;
2697         mem->mi_slice_top = mp->slice_top;
2698         mem->mi_slice_size = mp->slice_size;
2699 
2700         return (NULL);
2701 }
2702 
2703 sbd_error_t *
2704 drmach_mem_get_slice_info(drmachid_t id,
2705     uint64_t *bp, uint64_t *ep, uint64_t *sp)
2706 {
2707         drmach_mem_t *mp;
2708 
2709         if (!DRMACH_IS_MEM_ID(id))
2710                 return (drerr_new(0, EX86_INAPPROP, NULL));
2711         mp = (drmach_mem_t *)id;
2712 
2713         if (bp)
2714                 *bp = mp->slice_base;
2715         if (ep)
2716                 *ep = mp->slice_top;
2717         if (sp)
2718                 *sp = mp->slice_size;
2719 
2720         return (NULL);
2721 }
2722 
2723 sbd_error_t *
2724 drmach_mem_get_memlist(drmachid_t id, struct memlist **ml)
2725 {
2726 #ifdef  DEBUG
2727         int             rv;
2728 #endif
2729         drmach_mem_t    *mem;
2730         struct memlist  *mlist;
2731 
2732         if (!DRMACH_IS_MEM_ID(id))
2733                 return (drerr_new(0, EX86_INAPPROP, NULL));
2734         mem = (drmach_mem_t *)id;
2735 
2736         mlist = memlist_dup(mem->memlist);
2737         *ml = mlist;
2738 
2739 #ifdef DEBUG
2740         /*
2741          * Make sure the incoming memlist doesn't already
2742          * intersect with what's present in the system (phys_install).
2743          */
2744         memlist_read_lock();
2745         rv = memlist_intersect(phys_install, mlist);
2746         memlist_read_unlock();
2747         if (rv) {
2748                 DRMACH_PR("Derived memlist intersects with phys_install\n");
2749                 memlist_dump(mlist);
2750 
2751                 DRMACH_PR("phys_install memlist:\n");
2752                 memlist_dump(phys_install);
2753 
2754                 memlist_delete(mlist);
2755                 return (DRMACH_INTERNAL_ERROR());
2756         }
2757 
2758         DRMACH_PR("Derived memlist:");
2759         memlist_dump(mlist);
2760 #endif
2761 
2762         return (NULL);
2763 }
2764 
2765 processorid_t
2766 drmach_mem_cpu_affinity(drmachid_t id)
2767 {
2768         _NOTE(ARGUNUSED(id));
2769 
2770         return (CPU_CURRENT);
2771 }
2772 
2773 int
2774 drmach_copy_rename_need_suspend(drmachid_t id)
2775 {
2776         _NOTE(ARGUNUSED(id));
2777 
2778         return (0);
2779 }
2780 
2781 /*
2782  * IO specific interfaces to support dr driver
2783  */
2784 sbd_error_t *
2785 drmach_io_pre_release(drmachid_t id)
2786 {
2787         if (!DRMACH_IS_IO_ID(id))
2788                 return (drerr_new(0, EX86_INAPPROP, NULL));
2789 
2790         return (NULL);
2791 }
2792 
2793 sbd_error_t *
2794 drmach_io_unrelease(drmachid_t id)
2795 {
2796         if (!DRMACH_IS_IO_ID(id))
2797                 return (drerr_new(0, EX86_INAPPROP, NULL));
2798 
2799         return (NULL);
2800 }
2801 
2802 sbd_error_t *
2803 drmach_io_post_release(drmachid_t id)
2804 {
2805         _NOTE(ARGUNUSED(id));
2806 
2807         return (NULL);
2808 }
2809 
2810 sbd_error_t *
2811 drmach_io_post_attach(drmachid_t id)
2812 {
2813         if (!DRMACH_IS_IO_ID(id))
2814                 return (drerr_new(0, EX86_INAPPROP, NULL));
2815 
2816         return (NULL);
2817 }
2818 
2819 sbd_error_t *
2820 drmach_io_is_attached(drmachid_t id, int *yes)
2821 {
2822         drmach_device_t *dp;
2823         dev_info_t      *dip;
2824         int             state;
2825 
2826         if (!DRMACH_IS_IO_ID(id))
2827                 return (drerr_new(0, EX86_INAPPROP, NULL));
2828         dp = id;
2829 
2830         dip = dp->node->getdip(dp->node);
2831         if (dip == NULL) {
2832                 *yes = 0;
2833                 return (NULL);
2834         }
2835 
2836         state = ddi_get_devstate(dip);
2837         *yes = ((i_ddi_node_state(dip) >= DS_ATTACHED) ||
2838             (state == DDI_DEVSTATE_UP));
2839 
2840         return (NULL);
2841 }
2842 
2843 /*
2844  * Miscellaneous interfaces to support dr driver
2845  */
2846 int
2847 drmach_verify_sr(dev_info_t *dip, int sflag)
2848 {
2849         _NOTE(ARGUNUSED(dip, sflag));
2850 
2851         return (0);
2852 }
2853 
2854 void
2855 drmach_suspend_last(void)
2856 {
2857 }
2858 
2859 void
2860 drmach_resume_first(void)
2861 {
2862 }
2863 
2864 /*
2865  * Log a DR sysevent.
2866  * Return value: 0 success, non-zero failure.
2867  */
2868 int
2869 drmach_log_sysevent(int board, char *hint, int flag, int verbose)
2870 {
2871         sysevent_t                      *ev = NULL;
2872         sysevent_id_t                   eid;
2873         int                             rv, km_flag;
2874         sysevent_value_t                evnt_val;
2875         sysevent_attr_list_t            *evnt_attr_list = NULL;
2876         sbd_error_t                     *err;
2877         char                            attach_pnt[MAXNAMELEN];
2878 
2879         km_flag = (flag == SE_SLEEP) ? KM_SLEEP : KM_NOSLEEP;
2880         attach_pnt[0] = '\0';
2881         err = drmach_board_name(board, attach_pnt, MAXNAMELEN);
2882         if (err != NULL) {
2883                 sbd_err_clear(&err);
2884                 rv = -1;
2885                 goto logexit;
2886         }
2887         if (verbose) {
2888                 DRMACH_PR("drmach_log_sysevent: %s %s, flag: %d, verbose: %d\n",
2889                     attach_pnt, hint, flag, verbose);
2890         }
2891 
2892         if ((ev = sysevent_alloc(EC_DR, ESC_DR_AP_STATE_CHANGE,
2893             SUNW_KERN_PUB"dr", km_flag)) == NULL) {
2894                 rv = -2;
2895                 goto logexit;
2896         }
2897         evnt_val.value_type = SE_DATA_TYPE_STRING;
2898         evnt_val.value.sv_string = attach_pnt;
2899         if ((rv = sysevent_add_attr(&evnt_attr_list, DR_AP_ID, &evnt_val,
2900             km_flag)) != 0)
2901                 goto logexit;
2902 
2903         evnt_val.value_type = SE_DATA_TYPE_STRING;
2904         evnt_val.value.sv_string = hint;
2905         if ((rv = sysevent_add_attr(&evnt_attr_list, DR_HINT, &evnt_val,
2906             km_flag)) != 0) {
2907                 sysevent_free_attr(evnt_attr_list);
2908                 goto logexit;
2909         }
2910 
2911         (void) sysevent_attach_attributes(ev, evnt_attr_list);
2912 
2913         /*
2914          * Log the event but do not sleep waiting for its
2915          * delivery. This provides insulation from syseventd.
2916          */
2917         rv = log_sysevent(ev, SE_NOSLEEP, &eid);
2918 
2919 logexit:
2920         if (ev)
2921                 sysevent_free(ev);
2922         if ((rv != 0) && verbose)
2923                 cmn_err(CE_WARN, "!drmach_log_sysevent failed (rv %d) for %s "
2924                     " %s\n", rv, attach_pnt, hint);
2925 
2926         return (rv);
2927 }