Lines Matching +full:layers +full:- +full:configurable
1 /*-
264 acpi_ca_version, 0, "Version of Intel ACPI-CA");
369 * Pre-allocate space for RSDT/XSDT and DSDT tables and allow resizing
382 /* If the user manually set the disabled hint to 0, force-enable ACPI. */
429 if (rsdp->Revision > 1 && rsdp->XsdtPhysicalAddress != 0)
430 paddr = (ACPI_PHYSICAL_ADDRESS)rsdp->XsdtPhysicalAddress;
432 paddr = (ACPI_PHYSICAL_ADDRESS)rsdp->RsdtPhysicalAddress;
438 sbuf_bcat(&sb, rsdt->OemId, ACPI_OEM_ID_SIZE);
441 sbuf_bcat(&sb, rsdt->OemTableId, ACPI_OEM_TABLE_ID_SIZE);
479 sc->acpi_dev = dev;
480 callout_init(&sc->susp_force_to, 1);
496 resource_list_init(&sc->sysres_rl);
502 * Set the globals from our tunables. This is needed because ACPI-CA
511 * Disable all debugging layers and levels.
575 sysctl_ctx_init(&sc->acpi_sysctl_ctx);
576 sc->acpi_sysctl_tree = SYSCTL_ADD_NODE(&sc->acpi_sysctl_ctx,
579 SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
584 SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
587 &sc->acpi_power_button_sx, 0, acpi_sleep_state_sysctl, "A",
589 SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
592 &sc->acpi_sleep_button_sx, 0, acpi_sleep_state_sysctl, "A",
594 SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
597 &sc->acpi_lid_switch_sx, 0, acpi_sleep_state_sysctl, "A",
599 SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
602 &sc->acpi_standby_sx, 0, acpi_sleep_state_sysctl, "A", "");
603 SYSCTL_ADD_PROC(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
606 &sc->acpi_suspend_sx, 0, acpi_sleep_state_sysctl, "A", "");
607 SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
608 OID_AUTO, "sleep_delay", CTLFLAG_RW, &sc->acpi_sleep_delay, 0,
610 SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
611 OID_AUTO, "s4bios", CTLFLAG_RW, &sc->acpi_s4bios, 0, "S4BIOS mode");
612 SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
613 OID_AUTO, "verbose", CTLFLAG_RW, &sc->acpi_verbose, 0, "verbose mode");
614 SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
616 &sc->acpi_do_disable, 0, "Disable ACPI when rebooting/halting system");
617 SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
619 &sc->acpi_handle_reboot, 0, "Use ACPI Reset Register to reboot");
628 SYSCTL_ADD_INT(&sc->acpi_sysctl_ctx, SYSCTL_CHILDREN(sc->acpi_sysctl_tree),
631 "Force active-hi polarity for edge-triggered ISA IRQs");
638 sc->acpi_sleep_delay = 1;
640 sc->acpi_verbose = 1;
643 sc->acpi_verbose = 1;
649 sc->acpi_handle_reboot = 1;
653 if (AcpiGbl_FACS != NULL && AcpiGbl_FACS->Flags & ACPI_FACS_S4_BIOS_PRESENT)
654 sc->acpi_s4bios = 1;
669 sc->acpi_power_button_sx = acpi_sleep_states[ACPI_STATE_S5] ?
671 sc->acpi_lid_switch_sx = ACPI_STATE_UNKNOWN;
672 sc->acpi_standby_sx = acpi_sleep_states[ACPI_STATE_S1] ?
674 sc->acpi_suspend_sx = acpi_sleep_states[ACPI_STATE_S3] ?
678 sc->acpi_sleep_button_sx = ACPI_STATE_UNKNOWN;
681 sc->acpi_sleep_button_sx = state;
697 * XXX should be configurable eg. via userland policy manager.
705 sc->acpi_enabled = TRUE;
706 sc->acpi_sstate = ACPI_STATE_S0;
707 sc->acpi_sleep_disabled = TRUE;
710 sc->acpi_dev_t = make_dev(&acpi_cdevsw, 0, UID_ROOT, GID_OPERATOR, 0664,
712 sc->acpi_dev_t->si_drv1 = sc;
755 * Retrieve and set D-state for the sleep state if _SxD is present.
803 * Enable any GPEs that are able to power-on the system (i.e., RTC).
823 ad->ad_domain = ACPI_DEV_DOMAIN_UNKNOWN;
824 resource_list_init(&ad->ad_rl);
838 struct resource_list *rl = &adev->ad_rl;
906 if (dinfo->ad_handle) {
907 sbuf_printf(sb, "handle=%s", acpi_name(dinfo->ad_handle));
908 if (ACPI_SUCCESS(acpi_GetInteger(dinfo->ad_handle, "_PXM", &pxm))) {
927 (adinfo->Valid & ACPI_VALID_HID) ?
928 adinfo->HardwareId.String : "none",
929 (adinfo->Valid & ACPI_VALID_UID) ?
930 strtoul(adinfo->UniqueId.String, NULL, 10) : 0UL,
931 ((adinfo->Valid & ACPI_VALID_CID) &&
932 adinfo->CompatibleIdList.Count > 0) ?
933 adinfo->CompatibleIdList.Ids[0].String : "none");
944 return (acpi_pnpinfo(dinfo->ad_handle, sb));
976 if (!ACPI_FAILURE(AcpiGetObjectInfo(dinfo->ad_handle, &adinfo)) &&
977 dinfo->ad_handle != 0 && (adinfo->Valid & ACPI_VALID_HID)) {
978 const char *hid = adinfo->HardwareId.String;
979 u_long uid = (adinfo->Valid & ACPI_VALID_UID) ?
980 strtoul(adinfo->UniqueId.String, NULL, 10) : 0UL;
1032 if (acpi_get_device(dinfo->ad_handle) == child)
1033 AcpiDetachData(dinfo->ad_handle, acpi_fake_objhandler);
1037 * Handle per-device ivars
1052 *(ACPI_HANDLE *)result = ad->ad_handle;
1055 *(void **)result = ad->ad_private;
1058 *(int *)result = ad->ad_flags;
1061 *(int *)result = ad->ad_domain;
1066 *(int *)result = -1;
1072 *(uint8_t*)result = (ad->ad_cls_class >> 16) & 0xff;
1075 *(uint8_t*)result = (ad->ad_cls_class >> 8) & 0xff;
1078 *(uint8_t*)result = (ad->ad_cls_class >> 0) & 0xff;
1099 ad->ad_handle = (ACPI_HANDLE)value;
1102 ad->ad_private = (void *)value;
1105 ad->ad_flags = (int)value;
1108 ad->ad_domain = (int)value;
1127 return (&ad->ad_rl);
1134 struct resource_list *rl = &ad->ad_rl;
1138 if (rle->type != type)
1140 if (rle->start <= value && rle->end >= value)
1255 * -2 is returned. If any other error occurs, -1 is returned.
1268 return (-2);
1273 return (-2);
1276 return (-1);
1335 * Pre-allocate/manage all memory and IO resources. Since rman can't handle
1350 * had multi-pass probe/attach.
1360 STAILQ_FOREACH(rle, &sc->sysres_rl, link) {
1361 if (rle->res != NULL) {
1362 device_printf(dev, "duplicate resource for %jx\n", rle->start);
1367 rm = acpi_get_rman(dev, rle->type, 0);
1371 /* Pre-allocate resource and add to our rman pool. */
1372 res = bus_alloc_resource(dev, rle->type,
1373 &rle->rid, rle->start, rle->start + rle->count - 1, rle->count,
1377 rle->res = res;
1380 rle->start, rle->count, rle->type);
1387 * namespace scan once the boot-time attach of devices has completed.
1389 * Ideally reserving firmware-assigned resources would work in a
1390 * depth-first traversal of the device namespace, but this is
1411 rl = &ad->ad_rl;
1423 if (rle->type == SYS_RES_IRQ)
1431 if (rle->res != NULL)
1440 * acpi_alloc_resource() will sub-alloc from the system
1443 resource_list_reserve(rl, dev, children[i], rle->type, &rle->rid,
1444 rle->start, rle->end, rle->count, 0);
1455 struct resource_list *rl = &ad->ad_rl;
1474 end = (start + count - 1);
1499 rl = &ad->ad_rl;
1503 * devices. That is, if a non-default range is specified for
1536 start = rle->start;
1537 end = rle->end;
1538 count = rle->count;
1550 if (res == NULL && start + count - 1 == end)
1576 STAILQ_FOREACH(rle, &sc->sysres_rl, link) {
1577 if (rle->type != rman_get_type(r) || rle->res == NULL)
1579 if (rman_get_start(r) >= rman_get_start(rle->res) &&
1580 rman_get_end(r) <= rman_get_end(rle->res))
1581 return (rle->res);
1666 args.offset = start - rman_get_start(sysres);
1698 switch (gas->SpaceId) {
1713 if (gas->BitWidth && gas->BitWidth < 8)
1714 gas->BitWidth = 8;
1717 if (gas->Address == 0 || gas->BitWidth == 0)
1720 bus_set_resource(dev, res_type, *rid, gas->Address,
1721 gas->BitWidth / 8);
1747 pnpid = (devinfo->Valid & ACPI_VALID_HID) != 0 &&
1748 devinfo->HardwareId.Length >= ACPI_EISAID_STRING_SIZE ?
1749 PNP_EISAID(devinfo->HardwareId.String) : 0;
1773 if ((devinfo->Valid & ACPI_VALID_CID) == 0) {
1778 if (devinfo->CompatibleIdList.Count < count)
1779 count = devinfo->CompatibleIdList.Count;
1780 ids = devinfo->CompatibleIdList.Ids;
1848 if (ad->dsd_pkg == NULL) {
1849 if (ad->dsd.Pointer == NULL) {
1858 for (i = 0; i < ad->dsd_pkg->Package.Count; i ++) {
1859 pkg = &ad->dsd_pkg->Package.Elements[i];
1860 if (pkg->Type != ACPI_TYPE_PACKAGE || pkg->Package.Count != 2)
1863 name = &pkg->Package.Elements[0];
1864 val = &pkg->Package.Elements[1];
1865 if (name->Type != ACPI_TYPE_STRING)
1867 if (strncmp(propname, name->String.Pointer, name->String.Length) == 0) {
1884 ad->dsd.Length = ACPI_ALLOCATE_BUFFER;
1885 ad->dsd.Pointer = NULL;
1886 ad->dsd_pkg = NULL;
1888 status = AcpiEvaluateObject(ad->ad_handle, "_DSD", NULL, &ad->dsd);
1892 dsd = ad->dsd.Pointer;
1893 guid = &dsd->Package.Elements[0];
1894 pkg = &dsd->Package.Elements[1];
1896 if (guid->Type != ACPI_TYPE_BUFFER || pkg->Type != ACPI_TYPE_PACKAGE ||
1897 guid->Buffer.Length != sizeof(acpi_dsd_uuid))
1899 if (memcmp(guid->Buffer.Pointer, &acpi_dsd_uuid,
1902 ad->dsd_pkg = pkg;
1915 if (hobj->Type != ACPI_TYPE_PACKAGE)
1917 if (hobj->Package.Count != 1)
1920 pobj = &hobj->Package.Elements[0];
1923 if (pobj->Type != ACPI_TYPE_LOCAL_REFERENCE)
1935 return (-1);
1948 return (-1);
1959 return (-1);
1962 switch (obj->Type) {
1966 *((uint32_t *)propvalue) = obj->Integer.Value;
1970 *((uint64_t *) propvalue) = obj->Integer.Value;
1976 return (-1);
1979 memcpy(propvalue, obj->String.Pointer,
1980 MIN(size, obj->String.Length));
1981 return (obj->String.Length);
1985 memcpy(propvalue, obj->Buffer.Pointer,
1986 MIN(size, obj->Buffer.Length));
1987 return (obj->Buffer.Length);
2039 snprintf(sxd, sizeof(sxd), "_S%dD", sc->acpi_sstate);
2070 if (acpi_avoid(h) || h == ctx->parent)
2086 status = ctx->user_fn(h, &dev, level, ctx->arg);
2161 * ISA-style drivers attached to ACPI may persist and
2170 while (ids && ids->ip_id) {
2171 if (lid == ids->ip_id) {
2176 if (cids[i] == ids->ip_id) {
2185 if (result == 0 && ids->ip_desc)
2186 device_set_desc(child, ids->ip_desc);
2196 * On non-x86 architectures (arm64 for now), this will be done from the
2211 end = (ACPI_MCFG_ALLOCATION *)((char *)hdr + hdr->Length);
2214 pcie_cfgregopen(alloc->Address, alloc->PciSegment,
2215 alloc->StartBusNumber, alloc->EndBusNumber);
2228 /* 0811B06E-4A27-44F9-8D60-3CBBC22E7B48 */
2277 /* Pre-allocate resources for our rman from any sysresource devices. */
2387 * breadth-first. Orders less than ACPI_DEV_BASE_ORDER
2445 ad->ad_cls_class = 0xffffff;
2447 if ((devinfo->Valid & ACPI_VALID_CLS) != 0 &&
2448 devinfo->ClassCode.Length >= ACPI_PCICLS_STRING_SIZE) {
2449 ad->ad_cls_class = strtoul(devinfo->ClassCode.String,
2457 ad->ad_domain = d;
2489 device_printf(sc->acpi_dev, "AcpiEnterSleepStatePrep failed - %s\n",
2493 device_printf(sc->acpi_dev, "Powering system off\n");
2498 device_printf(sc->acpi_dev, "power-off failed - %s\n",
2503 device_printf(sc->acpi_dev, "power-off failed - timeout\n");
2505 } else if ((howto & RB_HALT) == 0 && sc->acpi_handle_reboot) {
2510 device_printf(sc->acpi_dev, "reset failed - timeout\n");
2512 device_printf(sc->acpi_dev, "reset failed - %s\n",
2514 } else if (sc->acpi_do_disable && !KERNEL_PANICKED()) {
2519 device_printf(sc->acpi_dev, "Shutting down\n");
2535 device_printf(sc->acpi_dev, "Power Button (fixed)\n");
2542 device_printf(sc->acpi_dev, "Sleep Button (fixed)\n");
2550 * be attached to. This requires the present, enabled, UI-visible
2551 * and diagnostics-passed bits to be set.
2567 * only returns non-zero for the OS string "Windows 2015". Otherwise it
2626 if ((devinfo->Valid & ACPI_VALID_HID) != 0)
2628 else if ((devinfo->Valid & ACPI_VALID_CID) != 0)
2629 if (devinfo->CompatibleIdList.Count > 0)
2654 if ((devinfo->Valid & ACPI_VALID_HID) != 0 &&
2655 strcmp(hid, devinfo->HardwareId.String) == 0)
2657 else if ((devinfo->Valid & ACPI_VALID_CID) != 0)
2658 for (i = 0; i < devinfo->CompatibleIdList.Count; i++) {
2659 if (strcmp(hid, devinfo->CompatibleIdList.Ids[i].String) == 0) {
2714 buf->Length = size;
2715 buf->Pointer = (void *)(buf + 1);
2788 p = (ACPI_OBJECT *)bufp->Pointer;
2789 if (p->Type == ACPI_TYPE_INTEGER) {
2790 *number = p->Integer.Value;
2793 if (p->Type != ACPI_TYPE_BUFFER)
2795 if (p->Buffer.Length > sizeof(int))
2799 val = p->Buffer.Pointer;
2800 for (i = 0; i < p->Buffer.Length; i++)
2818 if (pkg == NULL || pkg->Type != ACPI_TYPE_PACKAGE)
2823 comp = pkg->Package.Elements;
2824 for (; i < pkg->Package.Count; i++, comp++)
2839 rp = (ACPI_RESOURCE *)buf->Pointer;
2841 while (i-- > 0) {
2843 if (rp > (ACPI_RESOURCE *)((u_int8_t *)buf->Pointer + buf->Length))
2847 if (rp->Type == ACPI_RESOURCE_TYPE_END_TAG || rp->Length == 0)
2874 if (buf->Pointer == NULL) {
2875 buf->Length = ACPI_INITIAL_RESOURCE_BUFFER_SIZE;
2876 if ((buf->Pointer = AcpiOsAllocate(buf->Length)) == NULL)
2878 rp = (ACPI_RESOURCE *)buf->Pointer;
2879 rp->Type = ACPI_RESOURCE_TYPE_END_TAG;
2880 rp->Length = ACPI_RS_SIZE_MIN;
2890 rp = (ACPI_RESOURCE *)buf->Pointer;
2893 if (rp >= (ACPI_RESOURCE *)((u_int8_t *)buf->Pointer + buf->Length))
2895 if (rp->Type == ACPI_RESOURCE_TYPE_END_TAG || rp->Length == 0)
2911 while ((((u_int8_t *)rp - (u_int8_t *)buf->Pointer) +
2912 res->Length + ACPI_RS_SIZE_NO_DATA +
2913 ACPI_RS_SIZE_MIN) >= buf->Length) {
2914 if ((newp = AcpiOsAllocate(buf->Length * 2)) == NULL)
2916 bcopy(buf->Pointer, newp, buf->Length);
2918 ((u_int8_t *)rp - (u_int8_t *)buf->Pointer));
2919 AcpiOsFree(buf->Pointer);
2920 buf->Pointer = newp;
2921 buf->Length += buf->Length;
2925 bcopy(res, rp, res->Length + ACPI_RS_SIZE_NO_DATA);
2929 rp->Type = ACPI_RESOURCE_TYPE_END_TAG;
2930 rp->Length = ACPI_RS_SIZE_MIN;
2965 switch (obj->Type) {
2967 for (i = 0; i < MIN(obj->Buffer.Length, sizeof(ret)); i++)
2968 ret |= (((uint64_t)obj->Buffer.Pointer[i]) << (i * 8));
2973 ret = obj->Integer.Value;
2976 ACPI_WARNING((AE_INFO, "Unexpected return type %u\n", obj->Type));
3068 if (ret->Buffer.Length != count * sizeof(*caps_out)) {
3072 bcopy(ret->Buffer.Pointer, caps_out, ret->Buffer.Length);
3102 if (entry->Length < sizeof(ACPI_SUBTABLE_HEADER))
3106 entry = ACPI_ADD_PTR(ACPI_SUBTABLE_HEADER, entry, entry->Length);
3123 device_printf(sc->acpi_dev,
3136 if (ACPI_FAILURE(acpi_EnterSleepState(sc, sc->acpi_next_sstate)))
3137 device_printf(sc->acpi_dev, "force sleep state S%d failed\n",
3138 sc->acpi_next_sstate);
3146 device_printf(sc->acpi_dev,
3154 device_printf(sc->acpi_dev, "AcpiOsExecute() for sleeping failed\n");
3180 if (rebooting || sc->acpi_next_sstate != 0 || suspend_blocked) {
3185 while (sc->acpi_sleep_disabled) {
3191 sc->acpi_next_sstate = state;
3193 /* S5 (soft-off) should be entered directly with no waiting. */
3201 STAILQ_FOREACH(clone, &sc->apm_cdevs, entries) {
3202 clone->notify_status = APM_EV_NONE;
3203 if ((clone->flags & ACPI_EVF_DEVD) == 0) {
3204 selwakeuppri(&clone->sel_read, PZERO);
3205 KNOTE_LOCKED(&clone->sel_read.si_note, 0);
3223 callout_reset(&sc->susp_force_to, 10 * hz, acpi_sleep_force, sc);
3239 * error argument is non-zero, it indicates suspend should be cancelled
3252 sc = clone->acpi_sc;
3253 if (sc->acpi_next_sstate == 0) {
3260 sc->acpi_next_sstate = 0;
3261 callout_stop(&sc->susp_force_to);
3262 device_printf(sc->acpi_dev,
3264 devtoname(clone->cdev));
3272 * are writable since read-only devices couldn't ack the request.
3275 clone->notify_status = APM_EV_ACKED;
3276 STAILQ_FOREACH(clone, &sc->apm_cdevs, entries) {
3277 if ((clone->flags & ACPI_EVF_WRITE) != 0 &&
3278 clone->notify_status != APM_EV_ACKED) {
3286 callout_stop(&sc->susp_force_to);
3290 if (ACPI_FAILURE(acpi_EnterSleepState(sc, sc->acpi_next_sstate)))
3313 sc->acpi_sleep_disabled = FALSE;
3326 status = sc->acpi_sleep_disabled ? AE_ERROR : AE_OK;
3327 sc->acpi_sleep_disabled = TRUE;
3344 * Currently we support S1-S5 but S4 is only S4BIOS
3360 device_printf(sc->acpi_dev, "Sleep state S%d not supported by BIOS\n",
3365 /* Re-entry once we're suspending is not allowed. */
3368 device_printf(sc->acpi_dev,
3407 sc->acpi_sstate = state;
3417 * XXX Note that a better two-pass approach with a 'veto' pass
3422 device_printf(sc->acpi_dev, "device_suspend failed\n");
3429 device_printf(sc->acpi_dev, "AcpiEnterSleepStatePrep failed - %s\n",
3435 if (sc->acpi_sleep_delay > 0)
3436 DELAY(sc->acpi_sleep_delay * 1000000);
3446 * by ACPI platform (BIOS, firmware) to its pre-sleep state.
3458 * Prevent mis-interpretation of the wakeup by power button
3474 device_printf(sc->acpi_dev,
3486 if (sleep_result == -1)
3489 /* Re-enable ACPI hardware on wakeup from sleep state 4. */
3497 device_printf(sc->acpi_dev, "AcpiEnterSleepState failed - %s\n",
3513 sc->acpi_sstate = ACPI_STATE_S0;
3527 sc->acpi_next_sstate = 0;
3565 (void)timecounter->tc_get_timecount(timecounter);
3566 inittodr(time_second + sc->acpi_sleep_delay);
3609 /* Check that this is a wake-capable device and get its GPE. */
3644 * Check that this is a wake-capable device and get its GPE. Return
3655 * disabled before going to sleep so re-enable it. If it was enabled,
3661 device_printf(dev, "run_prep re-enabled %s\n", acpi_name(handle));
3699 /* Walk the tree rooted at acpi0 to attach per-device wake sysctls. */
3743 if (error != 0 || req->newptr == NULL)
3785 if (acpi_PkgInt32(res, 1, &prw->lowest_wake) != 0)
3791 switch (res->Package.Elements[0].Type) {
3799 prw->gpe_handle = NULL;
3800 prw->gpe_bit = res->Package.Elements[0].Integer.Value;
3817 res2 = &res->Package.Elements[0];
3820 prw->gpe_handle = acpi_GetReference(NULL, &res2->Package.Elements[0]);
3821 if (prw->gpe_handle == NULL)
3823 if (acpi_PkgInt32(res2, 1, &prw->gpe_bit) != 0)
3832 power_count = res->Package.Count - 2;
3837 prw->power_res_count = power_count;
3839 prw->power_res[i] = res->Package.Elements[i];
3868 device_printf(sc->acpi_dev,
3915 acpi_invoke_sleep_eventhandler, &sc->acpi_power_button_sx)))
3932 acpi_invoke_wake_eventhandler, &sc->acpi_power_button_sx)))
3945 acpi_invoke_sleep_eventhandler, &sc->acpi_sleep_button_sx)))
3958 acpi_invoke_wake_eventhandler, &sc->acpi_sleep_button_sx)))
3965 * use this for single-threaded callers.
3982 * Debugging/bug-avoidance. Avoid trying to fetch info on various
4019 * Debugging/bug-avoidance. Disable ACPI subsystem components.
4105 hp->cmd = cmd;
4106 hp->fn = fn;
4107 hp->arg = arg;
4127 if (hp->cmd == cmd && hp->fn == fn)
4158 sc = dev->si_drv1;
4166 if (hp->cmd == cmd)
4171 return (hp->fn(cmd, addr, hp->arg));
4174 * Core ioctls are not permitted for non-writable user.
4187 device_printf(sc->acpi_dev, "power off via acpi ioctl not supported\n");
4192 error = acpi_AckSleepState(sc->acpi_clone, error);
4217 sstate = sname[1] - '0';
4223 return (-1);
4262 old_state = *(int *)oidp->oid_arg1;
4265 if (error == 0 && req->newptr != NULL) {
4272 *(int *)oidp->oid_arg1 = new_state;
4380 /* Exceptionally verbose output -- also used in the global "DebugLevel" */
4412 l = ep - cp;
4469 if (strcmp(oidp->oid_arg1, "debug.acpi.layer") == 0) {
4481 } else if (req->newptr == NULL) {
4482 for (; tag->name != NULL; tag++) {
4483 if ((*dbg & tag->value) == tag->value)
4484 sbuf_printf(&sb, "%s ", tag->name);
4495 if (error == 0 && req->newptr != NULL) {
4497 kern_setenv((char *)oidp->oid_arg1, temp);
4523 if (error != 0 || req->newptr == NULL)
4564 iface->data = malloc(sizeof(*iface->data) * j, M_TEMP, M_WAITOK);
4565 iface->num = j;
4571 iface->data[j] = p + i;
4583 free(iface->data[0], M_TEMP);
4584 free(iface->data, M_TEMP);
4645 acpi_state = sc->acpi_standby_sx;
4648 acpi_state = sc->acpi_suspend_sx;