17c478bd9Sstevel@tonic-gate /* 28e56767dSsmall * CDDL HEADER START 38e56767dSsmall * 48e56767dSsmall * The contents of this file are subject to the terms of the 530082d0cSmyers * Common Development and Distribution License (the "License"). 630082d0cSmyers * You may not use this file except in compliance with the License. 78e56767dSsmall * 88e56767dSsmall * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 98e56767dSsmall * or http://www.opensolaris.org/os/licensing. 108e56767dSsmall * See the License for the specific language governing permissions 118e56767dSsmall * and limitations under the License. 128e56767dSsmall * 138e56767dSsmall * When distributing Covered Code, include this CDDL HEADER in each 148e56767dSsmall * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 158e56767dSsmall * If applicable, add the following below this CDDL HEADER, with the 168e56767dSsmall * fields enclosed by brackets "[]" replaced with your own identifying 178e56767dSsmall * information: Portions Copyright [yyyy] [name of copyright owner] 188e56767dSsmall * 198e56767dSsmall * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 21450d6964Smyers 227c478bd9Sstevel@tonic-gate /* 230e751525SEric Saxe * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 247c478bd9Sstevel@tonic-gate * Use is subject to license terms. 25*7b1019a6SJerry Jelinek * Copyright 2016 Joyent, Inc. 267c478bd9Sstevel@tonic-gate */ 27fa96bd91SMichael Corcoran /* 28a3114836SGerry Liu * Copyright (c) 2009-2010, Intel Corporation. 29fa96bd91SMichael Corcoran * All rights reserved. 30fa96bd91SMichael Corcoran */ 318e56767dSsmall /* 328e56767dSsmall * ACPI CA OSL for Solaris x86 338e56767dSsmall */ 347c478bd9Sstevel@tonic-gate 357c478bd9Sstevel@tonic-gate #include <sys/types.h> 367c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 377c478bd9Sstevel@tonic-gate #include <sys/psm.h> 387c478bd9Sstevel@tonic-gate #include <sys/pci_cfgspace.h> 39b9bfdccdSStuart Maybee #include <sys/apic.h> 407c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 414b1ce0a9SDana Myers #include <sys/sunddi.h> 425cff7825Smh #include <sys/sunndi.h> 437c478bd9Sstevel@tonic-gate #include <sys/pci.h> 447c478bd9Sstevel@tonic-gate #include <sys/kobj.h> 457c478bd9Sstevel@tonic-gate #include <sys/taskq.h> 467c478bd9Sstevel@tonic-gate #include <sys/strlog.h> 47b72d5b75SMichael Corcoran #include <sys/x86_archext.h> 487c478bd9Sstevel@tonic-gate #include <sys/note.h> 499bb29364SDana Myers #include <sys/promif.h> 507c478bd9Sstevel@tonic-gate 5178d5422cSMark Haywood #include <sys/acpi/accommon.h> 527c478bd9Sstevel@tonic-gate #include <sys/acpica.h> 537c478bd9Sstevel@tonic-gate 547c478bd9Sstevel@tonic-gate #define MAX_DAT_FILE_SIZE (64*1024) 557c478bd9Sstevel@tonic-gate 567c478bd9Sstevel@tonic-gate /* local functions */ 577c478bd9Sstevel@tonic-gate static int CompressEisaID(char *np); 587c478bd9Sstevel@tonic-gate 595cff7825Smh static void scan_d2a_subtree(dev_info_t *dip, ACPI_HANDLE acpiobj, int bus); 607c478bd9Sstevel@tonic-gate static int acpica_query_bbn_problem(void); 617c478bd9Sstevel@tonic-gate static int acpica_find_pcibus(int busno, ACPI_HANDLE *rh); 627c478bd9Sstevel@tonic-gate static int acpica_eval_hid(ACPI_HANDLE dev, char *method, int *rint); 635cff7825Smh static ACPI_STATUS acpica_set_devinfo(ACPI_HANDLE, dev_info_t *); 64fa96bd91SMichael Corcoran static ACPI_STATUS acpica_unset_devinfo(ACPI_HANDLE); 6557190917SDana Myers static void acpica_devinfo_handler(ACPI_HANDLE, void *); 667c478bd9Sstevel@tonic-gate 677c478bd9Sstevel@tonic-gate /* 687c478bd9Sstevel@tonic-gate * Event queue vars 697c478bd9Sstevel@tonic-gate */ 707c478bd9Sstevel@tonic-gate int acpica_eventq_init = 0; 7127f7c583Smyers ddi_taskq_t *osl_eventq[OSL_EC_BURST_HANDLER+1]; 727c478bd9Sstevel@tonic-gate 73db2bae30SDana Myers /* 74db2bae30SDana Myers * Priorities relative to minclsyspri that each taskq 75db2bae30SDana Myers * run at; OSL_NOTIFY_HANDLER needs to run at a higher 76db2bae30SDana Myers * priority than OSL_GPE_HANDLER. There's an implicit 77db2bae30SDana Myers * assumption that no priority here results in exceeding 78db2bae30SDana Myers * maxclsyspri. 79db2bae30SDana Myers * Note: these initializations need to match the order of 80db2bae30SDana Myers * ACPI_EXECUTE_TYPE. 81db2bae30SDana Myers */ 82db2bae30SDana Myers int osl_eventq_pri_delta[OSL_EC_BURST_HANDLER+1] = { 83db2bae30SDana Myers 0, /* OSL_GLOBAL_LOCK_HANDLER */ 84db2bae30SDana Myers 2, /* OSL_NOTIFY_HANDLER */ 85db2bae30SDana Myers 0, /* OSL_GPE_HANDLER */ 86db2bae30SDana Myers 0, /* OSL_DEBUGGER_THREAD */ 87db2bae30SDana Myers 0, /* OSL_EC_POLL_HANDLER */ 88db2bae30SDana Myers 0 /* OSL_EC_BURST_HANDLER */ 89db2bae30SDana Myers }; 90db2bae30SDana Myers 917c478bd9Sstevel@tonic-gate /* 927c478bd9Sstevel@tonic-gate * Note, if you change this path, you need to update 937c478bd9Sstevel@tonic-gate * /boot/grub/filelist.ramdisk and pkg SUNWckr/prototype_i386 947c478bd9Sstevel@tonic-gate */ 957c478bd9Sstevel@tonic-gate static char *acpi_table_path = "/boot/acpi/tables/"; 967c478bd9Sstevel@tonic-gate 975cff7825Smh /* non-zero while scan_d2a_map() is working */ 985cff7825Smh static int scanning_d2a_map = 0; 995cff7825Smh static int d2a_done = 0; 1007c478bd9Sstevel@tonic-gate 101fa96bd91SMichael Corcoran /* features supported by ACPICA and ACPI device configuration. */ 102a3114836SGerry Liu uint64_t acpica_core_features = ACPI_FEATURE_OSI_MODULE; 103fa96bd91SMichael Corcoran static uint64_t acpica_devcfg_features = 0; 104fa96bd91SMichael Corcoran 105137e2f25SGuoli Shu /* set by acpi_poweroff() in PSMs and appm_ioctl() in acpippm for S3 */ 106137e2f25SGuoli Shu int acpica_use_safe_delay = 0; 107859dcd3dSmyers 1085cff7825Smh /* CPU mapping data */ 1095cff7825Smh struct cpu_map_item { 110fa96bd91SMichael Corcoran processorid_t cpu_id; 111b6917abeSmishra UINT32 proc_id; 112fa96bd91SMichael Corcoran UINT32 apic_id; 1135cff7825Smh ACPI_HANDLE obj; 1145cff7825Smh }; 1155cff7825Smh 116a3114836SGerry Liu kmutex_t cpu_map_lock; 1175cff7825Smh static struct cpu_map_item **cpu_map = NULL; 118fa96bd91SMichael Corcoran static int cpu_map_count_max = 0; 1195cff7825Smh static int cpu_map_count = 0; 1205cff7825Smh static int cpu_map_built = 0; 1215cff7825Smh 122b72d5b75SMichael Corcoran /* 123b72d5b75SMichael Corcoran * On systems with the uppc PSM only, acpica_map_cpu() won't be called at all. 124b72d5b75SMichael Corcoran * This flag is used to check for uppc-only systems by detecting whether 125b72d5b75SMichael Corcoran * acpica_map_cpu() has been called or not. 126b72d5b75SMichael Corcoran */ 127b72d5b75SMichael Corcoran static int cpu_map_called = 0; 128b72d5b75SMichael Corcoran 1295cff7825Smh static int acpi_has_broken_bbn = -1; 1305cff7825Smh 13187bb58d6Smyers /* buffer for AcpiOsVprintf() */ 13287bb58d6Smyers #define ACPI_OSL_PR_BUFLEN 1024 13387bb58d6Smyers static char *acpi_osl_pr_buffer = NULL; 13487bb58d6Smyers static int acpi_osl_pr_buflen; 13587bb58d6Smyers 1365cff7825Smh #define D2A_DEBUG 1375cff7825Smh 1387c478bd9Sstevel@tonic-gate /* 1397c478bd9Sstevel@tonic-gate * 1407c478bd9Sstevel@tonic-gate */ 1417c478bd9Sstevel@tonic-gate static void 1427c478bd9Sstevel@tonic-gate discard_event_queues() 1437c478bd9Sstevel@tonic-gate { 14427f7c583Smyers int i; 1457c478bd9Sstevel@tonic-gate 1467c478bd9Sstevel@tonic-gate /* 1477c478bd9Sstevel@tonic-gate * destroy event queues 1487c478bd9Sstevel@tonic-gate */ 14927f7c583Smyers for (i = OSL_GLOBAL_LOCK_HANDLER; i <= OSL_EC_BURST_HANDLER; i++) { 15027f7c583Smyers if (osl_eventq[i]) 15127f7c583Smyers ddi_taskq_destroy(osl_eventq[i]); 15227f7c583Smyers } 1537c478bd9Sstevel@tonic-gate } 1547c478bd9Sstevel@tonic-gate 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate /* 1577c478bd9Sstevel@tonic-gate * 1587c478bd9Sstevel@tonic-gate */ 1597c478bd9Sstevel@tonic-gate static ACPI_STATUS 1607c478bd9Sstevel@tonic-gate init_event_queues() 1617c478bd9Sstevel@tonic-gate { 16227f7c583Smyers char namebuf[32]; 16327f7c583Smyers int i, error = 0; 1647c478bd9Sstevel@tonic-gate 1657c478bd9Sstevel@tonic-gate /* 1667c478bd9Sstevel@tonic-gate * Initialize event queues 1677c478bd9Sstevel@tonic-gate */ 1687c478bd9Sstevel@tonic-gate 169db2bae30SDana Myers /* Always allocate only 1 thread per queue to force FIFO execution */ 17027f7c583Smyers for (i = OSL_GLOBAL_LOCK_HANDLER; i <= OSL_EC_BURST_HANDLER; i++) { 17127f7c583Smyers snprintf(namebuf, 32, "ACPI%d", i); 172db2bae30SDana Myers osl_eventq[i] = ddi_taskq_create(NULL, namebuf, 1, 173db2bae30SDana Myers osl_eventq_pri_delta[i] + minclsyspri, 0); 17427f7c583Smyers if (osl_eventq[i] == NULL) 17527f7c583Smyers error++; 17627f7c583Smyers } 17727f7c583Smyers 17827f7c583Smyers if (error != 0) { 1797c478bd9Sstevel@tonic-gate discard_event_queues(); 1807c478bd9Sstevel@tonic-gate #ifdef DEBUG 1817c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!acpica: could not initialize event queues"); 1827c478bd9Sstevel@tonic-gate #endif 1837c478bd9Sstevel@tonic-gate return (AE_ERROR); 1847c478bd9Sstevel@tonic-gate } 1857c478bd9Sstevel@tonic-gate 1867c478bd9Sstevel@tonic-gate acpica_eventq_init = 1; 1877c478bd9Sstevel@tonic-gate return (AE_OK); 1887c478bd9Sstevel@tonic-gate } 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate /* 19187bb58d6Smyers * One-time initialization of OSL layer 1927c478bd9Sstevel@tonic-gate */ 1937c478bd9Sstevel@tonic-gate ACPI_STATUS 1947c478bd9Sstevel@tonic-gate AcpiOsInitialize(void) 1957c478bd9Sstevel@tonic-gate { 19687bb58d6Smyers /* 19787bb58d6Smyers * Allocate buffer for AcpiOsVprintf() here to avoid 19887bb58d6Smyers * kmem_alloc()/kmem_free() at high PIL 19987bb58d6Smyers */ 20087bb58d6Smyers acpi_osl_pr_buffer = kmem_alloc(ACPI_OSL_PR_BUFLEN, KM_SLEEP); 20187bb58d6Smyers if (acpi_osl_pr_buffer != NULL) 20287bb58d6Smyers acpi_osl_pr_buflen = ACPI_OSL_PR_BUFLEN; 20387bb58d6Smyers 2047c478bd9Sstevel@tonic-gate return (AE_OK); 2057c478bd9Sstevel@tonic-gate } 2067c478bd9Sstevel@tonic-gate 2077c478bd9Sstevel@tonic-gate /* 20887bb58d6Smyers * One-time shut-down of OSL layer 2097c478bd9Sstevel@tonic-gate */ 2107c478bd9Sstevel@tonic-gate ACPI_STATUS 2117c478bd9Sstevel@tonic-gate AcpiOsTerminate(void) 2127c478bd9Sstevel@tonic-gate { 2137c478bd9Sstevel@tonic-gate 21487bb58d6Smyers if (acpi_osl_pr_buffer != NULL) 21587bb58d6Smyers kmem_free(acpi_osl_pr_buffer, acpi_osl_pr_buflen); 21687bb58d6Smyers 2177c478bd9Sstevel@tonic-gate discard_event_queues(); 2187c478bd9Sstevel@tonic-gate return (AE_OK); 2197c478bd9Sstevel@tonic-gate } 2207c478bd9Sstevel@tonic-gate 2217c478bd9Sstevel@tonic-gate 222db2bae30SDana Myers ACPI_PHYSICAL_ADDRESS 223db2bae30SDana Myers AcpiOsGetRootPointer() 2247c478bd9Sstevel@tonic-gate { 225db2bae30SDana Myers ACPI_PHYSICAL_ADDRESS Address; 226f2be5148Sszhou 227f2be5148Sszhou /* 228f2be5148Sszhou * For EFI firmware, the root pointer is defined in EFI systab. 229f2be5148Sszhou * The boot code process the table and put the physical address 230f2be5148Sszhou * in the acpi-root-tab property. 231f2be5148Sszhou */ 232c1381f44SDana Myers Address = ddi_prop_get_int(DDI_DEV_T_ANY, ddi_root_node(), 233c1381f44SDana Myers DDI_PROP_DONTPASS, "acpi-root-tab", NULL); 234db2bae30SDana Myers 235db2bae30SDana Myers if ((Address == NULL) && ACPI_FAILURE(AcpiFindRootPointer(&Address))) 236db2bae30SDana Myers Address = NULL; 237db2bae30SDana Myers 238db2bae30SDana Myers return (Address); 2397c478bd9Sstevel@tonic-gate } 2407c478bd9Sstevel@tonic-gate 2417c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2427c478bd9Sstevel@tonic-gate ACPI_STATUS 2437c478bd9Sstevel@tonic-gate AcpiOsPredefinedOverride(const ACPI_PREDEFINED_NAMES *InitVal, 2447c478bd9Sstevel@tonic-gate ACPI_STRING *NewVal) 2457c478bd9Sstevel@tonic-gate { 2467c478bd9Sstevel@tonic-gate 2477c478bd9Sstevel@tonic-gate *NewVal = 0; 2487c478bd9Sstevel@tonic-gate return (AE_OK); 2497c478bd9Sstevel@tonic-gate } 2507c478bd9Sstevel@tonic-gate 2517c478bd9Sstevel@tonic-gate static void 2527c478bd9Sstevel@tonic-gate acpica_strncpy(char *dest, const char *src, int len) 2537c478bd9Sstevel@tonic-gate { 2547c478bd9Sstevel@tonic-gate 2557c478bd9Sstevel@tonic-gate /*LINTED*/ 2567c478bd9Sstevel@tonic-gate while ((*dest++ = *src++) && (--len > 0)) 2577c478bd9Sstevel@tonic-gate /* copy the string */; 2587c478bd9Sstevel@tonic-gate *dest = '\0'; 2597c478bd9Sstevel@tonic-gate } 2607c478bd9Sstevel@tonic-gate 2617c478bd9Sstevel@tonic-gate ACPI_STATUS 2627c478bd9Sstevel@tonic-gate AcpiOsTableOverride(ACPI_TABLE_HEADER *ExistingTable, 2637c478bd9Sstevel@tonic-gate ACPI_TABLE_HEADER **NewTable) 2647c478bd9Sstevel@tonic-gate { 2657c478bd9Sstevel@tonic-gate char signature[5]; 2667c478bd9Sstevel@tonic-gate char oemid[7]; 2677c478bd9Sstevel@tonic-gate char oemtableid[9]; 2687c478bd9Sstevel@tonic-gate struct _buf *file; 2697c478bd9Sstevel@tonic-gate char *buf1, *buf2; 2707c478bd9Sstevel@tonic-gate int count; 2717c478bd9Sstevel@tonic-gate char acpi_table_loc[128]; 2727c478bd9Sstevel@tonic-gate 2737c478bd9Sstevel@tonic-gate acpica_strncpy(signature, ExistingTable->Signature, 4); 2747c478bd9Sstevel@tonic-gate acpica_strncpy(oemid, ExistingTable->OemId, 6); 2757c478bd9Sstevel@tonic-gate acpica_strncpy(oemtableid, ExistingTable->OemTableId, 8); 2767c478bd9Sstevel@tonic-gate 2777c478bd9Sstevel@tonic-gate #ifdef DEBUG 2787c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!acpica: table [%s] v%d OEM ID [%s]" 2795dff2f34Smyers " OEM TABLE ID [%s] OEM rev %x", 2805dff2f34Smyers signature, ExistingTable->Revision, oemid, oemtableid, 2815dff2f34Smyers ExistingTable->OemRevision); 2827c478bd9Sstevel@tonic-gate #endif 2837c478bd9Sstevel@tonic-gate 2847c478bd9Sstevel@tonic-gate /* File name format is "signature_oemid_oemtableid.dat" */ 2857c478bd9Sstevel@tonic-gate (void) strcpy(acpi_table_loc, acpi_table_path); 2867c478bd9Sstevel@tonic-gate (void) strcat(acpi_table_loc, signature); /* for example, DSDT */ 2877c478bd9Sstevel@tonic-gate (void) strcat(acpi_table_loc, "_"); 2887c478bd9Sstevel@tonic-gate (void) strcat(acpi_table_loc, oemid); /* for example, IntelR */ 2897c478bd9Sstevel@tonic-gate (void) strcat(acpi_table_loc, "_"); 2907c478bd9Sstevel@tonic-gate (void) strcat(acpi_table_loc, oemtableid); /* for example, AWRDACPI */ 2917c478bd9Sstevel@tonic-gate (void) strcat(acpi_table_loc, ".dat"); 2927c478bd9Sstevel@tonic-gate 2937c478bd9Sstevel@tonic-gate file = kobj_open_file(acpi_table_loc); 2947c478bd9Sstevel@tonic-gate if (file == (struct _buf *)-1) { 2957c478bd9Sstevel@tonic-gate *NewTable = 0; 2967c478bd9Sstevel@tonic-gate return (AE_OK); 2977c478bd9Sstevel@tonic-gate } else { 2987c478bd9Sstevel@tonic-gate buf1 = (char *)kmem_alloc(MAX_DAT_FILE_SIZE, KM_SLEEP); 2997c478bd9Sstevel@tonic-gate count = kobj_read_file(file, buf1, MAX_DAT_FILE_SIZE-1, 0); 3007c478bd9Sstevel@tonic-gate if (count >= MAX_DAT_FILE_SIZE) { 3017c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!acpica: table %s file size too big", 3027c478bd9Sstevel@tonic-gate acpi_table_loc); 3037c478bd9Sstevel@tonic-gate *NewTable = 0; 3047c478bd9Sstevel@tonic-gate } else { 3057c478bd9Sstevel@tonic-gate buf2 = (char *)kmem_alloc(count, KM_SLEEP); 3067c478bd9Sstevel@tonic-gate (void) memcpy(buf2, buf1, count); 3077c478bd9Sstevel@tonic-gate *NewTable = (ACPI_TABLE_HEADER *)buf2; 3087c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!acpica: replacing table: %s", 3097c478bd9Sstevel@tonic-gate acpi_table_loc); 3107c478bd9Sstevel@tonic-gate } 3117c478bd9Sstevel@tonic-gate } 3127c478bd9Sstevel@tonic-gate kobj_close_file(file); 3137c478bd9Sstevel@tonic-gate kmem_free(buf1, MAX_DAT_FILE_SIZE); 3147c478bd9Sstevel@tonic-gate 3157c478bd9Sstevel@tonic-gate return (AE_OK); 3167c478bd9Sstevel@tonic-gate } 3177c478bd9Sstevel@tonic-gate 318*7b1019a6SJerry Jelinek ACPI_STATUS 319*7b1019a6SJerry Jelinek AcpiOsPhysicalTableOverride(ACPI_TABLE_HEADER *ExistingTable, 320*7b1019a6SJerry Jelinek ACPI_PHYSICAL_ADDRESS *NewAddress, UINT32 *NewTableLength) 321*7b1019a6SJerry Jelinek { 322*7b1019a6SJerry Jelinek return (AE_SUPPORT); 323*7b1019a6SJerry Jelinek } 3247c478bd9Sstevel@tonic-gate 32530082d0cSmyers /* 32630082d0cSmyers * ACPI semaphore implementation 32730082d0cSmyers */ 32830082d0cSmyers typedef struct { 32930082d0cSmyers kmutex_t mutex; 33030082d0cSmyers kcondvar_t cv; 33130082d0cSmyers uint32_t available; 33230082d0cSmyers uint32_t initial; 33330082d0cSmyers uint32_t maximum; 33430082d0cSmyers } acpi_sema_t; 33530082d0cSmyers 33630082d0cSmyers /* 33730082d0cSmyers * 33830082d0cSmyers */ 33930082d0cSmyers void 34027f7c583Smyers acpi_sema_init(acpi_sema_t *sp, unsigned max, unsigned count) 34130082d0cSmyers { 34230082d0cSmyers mutex_init(&sp->mutex, NULL, MUTEX_DRIVER, NULL); 34330082d0cSmyers cv_init(&sp->cv, NULL, CV_DRIVER, NULL); 34430082d0cSmyers /* no need to enter mutex here at creation */ 34530082d0cSmyers sp->available = count; 34630082d0cSmyers sp->initial = count; 34730082d0cSmyers sp->maximum = max; 34830082d0cSmyers } 34930082d0cSmyers 35030082d0cSmyers /* 35130082d0cSmyers * 35230082d0cSmyers */ 35330082d0cSmyers void 35430082d0cSmyers acpi_sema_destroy(acpi_sema_t *sp) 35530082d0cSmyers { 35630082d0cSmyers 35730082d0cSmyers cv_destroy(&sp->cv); 35830082d0cSmyers mutex_destroy(&sp->mutex); 35930082d0cSmyers } 36030082d0cSmyers 36130082d0cSmyers /* 36230082d0cSmyers * 36330082d0cSmyers */ 36430082d0cSmyers ACPI_STATUS 36530082d0cSmyers acpi_sema_p(acpi_sema_t *sp, unsigned count, uint16_t wait_time) 36630082d0cSmyers { 36730082d0cSmyers ACPI_STATUS rv = AE_OK; 36830082d0cSmyers clock_t deadline; 36930082d0cSmyers 37030082d0cSmyers mutex_enter(&sp->mutex); 37130082d0cSmyers 37230082d0cSmyers if (sp->available >= count) { 37330082d0cSmyers /* 37430082d0cSmyers * Enough units available, no blocking 37530082d0cSmyers */ 37630082d0cSmyers sp->available -= count; 37730082d0cSmyers mutex_exit(&sp->mutex); 37830082d0cSmyers return (rv); 37930082d0cSmyers } else if (wait_time == 0) { 38030082d0cSmyers /* 38130082d0cSmyers * Not enough units available and timeout 38230082d0cSmyers * specifies no blocking 38330082d0cSmyers */ 38430082d0cSmyers rv = AE_TIME; 38530082d0cSmyers mutex_exit(&sp->mutex); 38630082d0cSmyers return (rv); 38730082d0cSmyers } 38830082d0cSmyers 38930082d0cSmyers /* 39030082d0cSmyers * Not enough units available and timeout specifies waiting 39130082d0cSmyers */ 39230082d0cSmyers if (wait_time != ACPI_WAIT_FOREVER) 39330082d0cSmyers deadline = ddi_get_lbolt() + 39430082d0cSmyers (clock_t)drv_usectohz(wait_time * 1000); 39530082d0cSmyers 39630082d0cSmyers do { 39730082d0cSmyers if (wait_time == ACPI_WAIT_FOREVER) 39830082d0cSmyers cv_wait(&sp->cv, &sp->mutex); 39930082d0cSmyers else if (cv_timedwait(&sp->cv, &sp->mutex, deadline) < 0) { 40030082d0cSmyers rv = AE_TIME; 40130082d0cSmyers break; 40230082d0cSmyers } 40330082d0cSmyers } while (sp->available < count); 40430082d0cSmyers 40530082d0cSmyers /* if we dropped out of the wait with AE_OK, we got the units */ 40630082d0cSmyers if (rv == AE_OK) 40730082d0cSmyers sp->available -= count; 40830082d0cSmyers 40930082d0cSmyers mutex_exit(&sp->mutex); 41030082d0cSmyers return (rv); 41130082d0cSmyers } 41230082d0cSmyers 41330082d0cSmyers /* 41430082d0cSmyers * 41530082d0cSmyers */ 41630082d0cSmyers void 41730082d0cSmyers acpi_sema_v(acpi_sema_t *sp, unsigned count) 41830082d0cSmyers { 41930082d0cSmyers mutex_enter(&sp->mutex); 42030082d0cSmyers sp->available += count; 42130082d0cSmyers cv_broadcast(&sp->cv); 42230082d0cSmyers mutex_exit(&sp->mutex); 42330082d0cSmyers } 42430082d0cSmyers 42530082d0cSmyers 4267c478bd9Sstevel@tonic-gate ACPI_STATUS 4277c478bd9Sstevel@tonic-gate AcpiOsCreateSemaphore(UINT32 MaxUnits, UINT32 InitialUnits, 4287c478bd9Sstevel@tonic-gate ACPI_HANDLE *OutHandle) 4297c478bd9Sstevel@tonic-gate { 43030082d0cSmyers acpi_sema_t *sp; 4317c478bd9Sstevel@tonic-gate 4327c478bd9Sstevel@tonic-gate if ((OutHandle == NULL) || (InitialUnits > MaxUnits)) 4337c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 4347c478bd9Sstevel@tonic-gate 43530082d0cSmyers sp = (acpi_sema_t *)kmem_alloc(sizeof (acpi_sema_t), KM_SLEEP); 43627f7c583Smyers acpi_sema_init(sp, MaxUnits, InitialUnits); 43730082d0cSmyers *OutHandle = (ACPI_HANDLE)sp; 4387c478bd9Sstevel@tonic-gate return (AE_OK); 4397c478bd9Sstevel@tonic-gate } 4407c478bd9Sstevel@tonic-gate 4417c478bd9Sstevel@tonic-gate 4427c478bd9Sstevel@tonic-gate ACPI_STATUS 4437c478bd9Sstevel@tonic-gate AcpiOsDeleteSemaphore(ACPI_HANDLE Handle) 4447c478bd9Sstevel@tonic-gate { 4457c478bd9Sstevel@tonic-gate 44630082d0cSmyers if (Handle == NULL) 44730082d0cSmyers return (AE_BAD_PARAMETER); 44830082d0cSmyers 44930082d0cSmyers acpi_sema_destroy((acpi_sema_t *)Handle); 45030082d0cSmyers kmem_free((void *)Handle, sizeof (acpi_sema_t)); 4517c478bd9Sstevel@tonic-gate return (AE_OK); 4527c478bd9Sstevel@tonic-gate } 4537c478bd9Sstevel@tonic-gate 4547c478bd9Sstevel@tonic-gate ACPI_STATUS 4557c478bd9Sstevel@tonic-gate AcpiOsWaitSemaphore(ACPI_HANDLE Handle, UINT32 Units, UINT16 Timeout) 4567c478bd9Sstevel@tonic-gate { 4577c478bd9Sstevel@tonic-gate 45830082d0cSmyers if ((Handle == NULL) || (Units < 1)) 45930082d0cSmyers return (AE_BAD_PARAMETER); 4607c478bd9Sstevel@tonic-gate 46130082d0cSmyers return (acpi_sema_p((acpi_sema_t *)Handle, Units, Timeout)); 4627c478bd9Sstevel@tonic-gate } 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate ACPI_STATUS 4657c478bd9Sstevel@tonic-gate AcpiOsSignalSemaphore(ACPI_HANDLE Handle, UINT32 Units) 4667c478bd9Sstevel@tonic-gate { 4677c478bd9Sstevel@tonic-gate 46830082d0cSmyers if ((Handle == NULL) || (Units < 1)) 46930082d0cSmyers return (AE_BAD_PARAMETER); 47030082d0cSmyers 47130082d0cSmyers acpi_sema_v((acpi_sema_t *)Handle, Units); 4727c478bd9Sstevel@tonic-gate return (AE_OK); 4737c478bd9Sstevel@tonic-gate } 4747c478bd9Sstevel@tonic-gate 4757c478bd9Sstevel@tonic-gate ACPI_STATUS 4767c478bd9Sstevel@tonic-gate AcpiOsCreateLock(ACPI_HANDLE *OutHandle) 4777c478bd9Sstevel@tonic-gate { 47830082d0cSmyers kmutex_t *mp; 4797c478bd9Sstevel@tonic-gate 4807c478bd9Sstevel@tonic-gate if (OutHandle == NULL) 4817c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 4827c478bd9Sstevel@tonic-gate 48330082d0cSmyers mp = (kmutex_t *)kmem_alloc(sizeof (kmutex_t), KM_SLEEP); 48430082d0cSmyers mutex_init(mp, NULL, MUTEX_DRIVER, NULL); 48530082d0cSmyers *OutHandle = (ACPI_HANDLE)mp; 4867c478bd9Sstevel@tonic-gate return (AE_OK); 4877c478bd9Sstevel@tonic-gate } 4887c478bd9Sstevel@tonic-gate 4897c478bd9Sstevel@tonic-gate void 4907c478bd9Sstevel@tonic-gate AcpiOsDeleteLock(ACPI_HANDLE Handle) 4917c478bd9Sstevel@tonic-gate { 49230082d0cSmyers 49330082d0cSmyers if (Handle == NULL) 49430082d0cSmyers return; 49530082d0cSmyers 49630082d0cSmyers mutex_destroy((kmutex_t *)Handle); 49730082d0cSmyers kmem_free((void *)Handle, sizeof (kmutex_t)); 4987c478bd9Sstevel@tonic-gate } 4997c478bd9Sstevel@tonic-gate 500db2bae30SDana Myers ACPI_CPU_FLAGS 501450d6964Smyers AcpiOsAcquireLock(ACPI_HANDLE Handle) 5027c478bd9Sstevel@tonic-gate { 50330082d0cSmyers 5040e751525SEric Saxe 5050e751525SEric Saxe if (Handle == NULL) 5060e751525SEric Saxe return (AE_BAD_PARAMETER); 5070e751525SEric Saxe 5080e751525SEric Saxe if (curthread == CPU->cpu_idle_thread) { 5090e751525SEric Saxe while (!mutex_tryenter((kmutex_t *)Handle)) 5100e751525SEric Saxe /* spin */; 5110e751525SEric Saxe } else 5120e751525SEric Saxe mutex_enter((kmutex_t *)Handle); 5130e751525SEric Saxe return (AE_OK); 5147c478bd9Sstevel@tonic-gate } 5157c478bd9Sstevel@tonic-gate 5167c478bd9Sstevel@tonic-gate void 517db2bae30SDana Myers AcpiOsReleaseLock(ACPI_HANDLE Handle, ACPI_CPU_FLAGS Flags) 5187c478bd9Sstevel@tonic-gate { 519450d6964Smyers _NOTE(ARGUNUSED(Flags)) 5207c478bd9Sstevel@tonic-gate 52130082d0cSmyers mutex_exit((kmutex_t *)Handle); 5227c478bd9Sstevel@tonic-gate } 5237c478bd9Sstevel@tonic-gate 5247c478bd9Sstevel@tonic-gate 5257c478bd9Sstevel@tonic-gate void * 5267c478bd9Sstevel@tonic-gate AcpiOsAllocate(ACPI_SIZE Size) 5277c478bd9Sstevel@tonic-gate { 5287c478bd9Sstevel@tonic-gate ACPI_SIZE *tmp_ptr; 5297c478bd9Sstevel@tonic-gate 5307c478bd9Sstevel@tonic-gate Size += sizeof (Size); 5317c478bd9Sstevel@tonic-gate tmp_ptr = (ACPI_SIZE *)kmem_zalloc(Size, KM_SLEEP); 5327c478bd9Sstevel@tonic-gate *tmp_ptr++ = Size; 53330082d0cSmyers return (tmp_ptr); 5347c478bd9Sstevel@tonic-gate } 5357c478bd9Sstevel@tonic-gate 5367c478bd9Sstevel@tonic-gate void 5377c478bd9Sstevel@tonic-gate AcpiOsFree(void *Memory) 5387c478bd9Sstevel@tonic-gate { 5397c478bd9Sstevel@tonic-gate ACPI_SIZE size, *tmp_ptr; 5407c478bd9Sstevel@tonic-gate 5417c478bd9Sstevel@tonic-gate tmp_ptr = (ACPI_SIZE *)Memory; 5427c478bd9Sstevel@tonic-gate tmp_ptr -= 1; 5437c478bd9Sstevel@tonic-gate size = *tmp_ptr; 54430082d0cSmyers kmem_free(tmp_ptr, size); 5457c478bd9Sstevel@tonic-gate } 5467c478bd9Sstevel@tonic-gate 547b9bfdccdSStuart Maybee static int napics_found; /* number of ioapic addresses in array */ 548b9bfdccdSStuart Maybee static ACPI_PHYSICAL_ADDRESS ioapic_paddr[MAX_IO_APIC]; 549b9bfdccdSStuart Maybee static ACPI_TABLE_MADT *acpi_mapic_dtp = NULL; 550b9bfdccdSStuart Maybee static void *dummy_ioapicadr; 551b9bfdccdSStuart Maybee 552b9bfdccdSStuart Maybee void 553b9bfdccdSStuart Maybee acpica_find_ioapics(void) 554b9bfdccdSStuart Maybee { 555b9bfdccdSStuart Maybee int madt_seen, madt_size; 556b9bfdccdSStuart Maybee ACPI_SUBTABLE_HEADER *ap; 557b9bfdccdSStuart Maybee ACPI_MADT_IO_APIC *mia; 558b9bfdccdSStuart Maybee 559b9bfdccdSStuart Maybee if (acpi_mapic_dtp != NULL) 560b9bfdccdSStuart Maybee return; /* already parsed table */ 561b9bfdccdSStuart Maybee if (AcpiGetTable(ACPI_SIG_MADT, 1, 562b9bfdccdSStuart Maybee (ACPI_TABLE_HEADER **) &acpi_mapic_dtp) != AE_OK) 563b9bfdccdSStuart Maybee return; 564b9bfdccdSStuart Maybee 565b9bfdccdSStuart Maybee napics_found = 0; 566b9bfdccdSStuart Maybee 567b9bfdccdSStuart Maybee /* 568b9bfdccdSStuart Maybee * Search the MADT for ioapics 569b9bfdccdSStuart Maybee */ 570b9bfdccdSStuart Maybee ap = (ACPI_SUBTABLE_HEADER *) (acpi_mapic_dtp + 1); 571b9bfdccdSStuart Maybee madt_size = acpi_mapic_dtp->Header.Length; 572b9bfdccdSStuart Maybee madt_seen = sizeof (*acpi_mapic_dtp); 573b9bfdccdSStuart Maybee 574b9bfdccdSStuart Maybee while (madt_seen < madt_size) { 575b9bfdccdSStuart Maybee 576b9bfdccdSStuart Maybee switch (ap->Type) { 577b9bfdccdSStuart Maybee case ACPI_MADT_TYPE_IO_APIC: 578b9bfdccdSStuart Maybee mia = (ACPI_MADT_IO_APIC *) ap; 579b9bfdccdSStuart Maybee if (napics_found < MAX_IO_APIC) { 580b9bfdccdSStuart Maybee ioapic_paddr[napics_found++] = 581b9bfdccdSStuart Maybee (ACPI_PHYSICAL_ADDRESS) 582b9bfdccdSStuart Maybee (mia->Address & PAGEMASK); 583b9bfdccdSStuart Maybee } 584b9bfdccdSStuart Maybee break; 585b9bfdccdSStuart Maybee 586b9bfdccdSStuart Maybee default: 587b9bfdccdSStuart Maybee break; 588b9bfdccdSStuart Maybee } 589b9bfdccdSStuart Maybee 590b9bfdccdSStuart Maybee /* advance to next entry */ 591b9bfdccdSStuart Maybee madt_seen += ap->Length; 592b9bfdccdSStuart Maybee ap = (ACPI_SUBTABLE_HEADER *)(((char *)ap) + ap->Length); 593b9bfdccdSStuart Maybee } 594b9bfdccdSStuart Maybee if (dummy_ioapicadr == NULL) 595b9bfdccdSStuart Maybee dummy_ioapicadr = kmem_zalloc(PAGESIZE, KM_SLEEP); 596b9bfdccdSStuart Maybee } 597b9bfdccdSStuart Maybee 598b9bfdccdSStuart Maybee 599db2bae30SDana Myers void * 600db2bae30SDana Myers AcpiOsMapMemory(ACPI_PHYSICAL_ADDRESS PhysicalAddress, ACPI_SIZE Size) 6017c478bd9Sstevel@tonic-gate { 602b9bfdccdSStuart Maybee int i; 603b9bfdccdSStuart Maybee 604b9bfdccdSStuart Maybee /* 605b9bfdccdSStuart Maybee * If the iopaic address table is populated, check if trying 606b9bfdccdSStuart Maybee * to access an ioapic. Instead, return a pointer to a dummy ioapic. 607b9bfdccdSStuart Maybee */ 608b9bfdccdSStuart Maybee for (i = 0; i < napics_found; i++) { 609b9bfdccdSStuart Maybee if ((PhysicalAddress & PAGEMASK) == ioapic_paddr[i]) 610b9bfdccdSStuart Maybee return (dummy_ioapicadr); 611b9bfdccdSStuart Maybee } 6127c478bd9Sstevel@tonic-gate /* FUTUREWORK: test PhysicalAddress for > 32 bits */ 613db2bae30SDana Myers return (psm_map_new((paddr_t)PhysicalAddress, 614db2bae30SDana Myers (size_t)Size, PSM_PROT_WRITE | PSM_PROT_READ)); 6157c478bd9Sstevel@tonic-gate } 6167c478bd9Sstevel@tonic-gate 6177c478bd9Sstevel@tonic-gate void 6187c478bd9Sstevel@tonic-gate AcpiOsUnmapMemory(void *LogicalAddress, ACPI_SIZE Size) 6197c478bd9Sstevel@tonic-gate { 620b9bfdccdSStuart Maybee /* 621b9bfdccdSStuart Maybee * Check if trying to unmap dummy ioapic address. 622b9bfdccdSStuart Maybee */ 623b9bfdccdSStuart Maybee if (LogicalAddress == dummy_ioapicadr) 624b9bfdccdSStuart Maybee return; 6257c478bd9Sstevel@tonic-gate 6267c478bd9Sstevel@tonic-gate psm_unmap((caddr_t)LogicalAddress, (size_t)Size); 6277c478bd9Sstevel@tonic-gate } 6287c478bd9Sstevel@tonic-gate 6297c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 6307c478bd9Sstevel@tonic-gate ACPI_STATUS 6317c478bd9Sstevel@tonic-gate AcpiOsGetPhysicalAddress(void *LogicalAddress, 6327c478bd9Sstevel@tonic-gate ACPI_PHYSICAL_ADDRESS *PhysicalAddress) 6337c478bd9Sstevel@tonic-gate { 6347c478bd9Sstevel@tonic-gate 6357c478bd9Sstevel@tonic-gate /* UNIMPLEMENTED: not invoked by ACPI CA code */ 63603335b7aSmyers return (AE_NOT_IMPLEMENTED); 6377c478bd9Sstevel@tonic-gate } 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate 6407c478bd9Sstevel@tonic-gate ACPI_OSD_HANDLER acpi_isr; 6417c478bd9Sstevel@tonic-gate void *acpi_isr_context; 6427c478bd9Sstevel@tonic-gate 6437c478bd9Sstevel@tonic-gate uint_t 6447c478bd9Sstevel@tonic-gate acpi_wrapper_isr(char *arg) 6457c478bd9Sstevel@tonic-gate { 6467c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(arg)) 6477c478bd9Sstevel@tonic-gate 6487c478bd9Sstevel@tonic-gate int status; 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate status = (*acpi_isr)(acpi_isr_context); 6517c478bd9Sstevel@tonic-gate 6527c478bd9Sstevel@tonic-gate if (status == ACPI_INTERRUPT_HANDLED) { 6537c478bd9Sstevel@tonic-gate return (DDI_INTR_CLAIMED); 6547c478bd9Sstevel@tonic-gate } else { 6557c478bd9Sstevel@tonic-gate return (DDI_INTR_UNCLAIMED); 6567c478bd9Sstevel@tonic-gate } 6577c478bd9Sstevel@tonic-gate } 6587c478bd9Sstevel@tonic-gate 659186507a7Smyers static int acpi_intr_hooked = 0; 6607c478bd9Sstevel@tonic-gate 6617c478bd9Sstevel@tonic-gate ACPI_STATUS 6627c478bd9Sstevel@tonic-gate AcpiOsInstallInterruptHandler(UINT32 InterruptNumber, 6637c478bd9Sstevel@tonic-gate ACPI_OSD_HANDLER ServiceRoutine, 6647c478bd9Sstevel@tonic-gate void *Context) 6657c478bd9Sstevel@tonic-gate { 66627f7c583Smyers _NOTE(ARGUNUSED(InterruptNumber)) 66727f7c583Smyers 6687c478bd9Sstevel@tonic-gate int retval; 669450d6964Smyers int sci_vect; 670450d6964Smyers iflag_t sci_flags; 6717c478bd9Sstevel@tonic-gate 6727c478bd9Sstevel@tonic-gate acpi_isr = ServiceRoutine; 6737c478bd9Sstevel@tonic-gate acpi_isr_context = Context; 6747c478bd9Sstevel@tonic-gate 6757c478bd9Sstevel@tonic-gate /* 676450d6964Smyers * Get SCI (adjusted for PIC/APIC mode if necessary) 6777c478bd9Sstevel@tonic-gate */ 678450d6964Smyers if (acpica_get_sci(&sci_vect, &sci_flags) != AE_OK) { 679450d6964Smyers return (AE_ERROR); 680450d6964Smyers } 681450d6964Smyers 682450d6964Smyers #ifdef DEBUG 683450d6964Smyers cmn_err(CE_NOTE, "!acpica: attaching SCI %d", sci_vect); 684450d6964Smyers #endif 685450d6964Smyers 6867c478bd9Sstevel@tonic-gate retval = add_avintr(NULL, SCI_IPL, (avfunc)acpi_wrapper_isr, 6875dff2f34Smyers "ACPI SCI", sci_vect, NULL, NULL, NULL, NULL); 6887c478bd9Sstevel@tonic-gate if (retval) { 689186507a7Smyers acpi_intr_hooked = 1; 6907c478bd9Sstevel@tonic-gate return (AE_OK); 691186507a7Smyers } else 6927c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 6937c478bd9Sstevel@tonic-gate } 6947c478bd9Sstevel@tonic-gate 6957c478bd9Sstevel@tonic-gate ACPI_STATUS 6967c478bd9Sstevel@tonic-gate AcpiOsRemoveInterruptHandler(UINT32 InterruptNumber, 6977c478bd9Sstevel@tonic-gate ACPI_OSD_HANDLER ServiceRoutine) 6987c478bd9Sstevel@tonic-gate { 6997c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(ServiceRoutine)) 7007c478bd9Sstevel@tonic-gate 7017c478bd9Sstevel@tonic-gate #ifdef DEBUG 7027c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!acpica: detaching SCI %d", InterruptNumber); 7037c478bd9Sstevel@tonic-gate #endif 704186507a7Smyers if (acpi_intr_hooked) { 7057c478bd9Sstevel@tonic-gate rem_avintr(NULL, LOCK_LEVEL - 1, (avfunc)acpi_wrapper_isr, 7065dff2f34Smyers InterruptNumber); 707186507a7Smyers acpi_intr_hooked = 0; 7087c478bd9Sstevel@tonic-gate } 7097c478bd9Sstevel@tonic-gate return (AE_OK); 7107c478bd9Sstevel@tonic-gate } 7117c478bd9Sstevel@tonic-gate 7127c478bd9Sstevel@tonic-gate 71327f7c583Smyers ACPI_THREAD_ID 7147c478bd9Sstevel@tonic-gate AcpiOsGetThreadId(void) 7157c478bd9Sstevel@tonic-gate { 71627f7c583Smyers /* 717aa2aa9a6SDana Myers * ACPI CA doesn't care what actual value is returned as long 718aa2aa9a6SDana Myers * as it is non-zero and unique to each existing thread. 719aa2aa9a6SDana Myers * ACPI CA assumes that thread ID is castable to a pointer, 720aa2aa9a6SDana Myers * so we use the current thread pointer. 72127f7c583Smyers */ 72226f3cdf0SGordon Ross return (ACPI_CAST_PTHREAD_T((uintptr_t)curthread)); 7237c478bd9Sstevel@tonic-gate } 7247c478bd9Sstevel@tonic-gate 7257c478bd9Sstevel@tonic-gate /* 7267c478bd9Sstevel@tonic-gate * 7277c478bd9Sstevel@tonic-gate */ 7287c478bd9Sstevel@tonic-gate ACPI_STATUS 72927f7c583Smyers AcpiOsExecute(ACPI_EXECUTE_TYPE Type, ACPI_OSD_EXEC_CALLBACK Function, 73027f7c583Smyers void *Context) 7317c478bd9Sstevel@tonic-gate { 7327c478bd9Sstevel@tonic-gate 7337c478bd9Sstevel@tonic-gate if (!acpica_eventq_init) { 7347c478bd9Sstevel@tonic-gate /* 7357c478bd9Sstevel@tonic-gate * Create taskqs for event handling 7367c478bd9Sstevel@tonic-gate */ 7377c478bd9Sstevel@tonic-gate if (init_event_queues() != AE_OK) 7385dff2f34Smyers return (AE_ERROR); 7397c478bd9Sstevel@tonic-gate } 7407c478bd9Sstevel@tonic-gate 74127f7c583Smyers if (ddi_taskq_dispatch(osl_eventq[Type], Function, Context, 74227f7c583Smyers DDI_NOSLEEP) == DDI_FAILURE) { 7437c478bd9Sstevel@tonic-gate #ifdef DEBUG 7447c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!acpica: unable to dispatch event"); 7457c478bd9Sstevel@tonic-gate #endif 7467c478bd9Sstevel@tonic-gate return (AE_ERROR); 7477c478bd9Sstevel@tonic-gate } 7487c478bd9Sstevel@tonic-gate return (AE_OK); 7497c478bd9Sstevel@tonic-gate 7507c478bd9Sstevel@tonic-gate } 7517c478bd9Sstevel@tonic-gate 752*7b1019a6SJerry Jelinek 753*7b1019a6SJerry Jelinek void 754*7b1019a6SJerry Jelinek AcpiOsWaitEventsComplete(void) 755*7b1019a6SJerry Jelinek { 756*7b1019a6SJerry Jelinek int i; 757*7b1019a6SJerry Jelinek 758*7b1019a6SJerry Jelinek /* 759*7b1019a6SJerry Jelinek * Wait for event queues to be empty. 760*7b1019a6SJerry Jelinek */ 761*7b1019a6SJerry Jelinek for (i = OSL_GLOBAL_LOCK_HANDLER; i <= OSL_EC_BURST_HANDLER; i++) { 762*7b1019a6SJerry Jelinek if (osl_eventq[i] != NULL) { 763*7b1019a6SJerry Jelinek ddi_taskq_wait(osl_eventq[i]); 764*7b1019a6SJerry Jelinek } 765*7b1019a6SJerry Jelinek } 766*7b1019a6SJerry Jelinek } 767*7b1019a6SJerry Jelinek 7687c478bd9Sstevel@tonic-gate void 7697c478bd9Sstevel@tonic-gate AcpiOsSleep(ACPI_INTEGER Milliseconds) 7707c478bd9Sstevel@tonic-gate { 7717c478bd9Sstevel@tonic-gate /* 772137e2f25SGuoli Shu * During kernel startup, before the first tick interrupt 773137e2f25SGuoli Shu * has taken place, we can't call delay; very late in 774137e2f25SGuoli Shu * kernel shutdown or suspend/resume, clock interrupts 775859dcd3dSmyers * are blocked, so delay doesn't work then either. 776859dcd3dSmyers * So we busy wait if lbolt == 0 (kernel startup) 777137e2f25SGuoli Shu * or if acpica_use_safe_delay has been set to a 778137e2f25SGuoli Shu * non-zero value. 7797c478bd9Sstevel@tonic-gate */ 780137e2f25SGuoli Shu if ((ddi_get_lbolt() == 0) || acpica_use_safe_delay) 7817c478bd9Sstevel@tonic-gate drv_usecwait(Milliseconds * 1000); 7827c478bd9Sstevel@tonic-gate else 7837c478bd9Sstevel@tonic-gate delay(drv_usectohz(Milliseconds * 1000)); 7847c478bd9Sstevel@tonic-gate } 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate void 7877c478bd9Sstevel@tonic-gate AcpiOsStall(UINT32 Microseconds) 7887c478bd9Sstevel@tonic-gate { 7897c478bd9Sstevel@tonic-gate drv_usecwait(Microseconds); 7907c478bd9Sstevel@tonic-gate } 7917c478bd9Sstevel@tonic-gate 7927c478bd9Sstevel@tonic-gate 7937c478bd9Sstevel@tonic-gate /* 7947c478bd9Sstevel@tonic-gate * Implementation of "Windows 2001" compatible I/O permission map 7957c478bd9Sstevel@tonic-gate * 7967c478bd9Sstevel@tonic-gate */ 7977c478bd9Sstevel@tonic-gate #define OSL_IO_NONE (0) 7987c478bd9Sstevel@tonic-gate #define OSL_IO_READ (1<<0) 7997c478bd9Sstevel@tonic-gate #define OSL_IO_WRITE (1<<1) 8007c478bd9Sstevel@tonic-gate #define OSL_IO_RW (OSL_IO_READ | OSL_IO_WRITE) 8017c478bd9Sstevel@tonic-gate #define OSL_IO_TERM (1<<2) 8027c478bd9Sstevel@tonic-gate #define OSL_IO_DEFAULT OSL_IO_RW 8037c478bd9Sstevel@tonic-gate 8047c478bd9Sstevel@tonic-gate static struct io_perm { 8057c478bd9Sstevel@tonic-gate ACPI_IO_ADDRESS low; 8067c478bd9Sstevel@tonic-gate ACPI_IO_ADDRESS high; 8077c478bd9Sstevel@tonic-gate uint8_t perm; 8087c478bd9Sstevel@tonic-gate } osl_io_perm[] = { 8094cf02d40SSaurabh Misra { 0xcf8, 0xd00, OSL_IO_TERM | OSL_IO_RW} 8107c478bd9Sstevel@tonic-gate }; 8117c478bd9Sstevel@tonic-gate 8127c478bd9Sstevel@tonic-gate 8137c478bd9Sstevel@tonic-gate /* 8147c478bd9Sstevel@tonic-gate * 8157c478bd9Sstevel@tonic-gate */ 8167c478bd9Sstevel@tonic-gate static struct io_perm * 8177c478bd9Sstevel@tonic-gate osl_io_find_perm(ACPI_IO_ADDRESS addr) 8187c478bd9Sstevel@tonic-gate { 8197c478bd9Sstevel@tonic-gate struct io_perm *p; 8207c478bd9Sstevel@tonic-gate 8217c478bd9Sstevel@tonic-gate p = osl_io_perm; 8227c478bd9Sstevel@tonic-gate while (p != NULL) { 8237c478bd9Sstevel@tonic-gate if ((p->low <= addr) && (addr <= p->high)) 8247c478bd9Sstevel@tonic-gate break; 8257c478bd9Sstevel@tonic-gate p = (p->perm & OSL_IO_TERM) ? NULL : p+1; 8267c478bd9Sstevel@tonic-gate } 8277c478bd9Sstevel@tonic-gate 8287c478bd9Sstevel@tonic-gate return (p); 8297c478bd9Sstevel@tonic-gate } 8307c478bd9Sstevel@tonic-gate 8317c478bd9Sstevel@tonic-gate /* 8327c478bd9Sstevel@tonic-gate * 8337c478bd9Sstevel@tonic-gate */ 8347c478bd9Sstevel@tonic-gate ACPI_STATUS 8357c478bd9Sstevel@tonic-gate AcpiOsReadPort(ACPI_IO_ADDRESS Address, UINT32 *Value, UINT32 Width) 8367c478bd9Sstevel@tonic-gate { 8377c478bd9Sstevel@tonic-gate struct io_perm *p; 8387c478bd9Sstevel@tonic-gate 8397c478bd9Sstevel@tonic-gate /* verify permission */ 8407c478bd9Sstevel@tonic-gate p = osl_io_find_perm(Address); 8417c478bd9Sstevel@tonic-gate if (p && (p->perm & OSL_IO_READ) == 0) { 8427c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!AcpiOsReadPort: %lx %u not permitted", 8435dff2f34Smyers (long)Address, Width); 8447c478bd9Sstevel@tonic-gate *Value = 0xffffffff; 8457c478bd9Sstevel@tonic-gate return (AE_ERROR); 8467c478bd9Sstevel@tonic-gate } 8477c478bd9Sstevel@tonic-gate 8487c478bd9Sstevel@tonic-gate switch (Width) { 8497c478bd9Sstevel@tonic-gate case 8: 8507c478bd9Sstevel@tonic-gate *Value = inb(Address); 8517c478bd9Sstevel@tonic-gate break; 8527c478bd9Sstevel@tonic-gate case 16: 8537c478bd9Sstevel@tonic-gate *Value = inw(Address); 8547c478bd9Sstevel@tonic-gate break; 8557c478bd9Sstevel@tonic-gate case 32: 8567c478bd9Sstevel@tonic-gate *Value = inl(Address); 8577c478bd9Sstevel@tonic-gate break; 8587c478bd9Sstevel@tonic-gate default: 8597c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!AcpiOsReadPort: %lx %u failed", 8605dff2f34Smyers (long)Address, Width); 8617c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 8627c478bd9Sstevel@tonic-gate } 8637c478bd9Sstevel@tonic-gate return (AE_OK); 8647c478bd9Sstevel@tonic-gate } 8657c478bd9Sstevel@tonic-gate 8667c478bd9Sstevel@tonic-gate ACPI_STATUS 8677c478bd9Sstevel@tonic-gate AcpiOsWritePort(ACPI_IO_ADDRESS Address, UINT32 Value, UINT32 Width) 8687c478bd9Sstevel@tonic-gate { 8697c478bd9Sstevel@tonic-gate struct io_perm *p; 8707c478bd9Sstevel@tonic-gate 8717c478bd9Sstevel@tonic-gate /* verify permission */ 8727c478bd9Sstevel@tonic-gate p = osl_io_find_perm(Address); 8737c478bd9Sstevel@tonic-gate if (p && (p->perm & OSL_IO_WRITE) == 0) { 8747c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!AcpiOsWritePort: %lx %u not permitted", 8757c478bd9Sstevel@tonic-gate (long)Address, Width); 8767c478bd9Sstevel@tonic-gate return (AE_ERROR); 8777c478bd9Sstevel@tonic-gate } 8787c478bd9Sstevel@tonic-gate 8797c478bd9Sstevel@tonic-gate switch (Width) { 8807c478bd9Sstevel@tonic-gate case 8: 8817c478bd9Sstevel@tonic-gate outb(Address, Value); 8827c478bd9Sstevel@tonic-gate break; 8837c478bd9Sstevel@tonic-gate case 16: 8847c478bd9Sstevel@tonic-gate outw(Address, Value); 8857c478bd9Sstevel@tonic-gate break; 8867c478bd9Sstevel@tonic-gate case 32: 8877c478bd9Sstevel@tonic-gate outl(Address, Value); 8887c478bd9Sstevel@tonic-gate break; 8897c478bd9Sstevel@tonic-gate default: 8907c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!AcpiOsWritePort: %lx %u failed", 8917c478bd9Sstevel@tonic-gate (long)Address, Width); 8927c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 8937c478bd9Sstevel@tonic-gate } 8947c478bd9Sstevel@tonic-gate return (AE_OK); 8957c478bd9Sstevel@tonic-gate } 8967c478bd9Sstevel@tonic-gate 8977c478bd9Sstevel@tonic-gate 8987c478bd9Sstevel@tonic-gate /* 8997c478bd9Sstevel@tonic-gate * 9007c478bd9Sstevel@tonic-gate */ 9017c478bd9Sstevel@tonic-gate 9027c478bd9Sstevel@tonic-gate #define OSL_RW(ptr, val, type, rw) \ 9037c478bd9Sstevel@tonic-gate { if (rw) *((type *)(ptr)) = *((type *) val); \ 9047c478bd9Sstevel@tonic-gate else *((type *) val) = *((type *)(ptr)); } 9057c478bd9Sstevel@tonic-gate 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate static void 908*7b1019a6SJerry Jelinek osl_rw_memory(ACPI_PHYSICAL_ADDRESS Address, UINT64 *Value, 9097c478bd9Sstevel@tonic-gate UINT32 Width, int write) 9107c478bd9Sstevel@tonic-gate { 9117c478bd9Sstevel@tonic-gate size_t maplen = Width / 8; 9127c478bd9Sstevel@tonic-gate caddr_t ptr; 9137c478bd9Sstevel@tonic-gate 9147c478bd9Sstevel@tonic-gate ptr = psm_map_new((paddr_t)Address, maplen, 9157c478bd9Sstevel@tonic-gate PSM_PROT_WRITE | PSM_PROT_READ); 9167c478bd9Sstevel@tonic-gate 9177c478bd9Sstevel@tonic-gate switch (maplen) { 9187c478bd9Sstevel@tonic-gate case 1: 9197c478bd9Sstevel@tonic-gate OSL_RW(ptr, Value, uint8_t, write); 9207c478bd9Sstevel@tonic-gate break; 9217c478bd9Sstevel@tonic-gate case 2: 9227c478bd9Sstevel@tonic-gate OSL_RW(ptr, Value, uint16_t, write); 9237c478bd9Sstevel@tonic-gate break; 9247c478bd9Sstevel@tonic-gate case 4: 9257c478bd9Sstevel@tonic-gate OSL_RW(ptr, Value, uint32_t, write); 9267c478bd9Sstevel@tonic-gate break; 927*7b1019a6SJerry Jelinek case 8: 928*7b1019a6SJerry Jelinek OSL_RW(ptr, Value, uint64_t, write); 929*7b1019a6SJerry Jelinek break; 9307c478bd9Sstevel@tonic-gate default: 9317c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!osl_rw_memory: invalid size %d", 9327c478bd9Sstevel@tonic-gate Width); 9337c478bd9Sstevel@tonic-gate break; 9347c478bd9Sstevel@tonic-gate } 9357c478bd9Sstevel@tonic-gate 9367c478bd9Sstevel@tonic-gate psm_unmap(ptr, maplen); 9377c478bd9Sstevel@tonic-gate } 9387c478bd9Sstevel@tonic-gate 9397c478bd9Sstevel@tonic-gate ACPI_STATUS 9407c478bd9Sstevel@tonic-gate AcpiOsReadMemory(ACPI_PHYSICAL_ADDRESS Address, 941*7b1019a6SJerry Jelinek UINT64 *Value, UINT32 Width) 9427c478bd9Sstevel@tonic-gate { 9437c478bd9Sstevel@tonic-gate osl_rw_memory(Address, Value, Width, 0); 9447c478bd9Sstevel@tonic-gate return (AE_OK); 9457c478bd9Sstevel@tonic-gate } 9467c478bd9Sstevel@tonic-gate 9477c478bd9Sstevel@tonic-gate ACPI_STATUS 9487c478bd9Sstevel@tonic-gate AcpiOsWriteMemory(ACPI_PHYSICAL_ADDRESS Address, 949*7b1019a6SJerry Jelinek UINT64 Value, UINT32 Width) 9507c478bd9Sstevel@tonic-gate { 9517c478bd9Sstevel@tonic-gate osl_rw_memory(Address, &Value, Width, 1); 9527c478bd9Sstevel@tonic-gate return (AE_OK); 9537c478bd9Sstevel@tonic-gate } 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate 9567c478bd9Sstevel@tonic-gate ACPI_STATUS 95726f3cdf0SGordon Ross AcpiOsReadPciConfiguration(ACPI_PCI_ID *PciId, UINT32 Reg, 95826f3cdf0SGordon Ross UINT64 *Value, UINT32 Width) 9597c478bd9Sstevel@tonic-gate { 9607c478bd9Sstevel@tonic-gate 9617c478bd9Sstevel@tonic-gate switch (Width) { 9627c478bd9Sstevel@tonic-gate case 8: 96326f3cdf0SGordon Ross *Value = (UINT64)(*pci_getb_func) 96426f3cdf0SGordon Ross (PciId->Bus, PciId->Device, PciId->Function, Reg); 9657c478bd9Sstevel@tonic-gate break; 9667c478bd9Sstevel@tonic-gate case 16: 96726f3cdf0SGordon Ross *Value = (UINT64)(*pci_getw_func) 96826f3cdf0SGordon Ross (PciId->Bus, PciId->Device, PciId->Function, Reg); 9697c478bd9Sstevel@tonic-gate break; 9707c478bd9Sstevel@tonic-gate case 32: 97126f3cdf0SGordon Ross *Value = (UINT64)(*pci_getl_func) 97226f3cdf0SGordon Ross (PciId->Bus, PciId->Device, PciId->Function, Reg); 9737c478bd9Sstevel@tonic-gate break; 9747c478bd9Sstevel@tonic-gate case 64: 9757c478bd9Sstevel@tonic-gate default: 9767c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!AcpiOsReadPciConfiguration: %x %u failed", 97726f3cdf0SGordon Ross Reg, Width); 9787c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 9797c478bd9Sstevel@tonic-gate } 9807c478bd9Sstevel@tonic-gate return (AE_OK); 9817c478bd9Sstevel@tonic-gate } 9827c478bd9Sstevel@tonic-gate 9837c478bd9Sstevel@tonic-gate /* 9847c478bd9Sstevel@tonic-gate * 9857c478bd9Sstevel@tonic-gate */ 9867c478bd9Sstevel@tonic-gate int acpica_write_pci_config_ok = 1; 9877c478bd9Sstevel@tonic-gate 9887c478bd9Sstevel@tonic-gate ACPI_STATUS 98926f3cdf0SGordon Ross AcpiOsWritePciConfiguration(ACPI_PCI_ID *PciId, UINT32 Reg, 99026f3cdf0SGordon Ross UINT64 Value, UINT32 Width) 9917c478bd9Sstevel@tonic-gate { 9927c478bd9Sstevel@tonic-gate 9937c478bd9Sstevel@tonic-gate if (!acpica_write_pci_config_ok) { 9947c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!write to PCI cfg %x/%x/%x %x" 9957c478bd9Sstevel@tonic-gate " %lx %d not permitted", PciId->Bus, PciId->Device, 99626f3cdf0SGordon Ross PciId->Function, Reg, (long)Value, Width); 9977c478bd9Sstevel@tonic-gate return (AE_OK); 9987c478bd9Sstevel@tonic-gate } 9997c478bd9Sstevel@tonic-gate 10007c478bd9Sstevel@tonic-gate switch (Width) { 10017c478bd9Sstevel@tonic-gate case 8: 10027c478bd9Sstevel@tonic-gate (*pci_putb_func)(PciId->Bus, PciId->Device, PciId->Function, 100326f3cdf0SGordon Ross Reg, (uint8_t)Value); 10047c478bd9Sstevel@tonic-gate break; 10057c478bd9Sstevel@tonic-gate case 16: 10067c478bd9Sstevel@tonic-gate (*pci_putw_func)(PciId->Bus, PciId->Device, PciId->Function, 100726f3cdf0SGordon Ross Reg, (uint16_t)Value); 10087c478bd9Sstevel@tonic-gate break; 10097c478bd9Sstevel@tonic-gate case 32: 10107c478bd9Sstevel@tonic-gate (*pci_putl_func)(PciId->Bus, PciId->Device, PciId->Function, 101126f3cdf0SGordon Ross Reg, (uint32_t)Value); 10127c478bd9Sstevel@tonic-gate break; 10137c478bd9Sstevel@tonic-gate case 64: 10147c478bd9Sstevel@tonic-gate default: 10157c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!AcpiOsWritePciConfiguration: %x %u failed", 101626f3cdf0SGordon Ross Reg, Width); 10177c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 10187c478bd9Sstevel@tonic-gate } 10197c478bd9Sstevel@tonic-gate return (AE_OK); 10207c478bd9Sstevel@tonic-gate } 10217c478bd9Sstevel@tonic-gate 10227c478bd9Sstevel@tonic-gate /* 10237c478bd9Sstevel@tonic-gate * Called with ACPI_HANDLEs for both a PCI Config Space 10247c478bd9Sstevel@tonic-gate * OpRegion and (what ACPI CA thinks is) the PCI device 10255f68fde5SDana Myers * to which this ConfigSpace OpRegion belongs. 10267c478bd9Sstevel@tonic-gate * 10275f68fde5SDana Myers * ACPI CA uses _BBN and _ADR objects to determine the default 10285f68fde5SDana Myers * values for bus, segment, device and function; anything ACPI CA 10295f68fde5SDana Myers * can't figure out from the ACPI tables will be 0. One very 10305f68fde5SDana Myers * old 32-bit x86 system is known to have broken _BBN; this is 10315f68fde5SDana Myers * not addressed here. 10327c478bd9Sstevel@tonic-gate * 103327f7c583Smyers * Some BIOSes implement _BBN() by reading PCI config space 10345dff2f34Smyers * on bus #0 - which means that we'll recurse when we attempt 103527f7c583Smyers * to create the devinfo-to-ACPI map. If Derive is called during 10365cff7825Smh * scan_d2a_map, we don't translate the bus # and return. 10375cff7825Smh * 10385cff7825Smh * We get the parent of the OpRegion, which must be a PCI 10395cff7825Smh * node, fetch the associated devinfo node and snag the 10405cff7825Smh * b/d/f from it. 10417c478bd9Sstevel@tonic-gate */ 10427c478bd9Sstevel@tonic-gate void 10437c478bd9Sstevel@tonic-gate AcpiOsDerivePciId(ACPI_HANDLE rhandle, ACPI_HANDLE chandle, 10447c478bd9Sstevel@tonic-gate ACPI_PCI_ID **PciId) 10457c478bd9Sstevel@tonic-gate { 10467c478bd9Sstevel@tonic-gate ACPI_HANDLE handle; 10475cff7825Smh dev_info_t *dip; 10485cff7825Smh int bus, device, func, devfn; 10497c478bd9Sstevel@tonic-gate 105027f7c583Smyers /* 10515cff7825Smh * See above - avoid recursing during scanning_d2a_map. 105227f7c583Smyers */ 10535cff7825Smh if (scanning_d2a_map) 10547c478bd9Sstevel@tonic-gate return; 10557c478bd9Sstevel@tonic-gate 10567c478bd9Sstevel@tonic-gate /* 10575cff7825Smh * Get the OpRegion's parent 10587c478bd9Sstevel@tonic-gate */ 10597c478bd9Sstevel@tonic-gate if (AcpiGetParent(chandle, &handle) != AE_OK) 10607c478bd9Sstevel@tonic-gate return; 10617c478bd9Sstevel@tonic-gate 10625cff7825Smh /* 10635cff7825Smh * If we've mapped the ACPI node to the devinfo 10645cff7825Smh * tree, use the devinfo reg property 10655cff7825Smh */ 10665f68fde5SDana Myers if (ACPI_SUCCESS(acpica_get_devinfo(handle, &dip)) && 10675f68fde5SDana Myers (acpica_get_bdf(dip, &bus, &device, &func) >= 0)) { 10685cff7825Smh (*PciId)->Bus = bus; 10695cff7825Smh (*PciId)->Device = device; 10705cff7825Smh (*PciId)->Function = func; 10717c478bd9Sstevel@tonic-gate } 10727c478bd9Sstevel@tonic-gate } 10737c478bd9Sstevel@tonic-gate 10747c478bd9Sstevel@tonic-gate 107527f7c583Smyers /*ARGSUSED*/ 10767c478bd9Sstevel@tonic-gate BOOLEAN 10777c478bd9Sstevel@tonic-gate AcpiOsReadable(void *Pointer, ACPI_SIZE Length) 10787c478bd9Sstevel@tonic-gate { 10797c478bd9Sstevel@tonic-gate 10807c478bd9Sstevel@tonic-gate /* Always says yes; all mapped memory assumed readable */ 10817c478bd9Sstevel@tonic-gate return (1); 10827c478bd9Sstevel@tonic-gate } 10837c478bd9Sstevel@tonic-gate 108427f7c583Smyers /*ARGSUSED*/ 10857c478bd9Sstevel@tonic-gate BOOLEAN 10867c478bd9Sstevel@tonic-gate AcpiOsWritable(void *Pointer, ACPI_SIZE Length) 10877c478bd9Sstevel@tonic-gate { 10887c478bd9Sstevel@tonic-gate 10897c478bd9Sstevel@tonic-gate /* Always says yes; all mapped memory assumed writable */ 10907c478bd9Sstevel@tonic-gate return (1); 10917c478bd9Sstevel@tonic-gate } 10927c478bd9Sstevel@tonic-gate 10937c478bd9Sstevel@tonic-gate UINT64 10947c478bd9Sstevel@tonic-gate AcpiOsGetTimer(void) 10957c478bd9Sstevel@tonic-gate { 109627f7c583Smyers /* gethrtime() returns 1nS resolution; convert to 100nS granules */ 109727f7c583Smyers return ((gethrtime() + 50) / 100); 109827f7c583Smyers } 10997c478bd9Sstevel@tonic-gate 1100fa96bd91SMichael Corcoran static struct AcpiOSIFeature_s { 1101fa96bd91SMichael Corcoran uint64_t control_flag; 1102fa96bd91SMichael Corcoran const char *feature_name; 1103fa96bd91SMichael Corcoran } AcpiOSIFeatures[] = { 1104fa96bd91SMichael Corcoran { ACPI_FEATURE_OSI_MODULE, "Module Device" }, 1105fa96bd91SMichael Corcoran { 0, "Processor Device" } 1106fa96bd91SMichael Corcoran }; 1107fa96bd91SMichael Corcoran 110827f7c583Smyers /*ARGSUSED*/ 110927f7c583Smyers ACPI_STATUS 1110fa96bd91SMichael Corcoran AcpiOsValidateInterface(char *feature) 111127f7c583Smyers { 1112fa96bd91SMichael Corcoran int i; 1113fa96bd91SMichael Corcoran 1114fa96bd91SMichael Corcoran ASSERT(feature != NULL); 1115fa96bd91SMichael Corcoran for (i = 0; i < sizeof (AcpiOSIFeatures) / sizeof (AcpiOSIFeatures[0]); 1116fa96bd91SMichael Corcoran i++) { 1117fa96bd91SMichael Corcoran if (strcmp(feature, AcpiOSIFeatures[i].feature_name) != 0) { 1118fa96bd91SMichael Corcoran continue; 1119fa96bd91SMichael Corcoran } 1120fa96bd91SMichael Corcoran /* Check whether required core features are available. */ 1121fa96bd91SMichael Corcoran if (AcpiOSIFeatures[i].control_flag != 0 && 1122fa96bd91SMichael Corcoran acpica_get_core_feature(AcpiOSIFeatures[i].control_flag) != 1123fa96bd91SMichael Corcoran AcpiOSIFeatures[i].control_flag) { 1124fa96bd91SMichael Corcoran break; 1125fa96bd91SMichael Corcoran } 1126fa96bd91SMichael Corcoran /* Feature supported. */ 1127fa96bd91SMichael Corcoran return (AE_OK); 1128fa96bd91SMichael Corcoran } 1129fa96bd91SMichael Corcoran 113027f7c583Smyers return (AE_SUPPORT); 113127f7c583Smyers } 11327c478bd9Sstevel@tonic-gate 113327f7c583Smyers /*ARGSUSED*/ 113427f7c583Smyers ACPI_STATUS 113527f7c583Smyers AcpiOsValidateAddress(UINT8 spaceid, ACPI_PHYSICAL_ADDRESS addr, 113627f7c583Smyers ACPI_SIZE length) 113727f7c583Smyers { 113827f7c583Smyers return (AE_OK); 11397c478bd9Sstevel@tonic-gate } 11407c478bd9Sstevel@tonic-gate 11417c478bd9Sstevel@tonic-gate ACPI_STATUS 11427c478bd9Sstevel@tonic-gate AcpiOsSignal(UINT32 Function, void *Info) 11437c478bd9Sstevel@tonic-gate { 11447c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(Function, Info)) 11457c478bd9Sstevel@tonic-gate 11467c478bd9Sstevel@tonic-gate /* FUTUREWORK: debugger support */ 11477c478bd9Sstevel@tonic-gate 11487c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!OsSignal unimplemented"); 11497c478bd9Sstevel@tonic-gate return (AE_OK); 11507c478bd9Sstevel@tonic-gate } 11517c478bd9Sstevel@tonic-gate 11527c478bd9Sstevel@tonic-gate void ACPI_INTERNAL_VAR_XFACE 11537c478bd9Sstevel@tonic-gate AcpiOsPrintf(const char *Format, ...) 11547c478bd9Sstevel@tonic-gate { 11557c478bd9Sstevel@tonic-gate va_list ap; 1156186507a7Smyers 1157186507a7Smyers va_start(ap, Format); 1158186507a7Smyers AcpiOsVprintf(Format, ap); 1159186507a7Smyers va_end(ap); 1160186507a7Smyers } 1161186507a7Smyers 1162186507a7Smyers /* 1163186507a7Smyers * When != 0, sends output to console 1164186507a7Smyers * Patchable with kmdb or /etc/system. 1165186507a7Smyers */ 1166186507a7Smyers int acpica_console_out = 0; 1167186507a7Smyers 1168186507a7Smyers #define ACPICA_OUTBUF_LEN 160 1169186507a7Smyers char acpica_outbuf[ACPICA_OUTBUF_LEN]; 1170186507a7Smyers int acpica_outbuf_offset; 1171186507a7Smyers 1172186507a7Smyers /* 1173186507a7Smyers * 1174186507a7Smyers */ 1175186507a7Smyers static void 117687bb58d6Smyers acpica_pr_buf(char *buf) 1177186507a7Smyers { 1178186507a7Smyers char c, *bufp, *outp; 1179186507a7Smyers int out_remaining; 1180186507a7Smyers 1181186507a7Smyers /* 1182186507a7Smyers * copy the supplied buffer into the output buffer 1183186507a7Smyers * when we hit a '\n' or overflow the output buffer, 1184186507a7Smyers * output and reset the output buffer 1185186507a7Smyers */ 1186186507a7Smyers bufp = buf; 1187186507a7Smyers outp = acpica_outbuf + acpica_outbuf_offset; 1188186507a7Smyers out_remaining = ACPICA_OUTBUF_LEN - acpica_outbuf_offset - 1; 1189186507a7Smyers while (c = *bufp++) { 1190186507a7Smyers *outp++ = c; 1191186507a7Smyers if (c == '\n' || --out_remaining == 0) { 1192186507a7Smyers *outp = '\0'; 11939bb29364SDana Myers switch (acpica_console_out) { 11949bb29364SDana Myers case 1: 1195186507a7Smyers printf(acpica_outbuf); 11969bb29364SDana Myers break; 11979bb29364SDana Myers case 2: 11989bb29364SDana Myers prom_printf(acpica_outbuf); 11999bb29364SDana Myers break; 12009bb29364SDana Myers case 0: 12019bb29364SDana Myers default: 1202186507a7Smyers (void) strlog(0, 0, 0, 1203186507a7Smyers SL_CONSOLE | SL_NOTE | SL_LOGONLY, 1204186507a7Smyers acpica_outbuf); 12059bb29364SDana Myers break; 12069bb29364SDana Myers } 1207186507a7Smyers acpica_outbuf_offset = 0; 1208186507a7Smyers outp = acpica_outbuf; 1209186507a7Smyers out_remaining = ACPICA_OUTBUF_LEN - 1; 1210186507a7Smyers } 1211186507a7Smyers } 1212186507a7Smyers 1213186507a7Smyers acpica_outbuf_offset = outp - acpica_outbuf; 1214186507a7Smyers } 1215186507a7Smyers 1216186507a7Smyers void 1217186507a7Smyers AcpiOsVprintf(const char *Format, va_list Args) 1218186507a7Smyers { 12197c478bd9Sstevel@tonic-gate 12207c478bd9Sstevel@tonic-gate /* 122187bb58d6Smyers * If AcpiOsInitialize() failed to allocate a string buffer, 122287bb58d6Smyers * resort to vprintf(). 12237c478bd9Sstevel@tonic-gate */ 122487bb58d6Smyers if (acpi_osl_pr_buffer == NULL) { 1225186507a7Smyers vprintf(Format, Args); 12267c478bd9Sstevel@tonic-gate return; 12277c478bd9Sstevel@tonic-gate } 122887bb58d6Smyers 122987bb58d6Smyers /* 123087bb58d6Smyers * It is possible that a very long debug output statement will 123187bb58d6Smyers * be truncated; this is silently ignored. 123287bb58d6Smyers */ 123387bb58d6Smyers (void) vsnprintf(acpi_osl_pr_buffer, acpi_osl_pr_buflen, Format, Args); 123487bb58d6Smyers acpica_pr_buf(acpi_osl_pr_buffer); 12357c478bd9Sstevel@tonic-gate } 12367c478bd9Sstevel@tonic-gate 12377c478bd9Sstevel@tonic-gate void 12387c478bd9Sstevel@tonic-gate AcpiOsRedirectOutput(void *Destination) 12397c478bd9Sstevel@tonic-gate { 12407c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(Destination)) 12417c478bd9Sstevel@tonic-gate 12427c478bd9Sstevel@tonic-gate /* FUTUREWORK: debugger support */ 12437c478bd9Sstevel@tonic-gate 12447c478bd9Sstevel@tonic-gate #ifdef DEBUG 12457c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!acpica: AcpiOsRedirectOutput called"); 12467c478bd9Sstevel@tonic-gate #endif 12477c478bd9Sstevel@tonic-gate } 12487c478bd9Sstevel@tonic-gate 12497c478bd9Sstevel@tonic-gate 12507c478bd9Sstevel@tonic-gate UINT32 125126f3cdf0SGordon Ross AcpiOsGetLine(char *Buffer, UINT32 len, UINT32 *BytesRead) 12527c478bd9Sstevel@tonic-gate { 12537c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(Buffer)) 125426f3cdf0SGordon Ross _NOTE(ARGUNUSED(len)) 125526f3cdf0SGordon Ross _NOTE(ARGUNUSED(BytesRead)) 12567c478bd9Sstevel@tonic-gate 12577c478bd9Sstevel@tonic-gate /* FUTUREWORK: debugger support */ 12587c478bd9Sstevel@tonic-gate 12597c478bd9Sstevel@tonic-gate return (0); 12607c478bd9Sstevel@tonic-gate } 12617c478bd9Sstevel@tonic-gate 12627c478bd9Sstevel@tonic-gate /* 12637c478bd9Sstevel@tonic-gate * Device tree binding 12647c478bd9Sstevel@tonic-gate */ 1265fa96bd91SMichael Corcoran static ACPI_STATUS 1266fa96bd91SMichael Corcoran acpica_find_pcibus_walker(ACPI_HANDLE hdl, UINT32 lvl, void *ctxp, void **rvpp) 1267fa96bd91SMichael Corcoran { 1268fa96bd91SMichael Corcoran _NOTE(ARGUNUSED(lvl)); 1269fa96bd91SMichael Corcoran 1270fa96bd91SMichael Corcoran int sta, hid, bbn; 1271fa96bd91SMichael Corcoran int busno = (intptr_t)ctxp; 1272fa96bd91SMichael Corcoran ACPI_HANDLE *hdlp = (ACPI_HANDLE *)rvpp; 1273fa96bd91SMichael Corcoran 1274fa96bd91SMichael Corcoran /* Check whether device exists. */ 1275fa96bd91SMichael Corcoran if (ACPI_SUCCESS(acpica_eval_int(hdl, "_STA", &sta)) && 1276fa96bd91SMichael Corcoran !(sta & (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_FUNCTIONING))) { 1277fa96bd91SMichael Corcoran /* 1278fa96bd91SMichael Corcoran * Skip object if device doesn't exist. 1279fa96bd91SMichael Corcoran * According to ACPI Spec, 1280fa96bd91SMichael Corcoran * 1) setting either bit 0 or bit 3 means that device exists. 1281fa96bd91SMichael Corcoran * 2) Absence of _STA method means all status bits set. 1282fa96bd91SMichael Corcoran */ 1283fa96bd91SMichael Corcoran return (AE_CTRL_DEPTH); 1284fa96bd91SMichael Corcoran } 1285fa96bd91SMichael Corcoran 1286fa96bd91SMichael Corcoran if (ACPI_FAILURE(acpica_eval_hid(hdl, "_HID", &hid)) || 1287fa96bd91SMichael Corcoran (hid != HID_PCI_BUS && hid != HID_PCI_EXPRESS_BUS)) { 1288fa96bd91SMichael Corcoran /* Non PCI/PCIe host bridge. */ 1289fa96bd91SMichael Corcoran return (AE_OK); 1290fa96bd91SMichael Corcoran } 1291fa96bd91SMichael Corcoran 1292fa96bd91SMichael Corcoran if (acpi_has_broken_bbn) { 1293fa96bd91SMichael Corcoran ACPI_BUFFER rb; 1294fa96bd91SMichael Corcoran rb.Pointer = NULL; 1295fa96bd91SMichael Corcoran rb.Length = ACPI_ALLOCATE_BUFFER; 1296fa96bd91SMichael Corcoran 1297fa96bd91SMichael Corcoran /* Decree _BBN == n from PCI<n> */ 1298fa96bd91SMichael Corcoran if (AcpiGetName(hdl, ACPI_SINGLE_NAME, &rb) != AE_OK) { 1299fa96bd91SMichael Corcoran return (AE_CTRL_TERMINATE); 1300fa96bd91SMichael Corcoran } 1301fa96bd91SMichael Corcoran bbn = ((char *)rb.Pointer)[3] - '0'; 1302fa96bd91SMichael Corcoran AcpiOsFree(rb.Pointer); 1303fa96bd91SMichael Corcoran if (bbn == busno || busno == 0) { 1304fa96bd91SMichael Corcoran *hdlp = hdl; 1305fa96bd91SMichael Corcoran return (AE_CTRL_TERMINATE); 1306fa96bd91SMichael Corcoran } 1307fa96bd91SMichael Corcoran } else if (ACPI_SUCCESS(acpica_eval_int(hdl, "_BBN", &bbn))) { 1308fa96bd91SMichael Corcoran if (bbn == busno) { 1309fa96bd91SMichael Corcoran *hdlp = hdl; 1310fa96bd91SMichael Corcoran return (AE_CTRL_TERMINATE); 1311fa96bd91SMichael Corcoran } 1312fa96bd91SMichael Corcoran } else if (busno == 0) { 1313fa96bd91SMichael Corcoran *hdlp = hdl; 1314fa96bd91SMichael Corcoran return (AE_CTRL_TERMINATE); 1315fa96bd91SMichael Corcoran } 1316fa96bd91SMichael Corcoran 1317fa96bd91SMichael Corcoran return (AE_CTRL_DEPTH); 1318fa96bd91SMichael Corcoran } 13197c478bd9Sstevel@tonic-gate 13207c478bd9Sstevel@tonic-gate static int 13217c478bd9Sstevel@tonic-gate acpica_find_pcibus(int busno, ACPI_HANDLE *rh) 13227c478bd9Sstevel@tonic-gate { 13237c478bd9Sstevel@tonic-gate ACPI_HANDLE sbobj, busobj; 13247c478bd9Sstevel@tonic-gate 13257c478bd9Sstevel@tonic-gate /* initialize static flag by querying ACPI namespace for bug */ 13267c478bd9Sstevel@tonic-gate if (acpi_has_broken_bbn == -1) 13277c478bd9Sstevel@tonic-gate acpi_has_broken_bbn = acpica_query_bbn_problem(); 13287c478bd9Sstevel@tonic-gate 1329fa96bd91SMichael Corcoran if (ACPI_SUCCESS(AcpiGetHandle(NULL, "\\_SB", &sbobj))) { 1330fa96bd91SMichael Corcoran busobj = NULL; 1331fa96bd91SMichael Corcoran (void) AcpiWalkNamespace(ACPI_TYPE_DEVICE, sbobj, UINT32_MAX, 133257190917SDana Myers acpica_find_pcibus_walker, NULL, (void *)(intptr_t)busno, 1333fa96bd91SMichael Corcoran (void **)&busobj); 1334fa96bd91SMichael Corcoran if (busobj != NULL) { 1335fa96bd91SMichael Corcoran *rh = busobj; 1336fa96bd91SMichael Corcoran return (AE_OK); 13377c478bd9Sstevel@tonic-gate } 13387c478bd9Sstevel@tonic-gate } 1339fa96bd91SMichael Corcoran 13407c478bd9Sstevel@tonic-gate return (AE_ERROR); 13417c478bd9Sstevel@tonic-gate } 13427c478bd9Sstevel@tonic-gate 1343fa96bd91SMichael Corcoran static ACPI_STATUS 1344fa96bd91SMichael Corcoran acpica_query_bbn_walker(ACPI_HANDLE hdl, UINT32 lvl, void *ctxp, void **rvpp) 1345fa96bd91SMichael Corcoran { 1346fa96bd91SMichael Corcoran _NOTE(ARGUNUSED(lvl)); 1347fa96bd91SMichael Corcoran _NOTE(ARGUNUSED(rvpp)); 1348fa96bd91SMichael Corcoran 1349fa96bd91SMichael Corcoran int sta, hid, bbn; 1350fa96bd91SMichael Corcoran int *cntp = (int *)ctxp; 1351fa96bd91SMichael Corcoran 1352fa96bd91SMichael Corcoran /* Check whether device exists. */ 1353fa96bd91SMichael Corcoran if (ACPI_SUCCESS(acpica_eval_int(hdl, "_STA", &sta)) && 1354fa96bd91SMichael Corcoran !(sta & (ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_FUNCTIONING))) { 1355fa96bd91SMichael Corcoran /* 1356fa96bd91SMichael Corcoran * Skip object if device doesn't exist. 1357fa96bd91SMichael Corcoran * According to ACPI Spec, 1358fa96bd91SMichael Corcoran * 1) setting either bit 0 or bit 3 means that device exists. 1359fa96bd91SMichael Corcoran * 2) Absence of _STA method means all status bits set. 1360fa96bd91SMichael Corcoran */ 1361fa96bd91SMichael Corcoran return (AE_CTRL_DEPTH); 1362fa96bd91SMichael Corcoran } 1363fa96bd91SMichael Corcoran 1364fa96bd91SMichael Corcoran if (ACPI_FAILURE(acpica_eval_hid(hdl, "_HID", &hid)) || 1365fa96bd91SMichael Corcoran (hid != HID_PCI_BUS && hid != HID_PCI_EXPRESS_BUS)) { 1366fa96bd91SMichael Corcoran /* Non PCI/PCIe host bridge. */ 1367fa96bd91SMichael Corcoran return (AE_OK); 1368fa96bd91SMichael Corcoran } else if (ACPI_SUCCESS(acpica_eval_int(hdl, "_BBN", &bbn)) && 1369fa96bd91SMichael Corcoran bbn == 0 && ++(*cntp) > 1) { 1370fa96bd91SMichael Corcoran /* 1371fa96bd91SMichael Corcoran * If we find more than one bus with a 0 _BBN 1372fa96bd91SMichael Corcoran * we have the problem that BigBear's BIOS shows 1373fa96bd91SMichael Corcoran */ 1374fa96bd91SMichael Corcoran return (AE_CTRL_TERMINATE); 1375fa96bd91SMichael Corcoran } else { 1376fa96bd91SMichael Corcoran /* 1377fa96bd91SMichael Corcoran * Skip children of PCI/PCIe host bridge. 1378fa96bd91SMichael Corcoran */ 1379fa96bd91SMichael Corcoran return (AE_CTRL_DEPTH); 1380fa96bd91SMichael Corcoran } 1381fa96bd91SMichael Corcoran } 13827c478bd9Sstevel@tonic-gate 13837c478bd9Sstevel@tonic-gate /* 13847c478bd9Sstevel@tonic-gate * Look for ACPI problem where _BBN is zero for multiple PCI buses 13857c478bd9Sstevel@tonic-gate * This is a clear ACPI bug, but we have a workaround in acpica_find_pcibus() 13867c478bd9Sstevel@tonic-gate * below if it exists. 13877c478bd9Sstevel@tonic-gate */ 13887c478bd9Sstevel@tonic-gate static int 13897c478bd9Sstevel@tonic-gate acpica_query_bbn_problem(void) 13907c478bd9Sstevel@tonic-gate { 1391fa96bd91SMichael Corcoran ACPI_HANDLE sbobj; 13927c478bd9Sstevel@tonic-gate int zerobbncnt; 1393fa96bd91SMichael Corcoran void *rv; 13947c478bd9Sstevel@tonic-gate 13957c478bd9Sstevel@tonic-gate zerobbncnt = 0; 1396fa96bd91SMichael Corcoran if (ACPI_SUCCESS(AcpiGetHandle(NULL, "\\_SB", &sbobj))) { 1397fa96bd91SMichael Corcoran (void) AcpiWalkNamespace(ACPI_TYPE_DEVICE, sbobj, UINT32_MAX, 139857190917SDana Myers acpica_query_bbn_walker, NULL, &zerobbncnt, &rv); 13997c478bd9Sstevel@tonic-gate } 1400fa96bd91SMichael Corcoran 1401fa96bd91SMichael Corcoran return (zerobbncnt > 1 ? 1 : 0); 14027c478bd9Sstevel@tonic-gate } 14037c478bd9Sstevel@tonic-gate 14047c478bd9Sstevel@tonic-gate static const char hextab[] = "0123456789ABCDEF"; 14057c478bd9Sstevel@tonic-gate 14067c478bd9Sstevel@tonic-gate static int 14077c478bd9Sstevel@tonic-gate hexdig(int c) 14087c478bd9Sstevel@tonic-gate { 14097c478bd9Sstevel@tonic-gate /* 14107c478bd9Sstevel@tonic-gate * Get hex digit: 14117c478bd9Sstevel@tonic-gate * 14127c478bd9Sstevel@tonic-gate * Returns the 4-bit hex digit named by the input character. Returns 14137c478bd9Sstevel@tonic-gate * zero if the input character is not valid hex! 14147c478bd9Sstevel@tonic-gate */ 14157c478bd9Sstevel@tonic-gate 14167c478bd9Sstevel@tonic-gate int x = ((c < 'a') || (c > 'z')) ? c : (c - ' '); 14177c478bd9Sstevel@tonic-gate int j = sizeof (hextab); 14187c478bd9Sstevel@tonic-gate 14195dff2f34Smyers while (--j && (x != hextab[j])) { 14205dff2f34Smyers } 14217c478bd9Sstevel@tonic-gate return (j); 14227c478bd9Sstevel@tonic-gate } 14237c478bd9Sstevel@tonic-gate 14247c478bd9Sstevel@tonic-gate static int 14257c478bd9Sstevel@tonic-gate CompressEisaID(char *np) 14267c478bd9Sstevel@tonic-gate { 14277c478bd9Sstevel@tonic-gate /* 14287c478bd9Sstevel@tonic-gate * Compress an EISA device name: 14297c478bd9Sstevel@tonic-gate * 14307c478bd9Sstevel@tonic-gate * This routine converts a 7-byte ASCII device name into the 4-byte 14317c478bd9Sstevel@tonic-gate * compressed form used by EISA (50 bytes of ROM to save 1 byte of 14327c478bd9Sstevel@tonic-gate * NV-RAM!) 14337c478bd9Sstevel@tonic-gate */ 14347c478bd9Sstevel@tonic-gate 14357c478bd9Sstevel@tonic-gate union { char octets[4]; int retval; } myu; 14367c478bd9Sstevel@tonic-gate 14377c478bd9Sstevel@tonic-gate myu.octets[0] = ((np[0] & 0x1F) << 2) + ((np[1] >> 3) & 0x03); 14387c478bd9Sstevel@tonic-gate myu.octets[1] = ((np[1] & 0x07) << 5) + (np[2] & 0x1F); 14397c478bd9Sstevel@tonic-gate myu.octets[2] = (hexdig(np[3]) << 4) + hexdig(np[4]); 14407c478bd9Sstevel@tonic-gate myu.octets[3] = (hexdig(np[5]) << 4) + hexdig(np[6]); 14417c478bd9Sstevel@tonic-gate 14427c478bd9Sstevel@tonic-gate return (myu.retval); 14437c478bd9Sstevel@tonic-gate } 14447c478bd9Sstevel@tonic-gate 14455cff7825Smh ACPI_STATUS 14467c478bd9Sstevel@tonic-gate acpica_eval_int(ACPI_HANDLE dev, char *method, int *rint) 14477c478bd9Sstevel@tonic-gate { 14487c478bd9Sstevel@tonic-gate ACPI_STATUS status; 14497c478bd9Sstevel@tonic-gate ACPI_BUFFER rb; 14507c478bd9Sstevel@tonic-gate ACPI_OBJECT ro; 14517c478bd9Sstevel@tonic-gate 14527c478bd9Sstevel@tonic-gate rb.Pointer = &ro; 14537c478bd9Sstevel@tonic-gate rb.Length = sizeof (ro); 14547c478bd9Sstevel@tonic-gate if ((status = AcpiEvaluateObjectTyped(dev, method, NULL, &rb, 14555dff2f34Smyers ACPI_TYPE_INTEGER)) == AE_OK) 14567c478bd9Sstevel@tonic-gate *rint = ro.Integer.Value; 14577c478bd9Sstevel@tonic-gate 14587c478bd9Sstevel@tonic-gate return (status); 14597c478bd9Sstevel@tonic-gate } 14607c478bd9Sstevel@tonic-gate 14617c478bd9Sstevel@tonic-gate static int 14627c478bd9Sstevel@tonic-gate acpica_eval_hid(ACPI_HANDLE dev, char *method, int *rint) 14637c478bd9Sstevel@tonic-gate { 14647c478bd9Sstevel@tonic-gate ACPI_BUFFER rb; 14657c478bd9Sstevel@tonic-gate ACPI_OBJECT *rv; 14667c478bd9Sstevel@tonic-gate 14677c478bd9Sstevel@tonic-gate rb.Pointer = NULL; 14687c478bd9Sstevel@tonic-gate rb.Length = ACPI_ALLOCATE_BUFFER; 1469db2bae30SDana Myers if (AcpiEvaluateObject(dev, method, NULL, &rb) == AE_OK && 1470db2bae30SDana Myers rb.Length != 0) { 14717c478bd9Sstevel@tonic-gate rv = rb.Pointer; 14727c478bd9Sstevel@tonic-gate if (rv->Type == ACPI_TYPE_INTEGER) { 14737c478bd9Sstevel@tonic-gate *rint = rv->Integer.Value; 14747c478bd9Sstevel@tonic-gate AcpiOsFree(rv); 14757c478bd9Sstevel@tonic-gate return (AE_OK); 14767c478bd9Sstevel@tonic-gate } else if (rv->Type == ACPI_TYPE_STRING) { 14777c478bd9Sstevel@tonic-gate char *stringData; 14787c478bd9Sstevel@tonic-gate 14797c478bd9Sstevel@tonic-gate /* Convert the string into an EISA ID */ 14807c478bd9Sstevel@tonic-gate if (rv->String.Pointer == NULL) { 14817c478bd9Sstevel@tonic-gate AcpiOsFree(rv); 14827c478bd9Sstevel@tonic-gate return (AE_ERROR); 14837c478bd9Sstevel@tonic-gate } 14847c478bd9Sstevel@tonic-gate 14857c478bd9Sstevel@tonic-gate stringData = rv->String.Pointer; 14867c478bd9Sstevel@tonic-gate 14877c478bd9Sstevel@tonic-gate /* 14887c478bd9Sstevel@tonic-gate * If the string is an EisaID, it must be 7 14897c478bd9Sstevel@tonic-gate * characters; if it's an ACPI ID, it will be 8 14907c478bd9Sstevel@tonic-gate * (and we don't care about ACPI ids here). 14917c478bd9Sstevel@tonic-gate */ 14927c478bd9Sstevel@tonic-gate if (strlen(stringData) != 7) { 14937c478bd9Sstevel@tonic-gate AcpiOsFree(rv); 14947c478bd9Sstevel@tonic-gate return (AE_ERROR); 14957c478bd9Sstevel@tonic-gate } 14967c478bd9Sstevel@tonic-gate 14977c478bd9Sstevel@tonic-gate *rint = CompressEisaID(stringData); 14987c478bd9Sstevel@tonic-gate AcpiOsFree(rv); 14997c478bd9Sstevel@tonic-gate return (AE_OK); 15007c478bd9Sstevel@tonic-gate } else 15017c478bd9Sstevel@tonic-gate AcpiOsFree(rv); 15027c478bd9Sstevel@tonic-gate } 15037c478bd9Sstevel@tonic-gate return (AE_ERROR); 15047c478bd9Sstevel@tonic-gate } 15057c478bd9Sstevel@tonic-gate 15067c478bd9Sstevel@tonic-gate /* 15075cff7825Smh * Create linkage between devinfo nodes and ACPI nodes 15087c478bd9Sstevel@tonic-gate */ 1509fa96bd91SMichael Corcoran ACPI_STATUS 15105cff7825Smh acpica_tag_devinfo(dev_info_t *dip, ACPI_HANDLE acpiobj) 15117c478bd9Sstevel@tonic-gate { 15125cff7825Smh ACPI_STATUS status; 15135cff7825Smh ACPI_BUFFER rb; 15147c478bd9Sstevel@tonic-gate 15155cff7825Smh /* 15165cff7825Smh * Tag the devinfo node with the ACPI name 15175cff7825Smh */ 15185cff7825Smh rb.Pointer = NULL; 15195cff7825Smh rb.Length = ACPI_ALLOCATE_BUFFER; 1520fa96bd91SMichael Corcoran status = AcpiGetName(acpiobj, ACPI_FULL_PATHNAME, &rb); 1521fa96bd91SMichael Corcoran if (ACPI_FAILURE(status)) { 1522fa96bd91SMichael Corcoran cmn_err(CE_WARN, "acpica: could not get ACPI path!"); 1523fa96bd91SMichael Corcoran } else { 15245cff7825Smh (void) ndi_prop_update_string(DDI_DEV_T_NONE, dip, 15255cff7825Smh "acpi-namespace", (char *)rb.Pointer); 15265cff7825Smh AcpiOsFree(rb.Pointer); 15277c478bd9Sstevel@tonic-gate 1528fa96bd91SMichael Corcoran /* 1529fa96bd91SMichael Corcoran * Tag the ACPI node with the dip 1530fa96bd91SMichael Corcoran */ 1531fa96bd91SMichael Corcoran status = acpica_set_devinfo(acpiobj, dip); 1532fa96bd91SMichael Corcoran ASSERT(ACPI_SUCCESS(status)); 15335cff7825Smh } 15345cff7825Smh 1535fa96bd91SMichael Corcoran return (status); 1536fa96bd91SMichael Corcoran } 15375cff7825Smh 1538fa96bd91SMichael Corcoran /* 1539fa96bd91SMichael Corcoran * Destroy linkage between devinfo nodes and ACPI nodes 1540fa96bd91SMichael Corcoran */ 1541fa96bd91SMichael Corcoran ACPI_STATUS 1542fa96bd91SMichael Corcoran acpica_untag_devinfo(dev_info_t *dip, ACPI_HANDLE acpiobj) 1543fa96bd91SMichael Corcoran { 1544fa96bd91SMichael Corcoran (void) acpica_unset_devinfo(acpiobj); 1545fa96bd91SMichael Corcoran (void) ndi_prop_remove(DDI_DEV_T_NONE, dip, "acpi-namespace"); 15467c478bd9Sstevel@tonic-gate 1547fa96bd91SMichael Corcoran return (AE_OK); 15487c478bd9Sstevel@tonic-gate } 15497c478bd9Sstevel@tonic-gate 15507c478bd9Sstevel@tonic-gate /* 1551495256c0Smh * Return the ACPI device node matching the CPU dev_info node. 15527c478bd9Sstevel@tonic-gate */ 15535cff7825Smh ACPI_STATUS 15540e751525SEric Saxe acpica_get_handle_cpu(int cpu_id, ACPI_HANDLE *rh) 15557c478bd9Sstevel@tonic-gate { 1556fa96bd91SMichael Corcoran int i; 1557fa96bd91SMichael Corcoran 15585cff7825Smh /* 15595cff7825Smh * if cpu_map itself is NULL, we're a uppc system and 15605cff7825Smh * acpica_build_processor_map() hasn't been called yet. 15615cff7825Smh * So call it here 15625cff7825Smh */ 15635cff7825Smh if (cpu_map == NULL) { 15645cff7825Smh (void) acpica_build_processor_map(); 15655cff7825Smh if (cpu_map == NULL) 15665cff7825Smh return (AE_ERROR); 15677c478bd9Sstevel@tonic-gate } 15687c478bd9Sstevel@tonic-gate 1569fa96bd91SMichael Corcoran if (cpu_id < 0) { 15705cff7825Smh return (AE_ERROR); 1571fa96bd91SMichael Corcoran } 15725cff7825Smh 1573fa96bd91SMichael Corcoran /* 1574fa96bd91SMichael Corcoran * search object with cpuid in cpu_map 1575fa96bd91SMichael Corcoran */ 1576fa96bd91SMichael Corcoran mutex_enter(&cpu_map_lock); 1577fa96bd91SMichael Corcoran for (i = 0; i < cpu_map_count; i++) { 1578fa96bd91SMichael Corcoran if (cpu_map[i]->cpu_id == cpu_id) { 1579fa96bd91SMichael Corcoran break; 1580fa96bd91SMichael Corcoran } 1581fa96bd91SMichael Corcoran } 1582b72d5b75SMichael Corcoran if (i < cpu_map_count && (cpu_map[i]->obj != NULL)) { 1583a3114836SGerry Liu *rh = cpu_map[i]->obj; 1584fa96bd91SMichael Corcoran mutex_exit(&cpu_map_lock); 1585b72d5b75SMichael Corcoran return (AE_OK); 1586b72d5b75SMichael Corcoran } 1587b72d5b75SMichael Corcoran 1588b72d5b75SMichael Corcoran /* Handle special case for uppc-only systems. */ 1589b72d5b75SMichael Corcoran if (cpu_map_called == 0) { 1590b72d5b75SMichael Corcoran uint32_t apicid = cpuid_get_apicid(CPU); 1591b72d5b75SMichael Corcoran if (apicid != UINT32_MAX) { 1592b72d5b75SMichael Corcoran for (i = 0; i < cpu_map_count; i++) { 1593b72d5b75SMichael Corcoran if (cpu_map[i]->apic_id == apicid) { 1594b72d5b75SMichael Corcoran break; 1595b72d5b75SMichael Corcoran } 1596b72d5b75SMichael Corcoran } 1597b72d5b75SMichael Corcoran if (i < cpu_map_count && (cpu_map[i]->obj != NULL)) { 1598a3114836SGerry Liu *rh = cpu_map[i]->obj; 1599b72d5b75SMichael Corcoran mutex_exit(&cpu_map_lock); 1600b72d5b75SMichael Corcoran return (AE_OK); 1601b72d5b75SMichael Corcoran } 1602b72d5b75SMichael Corcoran } 1603fa96bd91SMichael Corcoran } 1604fa96bd91SMichael Corcoran mutex_exit(&cpu_map_lock); 1605fa96bd91SMichael Corcoran 1606b72d5b75SMichael Corcoran return (AE_ERROR); 16075cff7825Smh } 16085cff7825Smh 16095cff7825Smh /* 16105cff7825Smh * Determine if this object is a processor 16115cff7825Smh */ 16125cff7825Smh static ACPI_STATUS 16135cff7825Smh acpica_probe_processor(ACPI_HANDLE obj, UINT32 level, void *ctx, void **rv) 16145cff7825Smh { 16155cff7825Smh ACPI_STATUS status; 16165cff7825Smh ACPI_OBJECT_TYPE objtype; 16174b1ce0a9SDana Myers unsigned long acpi_id; 16185cff7825Smh ACPI_BUFFER rb; 161957190917SDana Myers ACPI_DEVICE_INFO *di; 16205cff7825Smh 16215cff7825Smh if (AcpiGetType(obj, &objtype) != AE_OK) 16225cff7825Smh return (AE_OK); 16235cff7825Smh 16245cff7825Smh if (objtype == ACPI_TYPE_PROCESSOR) { 16255cff7825Smh /* process a Processor */ 16267c478bd9Sstevel@tonic-gate rb.Pointer = NULL; 16277c478bd9Sstevel@tonic-gate rb.Length = ACPI_ALLOCATE_BUFFER; 1628db2bae30SDana Myers status = AcpiEvaluateObjectTyped(obj, NULL, NULL, &rb, 1629db2bae30SDana Myers ACPI_TYPE_PROCESSOR); 16305cff7825Smh if (status != AE_OK) { 16314b1ce0a9SDana Myers cmn_err(CE_WARN, "!acpica: error probing Processor"); 16325cff7825Smh return (status); 16337c478bd9Sstevel@tonic-gate } 16345cff7825Smh acpi_id = ((ACPI_OBJECT *)rb.Pointer)->Processor.ProcId; 16355cff7825Smh AcpiOsFree(rb.Pointer); 16365cff7825Smh } else if (objtype == ACPI_TYPE_DEVICE) { 16375cff7825Smh /* process a processor Device */ 163857190917SDana Myers status = AcpiGetObjectInfo(obj, &di); 1639b6917abeSmishra if (status != AE_OK) { 1640b6917abeSmishra cmn_err(CE_WARN, 16414b1ce0a9SDana Myers "!acpica: error probing Processor Device\n"); 1642b6917abeSmishra return (status); 1643b6917abeSmishra } 16444b1ce0a9SDana Myers 164557190917SDana Myers if (!(di->Valid & ACPI_VALID_UID) || 164657190917SDana Myers ddi_strtoul(di->UniqueId.String, NULL, 10, &acpi_id) != 0) { 164757190917SDana Myers ACPI_FREE(di); 16484b1ce0a9SDana Myers cmn_err(CE_WARN, 16494b1ce0a9SDana Myers "!acpica: error probing Processor Device _UID\n"); 16504b1ce0a9SDana Myers return (AE_ERROR); 16514b1ce0a9SDana Myers } 165257190917SDana Myers ACPI_FREE(di); 16537c478bd9Sstevel@tonic-gate } 1654fa96bd91SMichael Corcoran (void) acpica_add_processor_to_map(acpi_id, obj, UINT32_MAX); 16555cff7825Smh 16565cff7825Smh return (AE_OK); 16577c478bd9Sstevel@tonic-gate } 16587c478bd9Sstevel@tonic-gate 1659432cf5a9SDana Myers void 16605cff7825Smh scan_d2a_map(void) 16617c478bd9Sstevel@tonic-gate { 16627c478bd9Sstevel@tonic-gate dev_info_t *dip, *cdip; 16637c478bd9Sstevel@tonic-gate ACPI_HANDLE acpiobj; 16647c478bd9Sstevel@tonic-gate char *device_type_prop; 16657c478bd9Sstevel@tonic-gate int bus; 16667c478bd9Sstevel@tonic-gate static int map_error = 0; 16677c478bd9Sstevel@tonic-gate 1668432cf5a9SDana Myers if (map_error || (d2a_done != 0)) 16697c478bd9Sstevel@tonic-gate return; 16707c478bd9Sstevel@tonic-gate 16715cff7825Smh scanning_d2a_map = 1; 16727c478bd9Sstevel@tonic-gate 16737c478bd9Sstevel@tonic-gate /* 16747c478bd9Sstevel@tonic-gate * Find all child-of-root PCI buses, and find their corresponding 16757c478bd9Sstevel@tonic-gate * ACPI child-of-root PCI nodes. For each one, add to the 16767c478bd9Sstevel@tonic-gate * d2a table. 16777c478bd9Sstevel@tonic-gate */ 16787c478bd9Sstevel@tonic-gate 16797c478bd9Sstevel@tonic-gate for (dip = ddi_get_child(ddi_root_node()); 16807c478bd9Sstevel@tonic-gate dip != NULL; 16817c478bd9Sstevel@tonic-gate dip = ddi_get_next_sibling(dip)) { 16827c478bd9Sstevel@tonic-gate 16837c478bd9Sstevel@tonic-gate /* prune non-PCI nodes */ 1684fa96bd91SMichael Corcoran if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 1685fa96bd91SMichael Corcoran DDI_PROP_DONTPASS, 16867c478bd9Sstevel@tonic-gate "device_type", &device_type_prop) != DDI_PROP_SUCCESS) 16877c478bd9Sstevel@tonic-gate continue; 16887c478bd9Sstevel@tonic-gate 168970025d76Sjohnny if ((strcmp("pci", device_type_prop) != 0) && 169070025d76Sjohnny (strcmp("pciex", device_type_prop) != 0)) { 16917c478bd9Sstevel@tonic-gate ddi_prop_free(device_type_prop); 16927c478bd9Sstevel@tonic-gate continue; 16937c478bd9Sstevel@tonic-gate } 16947c478bd9Sstevel@tonic-gate 16957c478bd9Sstevel@tonic-gate ddi_prop_free(device_type_prop); 16967c478bd9Sstevel@tonic-gate 16977c478bd9Sstevel@tonic-gate /* 16987c478bd9Sstevel@tonic-gate * To get bus number of dip, get first child and get its 16997c478bd9Sstevel@tonic-gate * bus number. If NULL, just continue, because we don't 17007c478bd9Sstevel@tonic-gate * care about bus nodes with no children anyway. 17017c478bd9Sstevel@tonic-gate */ 17027c478bd9Sstevel@tonic-gate if ((cdip = ddi_get_child(dip)) == NULL) 17037c478bd9Sstevel@tonic-gate continue; 17047c478bd9Sstevel@tonic-gate 17057c478bd9Sstevel@tonic-gate if (acpica_get_bdf(cdip, &bus, NULL, NULL) < 0) { 17067c478bd9Sstevel@tonic-gate #ifdef D2ADEBUG 17077c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "Can't get bus number of PCI child?"); 17087c478bd9Sstevel@tonic-gate #endif 17097c478bd9Sstevel@tonic-gate map_error = 1; 17105cff7825Smh scanning_d2a_map = 0; 17115cff7825Smh d2a_done = 1; 17127c478bd9Sstevel@tonic-gate return; 17137c478bd9Sstevel@tonic-gate } 17147c478bd9Sstevel@tonic-gate 17157c478bd9Sstevel@tonic-gate if (acpica_find_pcibus(bus, &acpiobj) == AE_ERROR) { 17167c478bd9Sstevel@tonic-gate #ifdef D2ADEBUG 17177c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "No ACPI bus obj for bus %d?\n", bus); 17187c478bd9Sstevel@tonic-gate #endif 17197c478bd9Sstevel@tonic-gate map_error = 1; 17207c478bd9Sstevel@tonic-gate continue; 17217c478bd9Sstevel@tonic-gate } 17227c478bd9Sstevel@tonic-gate 17235cff7825Smh acpica_tag_devinfo(dip, acpiobj); 17247c478bd9Sstevel@tonic-gate 17255cff7825Smh /* call recursively to enumerate subtrees */ 17265cff7825Smh scan_d2a_subtree(dip, acpiobj, bus); 17277c478bd9Sstevel@tonic-gate } 17285cff7825Smh 17295cff7825Smh scanning_d2a_map = 0; 17305cff7825Smh d2a_done = 1; 17317c478bd9Sstevel@tonic-gate } 17327c478bd9Sstevel@tonic-gate 17337c478bd9Sstevel@tonic-gate /* 17347c478bd9Sstevel@tonic-gate * For all acpi child devices of acpiobj, find their matching 17357c478bd9Sstevel@tonic-gate * dip under "dip" argument. (matching means "matches dev/fn"). 17367c478bd9Sstevel@tonic-gate * bus is assumed to already be a match from caller, and is 17377c478bd9Sstevel@tonic-gate * used here only to record in the d2a entry. Recurse if necessary. 17387c478bd9Sstevel@tonic-gate */ 17397c478bd9Sstevel@tonic-gate static void 17405cff7825Smh scan_d2a_subtree(dev_info_t *dip, ACPI_HANDLE acpiobj, int bus) 17417c478bd9Sstevel@tonic-gate { 17427c478bd9Sstevel@tonic-gate int acpi_devfn, hid; 17437c478bd9Sstevel@tonic-gate ACPI_HANDLE acld; 17447c478bd9Sstevel@tonic-gate dev_info_t *dcld; 17457c478bd9Sstevel@tonic-gate int dcld_b, dcld_d, dcld_f; 17467c478bd9Sstevel@tonic-gate int dev, func; 17475cff7825Smh char *device_type_prop; 17487c478bd9Sstevel@tonic-gate 17497c478bd9Sstevel@tonic-gate acld = NULL; 1750186507a7Smyers while (AcpiGetNextObject(ACPI_TYPE_DEVICE, acpiobj, acld, &acld) 17517c478bd9Sstevel@tonic-gate == AE_OK) { 17527c478bd9Sstevel@tonic-gate /* get the dev/func we're looking for in the devinfo tree */ 17537c478bd9Sstevel@tonic-gate if (acpica_eval_int(acld, "_ADR", &acpi_devfn) != AE_OK) 17547c478bd9Sstevel@tonic-gate continue; 17557c478bd9Sstevel@tonic-gate dev = (acpi_devfn >> 16) & 0xFFFF; 17567c478bd9Sstevel@tonic-gate func = acpi_devfn & 0xFFFF; 17577c478bd9Sstevel@tonic-gate 17587c478bd9Sstevel@tonic-gate /* look through all the immediate children of dip */ 17597c478bd9Sstevel@tonic-gate for (dcld = ddi_get_child(dip); dcld != NULL; 17607c478bd9Sstevel@tonic-gate dcld = ddi_get_next_sibling(dcld)) { 17617c478bd9Sstevel@tonic-gate if (acpica_get_bdf(dcld, &dcld_b, &dcld_d, &dcld_f) < 0) 17627c478bd9Sstevel@tonic-gate continue; 17637c478bd9Sstevel@tonic-gate 17647c478bd9Sstevel@tonic-gate /* dev must match; function must match or wildcard */ 17657c478bd9Sstevel@tonic-gate if (dcld_d != dev || 17667c478bd9Sstevel@tonic-gate (func != 0xFFFF && func != dcld_f)) 17677c478bd9Sstevel@tonic-gate continue; 17687c478bd9Sstevel@tonic-gate bus = dcld_b; 17697c478bd9Sstevel@tonic-gate 17707c478bd9Sstevel@tonic-gate /* found a match, record it */ 17715cff7825Smh acpica_tag_devinfo(dcld, acld); 17725cff7825Smh 17735cff7825Smh /* if we find a bridge, recurse from here */ 1774fa96bd91SMichael Corcoran if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dcld, 1775fa96bd91SMichael Corcoran DDI_PROP_DONTPASS, "device_type", 1776fa96bd91SMichael Corcoran &device_type_prop) == DDI_PROP_SUCCESS) { 17775cff7825Smh if ((strcmp("pci", device_type_prop) == 0) || 17785cff7825Smh (strcmp("pciex", device_type_prop) == 0)) 17795cff7825Smh scan_d2a_subtree(dcld, acld, bus); 17805cff7825Smh ddi_prop_free(device_type_prop); 17815cff7825Smh } 17827c478bd9Sstevel@tonic-gate 17837c478bd9Sstevel@tonic-gate /* done finding a match, so break now */ 17847c478bd9Sstevel@tonic-gate break; 17857c478bd9Sstevel@tonic-gate } 17868e56767dSsmall } 17877c478bd9Sstevel@tonic-gate } 17887c478bd9Sstevel@tonic-gate 17897c478bd9Sstevel@tonic-gate /* 17907c478bd9Sstevel@tonic-gate * Return bus/dev/fn for PCI dip (note: not the parent "pci" node). 17917c478bd9Sstevel@tonic-gate */ 17927c478bd9Sstevel@tonic-gate int 17937c478bd9Sstevel@tonic-gate acpica_get_bdf(dev_info_t *dip, int *bus, int *device, int *func) 17947c478bd9Sstevel@tonic-gate { 17957c478bd9Sstevel@tonic-gate pci_regspec_t *pci_rp; 17967c478bd9Sstevel@tonic-gate int len; 17977c478bd9Sstevel@tonic-gate 17987c478bd9Sstevel@tonic-gate if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 17997c478bd9Sstevel@tonic-gate "reg", (int **)&pci_rp, (uint_t *)&len) != DDI_SUCCESS) 18007c478bd9Sstevel@tonic-gate return (-1); 18017c478bd9Sstevel@tonic-gate 18027c478bd9Sstevel@tonic-gate if (len < (sizeof (pci_regspec_t) / sizeof (int))) { 18037c478bd9Sstevel@tonic-gate ddi_prop_free(pci_rp); 18047c478bd9Sstevel@tonic-gate return (-1); 18057c478bd9Sstevel@tonic-gate } 18067c478bd9Sstevel@tonic-gate if (bus != NULL) 18077c478bd9Sstevel@tonic-gate *bus = (int)PCI_REG_BUS_G(pci_rp->pci_phys_hi); 18087c478bd9Sstevel@tonic-gate if (device != NULL) 18097c478bd9Sstevel@tonic-gate *device = (int)PCI_REG_DEV_G(pci_rp->pci_phys_hi); 18107c478bd9Sstevel@tonic-gate if (func != NULL) 18117c478bd9Sstevel@tonic-gate *func = (int)PCI_REG_FUNC_G(pci_rp->pci_phys_hi); 18127c478bd9Sstevel@tonic-gate ddi_prop_free(pci_rp); 18137c478bd9Sstevel@tonic-gate return (0); 18147c478bd9Sstevel@tonic-gate } 18155cff7825Smh 18165cff7825Smh /* 18175cff7825Smh * Return the ACPI device node matching this dev_info node, if it 18185cff7825Smh * exists in the ACPI tree. 18195cff7825Smh */ 18205cff7825Smh ACPI_STATUS 18215cff7825Smh acpica_get_handle(dev_info_t *dip, ACPI_HANDLE *rh) 18225cff7825Smh { 18235cff7825Smh ACPI_STATUS status; 18245cff7825Smh char *acpiname; 18255cff7825Smh 1826149e87b3SDana Myers #ifdef DEBUG 1827149e87b3SDana Myers if (d2a_done == 0) 1828149e87b3SDana Myers cmn_err(CE_WARN, "!acpica_get_handle:" 1829149e87b3SDana Myers " no ACPI mapping for %s", ddi_node_name(dip)); 1830149e87b3SDana Myers #endif 18315cff7825Smh 18325cff7825Smh if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 18335cff7825Smh "acpi-namespace", &acpiname) != DDI_PROP_SUCCESS) { 18340e751525SEric Saxe return (AE_ERROR); 18355cff7825Smh } 18365cff7825Smh 18375cff7825Smh status = AcpiGetHandle(NULL, acpiname, rh); 18385cff7825Smh ddi_prop_free((void *)acpiname); 18395cff7825Smh return (status); 18405cff7825Smh } 18415cff7825Smh 18425cff7825Smh 18435cff7825Smh 18445cff7825Smh /* 18455cff7825Smh * Manage OS data attachment to ACPI nodes 18465cff7825Smh */ 18475cff7825Smh 18485cff7825Smh /* 18495cff7825Smh * Return the (dev_info_t *) associated with the ACPI node. 18505cff7825Smh */ 18515cff7825Smh ACPI_STATUS 18525cff7825Smh acpica_get_devinfo(ACPI_HANDLE obj, dev_info_t **dipp) 18535cff7825Smh { 18545cff7825Smh ACPI_STATUS status; 18555cff7825Smh void *ptr; 18565cff7825Smh 18575cff7825Smh status = AcpiGetData(obj, acpica_devinfo_handler, &ptr); 18585cff7825Smh if (status == AE_OK) 18595cff7825Smh *dipp = (dev_info_t *)ptr; 18605cff7825Smh 18615cff7825Smh return (status); 18625cff7825Smh } 18635cff7825Smh 18645cff7825Smh /* 18655cff7825Smh * Set the dev_info_t associated with the ACPI node. 18665cff7825Smh */ 18675cff7825Smh static ACPI_STATUS 18685cff7825Smh acpica_set_devinfo(ACPI_HANDLE obj, dev_info_t *dip) 18695cff7825Smh { 18705cff7825Smh ACPI_STATUS status; 18715cff7825Smh 18725cff7825Smh status = AcpiAttachData(obj, acpica_devinfo_handler, (void *)dip); 18735cff7825Smh return (status); 18745cff7825Smh } 18755cff7825Smh 18765cff7825Smh /* 1877fa96bd91SMichael Corcoran * Unset the dev_info_t associated with the ACPI node. 18785cff7825Smh */ 1879fa96bd91SMichael Corcoran static ACPI_STATUS 1880fa96bd91SMichael Corcoran acpica_unset_devinfo(ACPI_HANDLE obj) 18815cff7825Smh { 1882fa96bd91SMichael Corcoran return (AcpiDetachData(obj, acpica_devinfo_handler)); 18835cff7825Smh } 18845cff7825Smh 18855cff7825Smh /* 18865cff7825Smh * 18875cff7825Smh */ 18885cff7825Smh void 188957190917SDana Myers acpica_devinfo_handler(ACPI_HANDLE obj, void *data) 18905cff7825Smh { 189157190917SDana Myers /* no-op */ 18925cff7825Smh } 18935cff7825Smh 1894fa96bd91SMichael Corcoran ACPI_STATUS 1895fa96bd91SMichael Corcoran acpica_build_processor_map(void) 18965cff7825Smh { 18975cff7825Smh ACPI_STATUS status; 18985cff7825Smh void *rv; 18995cff7825Smh 19005cff7825Smh /* 19015cff7825Smh * shouldn't be called more than once anyway 19025cff7825Smh */ 19035cff7825Smh if (cpu_map_built) 1904fa96bd91SMichael Corcoran return (AE_OK); 1905fa96bd91SMichael Corcoran 1906fa96bd91SMichael Corcoran /* 1907fa96bd91SMichael Corcoran * ACPI device configuration driver has built mapping information 1908fa96bd91SMichael Corcoran * among processor id and object handle, no need to probe again. 1909fa96bd91SMichael Corcoran */ 1910fa96bd91SMichael Corcoran if (acpica_get_devcfg_feature(ACPI_DEVCFG_CPU)) { 1911fa96bd91SMichael Corcoran cpu_map_built = 1; 1912fa96bd91SMichael Corcoran return (AE_OK); 1913fa96bd91SMichael Corcoran } 19145cff7825Smh 19155cff7825Smh /* 19165cff7825Smh * Look for Processor objects 19175cff7825Smh */ 19185cff7825Smh status = AcpiWalkNamespace(ACPI_TYPE_PROCESSOR, 19195cff7825Smh ACPI_ROOT_OBJECT, 19205cff7825Smh 4, 19215cff7825Smh acpica_probe_processor, 19225cff7825Smh NULL, 192357190917SDana Myers NULL, 19245cff7825Smh &rv); 19255cff7825Smh ASSERT(status == AE_OK); 19265cff7825Smh 19275cff7825Smh /* 19285cff7825Smh * Look for processor Device objects 19295cff7825Smh */ 19305cff7825Smh status = AcpiGetDevices("ACPI0007", 19315cff7825Smh acpica_probe_processor, 19325cff7825Smh NULL, 19335cff7825Smh &rv); 19345cff7825Smh ASSERT(status == AE_OK); 19355cff7825Smh cpu_map_built = 1; 1936fa96bd91SMichael Corcoran 1937fa96bd91SMichael Corcoran return (status); 1938fa96bd91SMichael Corcoran } 1939fa96bd91SMichael Corcoran 1940fa96bd91SMichael Corcoran /* 1941fa96bd91SMichael Corcoran * Grow cpu map table on demand. 1942fa96bd91SMichael Corcoran */ 1943fa96bd91SMichael Corcoran static void 1944fa96bd91SMichael Corcoran acpica_grow_cpu_map(void) 1945fa96bd91SMichael Corcoran { 1946fa96bd91SMichael Corcoran if (cpu_map_count == cpu_map_count_max) { 1947fa96bd91SMichael Corcoran size_t sz; 1948fa96bd91SMichael Corcoran struct cpu_map_item **new_map; 1949fa96bd91SMichael Corcoran 1950fa96bd91SMichael Corcoran ASSERT(cpu_map_count_max < INT_MAX / 2); 1951fa96bd91SMichael Corcoran cpu_map_count_max += max_ncpus; 1952fa96bd91SMichael Corcoran new_map = kmem_zalloc(sizeof (cpu_map[0]) * cpu_map_count_max, 1953fa96bd91SMichael Corcoran KM_SLEEP); 1954fa96bd91SMichael Corcoran if (cpu_map_count != 0) { 1955fa96bd91SMichael Corcoran ASSERT(cpu_map != NULL); 1956fa96bd91SMichael Corcoran sz = sizeof (cpu_map[0]) * cpu_map_count; 1957fa96bd91SMichael Corcoran kcopy(cpu_map, new_map, sz); 1958fa96bd91SMichael Corcoran kmem_free(cpu_map, sz); 1959fa96bd91SMichael Corcoran } 1960fa96bd91SMichael Corcoran cpu_map = new_map; 1961fa96bd91SMichael Corcoran } 1962fa96bd91SMichael Corcoran } 1963fa96bd91SMichael Corcoran 1964fa96bd91SMichael Corcoran /* 1965fa96bd91SMichael Corcoran * Maintain mapping information among (cpu id, ACPI processor id, APIC id, 1966fa96bd91SMichael Corcoran * ACPI handle). The mapping table will be setup in two steps: 1967fa96bd91SMichael Corcoran * 1) acpica_add_processor_to_map() builds mapping among APIC id, ACPI 1968fa96bd91SMichael Corcoran * processor id and ACPI object handle. 1969fa96bd91SMichael Corcoran * 2) acpica_map_cpu() builds mapping among cpu id and ACPI processor id. 1970b72d5b75SMichael Corcoran * On systems with which have ACPI device configuration for CPUs enabled, 1971b72d5b75SMichael Corcoran * acpica_map_cpu() will be called after acpica_add_processor_to_map(), 1972b72d5b75SMichael Corcoran * otherwise acpica_map_cpu() will be called before 1973b72d5b75SMichael Corcoran * acpica_add_processor_to_map(). 1974fa96bd91SMichael Corcoran */ 1975fa96bd91SMichael Corcoran ACPI_STATUS 1976fa96bd91SMichael Corcoran acpica_add_processor_to_map(UINT32 acpi_id, ACPI_HANDLE obj, UINT32 apic_id) 1977fa96bd91SMichael Corcoran { 1978fa96bd91SMichael Corcoran int i; 1979fa96bd91SMichael Corcoran ACPI_STATUS rc = AE_OK; 1980fa96bd91SMichael Corcoran struct cpu_map_item *item = NULL; 1981fa96bd91SMichael Corcoran 1982fa96bd91SMichael Corcoran ASSERT(obj != NULL); 1983fa96bd91SMichael Corcoran if (obj == NULL) { 1984fa96bd91SMichael Corcoran return (AE_ERROR); 1985fa96bd91SMichael Corcoran } 1986fa96bd91SMichael Corcoran 1987fa96bd91SMichael Corcoran mutex_enter(&cpu_map_lock); 1988fa96bd91SMichael Corcoran 1989fa96bd91SMichael Corcoran /* 1990fa96bd91SMichael Corcoran * Special case for uppc 1991fa96bd91SMichael Corcoran * If we're a uppc system and ACPI device configuration for CPU has 1992fa96bd91SMichael Corcoran * been disabled, there won't be a CPU map yet because uppc psm doesn't 1993fa96bd91SMichael Corcoran * call acpica_map_cpu(). So create one and use the passed-in processor 1994fa96bd91SMichael Corcoran * as CPU 0 1995b72d5b75SMichael Corcoran * Assumption: the first CPU returned by 1996b72d5b75SMichael Corcoran * AcpiGetDevices/AcpiWalkNamespace will be the BSP. 1997b72d5b75SMichael Corcoran * Unfortunately there appears to be no good way to ASSERT this. 1998fa96bd91SMichael Corcoran */ 1999fa96bd91SMichael Corcoran if (cpu_map == NULL && 2000fa96bd91SMichael Corcoran !acpica_get_devcfg_feature(ACPI_DEVCFG_CPU)) { 2001fa96bd91SMichael Corcoran acpica_grow_cpu_map(); 2002fa96bd91SMichael Corcoran ASSERT(cpu_map != NULL); 2003fa96bd91SMichael Corcoran item = kmem_zalloc(sizeof (*item), KM_SLEEP); 2004fa96bd91SMichael Corcoran item->cpu_id = 0; 2005fa96bd91SMichael Corcoran item->proc_id = acpi_id; 2006fa96bd91SMichael Corcoran item->apic_id = apic_id; 2007fa96bd91SMichael Corcoran item->obj = obj; 2008fa96bd91SMichael Corcoran cpu_map[0] = item; 2009fa96bd91SMichael Corcoran cpu_map_count = 1; 2010fa96bd91SMichael Corcoran mutex_exit(&cpu_map_lock); 2011fa96bd91SMichael Corcoran return (AE_OK); 2012fa96bd91SMichael Corcoran } 2013fa96bd91SMichael Corcoran 2014fa96bd91SMichael Corcoran for (i = 0; i < cpu_map_count; i++) { 2015fa96bd91SMichael Corcoran if (cpu_map[i]->obj == obj) { 2016fa96bd91SMichael Corcoran rc = AE_ALREADY_EXISTS; 2017fa96bd91SMichael Corcoran break; 2018fa96bd91SMichael Corcoran } else if (cpu_map[i]->proc_id == acpi_id) { 2019fa96bd91SMichael Corcoran ASSERT(item == NULL); 2020fa96bd91SMichael Corcoran item = cpu_map[i]; 2021fa96bd91SMichael Corcoran } 2022fa96bd91SMichael Corcoran } 2023fa96bd91SMichael Corcoran 2024fa96bd91SMichael Corcoran if (rc == AE_OK) { 2025fa96bd91SMichael Corcoran if (item != NULL) { 2026fa96bd91SMichael Corcoran /* 2027fa96bd91SMichael Corcoran * ACPI alias objects may cause more than one objects 2028fa96bd91SMichael Corcoran * with the same ACPI processor id, only remember the 2029fa96bd91SMichael Corcoran * the first object encountered. 2030fa96bd91SMichael Corcoran */ 2031fa96bd91SMichael Corcoran if (item->obj == NULL) { 2032fa96bd91SMichael Corcoran item->obj = obj; 2033fa96bd91SMichael Corcoran item->apic_id = apic_id; 2034fa96bd91SMichael Corcoran } else { 2035fa96bd91SMichael Corcoran rc = AE_ALREADY_EXISTS; 2036fa96bd91SMichael Corcoran } 2037fa96bd91SMichael Corcoran } else if (cpu_map_count >= INT_MAX / 2) { 2038fa96bd91SMichael Corcoran rc = AE_NO_MEMORY; 2039fa96bd91SMichael Corcoran } else { 2040fa96bd91SMichael Corcoran acpica_grow_cpu_map(); 2041fa96bd91SMichael Corcoran ASSERT(cpu_map != NULL); 2042fa96bd91SMichael Corcoran ASSERT(cpu_map_count < cpu_map_count_max); 2043fa96bd91SMichael Corcoran item = kmem_zalloc(sizeof (*item), KM_SLEEP); 2044fa96bd91SMichael Corcoran item->cpu_id = -1; 2045fa96bd91SMichael Corcoran item->proc_id = acpi_id; 2046fa96bd91SMichael Corcoran item->apic_id = apic_id; 2047fa96bd91SMichael Corcoran item->obj = obj; 2048fa96bd91SMichael Corcoran cpu_map[cpu_map_count] = item; 2049fa96bd91SMichael Corcoran cpu_map_count++; 2050fa96bd91SMichael Corcoran } 2051fa96bd91SMichael Corcoran } 2052fa96bd91SMichael Corcoran 2053fa96bd91SMichael Corcoran mutex_exit(&cpu_map_lock); 2054fa96bd91SMichael Corcoran 2055fa96bd91SMichael Corcoran return (rc); 2056fa96bd91SMichael Corcoran } 2057fa96bd91SMichael Corcoran 2058fa96bd91SMichael Corcoran ACPI_STATUS 2059fa96bd91SMichael Corcoran acpica_remove_processor_from_map(UINT32 acpi_id) 2060fa96bd91SMichael Corcoran { 2061fa96bd91SMichael Corcoran int i; 2062fa96bd91SMichael Corcoran ACPI_STATUS rc = AE_NOT_EXIST; 2063fa96bd91SMichael Corcoran 2064fa96bd91SMichael Corcoran mutex_enter(&cpu_map_lock); 2065fa96bd91SMichael Corcoran for (i = 0; i < cpu_map_count; i++) { 2066fa96bd91SMichael Corcoran if (cpu_map[i]->proc_id != acpi_id) { 2067fa96bd91SMichael Corcoran continue; 2068fa96bd91SMichael Corcoran } 2069fa96bd91SMichael Corcoran cpu_map[i]->obj = NULL; 2070fa96bd91SMichael Corcoran /* Free item if no more reference to it. */ 2071fa96bd91SMichael Corcoran if (cpu_map[i]->cpu_id == -1) { 2072fa96bd91SMichael Corcoran kmem_free(cpu_map[i], sizeof (struct cpu_map_item)); 2073fa96bd91SMichael Corcoran cpu_map[i] = NULL; 2074fa96bd91SMichael Corcoran cpu_map_count--; 2075fa96bd91SMichael Corcoran if (i != cpu_map_count) { 2076fa96bd91SMichael Corcoran cpu_map[i] = cpu_map[cpu_map_count]; 2077fa96bd91SMichael Corcoran cpu_map[cpu_map_count] = NULL; 2078fa96bd91SMichael Corcoran } 2079fa96bd91SMichael Corcoran } 2080fa96bd91SMichael Corcoran rc = AE_OK; 2081fa96bd91SMichael Corcoran break; 2082fa96bd91SMichael Corcoran } 2083fa96bd91SMichael Corcoran mutex_exit(&cpu_map_lock); 2084fa96bd91SMichael Corcoran 2085fa96bd91SMichael Corcoran return (rc); 2086fa96bd91SMichael Corcoran } 2087fa96bd91SMichael Corcoran 2088fa96bd91SMichael Corcoran ACPI_STATUS 2089fa96bd91SMichael Corcoran acpica_map_cpu(processorid_t cpuid, UINT32 acpi_id) 2090fa96bd91SMichael Corcoran { 2091fa96bd91SMichael Corcoran int i; 2092fa96bd91SMichael Corcoran ACPI_STATUS rc = AE_OK; 2093fa96bd91SMichael Corcoran struct cpu_map_item *item = NULL; 2094fa96bd91SMichael Corcoran 2095fa96bd91SMichael Corcoran ASSERT(cpuid != -1); 2096fa96bd91SMichael Corcoran if (cpuid == -1) { 2097fa96bd91SMichael Corcoran return (AE_ERROR); 2098fa96bd91SMichael Corcoran } 2099fa96bd91SMichael Corcoran 2100fa96bd91SMichael Corcoran mutex_enter(&cpu_map_lock); 2101b72d5b75SMichael Corcoran cpu_map_called = 1; 2102fa96bd91SMichael Corcoran for (i = 0; i < cpu_map_count; i++) { 2103fa96bd91SMichael Corcoran if (cpu_map[i]->cpu_id == cpuid) { 2104fa96bd91SMichael Corcoran rc = AE_ALREADY_EXISTS; 2105fa96bd91SMichael Corcoran break; 2106fa96bd91SMichael Corcoran } else if (cpu_map[i]->proc_id == acpi_id) { 2107fa96bd91SMichael Corcoran ASSERT(item == NULL); 2108fa96bd91SMichael Corcoran item = cpu_map[i]; 2109fa96bd91SMichael Corcoran } 2110fa96bd91SMichael Corcoran } 2111fa96bd91SMichael Corcoran if (rc == AE_OK) { 2112fa96bd91SMichael Corcoran if (item != NULL) { 2113fa96bd91SMichael Corcoran if (item->cpu_id == -1) { 2114fa96bd91SMichael Corcoran item->cpu_id = cpuid; 2115fa96bd91SMichael Corcoran } else { 2116fa96bd91SMichael Corcoran rc = AE_ALREADY_EXISTS; 2117fa96bd91SMichael Corcoran } 2118fa96bd91SMichael Corcoran } else if (cpu_map_count >= INT_MAX / 2) { 2119fa96bd91SMichael Corcoran rc = AE_NO_MEMORY; 2120fa96bd91SMichael Corcoran } else { 2121fa96bd91SMichael Corcoran acpica_grow_cpu_map(); 2122fa96bd91SMichael Corcoran ASSERT(cpu_map != NULL); 2123fa96bd91SMichael Corcoran ASSERT(cpu_map_count < cpu_map_count_max); 2124fa96bd91SMichael Corcoran item = kmem_zalloc(sizeof (*item), KM_SLEEP); 2125fa96bd91SMichael Corcoran item->cpu_id = cpuid; 2126fa96bd91SMichael Corcoran item->proc_id = acpi_id; 2127fa96bd91SMichael Corcoran item->apic_id = UINT32_MAX; 2128fa96bd91SMichael Corcoran item->obj = NULL; 2129fa96bd91SMichael Corcoran cpu_map[cpu_map_count] = item; 2130fa96bd91SMichael Corcoran cpu_map_count++; 2131fa96bd91SMichael Corcoran } 2132fa96bd91SMichael Corcoran } 2133fa96bd91SMichael Corcoran mutex_exit(&cpu_map_lock); 2134fa96bd91SMichael Corcoran 2135fa96bd91SMichael Corcoran return (rc); 2136fa96bd91SMichael Corcoran } 2137fa96bd91SMichael Corcoran 2138fa96bd91SMichael Corcoran ACPI_STATUS 2139fa96bd91SMichael Corcoran acpica_unmap_cpu(processorid_t cpuid) 2140fa96bd91SMichael Corcoran { 2141fa96bd91SMichael Corcoran int i; 2142fa96bd91SMichael Corcoran ACPI_STATUS rc = AE_NOT_EXIST; 2143fa96bd91SMichael Corcoran 2144fa96bd91SMichael Corcoran ASSERT(cpuid != -1); 2145fa96bd91SMichael Corcoran if (cpuid == -1) { 2146fa96bd91SMichael Corcoran return (rc); 2147fa96bd91SMichael Corcoran } 2148fa96bd91SMichael Corcoran 2149fa96bd91SMichael Corcoran mutex_enter(&cpu_map_lock); 2150fa96bd91SMichael Corcoran for (i = 0; i < cpu_map_count; i++) { 2151fa96bd91SMichael Corcoran if (cpu_map[i]->cpu_id != cpuid) { 2152fa96bd91SMichael Corcoran continue; 2153fa96bd91SMichael Corcoran } 2154fa96bd91SMichael Corcoran cpu_map[i]->cpu_id = -1; 2155fa96bd91SMichael Corcoran /* Free item if no more reference. */ 2156fa96bd91SMichael Corcoran if (cpu_map[i]->obj == NULL) { 2157fa96bd91SMichael Corcoran kmem_free(cpu_map[i], sizeof (struct cpu_map_item)); 2158fa96bd91SMichael Corcoran cpu_map[i] = NULL; 2159fa96bd91SMichael Corcoran cpu_map_count--; 2160fa96bd91SMichael Corcoran if (i != cpu_map_count) { 2161fa96bd91SMichael Corcoran cpu_map[i] = cpu_map[cpu_map_count]; 2162fa96bd91SMichael Corcoran cpu_map[cpu_map_count] = NULL; 2163fa96bd91SMichael Corcoran } 2164fa96bd91SMichael Corcoran } 2165fa96bd91SMichael Corcoran rc = AE_OK; 2166fa96bd91SMichael Corcoran break; 2167fa96bd91SMichael Corcoran } 2168fa96bd91SMichael Corcoran mutex_exit(&cpu_map_lock); 2169fa96bd91SMichael Corcoran 2170fa96bd91SMichael Corcoran return (rc); 2171fa96bd91SMichael Corcoran } 2172fa96bd91SMichael Corcoran 2173fa96bd91SMichael Corcoran ACPI_STATUS 2174fa96bd91SMichael Corcoran acpica_get_cpu_object_by_cpuid(processorid_t cpuid, ACPI_HANDLE *hdlp) 2175fa96bd91SMichael Corcoran { 2176fa96bd91SMichael Corcoran int i; 2177fa96bd91SMichael Corcoran ACPI_STATUS rc = AE_NOT_EXIST; 2178fa96bd91SMichael Corcoran 2179fa96bd91SMichael Corcoran ASSERT(cpuid != -1); 2180fa96bd91SMichael Corcoran if (cpuid == -1) { 2181fa96bd91SMichael Corcoran return (rc); 2182fa96bd91SMichael Corcoran } 2183fa96bd91SMichael Corcoran 2184fa96bd91SMichael Corcoran mutex_enter(&cpu_map_lock); 2185fa96bd91SMichael Corcoran for (i = 0; i < cpu_map_count; i++) { 2186fa96bd91SMichael Corcoran if (cpu_map[i]->cpu_id == cpuid && cpu_map[i]->obj != NULL) { 2187fa96bd91SMichael Corcoran *hdlp = cpu_map[i]->obj; 2188fa96bd91SMichael Corcoran rc = AE_OK; 2189fa96bd91SMichael Corcoran break; 2190fa96bd91SMichael Corcoran } 2191fa96bd91SMichael Corcoran } 2192fa96bd91SMichael Corcoran mutex_exit(&cpu_map_lock); 2193fa96bd91SMichael Corcoran 2194fa96bd91SMichael Corcoran return (rc); 2195fa96bd91SMichael Corcoran } 2196fa96bd91SMichael Corcoran 2197fa96bd91SMichael Corcoran ACPI_STATUS 2198fa96bd91SMichael Corcoran acpica_get_cpu_object_by_procid(UINT32 procid, ACPI_HANDLE *hdlp) 2199fa96bd91SMichael Corcoran { 2200fa96bd91SMichael Corcoran int i; 2201fa96bd91SMichael Corcoran ACPI_STATUS rc = AE_NOT_EXIST; 2202fa96bd91SMichael Corcoran 2203fa96bd91SMichael Corcoran mutex_enter(&cpu_map_lock); 2204fa96bd91SMichael Corcoran for (i = 0; i < cpu_map_count; i++) { 2205fa96bd91SMichael Corcoran if (cpu_map[i]->proc_id == procid && cpu_map[i]->obj != NULL) { 2206fa96bd91SMichael Corcoran *hdlp = cpu_map[i]->obj; 2207fa96bd91SMichael Corcoran rc = AE_OK; 2208fa96bd91SMichael Corcoran break; 2209fa96bd91SMichael Corcoran } 2210fa96bd91SMichael Corcoran } 2211fa96bd91SMichael Corcoran mutex_exit(&cpu_map_lock); 2212fa96bd91SMichael Corcoran 2213fa96bd91SMichael Corcoran return (rc); 2214fa96bd91SMichael Corcoran } 2215fa96bd91SMichael Corcoran 2216fa96bd91SMichael Corcoran ACPI_STATUS 2217fa96bd91SMichael Corcoran acpica_get_cpu_object_by_apicid(UINT32 apicid, ACPI_HANDLE *hdlp) 2218fa96bd91SMichael Corcoran { 2219fa96bd91SMichael Corcoran int i; 2220fa96bd91SMichael Corcoran ACPI_STATUS rc = AE_NOT_EXIST; 2221fa96bd91SMichael Corcoran 2222fa96bd91SMichael Corcoran ASSERT(apicid != UINT32_MAX); 2223fa96bd91SMichael Corcoran if (apicid == UINT32_MAX) { 2224fa96bd91SMichael Corcoran return (rc); 2225fa96bd91SMichael Corcoran } 2226fa96bd91SMichael Corcoran 2227fa96bd91SMichael Corcoran mutex_enter(&cpu_map_lock); 2228fa96bd91SMichael Corcoran for (i = 0; i < cpu_map_count; i++) { 2229fa96bd91SMichael Corcoran if (cpu_map[i]->apic_id == apicid && cpu_map[i]->obj != NULL) { 2230fa96bd91SMichael Corcoran *hdlp = cpu_map[i]->obj; 2231fa96bd91SMichael Corcoran rc = AE_OK; 2232fa96bd91SMichael Corcoran break; 2233fa96bd91SMichael Corcoran } 2234fa96bd91SMichael Corcoran } 2235fa96bd91SMichael Corcoran mutex_exit(&cpu_map_lock); 2236fa96bd91SMichael Corcoran 2237fa96bd91SMichael Corcoran return (rc); 2238fa96bd91SMichael Corcoran } 2239fa96bd91SMichael Corcoran 2240a3114836SGerry Liu ACPI_STATUS 2241a3114836SGerry Liu acpica_get_cpu_id_by_object(ACPI_HANDLE hdl, processorid_t *cpuidp) 2242a3114836SGerry Liu { 2243a3114836SGerry Liu int i; 2244a3114836SGerry Liu ACPI_STATUS rc = AE_NOT_EXIST; 2245a3114836SGerry Liu 2246a3114836SGerry Liu ASSERT(cpuidp != NULL); 2247a3114836SGerry Liu if (hdl == NULL || cpuidp == NULL) { 2248a3114836SGerry Liu return (rc); 2249a3114836SGerry Liu } 2250a3114836SGerry Liu 2251a3114836SGerry Liu *cpuidp = -1; 2252a3114836SGerry Liu mutex_enter(&cpu_map_lock); 2253a3114836SGerry Liu for (i = 0; i < cpu_map_count; i++) { 2254a3114836SGerry Liu if (cpu_map[i]->obj == hdl && cpu_map[i]->cpu_id != -1) { 2255a3114836SGerry Liu *cpuidp = cpu_map[i]->cpu_id; 2256a3114836SGerry Liu rc = AE_OK; 2257a3114836SGerry Liu break; 2258a3114836SGerry Liu } 2259a3114836SGerry Liu } 2260a3114836SGerry Liu mutex_exit(&cpu_map_lock); 2261a3114836SGerry Liu 2262a3114836SGerry Liu return (rc); 2263a3114836SGerry Liu } 2264a3114836SGerry Liu 2265a3114836SGerry Liu ACPI_STATUS 2266a3114836SGerry Liu acpica_get_apicid_by_object(ACPI_HANDLE hdl, UINT32 *rp) 2267a3114836SGerry Liu { 2268a3114836SGerry Liu int i; 2269a3114836SGerry Liu ACPI_STATUS rc = AE_NOT_EXIST; 2270a3114836SGerry Liu 2271a3114836SGerry Liu ASSERT(rp != NULL); 2272a3114836SGerry Liu if (hdl == NULL || rp == NULL) { 2273a3114836SGerry Liu return (rc); 2274a3114836SGerry Liu } 2275a3114836SGerry Liu 2276a3114836SGerry Liu *rp = UINT32_MAX; 2277a3114836SGerry Liu mutex_enter(&cpu_map_lock); 2278a3114836SGerry Liu for (i = 0; i < cpu_map_count; i++) { 2279a3114836SGerry Liu if (cpu_map[i]->obj == hdl && 2280a3114836SGerry Liu cpu_map[i]->apic_id != UINT32_MAX) { 2281a3114836SGerry Liu *rp = cpu_map[i]->apic_id; 2282a3114836SGerry Liu rc = AE_OK; 2283a3114836SGerry Liu break; 2284a3114836SGerry Liu } 2285a3114836SGerry Liu } 2286a3114836SGerry Liu mutex_exit(&cpu_map_lock); 2287a3114836SGerry Liu 2288a3114836SGerry Liu return (rc); 2289a3114836SGerry Liu } 2290a3114836SGerry Liu 2291a3114836SGerry Liu ACPI_STATUS 2292a3114836SGerry Liu acpica_get_procid_by_object(ACPI_HANDLE hdl, UINT32 *rp) 2293a3114836SGerry Liu { 2294a3114836SGerry Liu int i; 2295a3114836SGerry Liu ACPI_STATUS rc = AE_NOT_EXIST; 2296a3114836SGerry Liu 2297a3114836SGerry Liu ASSERT(rp != NULL); 2298a3114836SGerry Liu if (hdl == NULL || rp == NULL) { 2299a3114836SGerry Liu return (rc); 2300a3114836SGerry Liu } 2301a3114836SGerry Liu 2302a3114836SGerry Liu *rp = UINT32_MAX; 2303a3114836SGerry Liu mutex_enter(&cpu_map_lock); 2304a3114836SGerry Liu for (i = 0; i < cpu_map_count; i++) { 2305a3114836SGerry Liu if (cpu_map[i]->obj == hdl) { 2306a3114836SGerry Liu *rp = cpu_map[i]->proc_id; 2307a3114836SGerry Liu rc = AE_OK; 2308a3114836SGerry Liu break; 2309a3114836SGerry Liu } 2310a3114836SGerry Liu } 2311a3114836SGerry Liu mutex_exit(&cpu_map_lock); 2312a3114836SGerry Liu 2313a3114836SGerry Liu return (rc); 2314a3114836SGerry Liu } 2315a3114836SGerry Liu 2316fa96bd91SMichael Corcoran void 2317fa96bd91SMichael Corcoran acpica_set_core_feature(uint64_t features) 2318fa96bd91SMichael Corcoran { 2319fa96bd91SMichael Corcoran atomic_or_64(&acpica_core_features, features); 2320fa96bd91SMichael Corcoran } 2321fa96bd91SMichael Corcoran 2322fa96bd91SMichael Corcoran void 2323fa96bd91SMichael Corcoran acpica_clear_core_feature(uint64_t features) 2324fa96bd91SMichael Corcoran { 2325fa96bd91SMichael Corcoran atomic_and_64(&acpica_core_features, ~features); 2326fa96bd91SMichael Corcoran } 2327fa96bd91SMichael Corcoran 2328fa96bd91SMichael Corcoran uint64_t 2329fa96bd91SMichael Corcoran acpica_get_core_feature(uint64_t features) 2330fa96bd91SMichael Corcoran { 2331fa96bd91SMichael Corcoran return (acpica_core_features & features); 2332fa96bd91SMichael Corcoran } 2333fa96bd91SMichael Corcoran 2334fa96bd91SMichael Corcoran void 2335fa96bd91SMichael Corcoran acpica_set_devcfg_feature(uint64_t features) 2336fa96bd91SMichael Corcoran { 2337fa96bd91SMichael Corcoran atomic_or_64(&acpica_devcfg_features, features); 2338fa96bd91SMichael Corcoran } 2339fa96bd91SMichael Corcoran 2340fa96bd91SMichael Corcoran void 2341fa96bd91SMichael Corcoran acpica_clear_devcfg_feature(uint64_t features) 2342fa96bd91SMichael Corcoran { 2343fa96bd91SMichael Corcoran atomic_and_64(&acpica_devcfg_features, ~features); 2344fa96bd91SMichael Corcoran } 2345fa96bd91SMichael Corcoran 2346fa96bd91SMichael Corcoran uint64_t 2347fa96bd91SMichael Corcoran acpica_get_devcfg_feature(uint64_t features) 2348fa96bd91SMichael Corcoran { 2349fa96bd91SMichael Corcoran return (acpica_devcfg_features & features); 23505cff7825Smh } 23510e751525SEric Saxe 23520e751525SEric Saxe void 23530e751525SEric Saxe acpica_get_global_FADT(ACPI_TABLE_FADT **gbl_FADT) 23540e751525SEric Saxe { 23550e751525SEric Saxe *gbl_FADT = &AcpiGbl_FADT; 23560e751525SEric Saxe } 235778d5422cSMark Haywood 235878d5422cSMark Haywood void 235978d5422cSMark Haywood acpica_write_cpupm_capabilities(boolean_t pstates, boolean_t cstates) 236078d5422cSMark Haywood { 236178d5422cSMark Haywood if (pstates && AcpiGbl_FADT.PstateControl != 0) 236278d5422cSMark Haywood (void) AcpiHwRegisterWrite(ACPI_REGISTER_SMI_COMMAND_BLOCK, 236378d5422cSMark Haywood AcpiGbl_FADT.PstateControl); 236478d5422cSMark Haywood 236578d5422cSMark Haywood if (cstates && AcpiGbl_FADT.CstControl != 0) 236678d5422cSMark Haywood (void) AcpiHwRegisterWrite(ACPI_REGISTER_SMI_COMMAND_BLOCK, 236778d5422cSMark Haywood AcpiGbl_FADT.CstControl); 236878d5422cSMark Haywood } 2369*7b1019a6SJerry Jelinek 2370*7b1019a6SJerry Jelinek uint32_t 2371*7b1019a6SJerry Jelinek acpi_strtoul(const char *str, char **ep, int base) 2372*7b1019a6SJerry Jelinek { 2373*7b1019a6SJerry Jelinek ulong_t v; 2374*7b1019a6SJerry Jelinek 2375*7b1019a6SJerry Jelinek if (ddi_strtoul(str, ep, base, &v) != 0 || v > ACPI_UINT32_MAX) { 2376*7b1019a6SJerry Jelinek return (ACPI_UINT32_MAX); 2377*7b1019a6SJerry Jelinek } 2378*7b1019a6SJerry Jelinek 2379*7b1019a6SJerry Jelinek return ((uint32_t)v); 2380*7b1019a6SJerry Jelinek } 2381