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. 257c478bd9Sstevel@tonic-gate */ 268e56767dSsmall /* 278e56767dSsmall * ACPI CA OSL for Solaris x86 288e56767dSsmall */ 297c478bd9Sstevel@tonic-gate 307c478bd9Sstevel@tonic-gate #include <sys/types.h> 317c478bd9Sstevel@tonic-gate #include <sys/kmem.h> 327c478bd9Sstevel@tonic-gate #include <sys/psm.h> 337c478bd9Sstevel@tonic-gate #include <sys/pci_cfgspace.h> 34*b9bfdccdSStuart Maybee #include <sys/apic.h> 357c478bd9Sstevel@tonic-gate #include <sys/ddi.h> 364b1ce0a9SDana Myers #include <sys/sunddi.h> 375cff7825Smh #include <sys/sunndi.h> 387c478bd9Sstevel@tonic-gate #include <sys/pci.h> 397c478bd9Sstevel@tonic-gate #include <sys/kobj.h> 407c478bd9Sstevel@tonic-gate #include <sys/taskq.h> 417c478bd9Sstevel@tonic-gate #include <sys/strlog.h> 427c478bd9Sstevel@tonic-gate #include <sys/note.h> 437c478bd9Sstevel@tonic-gate 447c478bd9Sstevel@tonic-gate #include <sys/acpi/acpi.h> 457c478bd9Sstevel@tonic-gate #include <sys/acpica.h> 46b6917abeSmishra #include <sys/acpi/acinterp.h> 477c478bd9Sstevel@tonic-gate 487c478bd9Sstevel@tonic-gate #define MAX_DAT_FILE_SIZE (64*1024) 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate /* local functions */ 517c478bd9Sstevel@tonic-gate static int CompressEisaID(char *np); 527c478bd9Sstevel@tonic-gate 535cff7825Smh static void scan_d2a_map(void); 545cff7825Smh static void scan_d2a_subtree(dev_info_t *dip, ACPI_HANDLE acpiobj, int bus); 555cff7825Smh static void acpica_tag_devinfo(dev_info_t *dip, ACPI_HANDLE acpiobj); 567c478bd9Sstevel@tonic-gate 577c478bd9Sstevel@tonic-gate static int acpica_query_bbn_problem(void); 587c478bd9Sstevel@tonic-gate static int acpica_find_pcibus(int busno, ACPI_HANDLE *rh); 597c478bd9Sstevel@tonic-gate static int acpica_eval_hid(ACPI_HANDLE dev, char *method, int *rint); 605cff7825Smh static ACPI_STATUS acpica_set_devinfo(ACPI_HANDLE, dev_info_t *); 615cff7825Smh static void acpica_devinfo_handler(ACPI_HANDLE, UINT32, void *); 627c478bd9Sstevel@tonic-gate 637c478bd9Sstevel@tonic-gate /* 647c478bd9Sstevel@tonic-gate * Event queue vars 657c478bd9Sstevel@tonic-gate */ 667c478bd9Sstevel@tonic-gate int acpica_eventq_init = 0; 6727f7c583Smyers ddi_taskq_t *osl_eventq[OSL_EC_BURST_HANDLER+1]; 687c478bd9Sstevel@tonic-gate 69db2bae30SDana Myers /* 70db2bae30SDana Myers * Priorities relative to minclsyspri that each taskq 71db2bae30SDana Myers * run at; OSL_NOTIFY_HANDLER needs to run at a higher 72db2bae30SDana Myers * priority than OSL_GPE_HANDLER. There's an implicit 73db2bae30SDana Myers * assumption that no priority here results in exceeding 74db2bae30SDana Myers * maxclsyspri. 75db2bae30SDana Myers * Note: these initializations need to match the order of 76db2bae30SDana Myers * ACPI_EXECUTE_TYPE. 77db2bae30SDana Myers */ 78db2bae30SDana Myers int osl_eventq_pri_delta[OSL_EC_BURST_HANDLER+1] = { 79db2bae30SDana Myers 0, /* OSL_GLOBAL_LOCK_HANDLER */ 80db2bae30SDana Myers 2, /* OSL_NOTIFY_HANDLER */ 81db2bae30SDana Myers 0, /* OSL_GPE_HANDLER */ 82db2bae30SDana Myers 0, /* OSL_DEBUGGER_THREAD */ 83db2bae30SDana Myers 0, /* OSL_EC_POLL_HANDLER */ 84db2bae30SDana Myers 0 /* OSL_EC_BURST_HANDLER */ 85db2bae30SDana Myers }; 86db2bae30SDana Myers 877c478bd9Sstevel@tonic-gate /* 887c478bd9Sstevel@tonic-gate * Note, if you change this path, you need to update 897c478bd9Sstevel@tonic-gate * /boot/grub/filelist.ramdisk and pkg SUNWckr/prototype_i386 907c478bd9Sstevel@tonic-gate */ 917c478bd9Sstevel@tonic-gate static char *acpi_table_path = "/boot/acpi/tables/"; 927c478bd9Sstevel@tonic-gate 935cff7825Smh /* non-zero while scan_d2a_map() is working */ 945cff7825Smh static int scanning_d2a_map = 0; 955cff7825Smh static int d2a_done = 0; 967c478bd9Sstevel@tonic-gate 97137e2f25SGuoli Shu /* set by acpi_poweroff() in PSMs and appm_ioctl() in acpippm for S3 */ 98137e2f25SGuoli Shu int acpica_use_safe_delay = 0; 99859dcd3dSmyers 1005cff7825Smh /* CPU mapping data */ 1015cff7825Smh struct cpu_map_item { 102b6917abeSmishra UINT32 proc_id; 1035cff7825Smh ACPI_HANDLE obj; 1045cff7825Smh }; 1055cff7825Smh 1065cff7825Smh static struct cpu_map_item **cpu_map = NULL; 1075cff7825Smh static int cpu_map_count = 0; 1085cff7825Smh static int cpu_map_built = 0; 1095cff7825Smh 1105cff7825Smh static int acpi_has_broken_bbn = -1; 1115cff7825Smh 11287bb58d6Smyers /* buffer for AcpiOsVprintf() */ 11387bb58d6Smyers #define ACPI_OSL_PR_BUFLEN 1024 11487bb58d6Smyers static char *acpi_osl_pr_buffer = NULL; 11587bb58d6Smyers static int acpi_osl_pr_buflen; 11687bb58d6Smyers 1175cff7825Smh #define D2A_DEBUG 1185cff7825Smh 1197c478bd9Sstevel@tonic-gate /* 1207c478bd9Sstevel@tonic-gate * 1217c478bd9Sstevel@tonic-gate */ 1227c478bd9Sstevel@tonic-gate static void 1237c478bd9Sstevel@tonic-gate discard_event_queues() 1247c478bd9Sstevel@tonic-gate { 12527f7c583Smyers int i; 1267c478bd9Sstevel@tonic-gate 1277c478bd9Sstevel@tonic-gate /* 1287c478bd9Sstevel@tonic-gate * destroy event queues 1297c478bd9Sstevel@tonic-gate */ 13027f7c583Smyers for (i = OSL_GLOBAL_LOCK_HANDLER; i <= OSL_EC_BURST_HANDLER; i++) { 13127f7c583Smyers if (osl_eventq[i]) 13227f7c583Smyers ddi_taskq_destroy(osl_eventq[i]); 13327f7c583Smyers } 1347c478bd9Sstevel@tonic-gate } 1357c478bd9Sstevel@tonic-gate 1367c478bd9Sstevel@tonic-gate 1377c478bd9Sstevel@tonic-gate /* 1387c478bd9Sstevel@tonic-gate * 1397c478bd9Sstevel@tonic-gate */ 1407c478bd9Sstevel@tonic-gate static ACPI_STATUS 1417c478bd9Sstevel@tonic-gate init_event_queues() 1427c478bd9Sstevel@tonic-gate { 14327f7c583Smyers char namebuf[32]; 14427f7c583Smyers int i, error = 0; 1457c478bd9Sstevel@tonic-gate 1467c478bd9Sstevel@tonic-gate /* 1477c478bd9Sstevel@tonic-gate * Initialize event queues 1487c478bd9Sstevel@tonic-gate */ 1497c478bd9Sstevel@tonic-gate 150db2bae30SDana Myers /* Always allocate only 1 thread per queue to force FIFO execution */ 15127f7c583Smyers for (i = OSL_GLOBAL_LOCK_HANDLER; i <= OSL_EC_BURST_HANDLER; i++) { 15227f7c583Smyers snprintf(namebuf, 32, "ACPI%d", i); 153db2bae30SDana Myers osl_eventq[i] = ddi_taskq_create(NULL, namebuf, 1, 154db2bae30SDana Myers osl_eventq_pri_delta[i] + minclsyspri, 0); 15527f7c583Smyers if (osl_eventq[i] == NULL) 15627f7c583Smyers error++; 15727f7c583Smyers } 15827f7c583Smyers 15927f7c583Smyers if (error != 0) { 1607c478bd9Sstevel@tonic-gate discard_event_queues(); 1617c478bd9Sstevel@tonic-gate #ifdef DEBUG 1627c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!acpica: could not initialize event queues"); 1637c478bd9Sstevel@tonic-gate #endif 1647c478bd9Sstevel@tonic-gate return (AE_ERROR); 1657c478bd9Sstevel@tonic-gate } 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate acpica_eventq_init = 1; 1687c478bd9Sstevel@tonic-gate return (AE_OK); 1697c478bd9Sstevel@tonic-gate } 1707c478bd9Sstevel@tonic-gate 1717c478bd9Sstevel@tonic-gate /* 17287bb58d6Smyers * One-time initialization of OSL layer 1737c478bd9Sstevel@tonic-gate */ 1747c478bd9Sstevel@tonic-gate ACPI_STATUS 1757c478bd9Sstevel@tonic-gate AcpiOsInitialize(void) 1767c478bd9Sstevel@tonic-gate { 17787bb58d6Smyers /* 17887bb58d6Smyers * Allocate buffer for AcpiOsVprintf() here to avoid 17987bb58d6Smyers * kmem_alloc()/kmem_free() at high PIL 18087bb58d6Smyers */ 18187bb58d6Smyers acpi_osl_pr_buffer = kmem_alloc(ACPI_OSL_PR_BUFLEN, KM_SLEEP); 18287bb58d6Smyers if (acpi_osl_pr_buffer != NULL) 18387bb58d6Smyers acpi_osl_pr_buflen = ACPI_OSL_PR_BUFLEN; 18487bb58d6Smyers 1857c478bd9Sstevel@tonic-gate return (AE_OK); 1867c478bd9Sstevel@tonic-gate } 1877c478bd9Sstevel@tonic-gate 1887c478bd9Sstevel@tonic-gate /* 18987bb58d6Smyers * One-time shut-down of OSL layer 1907c478bd9Sstevel@tonic-gate */ 1917c478bd9Sstevel@tonic-gate ACPI_STATUS 1927c478bd9Sstevel@tonic-gate AcpiOsTerminate(void) 1937c478bd9Sstevel@tonic-gate { 1947c478bd9Sstevel@tonic-gate 19587bb58d6Smyers if (acpi_osl_pr_buffer != NULL) 19687bb58d6Smyers kmem_free(acpi_osl_pr_buffer, acpi_osl_pr_buflen); 19787bb58d6Smyers 1987c478bd9Sstevel@tonic-gate discard_event_queues(); 1997c478bd9Sstevel@tonic-gate return (AE_OK); 2007c478bd9Sstevel@tonic-gate } 2017c478bd9Sstevel@tonic-gate 2027c478bd9Sstevel@tonic-gate 203db2bae30SDana Myers ACPI_PHYSICAL_ADDRESS 204db2bae30SDana Myers AcpiOsGetRootPointer() 2057c478bd9Sstevel@tonic-gate { 206db2bae30SDana Myers ACPI_PHYSICAL_ADDRESS Address; 207f2be5148Sszhou 208f2be5148Sszhou /* 209f2be5148Sszhou * For EFI firmware, the root pointer is defined in EFI systab. 210f2be5148Sszhou * The boot code process the table and put the physical address 211f2be5148Sszhou * in the acpi-root-tab property. 212f2be5148Sszhou */ 213db2bae30SDana Myers Address = ddi_prop_get_int(DDI_DEV_T_ANY, ddi_root_node(), 0, 214db2bae30SDana Myers "acpi-root-tab", NULL); 215db2bae30SDana Myers 216db2bae30SDana Myers if ((Address == NULL) && ACPI_FAILURE(AcpiFindRootPointer(&Address))) 217db2bae30SDana Myers Address = NULL; 218db2bae30SDana Myers 219db2bae30SDana Myers return (Address); 2207c478bd9Sstevel@tonic-gate } 2217c478bd9Sstevel@tonic-gate 2227c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2237c478bd9Sstevel@tonic-gate ACPI_STATUS 2247c478bd9Sstevel@tonic-gate AcpiOsPredefinedOverride(const ACPI_PREDEFINED_NAMES *InitVal, 2257c478bd9Sstevel@tonic-gate ACPI_STRING *NewVal) 2267c478bd9Sstevel@tonic-gate { 2277c478bd9Sstevel@tonic-gate 2287c478bd9Sstevel@tonic-gate *NewVal = 0; 2297c478bd9Sstevel@tonic-gate return (AE_OK); 2307c478bd9Sstevel@tonic-gate } 2317c478bd9Sstevel@tonic-gate 2327c478bd9Sstevel@tonic-gate static void 2337c478bd9Sstevel@tonic-gate acpica_strncpy(char *dest, const char *src, int len) 2347c478bd9Sstevel@tonic-gate { 2357c478bd9Sstevel@tonic-gate 2367c478bd9Sstevel@tonic-gate /*LINTED*/ 2377c478bd9Sstevel@tonic-gate while ((*dest++ = *src++) && (--len > 0)) 2387c478bd9Sstevel@tonic-gate /* copy the string */; 2397c478bd9Sstevel@tonic-gate *dest = '\0'; 2407c478bd9Sstevel@tonic-gate } 2417c478bd9Sstevel@tonic-gate 2427c478bd9Sstevel@tonic-gate ACPI_STATUS 2437c478bd9Sstevel@tonic-gate AcpiOsTableOverride(ACPI_TABLE_HEADER *ExistingTable, 2447c478bd9Sstevel@tonic-gate ACPI_TABLE_HEADER **NewTable) 2457c478bd9Sstevel@tonic-gate { 2467c478bd9Sstevel@tonic-gate char signature[5]; 2477c478bd9Sstevel@tonic-gate char oemid[7]; 2487c478bd9Sstevel@tonic-gate char oemtableid[9]; 2497c478bd9Sstevel@tonic-gate struct _buf *file; 2507c478bd9Sstevel@tonic-gate char *buf1, *buf2; 2517c478bd9Sstevel@tonic-gate int count; 2527c478bd9Sstevel@tonic-gate char acpi_table_loc[128]; 2537c478bd9Sstevel@tonic-gate 2547c478bd9Sstevel@tonic-gate acpica_strncpy(signature, ExistingTable->Signature, 4); 2557c478bd9Sstevel@tonic-gate acpica_strncpy(oemid, ExistingTable->OemId, 6); 2567c478bd9Sstevel@tonic-gate acpica_strncpy(oemtableid, ExistingTable->OemTableId, 8); 2577c478bd9Sstevel@tonic-gate 2587c478bd9Sstevel@tonic-gate #ifdef DEBUG 2597c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!acpica: table [%s] v%d OEM ID [%s]" 2605dff2f34Smyers " OEM TABLE ID [%s] OEM rev %x", 2615dff2f34Smyers signature, ExistingTable->Revision, oemid, oemtableid, 2625dff2f34Smyers ExistingTable->OemRevision); 2637c478bd9Sstevel@tonic-gate #endif 2647c478bd9Sstevel@tonic-gate 2657c478bd9Sstevel@tonic-gate /* File name format is "signature_oemid_oemtableid.dat" */ 2667c478bd9Sstevel@tonic-gate (void) strcpy(acpi_table_loc, acpi_table_path); 2677c478bd9Sstevel@tonic-gate (void) strcat(acpi_table_loc, signature); /* for example, DSDT */ 2687c478bd9Sstevel@tonic-gate (void) strcat(acpi_table_loc, "_"); 2697c478bd9Sstevel@tonic-gate (void) strcat(acpi_table_loc, oemid); /* for example, IntelR */ 2707c478bd9Sstevel@tonic-gate (void) strcat(acpi_table_loc, "_"); 2717c478bd9Sstevel@tonic-gate (void) strcat(acpi_table_loc, oemtableid); /* for example, AWRDACPI */ 2727c478bd9Sstevel@tonic-gate (void) strcat(acpi_table_loc, ".dat"); 2737c478bd9Sstevel@tonic-gate 2747c478bd9Sstevel@tonic-gate file = kobj_open_file(acpi_table_loc); 2757c478bd9Sstevel@tonic-gate if (file == (struct _buf *)-1) { 2767c478bd9Sstevel@tonic-gate *NewTable = 0; 2777c478bd9Sstevel@tonic-gate return (AE_OK); 2787c478bd9Sstevel@tonic-gate } else { 2797c478bd9Sstevel@tonic-gate buf1 = (char *)kmem_alloc(MAX_DAT_FILE_SIZE, KM_SLEEP); 2807c478bd9Sstevel@tonic-gate count = kobj_read_file(file, buf1, MAX_DAT_FILE_SIZE-1, 0); 2817c478bd9Sstevel@tonic-gate if (count >= MAX_DAT_FILE_SIZE) { 2827c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!acpica: table %s file size too big", 2837c478bd9Sstevel@tonic-gate acpi_table_loc); 2847c478bd9Sstevel@tonic-gate *NewTable = 0; 2857c478bd9Sstevel@tonic-gate } else { 2867c478bd9Sstevel@tonic-gate buf2 = (char *)kmem_alloc(count, KM_SLEEP); 2877c478bd9Sstevel@tonic-gate (void) memcpy(buf2, buf1, count); 2887c478bd9Sstevel@tonic-gate *NewTable = (ACPI_TABLE_HEADER *)buf2; 2897c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!acpica: replacing table: %s", 2907c478bd9Sstevel@tonic-gate acpi_table_loc); 2917c478bd9Sstevel@tonic-gate } 2927c478bd9Sstevel@tonic-gate } 2937c478bd9Sstevel@tonic-gate kobj_close_file(file); 2947c478bd9Sstevel@tonic-gate kmem_free(buf1, MAX_DAT_FILE_SIZE); 2957c478bd9Sstevel@tonic-gate 2967c478bd9Sstevel@tonic-gate return (AE_OK); 2977c478bd9Sstevel@tonic-gate } 2987c478bd9Sstevel@tonic-gate 2997c478bd9Sstevel@tonic-gate 30030082d0cSmyers /* 30130082d0cSmyers * ACPI semaphore implementation 30230082d0cSmyers */ 30330082d0cSmyers typedef struct { 30430082d0cSmyers kmutex_t mutex; 30530082d0cSmyers kcondvar_t cv; 30630082d0cSmyers uint32_t available; 30730082d0cSmyers uint32_t initial; 30830082d0cSmyers uint32_t maximum; 30930082d0cSmyers } acpi_sema_t; 31030082d0cSmyers 31130082d0cSmyers /* 31230082d0cSmyers * 31330082d0cSmyers */ 31430082d0cSmyers void 31527f7c583Smyers acpi_sema_init(acpi_sema_t *sp, unsigned max, unsigned count) 31630082d0cSmyers { 31730082d0cSmyers mutex_init(&sp->mutex, NULL, MUTEX_DRIVER, NULL); 31830082d0cSmyers cv_init(&sp->cv, NULL, CV_DRIVER, NULL); 31930082d0cSmyers /* no need to enter mutex here at creation */ 32030082d0cSmyers sp->available = count; 32130082d0cSmyers sp->initial = count; 32230082d0cSmyers sp->maximum = max; 32330082d0cSmyers } 32430082d0cSmyers 32530082d0cSmyers /* 32630082d0cSmyers * 32730082d0cSmyers */ 32830082d0cSmyers void 32930082d0cSmyers acpi_sema_destroy(acpi_sema_t *sp) 33030082d0cSmyers { 33130082d0cSmyers 33230082d0cSmyers cv_destroy(&sp->cv); 33330082d0cSmyers mutex_destroy(&sp->mutex); 33430082d0cSmyers } 33530082d0cSmyers 33630082d0cSmyers /* 33730082d0cSmyers * 33830082d0cSmyers */ 33930082d0cSmyers ACPI_STATUS 34030082d0cSmyers acpi_sema_p(acpi_sema_t *sp, unsigned count, uint16_t wait_time) 34130082d0cSmyers { 34230082d0cSmyers ACPI_STATUS rv = AE_OK; 34330082d0cSmyers clock_t deadline; 34430082d0cSmyers 34530082d0cSmyers mutex_enter(&sp->mutex); 34630082d0cSmyers 34730082d0cSmyers if (sp->available >= count) { 34830082d0cSmyers /* 34930082d0cSmyers * Enough units available, no blocking 35030082d0cSmyers */ 35130082d0cSmyers sp->available -= count; 35230082d0cSmyers mutex_exit(&sp->mutex); 35330082d0cSmyers return (rv); 35430082d0cSmyers } else if (wait_time == 0) { 35530082d0cSmyers /* 35630082d0cSmyers * Not enough units available and timeout 35730082d0cSmyers * specifies no blocking 35830082d0cSmyers */ 35930082d0cSmyers rv = AE_TIME; 36030082d0cSmyers mutex_exit(&sp->mutex); 36130082d0cSmyers return (rv); 36230082d0cSmyers } 36330082d0cSmyers 36430082d0cSmyers /* 36530082d0cSmyers * Not enough units available and timeout specifies waiting 36630082d0cSmyers */ 36730082d0cSmyers if (wait_time != ACPI_WAIT_FOREVER) 36830082d0cSmyers deadline = ddi_get_lbolt() + 36930082d0cSmyers (clock_t)drv_usectohz(wait_time * 1000); 37030082d0cSmyers 37130082d0cSmyers do { 37230082d0cSmyers if (wait_time == ACPI_WAIT_FOREVER) 37330082d0cSmyers cv_wait(&sp->cv, &sp->mutex); 37430082d0cSmyers else if (cv_timedwait(&sp->cv, &sp->mutex, deadline) < 0) { 37530082d0cSmyers rv = AE_TIME; 37630082d0cSmyers break; 37730082d0cSmyers } 37830082d0cSmyers } while (sp->available < count); 37930082d0cSmyers 38030082d0cSmyers /* if we dropped out of the wait with AE_OK, we got the units */ 38130082d0cSmyers if (rv == AE_OK) 38230082d0cSmyers sp->available -= count; 38330082d0cSmyers 38430082d0cSmyers mutex_exit(&sp->mutex); 38530082d0cSmyers return (rv); 38630082d0cSmyers } 38730082d0cSmyers 38830082d0cSmyers /* 38930082d0cSmyers * 39030082d0cSmyers */ 39130082d0cSmyers void 39230082d0cSmyers acpi_sema_v(acpi_sema_t *sp, unsigned count) 39330082d0cSmyers { 39430082d0cSmyers mutex_enter(&sp->mutex); 39530082d0cSmyers sp->available += count; 39630082d0cSmyers cv_broadcast(&sp->cv); 39730082d0cSmyers mutex_exit(&sp->mutex); 39830082d0cSmyers } 39930082d0cSmyers 40030082d0cSmyers 4017c478bd9Sstevel@tonic-gate ACPI_STATUS 4027c478bd9Sstevel@tonic-gate AcpiOsCreateSemaphore(UINT32 MaxUnits, UINT32 InitialUnits, 4037c478bd9Sstevel@tonic-gate ACPI_HANDLE *OutHandle) 4047c478bd9Sstevel@tonic-gate { 40530082d0cSmyers acpi_sema_t *sp; 4067c478bd9Sstevel@tonic-gate 4077c478bd9Sstevel@tonic-gate if ((OutHandle == NULL) || (InitialUnits > MaxUnits)) 4087c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 4097c478bd9Sstevel@tonic-gate 41030082d0cSmyers sp = (acpi_sema_t *)kmem_alloc(sizeof (acpi_sema_t), KM_SLEEP); 41127f7c583Smyers acpi_sema_init(sp, MaxUnits, InitialUnits); 41230082d0cSmyers *OutHandle = (ACPI_HANDLE)sp; 4137c478bd9Sstevel@tonic-gate return (AE_OK); 4147c478bd9Sstevel@tonic-gate } 4157c478bd9Sstevel@tonic-gate 4167c478bd9Sstevel@tonic-gate 4177c478bd9Sstevel@tonic-gate ACPI_STATUS 4187c478bd9Sstevel@tonic-gate AcpiOsDeleteSemaphore(ACPI_HANDLE Handle) 4197c478bd9Sstevel@tonic-gate { 4207c478bd9Sstevel@tonic-gate 42130082d0cSmyers if (Handle == NULL) 42230082d0cSmyers return (AE_BAD_PARAMETER); 42330082d0cSmyers 42430082d0cSmyers acpi_sema_destroy((acpi_sema_t *)Handle); 42530082d0cSmyers kmem_free((void *)Handle, sizeof (acpi_sema_t)); 4267c478bd9Sstevel@tonic-gate return (AE_OK); 4277c478bd9Sstevel@tonic-gate } 4287c478bd9Sstevel@tonic-gate 4297c478bd9Sstevel@tonic-gate ACPI_STATUS 4307c478bd9Sstevel@tonic-gate AcpiOsWaitSemaphore(ACPI_HANDLE Handle, UINT32 Units, UINT16 Timeout) 4317c478bd9Sstevel@tonic-gate { 4327c478bd9Sstevel@tonic-gate 43330082d0cSmyers if ((Handle == NULL) || (Units < 1)) 43430082d0cSmyers return (AE_BAD_PARAMETER); 4357c478bd9Sstevel@tonic-gate 43630082d0cSmyers return (acpi_sema_p((acpi_sema_t *)Handle, Units, Timeout)); 4377c478bd9Sstevel@tonic-gate } 4387c478bd9Sstevel@tonic-gate 4397c478bd9Sstevel@tonic-gate ACPI_STATUS 4407c478bd9Sstevel@tonic-gate AcpiOsSignalSemaphore(ACPI_HANDLE Handle, UINT32 Units) 4417c478bd9Sstevel@tonic-gate { 4427c478bd9Sstevel@tonic-gate 44330082d0cSmyers if ((Handle == NULL) || (Units < 1)) 44430082d0cSmyers return (AE_BAD_PARAMETER); 44530082d0cSmyers 44630082d0cSmyers acpi_sema_v((acpi_sema_t *)Handle, Units); 4477c478bd9Sstevel@tonic-gate return (AE_OK); 4487c478bd9Sstevel@tonic-gate } 4497c478bd9Sstevel@tonic-gate 4507c478bd9Sstevel@tonic-gate ACPI_STATUS 4517c478bd9Sstevel@tonic-gate AcpiOsCreateLock(ACPI_HANDLE *OutHandle) 4527c478bd9Sstevel@tonic-gate { 45330082d0cSmyers kmutex_t *mp; 4547c478bd9Sstevel@tonic-gate 4557c478bd9Sstevel@tonic-gate if (OutHandle == NULL) 4567c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 4577c478bd9Sstevel@tonic-gate 45830082d0cSmyers mp = (kmutex_t *)kmem_alloc(sizeof (kmutex_t), KM_SLEEP); 45930082d0cSmyers mutex_init(mp, NULL, MUTEX_DRIVER, NULL); 46030082d0cSmyers *OutHandle = (ACPI_HANDLE)mp; 4617c478bd9Sstevel@tonic-gate return (AE_OK); 4627c478bd9Sstevel@tonic-gate } 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate void 4657c478bd9Sstevel@tonic-gate AcpiOsDeleteLock(ACPI_HANDLE Handle) 4667c478bd9Sstevel@tonic-gate { 46730082d0cSmyers 46830082d0cSmyers if (Handle == NULL) 46930082d0cSmyers return; 47030082d0cSmyers 47130082d0cSmyers mutex_destroy((kmutex_t *)Handle); 47230082d0cSmyers kmem_free((void *)Handle, sizeof (kmutex_t)); 4737c478bd9Sstevel@tonic-gate } 4747c478bd9Sstevel@tonic-gate 475db2bae30SDana Myers ACPI_CPU_FLAGS 476450d6964Smyers AcpiOsAcquireLock(ACPI_HANDLE Handle) 4777c478bd9Sstevel@tonic-gate { 47830082d0cSmyers 4790e751525SEric Saxe 4800e751525SEric Saxe if (Handle == NULL) 4810e751525SEric Saxe return (AE_BAD_PARAMETER); 4820e751525SEric Saxe 4830e751525SEric Saxe if (curthread == CPU->cpu_idle_thread) { 4840e751525SEric Saxe while (!mutex_tryenter((kmutex_t *)Handle)) 4850e751525SEric Saxe /* spin */; 4860e751525SEric Saxe } else 4870e751525SEric Saxe mutex_enter((kmutex_t *)Handle); 4880e751525SEric Saxe return (AE_OK); 4897c478bd9Sstevel@tonic-gate } 4907c478bd9Sstevel@tonic-gate 4917c478bd9Sstevel@tonic-gate void 492db2bae30SDana Myers AcpiOsReleaseLock(ACPI_HANDLE Handle, ACPI_CPU_FLAGS Flags) 4937c478bd9Sstevel@tonic-gate { 494450d6964Smyers _NOTE(ARGUNUSED(Flags)) 4957c478bd9Sstevel@tonic-gate 49630082d0cSmyers mutex_exit((kmutex_t *)Handle); 4977c478bd9Sstevel@tonic-gate } 4987c478bd9Sstevel@tonic-gate 4997c478bd9Sstevel@tonic-gate 5007c478bd9Sstevel@tonic-gate void * 5017c478bd9Sstevel@tonic-gate AcpiOsAllocate(ACPI_SIZE Size) 5027c478bd9Sstevel@tonic-gate { 5037c478bd9Sstevel@tonic-gate ACPI_SIZE *tmp_ptr; 5047c478bd9Sstevel@tonic-gate 5057c478bd9Sstevel@tonic-gate Size += sizeof (Size); 5067c478bd9Sstevel@tonic-gate tmp_ptr = (ACPI_SIZE *)kmem_zalloc(Size, KM_SLEEP); 5077c478bd9Sstevel@tonic-gate *tmp_ptr++ = Size; 50830082d0cSmyers return (tmp_ptr); 5097c478bd9Sstevel@tonic-gate } 5107c478bd9Sstevel@tonic-gate 5117c478bd9Sstevel@tonic-gate void 5127c478bd9Sstevel@tonic-gate AcpiOsFree(void *Memory) 5137c478bd9Sstevel@tonic-gate { 5147c478bd9Sstevel@tonic-gate ACPI_SIZE size, *tmp_ptr; 5157c478bd9Sstevel@tonic-gate 5167c478bd9Sstevel@tonic-gate tmp_ptr = (ACPI_SIZE *)Memory; 5177c478bd9Sstevel@tonic-gate tmp_ptr -= 1; 5187c478bd9Sstevel@tonic-gate size = *tmp_ptr; 51930082d0cSmyers kmem_free(tmp_ptr, size); 5207c478bd9Sstevel@tonic-gate } 5217c478bd9Sstevel@tonic-gate 522*b9bfdccdSStuart Maybee static int napics_found; /* number of ioapic addresses in array */ 523*b9bfdccdSStuart Maybee static ACPI_PHYSICAL_ADDRESS ioapic_paddr[MAX_IO_APIC]; 524*b9bfdccdSStuart Maybee static ACPI_TABLE_MADT *acpi_mapic_dtp = NULL; 525*b9bfdccdSStuart Maybee static void *dummy_ioapicadr; 526*b9bfdccdSStuart Maybee 527*b9bfdccdSStuart Maybee void 528*b9bfdccdSStuart Maybee acpica_find_ioapics(void) 529*b9bfdccdSStuart Maybee { 530*b9bfdccdSStuart Maybee int madt_seen, madt_size; 531*b9bfdccdSStuart Maybee ACPI_SUBTABLE_HEADER *ap; 532*b9bfdccdSStuart Maybee ACPI_MADT_IO_APIC *mia; 533*b9bfdccdSStuart Maybee 534*b9bfdccdSStuart Maybee if (acpi_mapic_dtp != NULL) 535*b9bfdccdSStuart Maybee return; /* already parsed table */ 536*b9bfdccdSStuart Maybee if (AcpiGetTable(ACPI_SIG_MADT, 1, 537*b9bfdccdSStuart Maybee (ACPI_TABLE_HEADER **) &acpi_mapic_dtp) != AE_OK) 538*b9bfdccdSStuart Maybee return; 539*b9bfdccdSStuart Maybee 540*b9bfdccdSStuart Maybee napics_found = 0; 541*b9bfdccdSStuart Maybee 542*b9bfdccdSStuart Maybee /* 543*b9bfdccdSStuart Maybee * Search the MADT for ioapics 544*b9bfdccdSStuart Maybee */ 545*b9bfdccdSStuart Maybee ap = (ACPI_SUBTABLE_HEADER *) (acpi_mapic_dtp + 1); 546*b9bfdccdSStuart Maybee madt_size = acpi_mapic_dtp->Header.Length; 547*b9bfdccdSStuart Maybee madt_seen = sizeof (*acpi_mapic_dtp); 548*b9bfdccdSStuart Maybee 549*b9bfdccdSStuart Maybee while (madt_seen < madt_size) { 550*b9bfdccdSStuart Maybee 551*b9bfdccdSStuart Maybee switch (ap->Type) { 552*b9bfdccdSStuart Maybee case ACPI_MADT_TYPE_IO_APIC: 553*b9bfdccdSStuart Maybee mia = (ACPI_MADT_IO_APIC *) ap; 554*b9bfdccdSStuart Maybee if (napics_found < MAX_IO_APIC) { 555*b9bfdccdSStuart Maybee ioapic_paddr[napics_found++] = 556*b9bfdccdSStuart Maybee (ACPI_PHYSICAL_ADDRESS) 557*b9bfdccdSStuart Maybee (mia->Address & PAGEMASK); 558*b9bfdccdSStuart Maybee } 559*b9bfdccdSStuart Maybee break; 560*b9bfdccdSStuart Maybee 561*b9bfdccdSStuart Maybee default: 562*b9bfdccdSStuart Maybee break; 563*b9bfdccdSStuart Maybee } 564*b9bfdccdSStuart Maybee 565*b9bfdccdSStuart Maybee /* advance to next entry */ 566*b9bfdccdSStuart Maybee madt_seen += ap->Length; 567*b9bfdccdSStuart Maybee ap = (ACPI_SUBTABLE_HEADER *)(((char *)ap) + ap->Length); 568*b9bfdccdSStuart Maybee } 569*b9bfdccdSStuart Maybee if (dummy_ioapicadr == NULL) 570*b9bfdccdSStuart Maybee dummy_ioapicadr = kmem_zalloc(PAGESIZE, KM_SLEEP); 571*b9bfdccdSStuart Maybee } 572*b9bfdccdSStuart Maybee 573*b9bfdccdSStuart Maybee 574db2bae30SDana Myers void * 575db2bae30SDana Myers AcpiOsMapMemory(ACPI_PHYSICAL_ADDRESS PhysicalAddress, ACPI_SIZE Size) 5767c478bd9Sstevel@tonic-gate { 577*b9bfdccdSStuart Maybee int i; 578*b9bfdccdSStuart Maybee 579*b9bfdccdSStuart Maybee /* 580*b9bfdccdSStuart Maybee * If the iopaic address table is populated, check if trying 581*b9bfdccdSStuart Maybee * to access an ioapic. Instead, return a pointer to a dummy ioapic. 582*b9bfdccdSStuart Maybee */ 583*b9bfdccdSStuart Maybee for (i = 0; i < napics_found; i++) { 584*b9bfdccdSStuart Maybee if ((PhysicalAddress & PAGEMASK) == ioapic_paddr[i]) 585*b9bfdccdSStuart Maybee return (dummy_ioapicadr); 586*b9bfdccdSStuart Maybee } 5877c478bd9Sstevel@tonic-gate /* FUTUREWORK: test PhysicalAddress for > 32 bits */ 588db2bae30SDana Myers return (psm_map_new((paddr_t)PhysicalAddress, 589db2bae30SDana Myers (size_t)Size, PSM_PROT_WRITE | PSM_PROT_READ)); 5907c478bd9Sstevel@tonic-gate } 5917c478bd9Sstevel@tonic-gate 5927c478bd9Sstevel@tonic-gate void 5937c478bd9Sstevel@tonic-gate AcpiOsUnmapMemory(void *LogicalAddress, ACPI_SIZE Size) 5947c478bd9Sstevel@tonic-gate { 595*b9bfdccdSStuart Maybee /* 596*b9bfdccdSStuart Maybee * Check if trying to unmap dummy ioapic address. 597*b9bfdccdSStuart Maybee */ 598*b9bfdccdSStuart Maybee if (LogicalAddress == dummy_ioapicadr) 599*b9bfdccdSStuart Maybee return; 6007c478bd9Sstevel@tonic-gate 6017c478bd9Sstevel@tonic-gate psm_unmap((caddr_t)LogicalAddress, (size_t)Size); 6027c478bd9Sstevel@tonic-gate } 6037c478bd9Sstevel@tonic-gate 6047c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 6057c478bd9Sstevel@tonic-gate ACPI_STATUS 6067c478bd9Sstevel@tonic-gate AcpiOsGetPhysicalAddress(void *LogicalAddress, 6077c478bd9Sstevel@tonic-gate ACPI_PHYSICAL_ADDRESS *PhysicalAddress) 6087c478bd9Sstevel@tonic-gate { 6097c478bd9Sstevel@tonic-gate 6107c478bd9Sstevel@tonic-gate /* UNIMPLEMENTED: not invoked by ACPI CA code */ 61103335b7aSmyers return (AE_NOT_IMPLEMENTED); 6127c478bd9Sstevel@tonic-gate } 6137c478bd9Sstevel@tonic-gate 6147c478bd9Sstevel@tonic-gate 6157c478bd9Sstevel@tonic-gate ACPI_OSD_HANDLER acpi_isr; 6167c478bd9Sstevel@tonic-gate void *acpi_isr_context; 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate uint_t 6197c478bd9Sstevel@tonic-gate acpi_wrapper_isr(char *arg) 6207c478bd9Sstevel@tonic-gate { 6217c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(arg)) 6227c478bd9Sstevel@tonic-gate 6237c478bd9Sstevel@tonic-gate int status; 6247c478bd9Sstevel@tonic-gate 6257c478bd9Sstevel@tonic-gate status = (*acpi_isr)(acpi_isr_context); 6267c478bd9Sstevel@tonic-gate 6277c478bd9Sstevel@tonic-gate if (status == ACPI_INTERRUPT_HANDLED) { 6287c478bd9Sstevel@tonic-gate return (DDI_INTR_CLAIMED); 6297c478bd9Sstevel@tonic-gate } else { 6307c478bd9Sstevel@tonic-gate return (DDI_INTR_UNCLAIMED); 6317c478bd9Sstevel@tonic-gate } 6327c478bd9Sstevel@tonic-gate } 6337c478bd9Sstevel@tonic-gate 634186507a7Smyers static int acpi_intr_hooked = 0; 6357c478bd9Sstevel@tonic-gate 6367c478bd9Sstevel@tonic-gate ACPI_STATUS 6377c478bd9Sstevel@tonic-gate AcpiOsInstallInterruptHandler(UINT32 InterruptNumber, 6387c478bd9Sstevel@tonic-gate ACPI_OSD_HANDLER ServiceRoutine, 6397c478bd9Sstevel@tonic-gate void *Context) 6407c478bd9Sstevel@tonic-gate { 64127f7c583Smyers _NOTE(ARGUNUSED(InterruptNumber)) 64227f7c583Smyers 6437c478bd9Sstevel@tonic-gate int retval; 644450d6964Smyers int sci_vect; 645450d6964Smyers iflag_t sci_flags; 6467c478bd9Sstevel@tonic-gate 6477c478bd9Sstevel@tonic-gate acpi_isr = ServiceRoutine; 6487c478bd9Sstevel@tonic-gate acpi_isr_context = Context; 6497c478bd9Sstevel@tonic-gate 6507c478bd9Sstevel@tonic-gate /* 651450d6964Smyers * Get SCI (adjusted for PIC/APIC mode if necessary) 6527c478bd9Sstevel@tonic-gate */ 653450d6964Smyers if (acpica_get_sci(&sci_vect, &sci_flags) != AE_OK) { 654450d6964Smyers return (AE_ERROR); 655450d6964Smyers } 656450d6964Smyers 657450d6964Smyers #ifdef DEBUG 658450d6964Smyers cmn_err(CE_NOTE, "!acpica: attaching SCI %d", sci_vect); 659450d6964Smyers #endif 660450d6964Smyers 6617c478bd9Sstevel@tonic-gate retval = add_avintr(NULL, SCI_IPL, (avfunc)acpi_wrapper_isr, 6625dff2f34Smyers "ACPI SCI", sci_vect, NULL, NULL, NULL, NULL); 6637c478bd9Sstevel@tonic-gate if (retval) { 664186507a7Smyers acpi_intr_hooked = 1; 6657c478bd9Sstevel@tonic-gate return (AE_OK); 666186507a7Smyers } else 6677c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 6687c478bd9Sstevel@tonic-gate } 6697c478bd9Sstevel@tonic-gate 6707c478bd9Sstevel@tonic-gate ACPI_STATUS 6717c478bd9Sstevel@tonic-gate AcpiOsRemoveInterruptHandler(UINT32 InterruptNumber, 6727c478bd9Sstevel@tonic-gate ACPI_OSD_HANDLER ServiceRoutine) 6737c478bd9Sstevel@tonic-gate { 6747c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(ServiceRoutine)) 6757c478bd9Sstevel@tonic-gate 6767c478bd9Sstevel@tonic-gate #ifdef DEBUG 6777c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!acpica: detaching SCI %d", InterruptNumber); 6787c478bd9Sstevel@tonic-gate #endif 679186507a7Smyers if (acpi_intr_hooked) { 6807c478bd9Sstevel@tonic-gate rem_avintr(NULL, LOCK_LEVEL - 1, (avfunc)acpi_wrapper_isr, 6815dff2f34Smyers InterruptNumber); 682186507a7Smyers acpi_intr_hooked = 0; 6837c478bd9Sstevel@tonic-gate } 6847c478bd9Sstevel@tonic-gate return (AE_OK); 6857c478bd9Sstevel@tonic-gate } 6867c478bd9Sstevel@tonic-gate 6877c478bd9Sstevel@tonic-gate 68827f7c583Smyers ACPI_THREAD_ID 6897c478bd9Sstevel@tonic-gate AcpiOsGetThreadId(void) 6907c478bd9Sstevel@tonic-gate { 69127f7c583Smyers /* 69227f7c583Smyers * ACPI CA regards thread ID as an error, but it's valid 69327f7c583Smyers * on Solaris during kernel initialization. Thus, 1 is added 69427f7c583Smyers * to the kernel thread ID to avoid returning 0 69527f7c583Smyers */ 69627f7c583Smyers return (ddi_get_kt_did() + 1); 6977c478bd9Sstevel@tonic-gate } 6987c478bd9Sstevel@tonic-gate 6997c478bd9Sstevel@tonic-gate /* 7007c478bd9Sstevel@tonic-gate * 7017c478bd9Sstevel@tonic-gate */ 7027c478bd9Sstevel@tonic-gate ACPI_STATUS 70327f7c583Smyers AcpiOsExecute(ACPI_EXECUTE_TYPE Type, ACPI_OSD_EXEC_CALLBACK Function, 70427f7c583Smyers void *Context) 7057c478bd9Sstevel@tonic-gate { 7067c478bd9Sstevel@tonic-gate 7077c478bd9Sstevel@tonic-gate if (!acpica_eventq_init) { 7087c478bd9Sstevel@tonic-gate /* 7097c478bd9Sstevel@tonic-gate * Create taskqs for event handling 7107c478bd9Sstevel@tonic-gate */ 7117c478bd9Sstevel@tonic-gate if (init_event_queues() != AE_OK) 7125dff2f34Smyers return (AE_ERROR); 7137c478bd9Sstevel@tonic-gate } 7147c478bd9Sstevel@tonic-gate 71527f7c583Smyers if (ddi_taskq_dispatch(osl_eventq[Type], Function, Context, 71627f7c583Smyers DDI_NOSLEEP) == DDI_FAILURE) { 7177c478bd9Sstevel@tonic-gate #ifdef DEBUG 7187c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!acpica: unable to dispatch event"); 7197c478bd9Sstevel@tonic-gate #endif 7207c478bd9Sstevel@tonic-gate return (AE_ERROR); 7217c478bd9Sstevel@tonic-gate } 7227c478bd9Sstevel@tonic-gate return (AE_OK); 7237c478bd9Sstevel@tonic-gate 7247c478bd9Sstevel@tonic-gate } 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate void 7277c478bd9Sstevel@tonic-gate AcpiOsSleep(ACPI_INTEGER Milliseconds) 7287c478bd9Sstevel@tonic-gate { 7297c478bd9Sstevel@tonic-gate /* 730137e2f25SGuoli Shu * During kernel startup, before the first tick interrupt 731137e2f25SGuoli Shu * has taken place, we can't call delay; very late in 732137e2f25SGuoli Shu * kernel shutdown or suspend/resume, clock interrupts 733859dcd3dSmyers * are blocked, so delay doesn't work then either. 734859dcd3dSmyers * So we busy wait if lbolt == 0 (kernel startup) 735137e2f25SGuoli Shu * or if acpica_use_safe_delay has been set to a 736137e2f25SGuoli Shu * non-zero value. 7377c478bd9Sstevel@tonic-gate */ 738137e2f25SGuoli Shu if ((ddi_get_lbolt() == 0) || acpica_use_safe_delay) 7397c478bd9Sstevel@tonic-gate drv_usecwait(Milliseconds * 1000); 7407c478bd9Sstevel@tonic-gate else 7417c478bd9Sstevel@tonic-gate delay(drv_usectohz(Milliseconds * 1000)); 7427c478bd9Sstevel@tonic-gate } 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate void 7457c478bd9Sstevel@tonic-gate AcpiOsStall(UINT32 Microseconds) 7467c478bd9Sstevel@tonic-gate { 7477c478bd9Sstevel@tonic-gate drv_usecwait(Microseconds); 7487c478bd9Sstevel@tonic-gate } 7497c478bd9Sstevel@tonic-gate 7507c478bd9Sstevel@tonic-gate 7517c478bd9Sstevel@tonic-gate /* 7527c478bd9Sstevel@tonic-gate * Implementation of "Windows 2001" compatible I/O permission map 7537c478bd9Sstevel@tonic-gate * 7547c478bd9Sstevel@tonic-gate */ 7557c478bd9Sstevel@tonic-gate #define OSL_IO_NONE (0) 7567c478bd9Sstevel@tonic-gate #define OSL_IO_READ (1<<0) 7577c478bd9Sstevel@tonic-gate #define OSL_IO_WRITE (1<<1) 7587c478bd9Sstevel@tonic-gate #define OSL_IO_RW (OSL_IO_READ | OSL_IO_WRITE) 7597c478bd9Sstevel@tonic-gate #define OSL_IO_TERM (1<<2) 7607c478bd9Sstevel@tonic-gate #define OSL_IO_DEFAULT OSL_IO_RW 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate static struct io_perm { 7637c478bd9Sstevel@tonic-gate ACPI_IO_ADDRESS low; 7647c478bd9Sstevel@tonic-gate ACPI_IO_ADDRESS high; 7657c478bd9Sstevel@tonic-gate uint8_t perm; 7667c478bd9Sstevel@tonic-gate } osl_io_perm[] = { 7677c478bd9Sstevel@tonic-gate { 0xcf8, 0xd00, OSL_IO_NONE | OSL_IO_TERM } 7687c478bd9Sstevel@tonic-gate }; 7697c478bd9Sstevel@tonic-gate 7707c478bd9Sstevel@tonic-gate 7717c478bd9Sstevel@tonic-gate /* 7727c478bd9Sstevel@tonic-gate * 7737c478bd9Sstevel@tonic-gate */ 7747c478bd9Sstevel@tonic-gate static struct io_perm * 7757c478bd9Sstevel@tonic-gate osl_io_find_perm(ACPI_IO_ADDRESS addr) 7767c478bd9Sstevel@tonic-gate { 7777c478bd9Sstevel@tonic-gate struct io_perm *p; 7787c478bd9Sstevel@tonic-gate 7797c478bd9Sstevel@tonic-gate p = osl_io_perm; 7807c478bd9Sstevel@tonic-gate while (p != NULL) { 7817c478bd9Sstevel@tonic-gate if ((p->low <= addr) && (addr <= p->high)) 7827c478bd9Sstevel@tonic-gate break; 7837c478bd9Sstevel@tonic-gate p = (p->perm & OSL_IO_TERM) ? NULL : p+1; 7847c478bd9Sstevel@tonic-gate } 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate return (p); 7877c478bd9Sstevel@tonic-gate } 7887c478bd9Sstevel@tonic-gate 7897c478bd9Sstevel@tonic-gate /* 7907c478bd9Sstevel@tonic-gate * 7917c478bd9Sstevel@tonic-gate */ 7927c478bd9Sstevel@tonic-gate ACPI_STATUS 7937c478bd9Sstevel@tonic-gate AcpiOsReadPort(ACPI_IO_ADDRESS Address, UINT32 *Value, UINT32 Width) 7947c478bd9Sstevel@tonic-gate { 7957c478bd9Sstevel@tonic-gate struct io_perm *p; 7967c478bd9Sstevel@tonic-gate 7977c478bd9Sstevel@tonic-gate /* verify permission */ 7987c478bd9Sstevel@tonic-gate p = osl_io_find_perm(Address); 7997c478bd9Sstevel@tonic-gate if (p && (p->perm & OSL_IO_READ) == 0) { 8007c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!AcpiOsReadPort: %lx %u not permitted", 8015dff2f34Smyers (long)Address, Width); 8027c478bd9Sstevel@tonic-gate *Value = 0xffffffff; 8037c478bd9Sstevel@tonic-gate return (AE_ERROR); 8047c478bd9Sstevel@tonic-gate } 8057c478bd9Sstevel@tonic-gate 8067c478bd9Sstevel@tonic-gate switch (Width) { 8077c478bd9Sstevel@tonic-gate case 8: 8087c478bd9Sstevel@tonic-gate *Value = inb(Address); 8097c478bd9Sstevel@tonic-gate break; 8107c478bd9Sstevel@tonic-gate case 16: 8117c478bd9Sstevel@tonic-gate *Value = inw(Address); 8127c478bd9Sstevel@tonic-gate break; 8137c478bd9Sstevel@tonic-gate case 32: 8147c478bd9Sstevel@tonic-gate *Value = inl(Address); 8157c478bd9Sstevel@tonic-gate break; 8167c478bd9Sstevel@tonic-gate default: 8177c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!AcpiOsReadPort: %lx %u failed", 8185dff2f34Smyers (long)Address, Width); 8197c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 8207c478bd9Sstevel@tonic-gate } 8217c478bd9Sstevel@tonic-gate return (AE_OK); 8227c478bd9Sstevel@tonic-gate } 8237c478bd9Sstevel@tonic-gate 8247c478bd9Sstevel@tonic-gate ACPI_STATUS 8257c478bd9Sstevel@tonic-gate AcpiOsWritePort(ACPI_IO_ADDRESS Address, UINT32 Value, UINT32 Width) 8267c478bd9Sstevel@tonic-gate { 8277c478bd9Sstevel@tonic-gate struct io_perm *p; 8287c478bd9Sstevel@tonic-gate 8297c478bd9Sstevel@tonic-gate /* verify permission */ 8307c478bd9Sstevel@tonic-gate p = osl_io_find_perm(Address); 8317c478bd9Sstevel@tonic-gate if (p && (p->perm & OSL_IO_WRITE) == 0) { 8327c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!AcpiOsWritePort: %lx %u not permitted", 8337c478bd9Sstevel@tonic-gate (long)Address, Width); 8347c478bd9Sstevel@tonic-gate return (AE_ERROR); 8357c478bd9Sstevel@tonic-gate } 8367c478bd9Sstevel@tonic-gate 8377c478bd9Sstevel@tonic-gate switch (Width) { 8387c478bd9Sstevel@tonic-gate case 8: 8397c478bd9Sstevel@tonic-gate outb(Address, Value); 8407c478bd9Sstevel@tonic-gate break; 8417c478bd9Sstevel@tonic-gate case 16: 8427c478bd9Sstevel@tonic-gate outw(Address, Value); 8437c478bd9Sstevel@tonic-gate break; 8447c478bd9Sstevel@tonic-gate case 32: 8457c478bd9Sstevel@tonic-gate outl(Address, Value); 8467c478bd9Sstevel@tonic-gate break; 8477c478bd9Sstevel@tonic-gate default: 8487c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!AcpiOsWritePort: %lx %u failed", 8497c478bd9Sstevel@tonic-gate (long)Address, Width); 8507c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 8517c478bd9Sstevel@tonic-gate } 8527c478bd9Sstevel@tonic-gate return (AE_OK); 8537c478bd9Sstevel@tonic-gate } 8547c478bd9Sstevel@tonic-gate 8557c478bd9Sstevel@tonic-gate 8567c478bd9Sstevel@tonic-gate /* 8577c478bd9Sstevel@tonic-gate * 8587c478bd9Sstevel@tonic-gate */ 8597c478bd9Sstevel@tonic-gate 8607c478bd9Sstevel@tonic-gate #define OSL_RW(ptr, val, type, rw) \ 8617c478bd9Sstevel@tonic-gate { if (rw) *((type *)(ptr)) = *((type *) val); \ 8627c478bd9Sstevel@tonic-gate else *((type *) val) = *((type *)(ptr)); } 8637c478bd9Sstevel@tonic-gate 8647c478bd9Sstevel@tonic-gate 8657c478bd9Sstevel@tonic-gate static void 8667c478bd9Sstevel@tonic-gate osl_rw_memory(ACPI_PHYSICAL_ADDRESS Address, UINT32 *Value, 8677c478bd9Sstevel@tonic-gate UINT32 Width, int write) 8687c478bd9Sstevel@tonic-gate { 8697c478bd9Sstevel@tonic-gate size_t maplen = Width / 8; 8707c478bd9Sstevel@tonic-gate caddr_t ptr; 8717c478bd9Sstevel@tonic-gate 8727c478bd9Sstevel@tonic-gate ptr = psm_map_new((paddr_t)Address, maplen, 8737c478bd9Sstevel@tonic-gate PSM_PROT_WRITE | PSM_PROT_READ); 8747c478bd9Sstevel@tonic-gate 8757c478bd9Sstevel@tonic-gate switch (maplen) { 8767c478bd9Sstevel@tonic-gate case 1: 8777c478bd9Sstevel@tonic-gate OSL_RW(ptr, Value, uint8_t, write); 8787c478bd9Sstevel@tonic-gate break; 8797c478bd9Sstevel@tonic-gate case 2: 8807c478bd9Sstevel@tonic-gate OSL_RW(ptr, Value, uint16_t, write); 8817c478bd9Sstevel@tonic-gate break; 8827c478bd9Sstevel@tonic-gate case 4: 8837c478bd9Sstevel@tonic-gate OSL_RW(ptr, Value, uint32_t, write); 8847c478bd9Sstevel@tonic-gate break; 8857c478bd9Sstevel@tonic-gate default: 8867c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!osl_rw_memory: invalid size %d", 8877c478bd9Sstevel@tonic-gate Width); 8887c478bd9Sstevel@tonic-gate break; 8897c478bd9Sstevel@tonic-gate } 8907c478bd9Sstevel@tonic-gate 8917c478bd9Sstevel@tonic-gate psm_unmap(ptr, maplen); 8927c478bd9Sstevel@tonic-gate } 8937c478bd9Sstevel@tonic-gate 8947c478bd9Sstevel@tonic-gate ACPI_STATUS 8957c478bd9Sstevel@tonic-gate AcpiOsReadMemory(ACPI_PHYSICAL_ADDRESS Address, 8967c478bd9Sstevel@tonic-gate UINT32 *Value, UINT32 Width) 8977c478bd9Sstevel@tonic-gate { 8987c478bd9Sstevel@tonic-gate osl_rw_memory(Address, Value, Width, 0); 8997c478bd9Sstevel@tonic-gate return (AE_OK); 9007c478bd9Sstevel@tonic-gate } 9017c478bd9Sstevel@tonic-gate 9027c478bd9Sstevel@tonic-gate ACPI_STATUS 9037c478bd9Sstevel@tonic-gate AcpiOsWriteMemory(ACPI_PHYSICAL_ADDRESS Address, 9047c478bd9Sstevel@tonic-gate UINT32 Value, UINT32 Width) 9057c478bd9Sstevel@tonic-gate { 9067c478bd9Sstevel@tonic-gate osl_rw_memory(Address, &Value, Width, 1); 9077c478bd9Sstevel@tonic-gate return (AE_OK); 9087c478bd9Sstevel@tonic-gate } 9097c478bd9Sstevel@tonic-gate 9107c478bd9Sstevel@tonic-gate 9117c478bd9Sstevel@tonic-gate ACPI_STATUS 9127c478bd9Sstevel@tonic-gate AcpiOsReadPciConfiguration(ACPI_PCI_ID *PciId, UINT32 Register, 9137c478bd9Sstevel@tonic-gate void *Value, UINT32 Width) 9147c478bd9Sstevel@tonic-gate { 9157c478bd9Sstevel@tonic-gate 9167c478bd9Sstevel@tonic-gate switch (Width) { 9177c478bd9Sstevel@tonic-gate case 8: 9187c478bd9Sstevel@tonic-gate *((UINT64 *)Value) = (UINT64)(*pci_getb_func) 9195dff2f34Smyers (PciId->Bus, PciId->Device, PciId->Function, Register); 9207c478bd9Sstevel@tonic-gate break; 9217c478bd9Sstevel@tonic-gate case 16: 9227c478bd9Sstevel@tonic-gate *((UINT64 *)Value) = (UINT64)(*pci_getw_func) 9235dff2f34Smyers (PciId->Bus, PciId->Device, PciId->Function, Register); 9247c478bd9Sstevel@tonic-gate break; 9257c478bd9Sstevel@tonic-gate case 32: 9267c478bd9Sstevel@tonic-gate *((UINT64 *)Value) = (UINT64)(*pci_getl_func) 9275dff2f34Smyers (PciId->Bus, PciId->Device, PciId->Function, Register); 9287c478bd9Sstevel@tonic-gate break; 9297c478bd9Sstevel@tonic-gate case 64: 9307c478bd9Sstevel@tonic-gate default: 9317c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!AcpiOsReadPciConfiguration: %x %u failed", 9327c478bd9Sstevel@tonic-gate Register, Width); 9337c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 9347c478bd9Sstevel@tonic-gate } 9357c478bd9Sstevel@tonic-gate return (AE_OK); 9367c478bd9Sstevel@tonic-gate } 9377c478bd9Sstevel@tonic-gate 9387c478bd9Sstevel@tonic-gate /* 9397c478bd9Sstevel@tonic-gate * 9407c478bd9Sstevel@tonic-gate */ 9417c478bd9Sstevel@tonic-gate int acpica_write_pci_config_ok = 1; 9427c478bd9Sstevel@tonic-gate 9437c478bd9Sstevel@tonic-gate ACPI_STATUS 9447c478bd9Sstevel@tonic-gate AcpiOsWritePciConfiguration(ACPI_PCI_ID *PciId, UINT32 Register, 9457c478bd9Sstevel@tonic-gate ACPI_INTEGER Value, UINT32 Width) 9467c478bd9Sstevel@tonic-gate { 9477c478bd9Sstevel@tonic-gate 9487c478bd9Sstevel@tonic-gate if (!acpica_write_pci_config_ok) { 9497c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!write to PCI cfg %x/%x/%x %x" 9507c478bd9Sstevel@tonic-gate " %lx %d not permitted", PciId->Bus, PciId->Device, 9517c478bd9Sstevel@tonic-gate PciId->Function, Register, (long)Value, Width); 9527c478bd9Sstevel@tonic-gate return (AE_OK); 9537c478bd9Sstevel@tonic-gate } 9547c478bd9Sstevel@tonic-gate 9557c478bd9Sstevel@tonic-gate switch (Width) { 9567c478bd9Sstevel@tonic-gate case 8: 9577c478bd9Sstevel@tonic-gate (*pci_putb_func)(PciId->Bus, PciId->Device, PciId->Function, 9585dff2f34Smyers Register, (uint8_t)Value); 9597c478bd9Sstevel@tonic-gate break; 9607c478bd9Sstevel@tonic-gate case 16: 9617c478bd9Sstevel@tonic-gate (*pci_putw_func)(PciId->Bus, PciId->Device, PciId->Function, 9625dff2f34Smyers Register, (uint16_t)Value); 9637c478bd9Sstevel@tonic-gate break; 9647c478bd9Sstevel@tonic-gate case 32: 9657c478bd9Sstevel@tonic-gate (*pci_putl_func)(PciId->Bus, PciId->Device, PciId->Function, 9665dff2f34Smyers Register, (uint32_t)Value); 9677c478bd9Sstevel@tonic-gate break; 9687c478bd9Sstevel@tonic-gate case 64: 9697c478bd9Sstevel@tonic-gate default: 9707c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!AcpiOsWritePciConfiguration: %x %u failed", 9717c478bd9Sstevel@tonic-gate Register, Width); 9727c478bd9Sstevel@tonic-gate return (AE_BAD_PARAMETER); 9737c478bd9Sstevel@tonic-gate } 9747c478bd9Sstevel@tonic-gate return (AE_OK); 9757c478bd9Sstevel@tonic-gate } 9767c478bd9Sstevel@tonic-gate 9777c478bd9Sstevel@tonic-gate /* 9787c478bd9Sstevel@tonic-gate * Called with ACPI_HANDLEs for both a PCI Config Space 9797c478bd9Sstevel@tonic-gate * OpRegion and (what ACPI CA thinks is) the PCI device 98027f7c583Smyers * to which this ConfigSpace OpRegion belongs. Since 98127f7c583Smyers * ACPI CA depends on a valid _BBN object being present 98227f7c583Smyers * and this is not always true (one old x86 had broken _BBN), 98327f7c583Smyers * we go ahead and get the correct PCI bus number using the 98427f7c583Smyers * devinfo mapping (which compensates for broken _BBN). 9857c478bd9Sstevel@tonic-gate * 9867c478bd9Sstevel@tonic-gate * Default values for bus, segment, device and function are 9877c478bd9Sstevel@tonic-gate * all 0 when ACPI CA can't figure them out. 9887c478bd9Sstevel@tonic-gate * 98927f7c583Smyers * Some BIOSes implement _BBN() by reading PCI config space 9905dff2f34Smyers * on bus #0 - which means that we'll recurse when we attempt 99127f7c583Smyers * to create the devinfo-to-ACPI map. If Derive is called during 9925cff7825Smh * scan_d2a_map, we don't translate the bus # and return. 9935cff7825Smh * 9945cff7825Smh * We get the parent of the OpRegion, which must be a PCI 9955cff7825Smh * node, fetch the associated devinfo node and snag the 9965cff7825Smh * b/d/f from it. 9977c478bd9Sstevel@tonic-gate */ 9987c478bd9Sstevel@tonic-gate void 9997c478bd9Sstevel@tonic-gate AcpiOsDerivePciId(ACPI_HANDLE rhandle, ACPI_HANDLE chandle, 10007c478bd9Sstevel@tonic-gate ACPI_PCI_ID **PciId) 10017c478bd9Sstevel@tonic-gate { 10027c478bd9Sstevel@tonic-gate ACPI_HANDLE handle; 10035cff7825Smh dev_info_t *dip; 10045cff7825Smh int bus, device, func, devfn; 10057c478bd9Sstevel@tonic-gate 10067c478bd9Sstevel@tonic-gate 100727f7c583Smyers /* 10085cff7825Smh * See above - avoid recursing during scanning_d2a_map. 100927f7c583Smyers */ 10105cff7825Smh if (scanning_d2a_map) 10117c478bd9Sstevel@tonic-gate return; 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate /* 10145cff7825Smh * Get the OpRegion's parent 10157c478bd9Sstevel@tonic-gate */ 10167c478bd9Sstevel@tonic-gate if (AcpiGetParent(chandle, &handle) != AE_OK) 10177c478bd9Sstevel@tonic-gate return; 10187c478bd9Sstevel@tonic-gate 10195cff7825Smh /* 10205cff7825Smh * If we've mapped the ACPI node to the devinfo 10215cff7825Smh * tree, use the devinfo reg property 10225cff7825Smh */ 10235cff7825Smh if (acpica_get_devinfo(handle, &dip) == AE_OK) { 10245cff7825Smh (void) acpica_get_bdf(dip, &bus, &device, &func); 10255cff7825Smh (*PciId)->Bus = bus; 10265cff7825Smh (*PciId)->Device = device; 10275cff7825Smh (*PciId)->Function = func; 10285cff7825Smh } else if (acpica_eval_int(handle, "_ADR", &devfn) == AE_OK) { 10295cff7825Smh /* no devinfo node - just confirm the d/f */ 10305cff7825Smh (*PciId)->Device = (devfn >> 16) & 0xFFFF; 10315cff7825Smh (*PciId)->Function = devfn & 0xFFFF; 10327c478bd9Sstevel@tonic-gate } 10337c478bd9Sstevel@tonic-gate } 10347c478bd9Sstevel@tonic-gate 10357c478bd9Sstevel@tonic-gate 103627f7c583Smyers /*ARGSUSED*/ 10377c478bd9Sstevel@tonic-gate BOOLEAN 10387c478bd9Sstevel@tonic-gate AcpiOsReadable(void *Pointer, ACPI_SIZE Length) 10397c478bd9Sstevel@tonic-gate { 10407c478bd9Sstevel@tonic-gate 10417c478bd9Sstevel@tonic-gate /* Always says yes; all mapped memory assumed readable */ 10427c478bd9Sstevel@tonic-gate return (1); 10437c478bd9Sstevel@tonic-gate } 10447c478bd9Sstevel@tonic-gate 104527f7c583Smyers /*ARGSUSED*/ 10467c478bd9Sstevel@tonic-gate BOOLEAN 10477c478bd9Sstevel@tonic-gate AcpiOsWritable(void *Pointer, ACPI_SIZE Length) 10487c478bd9Sstevel@tonic-gate { 10497c478bd9Sstevel@tonic-gate 10507c478bd9Sstevel@tonic-gate /* Always says yes; all mapped memory assumed writable */ 10517c478bd9Sstevel@tonic-gate return (1); 10527c478bd9Sstevel@tonic-gate } 10537c478bd9Sstevel@tonic-gate 10547c478bd9Sstevel@tonic-gate UINT64 10557c478bd9Sstevel@tonic-gate AcpiOsGetTimer(void) 10567c478bd9Sstevel@tonic-gate { 105727f7c583Smyers /* gethrtime() returns 1nS resolution; convert to 100nS granules */ 105827f7c583Smyers return ((gethrtime() + 50) / 100); 105927f7c583Smyers } 10607c478bd9Sstevel@tonic-gate 106127f7c583Smyers /*ARGSUSED*/ 106227f7c583Smyers ACPI_STATUS 106327f7c583Smyers AcpiOsValidateInterface(char *interface) 106427f7c583Smyers { 106527f7c583Smyers return (AE_SUPPORT); 106627f7c583Smyers } 10677c478bd9Sstevel@tonic-gate 106827f7c583Smyers /*ARGSUSED*/ 106927f7c583Smyers ACPI_STATUS 107027f7c583Smyers AcpiOsValidateAddress(UINT8 spaceid, ACPI_PHYSICAL_ADDRESS addr, 107127f7c583Smyers ACPI_SIZE length) 107227f7c583Smyers { 107327f7c583Smyers return (AE_OK); 10747c478bd9Sstevel@tonic-gate } 10757c478bd9Sstevel@tonic-gate 10767c478bd9Sstevel@tonic-gate ACPI_STATUS 10777c478bd9Sstevel@tonic-gate AcpiOsSignal(UINT32 Function, void *Info) 10787c478bd9Sstevel@tonic-gate { 10797c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(Function, Info)) 10807c478bd9Sstevel@tonic-gate 10817c478bd9Sstevel@tonic-gate /* FUTUREWORK: debugger support */ 10827c478bd9Sstevel@tonic-gate 10837c478bd9Sstevel@tonic-gate cmn_err(CE_NOTE, "!OsSignal unimplemented"); 10847c478bd9Sstevel@tonic-gate return (AE_OK); 10857c478bd9Sstevel@tonic-gate } 10867c478bd9Sstevel@tonic-gate 10877c478bd9Sstevel@tonic-gate void ACPI_INTERNAL_VAR_XFACE 10887c478bd9Sstevel@tonic-gate AcpiOsPrintf(const char *Format, ...) 10897c478bd9Sstevel@tonic-gate { 10907c478bd9Sstevel@tonic-gate va_list ap; 1091186507a7Smyers 1092186507a7Smyers va_start(ap, Format); 1093186507a7Smyers AcpiOsVprintf(Format, ap); 1094186507a7Smyers va_end(ap); 1095186507a7Smyers } 1096186507a7Smyers 1097186507a7Smyers /* 1098186507a7Smyers * When != 0, sends output to console 1099186507a7Smyers * Patchable with kmdb or /etc/system. 1100186507a7Smyers */ 1101186507a7Smyers int acpica_console_out = 0; 1102186507a7Smyers 1103186507a7Smyers #define ACPICA_OUTBUF_LEN 160 1104186507a7Smyers char acpica_outbuf[ACPICA_OUTBUF_LEN]; 1105186507a7Smyers int acpica_outbuf_offset; 1106186507a7Smyers 1107186507a7Smyers /* 1108186507a7Smyers * 1109186507a7Smyers */ 1110186507a7Smyers static void 111187bb58d6Smyers acpica_pr_buf(char *buf) 1112186507a7Smyers { 1113186507a7Smyers char c, *bufp, *outp; 1114186507a7Smyers int out_remaining; 1115186507a7Smyers 1116186507a7Smyers /* 1117186507a7Smyers * copy the supplied buffer into the output buffer 1118186507a7Smyers * when we hit a '\n' or overflow the output buffer, 1119186507a7Smyers * output and reset the output buffer 1120186507a7Smyers */ 1121186507a7Smyers bufp = buf; 1122186507a7Smyers outp = acpica_outbuf + acpica_outbuf_offset; 1123186507a7Smyers out_remaining = ACPICA_OUTBUF_LEN - acpica_outbuf_offset - 1; 1124186507a7Smyers while (c = *bufp++) { 1125186507a7Smyers *outp++ = c; 1126186507a7Smyers if (c == '\n' || --out_remaining == 0) { 1127186507a7Smyers *outp = '\0'; 1128186507a7Smyers if (acpica_console_out) 1129186507a7Smyers printf(acpica_outbuf); 1130186507a7Smyers else 1131186507a7Smyers (void) strlog(0, 0, 0, 1132186507a7Smyers SL_CONSOLE | SL_NOTE | SL_LOGONLY, 1133186507a7Smyers acpica_outbuf); 1134186507a7Smyers acpica_outbuf_offset = 0; 1135186507a7Smyers outp = acpica_outbuf; 1136186507a7Smyers out_remaining = ACPICA_OUTBUF_LEN - 1; 1137186507a7Smyers } 1138186507a7Smyers } 1139186507a7Smyers 1140186507a7Smyers acpica_outbuf_offset = outp - acpica_outbuf; 1141186507a7Smyers } 1142186507a7Smyers 1143186507a7Smyers void 1144186507a7Smyers AcpiOsVprintf(const char *Format, va_list Args) 1145186507a7Smyers { 11467c478bd9Sstevel@tonic-gate 11477c478bd9Sstevel@tonic-gate /* 114887bb58d6Smyers * If AcpiOsInitialize() failed to allocate a string buffer, 114987bb58d6Smyers * resort to vprintf(). 11507c478bd9Sstevel@tonic-gate */ 115187bb58d6Smyers if (acpi_osl_pr_buffer == NULL) { 1152186507a7Smyers vprintf(Format, Args); 11537c478bd9Sstevel@tonic-gate return; 11547c478bd9Sstevel@tonic-gate } 115587bb58d6Smyers 115687bb58d6Smyers /* 115787bb58d6Smyers * It is possible that a very long debug output statement will 115887bb58d6Smyers * be truncated; this is silently ignored. 115987bb58d6Smyers */ 116087bb58d6Smyers (void) vsnprintf(acpi_osl_pr_buffer, acpi_osl_pr_buflen, Format, Args); 116187bb58d6Smyers acpica_pr_buf(acpi_osl_pr_buffer); 11627c478bd9Sstevel@tonic-gate } 11637c478bd9Sstevel@tonic-gate 11647c478bd9Sstevel@tonic-gate void 11657c478bd9Sstevel@tonic-gate AcpiOsRedirectOutput(void *Destination) 11667c478bd9Sstevel@tonic-gate { 11677c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(Destination)) 11687c478bd9Sstevel@tonic-gate 11697c478bd9Sstevel@tonic-gate /* FUTUREWORK: debugger support */ 11707c478bd9Sstevel@tonic-gate 11717c478bd9Sstevel@tonic-gate #ifdef DEBUG 11727c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "!acpica: AcpiOsRedirectOutput called"); 11737c478bd9Sstevel@tonic-gate #endif 11747c478bd9Sstevel@tonic-gate } 11757c478bd9Sstevel@tonic-gate 11767c478bd9Sstevel@tonic-gate 11777c478bd9Sstevel@tonic-gate UINT32 11787c478bd9Sstevel@tonic-gate AcpiOsGetLine(char *Buffer) 11797c478bd9Sstevel@tonic-gate { 11807c478bd9Sstevel@tonic-gate _NOTE(ARGUNUSED(Buffer)) 11817c478bd9Sstevel@tonic-gate 11827c478bd9Sstevel@tonic-gate /* FUTUREWORK: debugger support */ 11837c478bd9Sstevel@tonic-gate 11847c478bd9Sstevel@tonic-gate return (0); 11857c478bd9Sstevel@tonic-gate } 11867c478bd9Sstevel@tonic-gate 11877c478bd9Sstevel@tonic-gate 11887c478bd9Sstevel@tonic-gate 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate /* 11917c478bd9Sstevel@tonic-gate * Device tree binding 11927c478bd9Sstevel@tonic-gate */ 11937c478bd9Sstevel@tonic-gate 11947c478bd9Sstevel@tonic-gate static int 11957c478bd9Sstevel@tonic-gate acpica_find_pcibus(int busno, ACPI_HANDLE *rh) 11967c478bd9Sstevel@tonic-gate { 11977c478bd9Sstevel@tonic-gate ACPI_HANDLE sbobj, busobj; 11987c478bd9Sstevel@tonic-gate int hid, bbn; 11997c478bd9Sstevel@tonic-gate 12007c478bd9Sstevel@tonic-gate /* initialize static flag by querying ACPI namespace for bug */ 12017c478bd9Sstevel@tonic-gate if (acpi_has_broken_bbn == -1) 12027c478bd9Sstevel@tonic-gate acpi_has_broken_bbn = acpica_query_bbn_problem(); 12037c478bd9Sstevel@tonic-gate 12047c478bd9Sstevel@tonic-gate busobj = NULL; 12057c478bd9Sstevel@tonic-gate AcpiGetHandle(NULL, "\\_SB", &sbobj); 12067c478bd9Sstevel@tonic-gate while (AcpiGetNextObject(ACPI_TYPE_DEVICE, sbobj, busobj, 12077c478bd9Sstevel@tonic-gate &busobj) == AE_OK) { 12087c478bd9Sstevel@tonic-gate if (acpica_eval_hid(busobj, "_HID", &hid) == AE_OK && 12097c478bd9Sstevel@tonic-gate (hid == HID_PCI_BUS || hid == HID_PCI_EXPRESS_BUS)) { 12107c478bd9Sstevel@tonic-gate if (acpi_has_broken_bbn) { 12117c478bd9Sstevel@tonic-gate ACPI_BUFFER rb; 12127c478bd9Sstevel@tonic-gate rb.Pointer = NULL; 12137c478bd9Sstevel@tonic-gate rb.Length = ACPI_ALLOCATE_BUFFER; 12147c478bd9Sstevel@tonic-gate 12157c478bd9Sstevel@tonic-gate /* Decree _BBN == n from PCI<n> */ 12167c478bd9Sstevel@tonic-gate if (AcpiGetName(busobj, ACPI_SINGLE_NAME, &rb) 12175dff2f34Smyers != AE_OK) { 12187c478bd9Sstevel@tonic-gate return (AE_ERROR); 12197c478bd9Sstevel@tonic-gate } 12207c478bd9Sstevel@tonic-gate bbn = ((char *)rb.Pointer)[3] - '0'; 12217c478bd9Sstevel@tonic-gate AcpiOsFree(rb.Pointer); 12227c478bd9Sstevel@tonic-gate if (bbn == busno || busno == 0) { 12237c478bd9Sstevel@tonic-gate *rh = busobj; 12247c478bd9Sstevel@tonic-gate return (AE_OK); 12257c478bd9Sstevel@tonic-gate } 12267c478bd9Sstevel@tonic-gate } else { 12277c478bd9Sstevel@tonic-gate if (acpica_eval_int(busobj, "_BBN", &bbn) == 12287c478bd9Sstevel@tonic-gate AE_OK) { 12297c478bd9Sstevel@tonic-gate if (bbn == busno) { 12307c478bd9Sstevel@tonic-gate *rh = busobj; 12317c478bd9Sstevel@tonic-gate return (AE_OK); 12327c478bd9Sstevel@tonic-gate } 12337c478bd9Sstevel@tonic-gate } else if (busno == 0) { 12347c478bd9Sstevel@tonic-gate *rh = busobj; 12357c478bd9Sstevel@tonic-gate return (AE_OK); 12367c478bd9Sstevel@tonic-gate } 12377c478bd9Sstevel@tonic-gate } 12387c478bd9Sstevel@tonic-gate } 12397c478bd9Sstevel@tonic-gate } 12407c478bd9Sstevel@tonic-gate return (AE_ERROR); 12417c478bd9Sstevel@tonic-gate } 12427c478bd9Sstevel@tonic-gate 12437c478bd9Sstevel@tonic-gate 12447c478bd9Sstevel@tonic-gate /* 12457c478bd9Sstevel@tonic-gate * Look for ACPI problem where _BBN is zero for multiple PCI buses 12467c478bd9Sstevel@tonic-gate * This is a clear ACPI bug, but we have a workaround in acpica_find_pcibus() 12477c478bd9Sstevel@tonic-gate * below if it exists. 12487c478bd9Sstevel@tonic-gate */ 12497c478bd9Sstevel@tonic-gate static int 12507c478bd9Sstevel@tonic-gate acpica_query_bbn_problem(void) 12517c478bd9Sstevel@tonic-gate { 12527c478bd9Sstevel@tonic-gate ACPI_HANDLE sbobj, busobj; 12537c478bd9Sstevel@tonic-gate int hid, bbn; 12547c478bd9Sstevel@tonic-gate int zerobbncnt; 12557c478bd9Sstevel@tonic-gate 12567c478bd9Sstevel@tonic-gate busobj = NULL; 12577c478bd9Sstevel@tonic-gate zerobbncnt = 0; 12587c478bd9Sstevel@tonic-gate 12597c478bd9Sstevel@tonic-gate AcpiGetHandle(NULL, "\\_SB", &sbobj); 12607c478bd9Sstevel@tonic-gate 12617c478bd9Sstevel@tonic-gate while (AcpiGetNextObject(ACPI_TYPE_DEVICE, sbobj, busobj, 12627c478bd9Sstevel@tonic-gate &busobj) == AE_OK) { 12637c478bd9Sstevel@tonic-gate if ((acpica_eval_hid(busobj, "_HID", &hid) == AE_OK) && 12647c478bd9Sstevel@tonic-gate (hid == HID_PCI_BUS || hid == HID_PCI_EXPRESS_BUS) && 12657c478bd9Sstevel@tonic-gate (acpica_eval_int(busobj, "_BBN", &bbn) == AE_OK)) { 12667c478bd9Sstevel@tonic-gate if (bbn == 0) { 12677c478bd9Sstevel@tonic-gate /* 12687c478bd9Sstevel@tonic-gate * If we find more than one bus with a 0 _BBN 12697c478bd9Sstevel@tonic-gate * we have the problem that BigBear's BIOS shows 12707c478bd9Sstevel@tonic-gate */ 12717c478bd9Sstevel@tonic-gate if (++zerobbncnt > 1) 12727c478bd9Sstevel@tonic-gate return (1); 12737c478bd9Sstevel@tonic-gate } 12747c478bd9Sstevel@tonic-gate } 12757c478bd9Sstevel@tonic-gate } 12767c478bd9Sstevel@tonic-gate return (0); 12777c478bd9Sstevel@tonic-gate } 12787c478bd9Sstevel@tonic-gate 12797c478bd9Sstevel@tonic-gate static const char hextab[] = "0123456789ABCDEF"; 12807c478bd9Sstevel@tonic-gate 12817c478bd9Sstevel@tonic-gate static int 12827c478bd9Sstevel@tonic-gate hexdig(int c) 12837c478bd9Sstevel@tonic-gate { 12847c478bd9Sstevel@tonic-gate /* 12857c478bd9Sstevel@tonic-gate * Get hex digit: 12867c478bd9Sstevel@tonic-gate * 12877c478bd9Sstevel@tonic-gate * Returns the 4-bit hex digit named by the input character. Returns 12887c478bd9Sstevel@tonic-gate * zero if the input character is not valid hex! 12897c478bd9Sstevel@tonic-gate */ 12907c478bd9Sstevel@tonic-gate 12917c478bd9Sstevel@tonic-gate int x = ((c < 'a') || (c > 'z')) ? c : (c - ' '); 12927c478bd9Sstevel@tonic-gate int j = sizeof (hextab); 12937c478bd9Sstevel@tonic-gate 12945dff2f34Smyers while (--j && (x != hextab[j])) { 12955dff2f34Smyers } 12967c478bd9Sstevel@tonic-gate return (j); 12977c478bd9Sstevel@tonic-gate } 12987c478bd9Sstevel@tonic-gate 12997c478bd9Sstevel@tonic-gate static int 13007c478bd9Sstevel@tonic-gate CompressEisaID(char *np) 13017c478bd9Sstevel@tonic-gate { 13027c478bd9Sstevel@tonic-gate /* 13037c478bd9Sstevel@tonic-gate * Compress an EISA device name: 13047c478bd9Sstevel@tonic-gate * 13057c478bd9Sstevel@tonic-gate * This routine converts a 7-byte ASCII device name into the 4-byte 13067c478bd9Sstevel@tonic-gate * compressed form used by EISA (50 bytes of ROM to save 1 byte of 13077c478bd9Sstevel@tonic-gate * NV-RAM!) 13087c478bd9Sstevel@tonic-gate */ 13097c478bd9Sstevel@tonic-gate 13107c478bd9Sstevel@tonic-gate union { char octets[4]; int retval; } myu; 13117c478bd9Sstevel@tonic-gate 13127c478bd9Sstevel@tonic-gate myu.octets[0] = ((np[0] & 0x1F) << 2) + ((np[1] >> 3) & 0x03); 13137c478bd9Sstevel@tonic-gate myu.octets[1] = ((np[1] & 0x07) << 5) + (np[2] & 0x1F); 13147c478bd9Sstevel@tonic-gate myu.octets[2] = (hexdig(np[3]) << 4) + hexdig(np[4]); 13157c478bd9Sstevel@tonic-gate myu.octets[3] = (hexdig(np[5]) << 4) + hexdig(np[6]); 13167c478bd9Sstevel@tonic-gate 13177c478bd9Sstevel@tonic-gate return (myu.retval); 13187c478bd9Sstevel@tonic-gate } 13197c478bd9Sstevel@tonic-gate 13205cff7825Smh ACPI_STATUS 13217c478bd9Sstevel@tonic-gate acpica_eval_int(ACPI_HANDLE dev, char *method, int *rint) 13227c478bd9Sstevel@tonic-gate { 13237c478bd9Sstevel@tonic-gate ACPI_STATUS status; 13247c478bd9Sstevel@tonic-gate ACPI_BUFFER rb; 13257c478bd9Sstevel@tonic-gate ACPI_OBJECT ro; 13267c478bd9Sstevel@tonic-gate 13277c478bd9Sstevel@tonic-gate rb.Pointer = &ro; 13287c478bd9Sstevel@tonic-gate rb.Length = sizeof (ro); 13297c478bd9Sstevel@tonic-gate if ((status = AcpiEvaluateObjectTyped(dev, method, NULL, &rb, 13305dff2f34Smyers ACPI_TYPE_INTEGER)) == AE_OK) 13317c478bd9Sstevel@tonic-gate *rint = ro.Integer.Value; 13327c478bd9Sstevel@tonic-gate 13337c478bd9Sstevel@tonic-gate return (status); 13347c478bd9Sstevel@tonic-gate } 13357c478bd9Sstevel@tonic-gate 13367c478bd9Sstevel@tonic-gate static int 13377c478bd9Sstevel@tonic-gate acpica_eval_hid(ACPI_HANDLE dev, char *method, int *rint) 13387c478bd9Sstevel@tonic-gate { 13397c478bd9Sstevel@tonic-gate ACPI_BUFFER rb; 13407c478bd9Sstevel@tonic-gate ACPI_OBJECT *rv; 13417c478bd9Sstevel@tonic-gate 13427c478bd9Sstevel@tonic-gate rb.Pointer = NULL; 13437c478bd9Sstevel@tonic-gate rb.Length = ACPI_ALLOCATE_BUFFER; 1344db2bae30SDana Myers if (AcpiEvaluateObject(dev, method, NULL, &rb) == AE_OK && 1345db2bae30SDana Myers rb.Length != 0) { 13467c478bd9Sstevel@tonic-gate rv = rb.Pointer; 13477c478bd9Sstevel@tonic-gate if (rv->Type == ACPI_TYPE_INTEGER) { 13487c478bd9Sstevel@tonic-gate *rint = rv->Integer.Value; 13497c478bd9Sstevel@tonic-gate AcpiOsFree(rv); 13507c478bd9Sstevel@tonic-gate return (AE_OK); 13517c478bd9Sstevel@tonic-gate } else if (rv->Type == ACPI_TYPE_STRING) { 13527c478bd9Sstevel@tonic-gate char *stringData; 13537c478bd9Sstevel@tonic-gate 13547c478bd9Sstevel@tonic-gate /* Convert the string into an EISA ID */ 13557c478bd9Sstevel@tonic-gate if (rv->String.Pointer == NULL) { 13567c478bd9Sstevel@tonic-gate AcpiOsFree(rv); 13577c478bd9Sstevel@tonic-gate return (AE_ERROR); 13587c478bd9Sstevel@tonic-gate } 13597c478bd9Sstevel@tonic-gate 13607c478bd9Sstevel@tonic-gate stringData = rv->String.Pointer; 13617c478bd9Sstevel@tonic-gate 13627c478bd9Sstevel@tonic-gate /* 13637c478bd9Sstevel@tonic-gate * If the string is an EisaID, it must be 7 13647c478bd9Sstevel@tonic-gate * characters; if it's an ACPI ID, it will be 8 13657c478bd9Sstevel@tonic-gate * (and we don't care about ACPI ids here). 13667c478bd9Sstevel@tonic-gate */ 13677c478bd9Sstevel@tonic-gate if (strlen(stringData) != 7) { 13687c478bd9Sstevel@tonic-gate AcpiOsFree(rv); 13697c478bd9Sstevel@tonic-gate return (AE_ERROR); 13707c478bd9Sstevel@tonic-gate } 13717c478bd9Sstevel@tonic-gate 13727c478bd9Sstevel@tonic-gate *rint = CompressEisaID(stringData); 13737c478bd9Sstevel@tonic-gate AcpiOsFree(rv); 13747c478bd9Sstevel@tonic-gate return (AE_OK); 13757c478bd9Sstevel@tonic-gate } else 13767c478bd9Sstevel@tonic-gate AcpiOsFree(rv); 13777c478bd9Sstevel@tonic-gate } 13787c478bd9Sstevel@tonic-gate return (AE_ERROR); 13797c478bd9Sstevel@tonic-gate } 13807c478bd9Sstevel@tonic-gate 13817c478bd9Sstevel@tonic-gate /* 13825cff7825Smh * Create linkage between devinfo nodes and ACPI nodes 13837c478bd9Sstevel@tonic-gate */ 13845cff7825Smh static void 13855cff7825Smh acpica_tag_devinfo(dev_info_t *dip, ACPI_HANDLE acpiobj) 13867c478bd9Sstevel@tonic-gate { 13875cff7825Smh ACPI_STATUS status; 13885cff7825Smh ACPI_BUFFER rb; 13897c478bd9Sstevel@tonic-gate 13905cff7825Smh /* 13915cff7825Smh * Tag the ACPI node with the dip 13925cff7825Smh */ 13935cff7825Smh status = acpica_set_devinfo(acpiobj, dip); 13945cff7825Smh ASSERT(status == AE_OK); 13957c478bd9Sstevel@tonic-gate 13965cff7825Smh /* 13975cff7825Smh * Tag the devinfo node with the ACPI name 13985cff7825Smh */ 13995cff7825Smh rb.Pointer = NULL; 14005cff7825Smh rb.Length = ACPI_ALLOCATE_BUFFER; 14015cff7825Smh if (AcpiGetName(acpiobj, ACPI_FULL_PATHNAME, &rb) == AE_OK) { 14025cff7825Smh (void) ndi_prop_update_string(DDI_DEV_T_NONE, dip, 14035cff7825Smh "acpi-namespace", (char *)rb.Pointer); 14045cff7825Smh AcpiOsFree(rb.Pointer); 14055cff7825Smh } else { 14065cff7825Smh cmn_err(CE_WARN, "acpica: could not get ACPI path!"); 14075cff7825Smh } 14087c478bd9Sstevel@tonic-gate } 14097c478bd9Sstevel@tonic-gate 14105cff7825Smh static void 14115cff7825Smh acpica_add_processor_to_map(UINT32 acpi_id, ACPI_HANDLE obj) 14127c478bd9Sstevel@tonic-gate { 14135cff7825Smh int cpu_id; 14147c478bd9Sstevel@tonic-gate 14155cff7825Smh /* 14165cff7825Smh * Special case: if we're a uppc system, there won't be 14175cff7825Smh * a CPU map yet. So we create one and use the passed-in 14185cff7825Smh * processor as CPU 0 14195cff7825Smh */ 14205cff7825Smh if (cpu_map == NULL) { 14215cff7825Smh cpu_map = kmem_zalloc(sizeof (cpu_map[0]) * NCPU, KM_SLEEP); 14225cff7825Smh cpu_map[0] = kmem_zalloc(sizeof (*cpu_map[0]), KM_SLEEP); 14235cff7825Smh cpu_map[0]->obj = obj; 14245cff7825Smh cpu_map_count = 1; 14255cff7825Smh return; 14265cff7825Smh } 14275cff7825Smh 14285cff7825Smh for (cpu_id = 0; cpu_id < NCPU; cpu_id++) { 14295cff7825Smh if (cpu_map[cpu_id] == NULL) 14305cff7825Smh continue; 14315cff7825Smh 1432b6917abeSmishra if (cpu_map[cpu_id]->proc_id == acpi_id) { 14334e93b15cSmh if (cpu_map[cpu_id]->obj == NULL) 14344e93b15cSmh cpu_map[cpu_id]->obj = obj; 14355cff7825Smh break; 14367c478bd9Sstevel@tonic-gate } 14375cff7825Smh } 14387c478bd9Sstevel@tonic-gate 14397c478bd9Sstevel@tonic-gate } 14407c478bd9Sstevel@tonic-gate 14417c478bd9Sstevel@tonic-gate /* 1442495256c0Smh * Return the ACPI device node matching the CPU dev_info node. 14437c478bd9Sstevel@tonic-gate */ 14445cff7825Smh ACPI_STATUS 14450e751525SEric Saxe acpica_get_handle_cpu(int cpu_id, ACPI_HANDLE *rh) 14467c478bd9Sstevel@tonic-gate { 14475cff7825Smh /* 14485cff7825Smh * if cpu_map itself is NULL, we're a uppc system and 14495cff7825Smh * acpica_build_processor_map() hasn't been called yet. 14505cff7825Smh * So call it here 14515cff7825Smh */ 14525cff7825Smh if (cpu_map == NULL) { 14535cff7825Smh (void) acpica_build_processor_map(); 14545cff7825Smh if (cpu_map == NULL) 14555cff7825Smh return (AE_ERROR); 14567c478bd9Sstevel@tonic-gate } 14577c478bd9Sstevel@tonic-gate 14585cff7825Smh if ((cpu_id < 0) || (cpu_map[cpu_id] == NULL) || 14595cff7825Smh (cpu_map[cpu_id]->obj == NULL)) 14605cff7825Smh return (AE_ERROR); 14615cff7825Smh 14625cff7825Smh *rh = cpu_map[cpu_id]->obj; 14635cff7825Smh return (AE_OK); 14645cff7825Smh } 14655cff7825Smh 14665cff7825Smh /* 14675cff7825Smh * Determine if this object is a processor 14685cff7825Smh */ 14695cff7825Smh static ACPI_STATUS 14705cff7825Smh acpica_probe_processor(ACPI_HANDLE obj, UINT32 level, void *ctx, void **rv) 14715cff7825Smh { 14725cff7825Smh ACPI_STATUS status; 14735cff7825Smh ACPI_OBJECT_TYPE objtype; 14744b1ce0a9SDana Myers unsigned long acpi_id; 14755cff7825Smh ACPI_BUFFER rb; 14765cff7825Smh 14775cff7825Smh if (AcpiGetType(obj, &objtype) != AE_OK) 14785cff7825Smh return (AE_OK); 14795cff7825Smh 14805cff7825Smh if (objtype == ACPI_TYPE_PROCESSOR) { 14815cff7825Smh /* process a Processor */ 14827c478bd9Sstevel@tonic-gate rb.Pointer = NULL; 14837c478bd9Sstevel@tonic-gate rb.Length = ACPI_ALLOCATE_BUFFER; 1484db2bae30SDana Myers status = AcpiEvaluateObjectTyped(obj, NULL, NULL, &rb, 1485db2bae30SDana Myers ACPI_TYPE_PROCESSOR); 14865cff7825Smh if (status != AE_OK) { 14874b1ce0a9SDana Myers cmn_err(CE_WARN, "!acpica: error probing Processor"); 14885cff7825Smh return (status); 14897c478bd9Sstevel@tonic-gate } 14905cff7825Smh acpi_id = ((ACPI_OBJECT *)rb.Pointer)->Processor.ProcId; 14915cff7825Smh AcpiOsFree(rb.Pointer); 14925cff7825Smh } else if (objtype == ACPI_TYPE_DEVICE) { 14935cff7825Smh /* process a processor Device */ 1494b6917abeSmishra rb.Pointer = NULL; 1495b6917abeSmishra rb.Length = ACPI_ALLOCATE_BUFFER; 1496b6917abeSmishra status = AcpiGetObjectInfo(obj, &rb); 1497b6917abeSmishra if (status != AE_OK) { 1498b6917abeSmishra cmn_err(CE_WARN, 14994b1ce0a9SDana Myers "!acpica: error probing Processor Device\n"); 1500b6917abeSmishra return (status); 1501b6917abeSmishra } 1502b6917abeSmishra ASSERT(((ACPI_OBJECT *)rb.Pointer)->Type == 1503b6917abeSmishra ACPI_TYPE_DEVICE); 15044b1ce0a9SDana Myers 15054b1ce0a9SDana Myers if (ddi_strtoul( 15064b1ce0a9SDana Myers ((ACPI_DEVICE_INFO *)rb.Pointer)->UniqueId.Value, 15074b1ce0a9SDana Myers NULL, 10, &acpi_id) != 0) { 15084b1ce0a9SDana Myers AcpiOsFree(rb.Pointer); 15094b1ce0a9SDana Myers cmn_err(CE_WARN, 15104b1ce0a9SDana Myers "!acpica: error probing Processor Device _UID\n"); 15114b1ce0a9SDana Myers return (AE_ERROR); 15124b1ce0a9SDana Myers } 1513b6917abeSmishra AcpiOsFree(rb.Pointer); 15147c478bd9Sstevel@tonic-gate } 15155cff7825Smh 15165cff7825Smh acpica_add_processor_to_map(acpi_id, obj); 15175cff7825Smh return (AE_OK); 15187c478bd9Sstevel@tonic-gate } 15197c478bd9Sstevel@tonic-gate 15205cff7825Smh 15217c478bd9Sstevel@tonic-gate static void 15225cff7825Smh scan_d2a_map(void) 15237c478bd9Sstevel@tonic-gate { 15247c478bd9Sstevel@tonic-gate dev_info_t *dip, *cdip; 15257c478bd9Sstevel@tonic-gate ACPI_HANDLE acpiobj; 15267c478bd9Sstevel@tonic-gate char *device_type_prop; 15277c478bd9Sstevel@tonic-gate int bus; 15287c478bd9Sstevel@tonic-gate static int map_error = 0; 15297c478bd9Sstevel@tonic-gate 15307c478bd9Sstevel@tonic-gate if (map_error) 15317c478bd9Sstevel@tonic-gate return; 15327c478bd9Sstevel@tonic-gate 15335cff7825Smh scanning_d2a_map = 1; 15347c478bd9Sstevel@tonic-gate 15357c478bd9Sstevel@tonic-gate /* 15367c478bd9Sstevel@tonic-gate * Find all child-of-root PCI buses, and find their corresponding 15377c478bd9Sstevel@tonic-gate * ACPI child-of-root PCI nodes. For each one, add to the 15387c478bd9Sstevel@tonic-gate * d2a table. 15397c478bd9Sstevel@tonic-gate */ 15407c478bd9Sstevel@tonic-gate 15417c478bd9Sstevel@tonic-gate for (dip = ddi_get_child(ddi_root_node()); 15427c478bd9Sstevel@tonic-gate dip != NULL; 15437c478bd9Sstevel@tonic-gate dip = ddi_get_next_sibling(dip)) { 15447c478bd9Sstevel@tonic-gate 15457c478bd9Sstevel@tonic-gate /* prune non-PCI nodes */ 15467c478bd9Sstevel@tonic-gate if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, 0, 15477c478bd9Sstevel@tonic-gate "device_type", &device_type_prop) != DDI_PROP_SUCCESS) 15487c478bd9Sstevel@tonic-gate continue; 15497c478bd9Sstevel@tonic-gate 155070025d76Sjohnny if ((strcmp("pci", device_type_prop) != 0) && 155170025d76Sjohnny (strcmp("pciex", device_type_prop) != 0)) { 15527c478bd9Sstevel@tonic-gate ddi_prop_free(device_type_prop); 15537c478bd9Sstevel@tonic-gate continue; 15547c478bd9Sstevel@tonic-gate } 15557c478bd9Sstevel@tonic-gate 15567c478bd9Sstevel@tonic-gate ddi_prop_free(device_type_prop); 15577c478bd9Sstevel@tonic-gate 15587c478bd9Sstevel@tonic-gate /* 15597c478bd9Sstevel@tonic-gate * To get bus number of dip, get first child and get its 15607c478bd9Sstevel@tonic-gate * bus number. If NULL, just continue, because we don't 15617c478bd9Sstevel@tonic-gate * care about bus nodes with no children anyway. 15627c478bd9Sstevel@tonic-gate */ 15637c478bd9Sstevel@tonic-gate if ((cdip = ddi_get_child(dip)) == NULL) 15647c478bd9Sstevel@tonic-gate continue; 15657c478bd9Sstevel@tonic-gate 15667c478bd9Sstevel@tonic-gate if (acpica_get_bdf(cdip, &bus, NULL, NULL) < 0) { 15677c478bd9Sstevel@tonic-gate #ifdef D2ADEBUG 15687c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "Can't get bus number of PCI child?"); 15697c478bd9Sstevel@tonic-gate #endif 15707c478bd9Sstevel@tonic-gate map_error = 1; 15715cff7825Smh scanning_d2a_map = 0; 15725cff7825Smh d2a_done = 1; 15737c478bd9Sstevel@tonic-gate return; 15747c478bd9Sstevel@tonic-gate } 15757c478bd9Sstevel@tonic-gate 15767c478bd9Sstevel@tonic-gate if (acpica_find_pcibus(bus, &acpiobj) == AE_ERROR) { 15777c478bd9Sstevel@tonic-gate #ifdef D2ADEBUG 15787c478bd9Sstevel@tonic-gate cmn_err(CE_WARN, "No ACPI bus obj for bus %d?\n", bus); 15797c478bd9Sstevel@tonic-gate #endif 15807c478bd9Sstevel@tonic-gate map_error = 1; 15817c478bd9Sstevel@tonic-gate continue; 15827c478bd9Sstevel@tonic-gate } 15837c478bd9Sstevel@tonic-gate 15845cff7825Smh acpica_tag_devinfo(dip, acpiobj); 15857c478bd9Sstevel@tonic-gate 15865cff7825Smh /* call recursively to enumerate subtrees */ 15875cff7825Smh scan_d2a_subtree(dip, acpiobj, bus); 15887c478bd9Sstevel@tonic-gate } 15895cff7825Smh 15905cff7825Smh scanning_d2a_map = 0; 15915cff7825Smh d2a_done = 1; 15927c478bd9Sstevel@tonic-gate } 15937c478bd9Sstevel@tonic-gate 15947c478bd9Sstevel@tonic-gate /* 15957c478bd9Sstevel@tonic-gate * For all acpi child devices of acpiobj, find their matching 15967c478bd9Sstevel@tonic-gate * dip under "dip" argument. (matching means "matches dev/fn"). 15977c478bd9Sstevel@tonic-gate * bus is assumed to already be a match from caller, and is 15987c478bd9Sstevel@tonic-gate * used here only to record in the d2a entry. Recurse if necessary. 15997c478bd9Sstevel@tonic-gate */ 16007c478bd9Sstevel@tonic-gate static void 16015cff7825Smh scan_d2a_subtree(dev_info_t *dip, ACPI_HANDLE acpiobj, int bus) 16027c478bd9Sstevel@tonic-gate { 16037c478bd9Sstevel@tonic-gate int acpi_devfn, hid; 16047c478bd9Sstevel@tonic-gate ACPI_HANDLE acld; 16057c478bd9Sstevel@tonic-gate dev_info_t *dcld; 16067c478bd9Sstevel@tonic-gate int dcld_b, dcld_d, dcld_f; 16077c478bd9Sstevel@tonic-gate int dev, func; 16085cff7825Smh char *device_type_prop; 16097c478bd9Sstevel@tonic-gate 16107c478bd9Sstevel@tonic-gate acld = NULL; 1611186507a7Smyers while (AcpiGetNextObject(ACPI_TYPE_DEVICE, acpiobj, acld, &acld) 16127c478bd9Sstevel@tonic-gate == AE_OK) { 16137c478bd9Sstevel@tonic-gate /* get the dev/func we're looking for in the devinfo tree */ 16147c478bd9Sstevel@tonic-gate if (acpica_eval_int(acld, "_ADR", &acpi_devfn) != AE_OK) 16157c478bd9Sstevel@tonic-gate continue; 16167c478bd9Sstevel@tonic-gate dev = (acpi_devfn >> 16) & 0xFFFF; 16177c478bd9Sstevel@tonic-gate func = acpi_devfn & 0xFFFF; 16187c478bd9Sstevel@tonic-gate 16197c478bd9Sstevel@tonic-gate /* look through all the immediate children of dip */ 16207c478bd9Sstevel@tonic-gate for (dcld = ddi_get_child(dip); dcld != NULL; 16217c478bd9Sstevel@tonic-gate dcld = ddi_get_next_sibling(dcld)) { 16227c478bd9Sstevel@tonic-gate if (acpica_get_bdf(dcld, &dcld_b, &dcld_d, &dcld_f) < 0) 16237c478bd9Sstevel@tonic-gate continue; 16247c478bd9Sstevel@tonic-gate 16257c478bd9Sstevel@tonic-gate /* dev must match; function must match or wildcard */ 16267c478bd9Sstevel@tonic-gate if (dcld_d != dev || 16277c478bd9Sstevel@tonic-gate (func != 0xFFFF && func != dcld_f)) 16287c478bd9Sstevel@tonic-gate continue; 16297c478bd9Sstevel@tonic-gate bus = dcld_b; 16307c478bd9Sstevel@tonic-gate 16317c478bd9Sstevel@tonic-gate /* found a match, record it */ 16325cff7825Smh acpica_tag_devinfo(dcld, acld); 16335cff7825Smh 16345cff7825Smh /* if we find a bridge, recurse from here */ 16355cff7825Smh if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dcld, 0, 16365cff7825Smh "device_type", &device_type_prop) == 16375cff7825Smh DDI_PROP_SUCCESS) { 16385cff7825Smh if ((strcmp("pci", device_type_prop) == 0) || 16395cff7825Smh (strcmp("pciex", device_type_prop) == 0)) 16405cff7825Smh scan_d2a_subtree(dcld, acld, bus); 16415cff7825Smh ddi_prop_free(device_type_prop); 16425cff7825Smh } 16437c478bd9Sstevel@tonic-gate 16447c478bd9Sstevel@tonic-gate /* done finding a match, so break now */ 16457c478bd9Sstevel@tonic-gate break; 16467c478bd9Sstevel@tonic-gate } 16478e56767dSsmall } 16487c478bd9Sstevel@tonic-gate } 16497c478bd9Sstevel@tonic-gate 16507c478bd9Sstevel@tonic-gate /* 16517c478bd9Sstevel@tonic-gate * Return bus/dev/fn for PCI dip (note: not the parent "pci" node). 16527c478bd9Sstevel@tonic-gate */ 16537c478bd9Sstevel@tonic-gate int 16547c478bd9Sstevel@tonic-gate acpica_get_bdf(dev_info_t *dip, int *bus, int *device, int *func) 16557c478bd9Sstevel@tonic-gate { 16567c478bd9Sstevel@tonic-gate pci_regspec_t *pci_rp; 16577c478bd9Sstevel@tonic-gate int len; 16587c478bd9Sstevel@tonic-gate 16597c478bd9Sstevel@tonic-gate if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 16607c478bd9Sstevel@tonic-gate "reg", (int **)&pci_rp, (uint_t *)&len) != DDI_SUCCESS) 16617c478bd9Sstevel@tonic-gate return (-1); 16627c478bd9Sstevel@tonic-gate 16637c478bd9Sstevel@tonic-gate if (len < (sizeof (pci_regspec_t) / sizeof (int))) { 16647c478bd9Sstevel@tonic-gate ddi_prop_free(pci_rp); 16657c478bd9Sstevel@tonic-gate return (-1); 16667c478bd9Sstevel@tonic-gate } 16677c478bd9Sstevel@tonic-gate if (bus != NULL) 16687c478bd9Sstevel@tonic-gate *bus = (int)PCI_REG_BUS_G(pci_rp->pci_phys_hi); 16697c478bd9Sstevel@tonic-gate if (device != NULL) 16707c478bd9Sstevel@tonic-gate *device = (int)PCI_REG_DEV_G(pci_rp->pci_phys_hi); 16717c478bd9Sstevel@tonic-gate if (func != NULL) 16727c478bd9Sstevel@tonic-gate *func = (int)PCI_REG_FUNC_G(pci_rp->pci_phys_hi); 16737c478bd9Sstevel@tonic-gate ddi_prop_free(pci_rp); 16747c478bd9Sstevel@tonic-gate return (0); 16757c478bd9Sstevel@tonic-gate } 16765cff7825Smh 16775cff7825Smh /* 16785cff7825Smh * Return the ACPI device node matching this dev_info node, if it 16795cff7825Smh * exists in the ACPI tree. 16805cff7825Smh */ 16815cff7825Smh ACPI_STATUS 16825cff7825Smh acpica_get_handle(dev_info_t *dip, ACPI_HANDLE *rh) 16835cff7825Smh { 16845cff7825Smh ACPI_STATUS status; 16855cff7825Smh char *acpiname; 16865cff7825Smh 16875cff7825Smh if (!d2a_done) 16885cff7825Smh scan_d2a_map(); 16895cff7825Smh 16905cff7825Smh if (ddi_prop_lookup_string(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS, 16915cff7825Smh "acpi-namespace", &acpiname) != DDI_PROP_SUCCESS) { 16920e751525SEric Saxe return (AE_ERROR); 16935cff7825Smh } 16945cff7825Smh 16955cff7825Smh status = AcpiGetHandle(NULL, acpiname, rh); 16965cff7825Smh ddi_prop_free((void *)acpiname); 16975cff7825Smh return (status); 16985cff7825Smh } 16995cff7825Smh 17005cff7825Smh 17015cff7825Smh 17025cff7825Smh /* 17035cff7825Smh * Manage OS data attachment to ACPI nodes 17045cff7825Smh */ 17055cff7825Smh 17065cff7825Smh /* 17075cff7825Smh * Return the (dev_info_t *) associated with the ACPI node. 17085cff7825Smh */ 17095cff7825Smh ACPI_STATUS 17105cff7825Smh acpica_get_devinfo(ACPI_HANDLE obj, dev_info_t **dipp) 17115cff7825Smh { 17125cff7825Smh ACPI_STATUS status; 17135cff7825Smh void *ptr; 17145cff7825Smh 17155cff7825Smh status = AcpiGetData(obj, acpica_devinfo_handler, &ptr); 17165cff7825Smh if (status == AE_OK) 17175cff7825Smh *dipp = (dev_info_t *)ptr; 17185cff7825Smh 17195cff7825Smh return (status); 17205cff7825Smh } 17215cff7825Smh 17225cff7825Smh /* 17235cff7825Smh * Set the dev_info_t associated with the ACPI node. 17245cff7825Smh */ 17255cff7825Smh static ACPI_STATUS 17265cff7825Smh acpica_set_devinfo(ACPI_HANDLE obj, dev_info_t *dip) 17275cff7825Smh { 17285cff7825Smh ACPI_STATUS status; 17295cff7825Smh 17305cff7825Smh status = AcpiAttachData(obj, acpica_devinfo_handler, (void *)dip); 17315cff7825Smh return (status); 17325cff7825Smh } 17335cff7825Smh 17345cff7825Smh 17355cff7825Smh /* 17365cff7825Smh * 17375cff7825Smh */ 17385cff7825Smh void 17395cff7825Smh acpica_devinfo_handler(ACPI_HANDLE obj, UINT32 func, void *data) 17405cff7825Smh { 17415cff7825Smh /* noop */ 17425cff7825Smh } 17435cff7825Smh 17445cff7825Smh 17455cff7825Smh /* 17465cff7825Smh * 17475cff7825Smh */ 17485cff7825Smh void 1749b6917abeSmishra acpica_map_cpu(processorid_t cpuid, UINT32 proc_id) 17505cff7825Smh { 17515cff7825Smh struct cpu_map_item *item; 17525cff7825Smh 17535cff7825Smh if (cpu_map == NULL) 17545cff7825Smh cpu_map = kmem_zalloc(sizeof (item) * NCPU, KM_SLEEP); 17555cff7825Smh 17565cff7825Smh item = kmem_zalloc(sizeof (*item), KM_SLEEP); 1757b6917abeSmishra item->proc_id = proc_id; 17585cff7825Smh item->obj = NULL; 17595cff7825Smh cpu_map[cpuid] = item; 17605cff7825Smh cpu_map_count++; 17615cff7825Smh } 17625cff7825Smh 17635cff7825Smh void 17645cff7825Smh acpica_build_processor_map() 17655cff7825Smh { 17665cff7825Smh ACPI_STATUS status; 17675cff7825Smh void *rv; 17685cff7825Smh 17695cff7825Smh /* 17705cff7825Smh * shouldn't be called more than once anyway 17715cff7825Smh */ 17725cff7825Smh if (cpu_map_built) 17735cff7825Smh return; 17745cff7825Smh 17755cff7825Smh /* 17765cff7825Smh * Look for Processor objects 17775cff7825Smh */ 17785cff7825Smh status = AcpiWalkNamespace(ACPI_TYPE_PROCESSOR, 17795cff7825Smh ACPI_ROOT_OBJECT, 17805cff7825Smh 4, 17815cff7825Smh acpica_probe_processor, 17825cff7825Smh NULL, 17835cff7825Smh &rv); 17845cff7825Smh ASSERT(status == AE_OK); 17855cff7825Smh 17865cff7825Smh /* 17875cff7825Smh * Look for processor Device objects 17885cff7825Smh */ 17895cff7825Smh status = AcpiGetDevices("ACPI0007", 17905cff7825Smh acpica_probe_processor, 17915cff7825Smh NULL, 17925cff7825Smh &rv); 17935cff7825Smh ASSERT(status == AE_OK); 17945cff7825Smh cpu_map_built = 1; 17955cff7825Smh } 17960e751525SEric Saxe 17970e751525SEric Saxe void 17980e751525SEric Saxe acpica_get_global_FADT(ACPI_TABLE_FADT **gbl_FADT) 17990e751525SEric Saxe { 18000e751525SEric Saxe *gbl_FADT = &AcpiGbl_FADT; 18010e751525SEric Saxe } 1802