usr/src/uts/i86pc/io/acpi/acpidev/acpidev_cpu.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  * Copyright 2016 Nexenta Systems, Inc.
  26  */
  27 /*
  28  * Copyright (c) 2009-2010, Intel Corporation.
  29  * All rights reserved.
  30  */
  31
  32 /*
  33  * [Support of X2APIC]
  34  * According to the ACPI Spec, when using the X2APIC interrupt model, logical
  35  * processors with APIC ID values of 255 and greater are required to have a
  36  * Processor Device object and must convey the Processor's APIC information to
  37  * OSPM using the Processor Local X2APIC structure. Logical Processors with APIC
  38  * ID values less than 255 must use the Processor Local XAPIC structure to
  39  * convey their APIC information to OSPM.
  40  *
  41  * Some systems ignore that requirement of ACPI Spec and use Processor Local
  42  * X2APIC structures even for Logical Processors with APIC ID values less than
  43  * 255.
  44  */
  45
  46 #include <sys/types.h>
  47 #include <sys/atomic.h>
  48 #include <sys/bootconf.h>
  49 #include <sys/cpuvar.h>
  50 #include <sys/machsystm.h>
  51 #include <sys/note.h>
  52 #include <sys/psm_types.h>
  53 #include <sys/x86_archext.h>
  54 #include <sys/sunddi.h>
  55 #include <sys/sunndi.h>
  56 #include <sys/acpi/acpi.h>
  57 #include <sys/acpica.h>
  58 #include <sys/acpidev.h>
  59 #include <sys/acpidev_impl.h>
  60
  61 struct acpidev_cpu_map_item {
  62         uint32_t        proc_id;
  63         uint32_t        apic_id;
  64 };
  65
  66 struct acpidev_cpu_MAT_arg {
  67         boolean_t       found;
  68         boolean_t       enabled;
  69         uint32_t        proc_id;
  70         uint32_t        apic_id;
  71 };
  72
  73 static ACPI_STATUS acpidev_cpu_pre_probe(acpidev_walk_info_t *infop);
  74 static ACPI_STATUS acpidev_cpu_post_probe(acpidev_walk_info_t *infop);
  75 static ACPI_STATUS acpidev_cpu_probe(acpidev_walk_info_t *infop);
  76 static acpidev_filter_result_t acpidev_cpu_filter(acpidev_walk_info_t *infop,
  77     char *devname, int maxlen);
  78 static ACPI_STATUS acpidev_cpu_init(acpidev_walk_info_t *infop);
  79 static void acpidev_cpu_fini(ACPI_HANDLE hdl, acpidev_data_handle_t dhdl,
  80     acpidev_class_t *clsp);
  81
  82 static acpidev_filter_result_t acpidev_cpu_filter_func(
  83     acpidev_walk_info_t *infop, ACPI_HANDLE hdl, acpidev_filter_rule_t *afrp,
  84     char *devname, int len);
  85 static int acpidev_cpu_create_dip(cpu_t *, dev_info_t **);
  86 static int acpidev_cpu_get_dip(cpu_t *, dev_info_t **);
  87
  88 /*
  89  * Default class driver for ACPI processor/CPU objects.
  90  */
  91 acpidev_class_t acpidev_class_cpu = {
  92         0,                              /* adc_refcnt */
  93         ACPIDEV_CLASS_REV1,             /* adc_version */
  94         ACPIDEV_CLASS_ID_CPU,           /* adc_class_id */
  95         "ACPI CPU",                     /* adc_class_name */
  96         ACPIDEV_TYPE_CPU,               /* adc_dev_type */
  97         NULL,                           /* adc_private */
  98         acpidev_cpu_pre_probe,          /* adc_pre_probe */
  99         acpidev_cpu_post_probe,         /* adc_post_probe */
 100         acpidev_cpu_probe,              /* adc_probe */
 101         acpidev_cpu_filter,             /* adc_filter */
 102         acpidev_cpu_init,               /* adc_init */
 103         acpidev_cpu_fini,               /* adc_fini */
 104 };
 105
 106 /*
 107  * List of class drivers which will be called in order when handling
 108  * children of ACPI cpu/processor objects.
 109  */
 110 acpidev_class_list_t *acpidev_class_list_cpu = NULL;
 111
 112 /* Filter rule table for the first probe at boot time. */
 113 static acpidev_filter_rule_t acpidev_cpu_filters[] = {
 114         {       /* Skip all processors under root node, should be there. */
 115                 NULL,
 116                 0,
 117                 ACPIDEV_FILTER_SKIP,
 118                 NULL,
 119                 1,
 120                 1,
 121                 NULL,
 122                 NULL,
 123         },
 124         {       /* Create and scan other processor objects */
 125                 acpidev_cpu_filter_func,
 126                 0,
 127                 ACPIDEV_FILTER_DEFAULT,
 128                 &acpidev_class_list_cpu,
 129                 2,
 130                 INT_MAX,
 131                 NULL,
 132                 ACPIDEV_NODE_NAME_CPU,
 133         }
 134 };
 135
 136 /* ACPI/PNP hardware id for processor. */
 137 static char *acpidev_processor_device_ids[] = {
 138         ACPIDEV_HID_CPU,
 139 };
 140
 141 static char *acpidev_cpu_uid_formats[] = {
 142         "SCK%x-CPU%x",
 143 };
 144
 145 static ACPI_HANDLE acpidev_cpu_map_hdl;
 146 static uint32_t acpidev_cpu_map_count;
 147 static struct acpidev_cpu_map_item *acpidev_cpu_map;
 148
 149 extern int (*psm_cpu_create_devinfo)(cpu_t *, dev_info_t **);
 150 static int (*psm_cpu_create_devinfo_old)(cpu_t *, dev_info_t **);
 151 extern int (*psm_cpu_get_devinfo)(cpu_t *, dev_info_t **);
 152 static int (*psm_cpu_get_devinfo_old)(cpu_t *, dev_info_t **);
 153
 154 /* Count how many enabled CPUs are in the MADT table. */
 155 static ACPI_STATUS
 156 acpidev_cpu_count_MADT(ACPI_SUBTABLE_HEADER *ap, void *context)
 157 {
 158         uint32_t *cntp;
 159         ACPI_MADT_LOCAL_APIC *mpa;
 160         ACPI_MADT_LOCAL_X2APIC *mpx2a;
 161
 162         cntp = (uint32_t *)context;
 163         switch (ap->Type) {
 164         case ACPI_MADT_TYPE_LOCAL_APIC:
 165                 mpa = (ACPI_MADT_LOCAL_APIC *)ap;
 166                 if (mpa->LapicFlags & ACPI_MADT_ENABLED) {
 167                         ASSERT(mpa->Id != 255);
 168                         (*cntp)++;
 169                 }
 170                 break;
 171
 172         case ACPI_MADT_TYPE_LOCAL_X2APIC:
 173                 mpx2a = (ACPI_MADT_LOCAL_X2APIC *)ap;
 174                 if ((mpx2a->LapicFlags & ACPI_MADT_ENABLED)) {
 175                         (*cntp)++;
 176                 }
 177                 break;
 178
 179         default:
 180                 break;
 181         }
 182
 183         return (AE_OK);
 184 }
 185
 186 /* Extract information from the enabled CPUs using the MADT table. */
 187 static ACPI_STATUS
 188 acpidev_cpu_parse_MADT(ACPI_SUBTABLE_HEADER *ap, void *context)
 189 {
 190         uint32_t *cntp;
 191         ACPI_MADT_LOCAL_APIC *mpa;
 192         ACPI_MADT_LOCAL_X2APIC *mpx2a;
 193
 194         cntp = (uint32_t *)context;
 195         switch (ap->Type) {
 196         case ACPI_MADT_TYPE_LOCAL_APIC:
 197                 mpa = (ACPI_MADT_LOCAL_APIC *)ap;
 198                 if (mpa->LapicFlags & ACPI_MADT_ENABLED) {
 199                         ASSERT(mpa->Id != 255);
 200                         ASSERT(*cntp < acpidev_cpu_map_count);
 201                         acpidev_cpu_map[*cntp].proc_id = mpa->ProcessorId;
 202                         acpidev_cpu_map[*cntp].apic_id = mpa->Id;
 203                         (*cntp)++;
 204                 }
 205                 break;
 206
 207         case ACPI_MADT_TYPE_LOCAL_X2APIC:
 208                 mpx2a = (ACPI_MADT_LOCAL_X2APIC *)ap;
 209                 /* See comment at beginning about 255 limitation. */
 210                 if (mpx2a->LocalApicId < 255) {
 211                         ACPIDEV_DEBUG(CE_WARN,
 212                             "!acpidev: encountered CPU with X2APIC Id < 255.");
 213                 }
 214                 if (mpx2a->LapicFlags & ACPI_MADT_ENABLED) {
 215                         ASSERT(*cntp < acpidev_cpu_map_count);
 216                         acpidev_cpu_map[*cntp].proc_id = mpx2a->Uid;
 217                         acpidev_cpu_map[*cntp].apic_id = mpx2a->LocalApicId;
 218                         (*cntp)++;
 219                 }
 220                 break;
 221
 222         default:
 223                 break;
 224         }
 225
 226         return (AE_OK);
 227 }
 228
 229 static ACPI_STATUS
 230 acpidev_cpu_get_apicid(uint32_t procid, uint32_t *apicidp)
 231 {
 232         uint32_t i;
 233
 234         for (i = 0; i < acpidev_cpu_map_count; i++) {
 235                 if (acpidev_cpu_map[i].proc_id == procid) {
 236                         *apicidp = acpidev_cpu_map[i].apic_id;
 237                         return (AE_OK);
 238                 }
 239         }
 240
 241         return (AE_NOT_FOUND);
 242 }
 243
 244 /*
 245  * Extract information for enabled CPUs from the buffer returned
 246  * by the _MAT method.
 247  */
 248 static ACPI_STATUS
 249 acpidev_cpu_query_MAT(ACPI_SUBTABLE_HEADER *ap, void *context)
 250 {
 251         ACPI_MADT_LOCAL_APIC *mpa;
 252         ACPI_MADT_LOCAL_X2APIC *mpx2a;
 253         struct acpidev_cpu_MAT_arg *rp;
 254
 255         rp = (struct acpidev_cpu_MAT_arg *)context;
 256         switch (ap->Type) {
 257         case ACPI_MADT_TYPE_LOCAL_APIC:
 258                 mpa = (ACPI_MADT_LOCAL_APIC *)ap;
 259                 rp->found = B_TRUE;
 260                 rp->proc_id = mpa->ProcessorId;
 261                 rp->apic_id = mpa->Id;
 262                 if (mpa->LapicFlags & ACPI_MADT_ENABLED) {
 263                         ASSERT(mpa->Id != 255);
 264                         rp->enabled = B_TRUE;
 265                 } else {
 266                         rp->enabled = B_FALSE;
 267                 }
 268                 return (AE_CTRL_TERMINATE);
 269
 270         case ACPI_MADT_TYPE_LOCAL_X2APIC:
 271                 mpx2a = (ACPI_MADT_LOCAL_X2APIC *)ap;
 272                 if (mpx2a->LocalApicId < 255) {
 273                         ACPIDEV_DEBUG(CE_WARN, "!acpidev: encountered CPU "
 274                             "with X2APIC Id < 255 in _MAT.");
 275                 }
 276                 rp->found = B_TRUE;
 277                 rp->proc_id = mpx2a->Uid;
 278                 rp->apic_id = mpx2a->LocalApicId;
 279                 if (mpx2a->LapicFlags & ACPI_MADT_ENABLED) {
 280                         rp->enabled = B_TRUE;
 281                 } else {
 282                         rp->enabled = B_FALSE;
 283                 }
 284                 return (AE_CTRL_TERMINATE);
 285
 286         case ACPI_MADT_TYPE_LOCAL_APIC_NMI:
 287                 /* UNIMPLEMENTED */
 288                 break;
 289
 290         case ACPI_MADT_TYPE_LOCAL_X2APIC_NMI:
 291                 /* UNIMPLEMENTED */
 292                 break;
 293
 294         default:
 295                 /*
 296                  * According to the ACPI Spec, the buffer returned by _MAT
 297                  * for a processor object should only contain Local APIC,
 298                  * Local SAPIC, and local APIC NMI entries.
 299                  * x2APIC Specification extends it to support Processor
 300                  * x2APIC and x2APIC NMI Structure.
 301                  */
 302                 ACPIDEV_DEBUG(CE_NOTE,
 303                     "!acpidev: unknown APIC entry type %u in _MAT.", ap->Type);
 304                 break;
 305         }
 306
 307         return (AE_OK);
 308 }
 309
 310 /*
 311  * Query ACPI processor ID by evaluating ACPI _MAT, _UID, and PROCESSOR
 312  * objects.
 313  */
 314 static ACPI_STATUS
 315 acpidev_cpu_get_procid(acpidev_walk_info_t *infop, uint32_t *idp)
 316 {
 317         int id;
 318         ACPI_HANDLE hdl;
 319         struct acpidev_cpu_MAT_arg mat;
 320
 321         if (infop->awi_info->Type != ACPI_TYPE_PROCESSOR &&
 322             infop->awi_info->Type != ACPI_TYPE_DEVICE) {
 323                 ACPIDEV_DEBUG(CE_WARN,
 324                     "!acpidev: object %s is not PROCESSOR or DEVICE.",
 325                     infop->awi_name);
 326                 return (AE_BAD_PARAMETER);
 327         }
 328         hdl = infop->awi_hdl;
 329
 330         /*
 331          * First try to evaluate _MAT.
 332          * According to the ACPI Spec3.0b, it's legal for ACPI PROCESSOR objects
 333          * to have ACPI method objects.
 334          */
 335         bzero(&mat, sizeof (mat));
 336         (void) acpidev_walk_apic(NULL, hdl, ACPIDEV_METHOD_NAME_MAT,
 337             acpidev_cpu_query_MAT, &mat);
 338         if (mat.found) {
 339                 *idp = mat.proc_id;
 340                 return (AE_OK);
 341         }
 342
 343         /* Then evalute PROCESSOR object. */
 344         if (infop->awi_info->Type == ACPI_TYPE_PROCESSOR) {
 345                 ACPI_BUFFER rb;
 346
 347                 rb.Pointer = NULL;
 348                 rb.Length = ACPI_ALLOCATE_BUFFER;
 349                 if (ACPI_SUCCESS(AcpiEvaluateObjectTyped(hdl, NULL, NULL, &rb,
 350                     ACPI_TYPE_PROCESSOR))) {
 351                         *idp = ((ACPI_OBJECT *)rb.Pointer)->Processor.ProcId;
 352                         AcpiOsFree(rb.Pointer);
 353                         return (AE_OK);
 354                 } else {
 355                         ACPIDEV_DEBUG(CE_WARN,
 356                             "!acpidev: failed to evaluate ACPI object %s.",
 357                             infop->awi_name);
 358                 }
 359         }
 360
 361         /*
 362          * Finally, try to evalute the _UID method.
 363          * According to the ACPI Spec3.0b, it's legal for ACPI PROCESSOR objects
 364          * to have ACPI method objects.
 365          * The CPU _UID method should return Processor Id as an integer on x86.
 366          */
 367         if (ACPI_SUCCESS(acpica_eval_int(hdl, METHOD_NAME__UID, &id))) {
 368                 *idp = id;
 369                 return (AE_OK);
 370         }
 371
 372         return (AE_NOT_FOUND);
 373 }
 374
 375 static ACPI_STATUS
 376 acpidev_cpu_get_proximity_id(ACPI_HANDLE hdl, uint32_t apicid, uint32_t *pxmidp)
 377 {
 378         int len, off;
 379         ACPI_SUBTABLE_HEADER *sp;
 380         ACPI_SRAT_CPU_AFFINITY *xp;
 381         ACPI_SRAT_X2APIC_CPU_AFFINITY *x2p;
 382
 383         ASSERT(hdl != NULL);
 384         ASSERT(pxmidp != NULL);
 385         *pxmidp = UINT32_MAX;
 386
 387         if (ACPI_SUCCESS(acpidev_eval_pxm(hdl, pxmidp))) {
 388                 return (AE_OK);
 389         }
 390         if (acpidev_srat_tbl_ptr == NULL) {
 391                 return (AE_NOT_FOUND);
 392         }
 393
 394         /* Search the static ACPI SRAT table for proximity domain id. */
 395         sp = (ACPI_SUBTABLE_HEADER *)(acpidev_srat_tbl_ptr + 1);
 396         len = acpidev_srat_tbl_ptr->Header.Length;
 397         off = sizeof (*acpidev_srat_tbl_ptr);
 398         while (off < len) {
 399                 switch (sp->Type) {
 400                 case ACPI_SRAT_TYPE_CPU_AFFINITY:
 401                         xp = (ACPI_SRAT_CPU_AFFINITY *)sp;
 402                         if ((xp->Flags & ACPI_SRAT_CPU_ENABLED) &&
 403                             xp->ApicId == apicid) {
 404                                 *pxmidp = xp->ProximityDomainLo;
 405                                 *pxmidp |= xp->ProximityDomainHi[0] << 8;
 406                                 *pxmidp |= xp->ProximityDomainHi[1] << 16;
 407                                 *pxmidp |= xp->ProximityDomainHi[2] << 24;
 408                                 return (AE_OK);
 409                         }
 410                         break;
 411
 412                 case ACPI_SRAT_TYPE_X2APIC_CPU_AFFINITY:
 413                         x2p = (ACPI_SRAT_X2APIC_CPU_AFFINITY *)sp;
 414                         if ((x2p->Flags & ACPI_SRAT_CPU_ENABLED) &&
 415                             x2p->ApicId == apicid) {
 416                                 *pxmidp = x2p->ProximityDomain;
 417                                 return (AE_OK);
 418                         }
 419                         break;
 420                 }
 421                 off += sp->Length;
 422                 sp = (ACPI_SUBTABLE_HEADER *)(((char *)sp) + sp->Length);
 423         }
 424
 425         return (AE_NOT_FOUND);
 426 }
 427
 428 static ACPI_STATUS
 429 acpidev_cpu_pre_probe(acpidev_walk_info_t *infop)
 430 {
 431         uint32_t count = 0;
 432
 433         /* Parse and cache APIC info in MADT on the first probe at boot time. */
 434         ASSERT(infop != NULL);
 435         if (infop->awi_op_type == ACPIDEV_OP_BOOT_PROBE &&
 436             acpidev_cpu_map_hdl == NULL) {
 437                 /* Parse CPU relative information in the ACPI MADT table. */
 438                 (void) acpidev_walk_apic(NULL, NULL, NULL,
 439                     acpidev_cpu_count_MADT, &acpidev_cpu_map_count);
 440                 acpidev_cpu_map = kmem_zalloc(sizeof (acpidev_cpu_map[0])
 441                     * acpidev_cpu_map_count, KM_SLEEP);
 442                 (void) acpidev_walk_apic(NULL, NULL, NULL,
 443                     acpidev_cpu_parse_MADT, &count);
 444                 ASSERT(count == acpidev_cpu_map_count);
 445                 acpidev_cpu_map_hdl = infop->awi_hdl;
 446
 447                 /* Cache pointer to the ACPI SRAT table. */
 448                 if (ACPI_FAILURE(AcpiGetTable(ACPI_SIG_SRAT, 1,
 449                     (ACPI_TABLE_HEADER **)&acpidev_srat_tbl_ptr))) {
 450                         acpidev_srat_tbl_ptr = NULL;
 451                 }
 452         }
 453
 454         return (AE_OK);
 455 }
 456
 457 static ACPI_STATUS
 458 acpidev_cpu_post_probe(acpidev_walk_info_t *infop)
 459 {
 460         /* Free cached APIC info on the second probe at boot time. */
 461         ASSERT(infop != NULL);
 462         if (infop->awi_op_type == ACPIDEV_OP_BOOT_REPROBE &&
 463             acpidev_cpu_map_hdl != NULL &&
 464             infop->awi_hdl == acpidev_cpu_map_hdl) {
 465                 if (acpidev_cpu_map != NULL && acpidev_cpu_map_count != 0) {
 466                         kmem_free(acpidev_cpu_map, sizeof (acpidev_cpu_map[0])
 467                             * acpidev_cpu_map_count);
 468                 }
 469                 acpidev_cpu_map = NULL;
 470                 acpidev_cpu_map_count = 0;
 471                 acpidev_cpu_map_hdl = NULL;
 472
 473                 /* replace psm_cpu_create_devinfo with local implementation. */
 474                 psm_cpu_create_devinfo_old = psm_cpu_create_devinfo;
 475                 psm_cpu_create_devinfo = acpidev_cpu_create_dip;
 476                 psm_cpu_get_devinfo_old = psm_cpu_get_devinfo;
 477                 psm_cpu_get_devinfo = acpidev_cpu_get_dip;
 478         }
 479
 480         return (AE_OK);
 481 }
 482
 483 static ACPI_STATUS
 484 acpidev_cpu_probe(acpidev_walk_info_t *infop)
 485 {
 486         ACPI_STATUS rc = AE_OK;
 487         int flags;
 488
 489         ASSERT(infop != NULL);
 490         ASSERT(infop->awi_hdl != NULL);
 491         ASSERT(infop->awi_info != NULL);
 492         ASSERT(infop->awi_class_curr == &acpidev_class_cpu);
 493         if (infop->awi_info->Type != ACPI_TYPE_PROCESSOR &&
 494             (infop->awi_info->Type != ACPI_TYPE_DEVICE ||
 495             acpidev_match_device_id(infop->awi_info,
 496             ACPIDEV_ARRAY_PARAM(acpidev_processor_device_ids)) == 0)) {
 497                 return (AE_OK);
 498         }
 499
 500         flags = ACPIDEV_PROCESS_FLAG_SCAN;
 501         switch (infop->awi_op_type) {
 502         case  ACPIDEV_OP_BOOT_PROBE:
 503                 /*
 504                  * Mark device as offline. It will be changed to online state
 505                  * when the corresponding CPU starts up.
 506                  */
 507                 if (acpica_get_devcfg_feature(ACPI_DEVCFG_CPU)) {
 508                         flags |= ACPIDEV_PROCESS_FLAG_CREATE |
 509                             ACPIDEV_PROCESS_FLAG_OFFLINE;
 510                 }
 511                 break;
 512
 513         case ACPIDEV_OP_BOOT_REPROBE:
 514                 break;
 515
 516         case ACPIDEV_OP_HOTPLUG_PROBE:
 517                 if (acpica_get_devcfg_feature(ACPI_DEVCFG_CPU)) {
 518                         flags |= ACPIDEV_PROCESS_FLAG_CREATE |
 519                             ACPIDEV_PROCESS_FLAG_OFFLINE |
 520                             ACPIDEV_PROCESS_FLAG_SYNCSTATUS |
 521                             ACPIDEV_PROCESS_FLAG_HOLDBRANCH;
 522                 }
 523                 break;
 524
 525         default:
 526                 ACPIDEV_DEBUG(CE_WARN, "!acpidev: unknown operation type %u in "
 527                     "acpidev_cpu_probe().", infop->awi_op_type);
 528                 rc = AE_BAD_PARAMETER;
 529                 break;
 530         }
 531
 532         if (rc == AE_OK) {
 533                 rc = acpidev_process_object(infop, flags);
 534         }
 535         if (ACPI_FAILURE(rc) && rc != AE_NOT_EXIST && rc != AE_ALREADY_EXISTS) {
 536                 cmn_err(CE_WARN,
 537                     "!acpidev: failed to process processor object %s.",
 538                     infop->awi_name);
 539         } else {
 540                 rc = AE_OK;
 541         }
 542
 543         return (rc);
 544 }
 545
 546 static acpidev_filter_result_t
 547 acpidev_cpu_filter_func(acpidev_walk_info_t *infop, ACPI_HANDLE hdl,
 548     acpidev_filter_rule_t *afrp, char *devname, int len)
 549 {
 550         acpidev_filter_result_t res;
 551
 552         ASSERT(afrp != NULL);
 553         if (infop->awi_op_type == ACPIDEV_OP_BOOT_PROBE ||
 554             infop->awi_op_type == ACPIDEV_OP_BOOT_REPROBE) {
 555                 uint32_t procid;
 556                 uint32_t apicid;
 557
 558                 if (acpidev_cpu_get_procid(infop, &procid) != 0) {
 559                         ACPIDEV_DEBUG(CE_WARN,
 560                             "!acpidev: failed to query processor id for %s.",
 561                             infop->awi_name);
 562                         return (ACPIDEV_FILTER_SKIP);
 563                 } else if (acpidev_cpu_get_apicid(procid, &apicid) != 0) {
 564                         ACPIDEV_DEBUG(CE_WARN,
 565                             "!acpidev: failed to query apic id for %s.",
 566                             infop->awi_name);
 567                         return (ACPIDEV_FILTER_SKIP);
 568                 }
 569
 570                 infop->awi_scratchpad[0] = procid;
 571                 infop->awi_scratchpad[1] = apicid;
 572         } else if (infop->awi_op_type == ACPIDEV_OP_HOTPLUG_PROBE) {
 573                 struct acpidev_cpu_MAT_arg mat;
 574
 575                 bzero(&mat, sizeof (mat));
 576                 (void) acpidev_walk_apic(NULL, hdl, ACPIDEV_METHOD_NAME_MAT,
 577                     acpidev_cpu_query_MAT, &mat);
 578                 if (!mat.found) {
 579                         cmn_err(CE_WARN,
 580                             "!acpidev: failed to walk apic resource for %s.",
 581                             infop->awi_name);
 582                         return (ACPIDEV_FILTER_SKIP);
 583                 } else if (!mat.enabled) {
 584                         ACPIDEV_DEBUG(CE_NOTE,
 585                             "!acpidev: CPU %s has been disabled.",
 586                             infop->awi_name);
 587                         return (ACPIDEV_FILTER_SKIP);
 588                 }
 589                 /* Save processor id and APIC id in scratchpad memory. */
 590                 infop->awi_scratchpad[0] = mat.proc_id;
 591                 infop->awi_scratchpad[1] = mat.apic_id;
 592         }
 593
 594         res = acpidev_filter_default(infop, hdl, afrp, devname, len);
 595
 596         return (res);
 597 }
 598
 599 static acpidev_filter_result_t
 600 acpidev_cpu_filter(acpidev_walk_info_t *infop, char *devname, int maxlen)
 601 {
 602         acpidev_filter_result_t res;
 603
 604         ASSERT(infop != NULL);
 605         ASSERT(devname == NULL || maxlen >= ACPIDEV_MAX_NAMELEN);
 606         if (infop->awi_op_type == ACPIDEV_OP_BOOT_PROBE ||
 607             infop->awi_op_type == ACPIDEV_OP_BOOT_REPROBE ||
 608             infop->awi_op_type == ACPIDEV_OP_HOTPLUG_PROBE) {
 609                 res = acpidev_filter_device(infop, infop->awi_hdl,
 610                     ACPIDEV_ARRAY_PARAM(acpidev_cpu_filters), devname, maxlen);
 611         } else {
 612                 res = ACPIDEV_FILTER_FAILED;
 613         }
 614
 615         return (res);
 616 }
 617
 618 static ACPI_STATUS
 619 acpidev_cpu_init(acpidev_walk_info_t *infop)
 620 {
 621         int count;
 622         uint32_t pxmid;
 623         dev_info_t *dip;
 624         ACPI_HANDLE hdl;
 625         char unitaddr[64];
 626         char **compatpp;
 627         static char *compatible[] = {
 628                 ACPIDEV_HID_PROCESSOR,
 629                 ACPIDEV_TYPE_CPU,
 630                 "cpu"
 631         };
 632
 633         ASSERT(infop != NULL);
 634         dip = infop->awi_dip;
 635         hdl = infop->awi_hdl;
 636
 637         /* Create "apic_id", "processor_id" and "proximity_id" properties. */
 638         if (ndi_prop_update_int(DDI_DEV_T_NONE, dip,
 639             ACPIDEV_PROP_NAME_PROCESSOR_ID, infop->awi_scratchpad[0]) !=
 640             NDI_SUCCESS) {
 641                 cmn_err(CE_WARN,
 642                     "!acpidev: failed to set processor_id property for %s.",
 643                     infop->awi_name);
 644                 return (AE_ERROR);
 645         }
 646         if (ndi_prop_update_int(DDI_DEV_T_NONE, dip,
 647             ACPIDEV_PROP_NAME_LOCALAPIC_ID, infop->awi_scratchpad[1]) !=
 648             NDI_SUCCESS) {
 649                 cmn_err(CE_WARN,
 650                     "!acpidev: failed to set apic_id property for %s.",
 651                     infop->awi_name);
 652                 return (AE_ERROR);
 653         }
 654         if (ACPI_SUCCESS(acpidev_cpu_get_proximity_id(infop->awi_hdl,
 655             infop->awi_scratchpad[1], &pxmid))) {
 656                 if (ndi_prop_update_int(DDI_DEV_T_NONE, dip,
 657                     ACPIDEV_PROP_NAME_PROXIMITY_ID, pxmid) != NDI_SUCCESS) {
 658                         cmn_err(CE_WARN, "!acpidev: failed to set proximity id "
 659                             "property for %s.", infop->awi_name);
 660                         return (AE_ERROR);
 661                 }
 662         }
 663
 664         /* Set "compatible" property for CPU dip */
 665         count = sizeof (compatible) / sizeof (compatible[0]);
 666         if (infop->awi_info->Type == ACPI_TYPE_PROCESSOR) {
 667                 compatpp = compatible;
 668         } else if (infop->awi_info->Type == ACPI_TYPE_DEVICE) {
 669                 /*
 670                  * skip first item for pseudo processor HID.
 671                  * acpidev_set_compatible() will handle HID/CID for CPU device.
 672                  */
 673                 compatpp = &compatible[1];
 674                 count--;
 675         } else {
 676                 return (AE_BAD_PARAMETER);
 677         }
 678         if (ACPI_FAILURE(acpidev_set_compatible(infop, compatpp, count))) {
 679                 return (AE_ERROR);
 680         }
 681
 682         /*
 683          * Set device unit-address property.
 684          * First try to generate meaningful unit address from _UID,
 685          * then use Processor Id if that fails.
 686          */
 687         if ((infop->awi_info->Valid & ACPI_VALID_UID) == 0 ||
 688             acpidev_generate_unitaddr(infop->awi_info->UniqueId.String,
 689             ACPIDEV_ARRAY_PARAM(acpidev_cpu_uid_formats),
 690             unitaddr, sizeof (unitaddr)) == NULL) {
 691                 (void) snprintf(unitaddr, sizeof (unitaddr), "%u",
 692                     (uint32_t)infop->awi_scratchpad[0]);
 693         }
 694         if (ACPI_FAILURE(acpidev_set_unitaddr(infop, NULL, 0, unitaddr))) {
 695                 return (AE_ERROR);
 696         }
 697
 698         /*
 699          * Build binding information for CPUs.
 700          */
 701         if (infop->awi_op_type == ACPIDEV_OP_BOOT_PROBE ||
 702             infop->awi_op_type == ACPIDEV_OP_BOOT_REPROBE ||
 703             infop->awi_op_type == ACPIDEV_OP_HOTPLUG_PROBE) {
 704                 if (ACPI_FAILURE(acpica_add_processor_to_map(
 705                     infop->awi_scratchpad[0], hdl, infop->awi_scratchpad[1]))) {
 706                         cmn_err(CE_WARN, "!acpidev: failed to bind processor "
 707                             "id/object handle for %s.", infop->awi_name);
 708                         return (AE_ERROR);
 709                 }
 710         } else {
 711                 ACPIDEV_DEBUG(CE_WARN,
 712                     "!acpidev: unknown operation type %u in acpidev_cpu_init.",
 713                     infop->awi_op_type);
 714                 return (AE_BAD_PARAMETER);
 715         }
 716
 717         return (AE_OK);
 718 }
 719
 720 static void
 721 acpidev_cpu_fini(ACPI_HANDLE hdl, acpidev_data_handle_t dhdl,
 722     acpidev_class_t *clsp)
 723 {
 724         _NOTE(ARGUNUSED(clsp, dhdl));
 725
 726         int rc;
 727         uint32_t procid;
 728
 729         rc = acpica_get_procid_by_object(hdl, &procid);
 730         ASSERT(ACPI_SUCCESS(rc));
 731         if (ACPI_SUCCESS(rc)) {
 732                 rc = acpica_remove_processor_from_map(procid);
 733                 ASSERT(ACPI_SUCCESS(rc));
 734                 if (ACPI_FAILURE(rc)) {
 735                         cmn_err(CE_WARN, "!acpidev: failed to remove "
 736                             "processor from ACPICA.");
 737                 }
 738         }
 739 }
 740
 741 /*
 742  * Lookup the dip for a CPU if ACPI CPU autoconfig is enabled.
 743  */
 744 static int
 745 acpidev_cpu_lookup_dip(cpu_t *cp, dev_info_t **dipp)
 746 {
 747         uint32_t apicid;
 748         ACPI_HANDLE hdl;
 749         dev_info_t *dip = NULL;
 750
 751         *dipp = NULL;
 752         if (acpica_get_devcfg_feature(ACPI_DEVCFG_CPU)) {
 753                 apicid = cpuid_get_apicid(cp);
 754                 if (acpica_get_cpu_object_by_cpuid(cp->cpu_id, &hdl) == 0 ||
 755                     (apicid != UINT32_MAX &&
 756                     acpica_get_cpu_object_by_apicid(apicid, &hdl) == 0)) {
 757                         ASSERT(hdl != NULL);
 758                         if (ACPI_SUCCESS(acpica_get_devinfo(hdl, &dip))) {
 759                                 ASSERT(dip != NULL);
 760                                 *dipp = dip;
 761                                 return (PSM_SUCCESS);
 762                         }
 763                 }
 764                 ACPIDEV_DEBUG(CE_WARN,
 765                     "!acpidev: failed to lookup dip for cpu %d(%p).",
 766                     cp->cpu_id, (void *)cp);
 767         }
 768
 769         return (PSM_FAILURE);
 770 }
 771
 772 static int
 773 acpidev_cpu_create_dip(cpu_t *cp, dev_info_t **dipp)
 774 {
 775         if (acpidev_cpu_lookup_dip(cp, dipp) == PSM_SUCCESS) {
 776                 ndi_hold_devi(*dipp);
 777                 return (PSM_SUCCESS);
 778         }
 779         if (psm_cpu_create_devinfo_old != NULL) {
 780                 return (psm_cpu_create_devinfo_old(cp, dipp));
 781         } else {
 782                 return (PSM_FAILURE);
 783         }
 784 }
 785
 786 static int
 787 acpidev_cpu_get_dip(cpu_t *cp, dev_info_t **dipp)
 788 {
 789         if (acpidev_cpu_lookup_dip(cp, dipp) == PSM_SUCCESS) {
 790                 return (PSM_SUCCESS);
 791         }
 792         if (psm_cpu_get_devinfo_old != NULL) {
 793                 return (psm_cpu_get_devinfo_old(cp, dipp));
 794         } else {
 795                 return (PSM_FAILURE);
 796         }
 797 }