static void fujitsu_hk_attach(device_t parent, device_t self, void *aux) { struct fujitsu_hk_softc *sc = device_private(self); struct acpi_attach_args *aa = aux; struct acpi_devnode *ad = aa->aa_node; int i; aprint_naive(": Fujitsu Hotkeys\n"); aprint_normal(": Fujitsu Hotkeys\n"); sc->sc_dev = self; sc->sc_node = ad; sc->sc_log = NULL; sc->sc_caps = fujitsu_hk_capabilities(ad); mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_NONE); for (i = 0; i < FUJITSU_HK_PSW_COUNT; i++) { (void)snprintf(sc->sc_smpsw_name[i], sizeof(sc->sc_smpsw_name[i]), "%s-%d", device_xname(self), i); sc->sc_smpsw[i].smpsw_name = sc->sc_smpsw_name[i]; sc->sc_smpsw[i].smpsw_type = PSWITCH_TYPE_HOTKEY; (void)sysmon_pswitch_register(&sc->sc_smpsw[i]); } fujitsu_hk_sysctl_setup(sc); (void)pmf_device_register(self, fujitsu_hk_suspend, fujitsu_hk_resume); (void)acpi_register_notify(sc->sc_node, fujitsu_hk_notify_handler); }
/* * acpitz_attach: autoconf(9) attach routine */ static void acpitz_attach(device_t parent, device_t self, void *aux) { struct acpitz_softc *sc = device_private(self); struct acpi_attach_args *aa = aux; ACPI_INTEGER val; ACPI_STATUS rv; sc->sc_first = true; sc->sc_have_fan = false; sc->sc_node = aa->aa_node; sc->sc_zone.tzp = ATZ_TZP_RATE; aprint_naive("\n"); acpitz_print_processor_list(self); aprint_normal("\n"); /* * The _TZP (ACPI 4.0, p. 430) defines the recommended * polling interval (in tenths of seconds). A value zero * means that polling "should not be necessary". */ rv = acpi_eval_integer(sc->sc_node->ad_handle, "_TZP", &val); if (ACPI_SUCCESS(rv) && val != 0) sc->sc_zone.tzp = val; aprint_debug_dev(self, "polling interval %d.%d seconds\n", sc->sc_zone.tzp / 10, sc->sc_zone.tzp % 10); sc->sc_zone_expire = ATZ_ZONE_EXPIRE / sc->sc_zone.tzp; /* * XXX: The fan controls seen here are available on * some HP laptops. Arguably these should not * appear in a generic device driver like this. */ if (acpitz_get_fanspeed(self, &sc->sc_zone.fanmin, &sc->sc_zone.fanmax, &sc->sc_zone.fancurrent) == 0) sc->sc_have_fan = true; acpitz_get_zone(self, 1); acpitz_get_status(self); (void)pmf_device_register(self, NULL, NULL); (void)acpi_power_register(sc->sc_node->ad_handle); (void)acpi_register_notify(sc->sc_node, acpitz_notify_handler); callout_init(&sc->sc_callout, CALLOUT_MPSAFE); callout_setfunc(&sc->sc_callout, acpitz_tick, self); acpitz_init_envsys(self); callout_schedule(&sc->sc_callout, sc->sc_zone.tzp * hz / 10); }
static void asus_attach(device_t parent, device_t self, void *opaque) { struct asus_softc *sc = device_private(self); struct acpi_attach_args *aa = opaque; sc->sc_dev = self; sc->sc_node = aa->aa_node; aprint_naive("\n"); aprint_normal("\n"); asus_init(self); asus_sysctl_setup(sc); sc->sc_smpsw_valid = true; sc->sc_smpsw[ASUS_PSW_DISPLAY_CYCLE].smpsw_name = PSWITCH_HK_DISPLAY_CYCLE; sc->sc_smpsw[ASUS_PSW_DISPLAY_CYCLE].smpsw_type = PSWITCH_TYPE_HOTKEY; if (sysmon_pswitch_register(&sc->sc_smpsw[ASUS_PSW_DISPLAY_CYCLE])) { aprint_error_dev(self, "couldn't register with sysmon\n"); sc->sc_smpsw_valid = false; } if (asus_get_fan_speed(sc, NULL) == false) goto out; sc->sc_sme = sysmon_envsys_create(); strcpy(sc->sc_sensor[ASUS_SENSOR_FAN].desc, "fan"); sc->sc_sensor[ASUS_SENSOR_FAN].units = ENVSYS_SFANRPM; sc->sc_sensor[ASUS_SENSOR_FAN].state = ENVSYS_SINVALID; sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor[ASUS_SENSOR_FAN]); sc->sc_sme->sme_name = device_xname(self); sc->sc_sme->sme_cookie = sc; sc->sc_sme->sme_refresh = asus_sensors_refresh; sc->sc_sme->sme_flags = SME_POLL_ONLY; if (sysmon_envsys_register(sc->sc_sme)) { aprint_error_dev(self, "couldn't register with envsys\n"); sysmon_envsys_destroy(sc->sc_sme); sc->sc_sme = NULL; } out: (void)pmf_device_register(self, asus_suspend, asus_resume); (void)acpi_register_notify(sc->sc_node, asus_notify_handler); }
static void acpi_dalb_attach(device_t parent, device_t self, void *aux) { struct acpi_dalb_softc *sc = device_private(self); struct acpi_attach_args *aa = aux; aprint_naive("\n"); aprint_normal(": Direct Application Launch Button\n"); sc->sc_dev = self; sc->sc_node = aa->aa_node; config_interrupts(self, acpi_dalb_init); (void)pmf_device_register(self, NULL, acpi_dalb_resume); (void)acpi_register_notify(sc->sc_node, acpi_dalb_notify_handler); sc->sc_smpsw_valid = false; acpi_dalb_sysmon_init(sc); }
/* * valz_acpi_attach: * * Autoconfiguration `attach' routine. */ static void valz_acpi_attach(device_t parent, device_t self, void *aux) { struct valz_acpi_softc *sc = device_private(self); struct acpi_attach_args *aa = aux; ACPI_STATUS rv; aprint_naive(": Toshiba VALZ\n"); aprint_normal(": Toshiba VALZ\n"); sc->sc_node = aa->aa_node; sc->sc_dev = self; /* enable valz notify */ rv = AcpiEvaluateObject(sc->sc_node->ad_handle, METHOD_HCI_ENABLE, NULL, NULL); if (ACPI_FAILURE(rv)) { aprint_error("Cannot enable VALZ.\n"); } else { (void)acpi_register_notify(sc->sc_node, valz_acpi_notify_handler); } }
static void acpicpu_attach(device_t parent, device_t self, void *aux) { struct acpicpu_softc *sc = device_private(self); struct cpu_info *ci; ACPI_HANDLE hdl; cpuid_t id; int rv; ci = acpicpu_md_attach(parent, self, aux); if (ci == NULL) return; sc->sc_ci = ci; sc->sc_dev = self; sc->sc_cold = true; hdl = acpi_match_cpu_info(ci); if (hdl == NULL) { aprint_normal(": failed to match processor\n"); return; } sc->sc_node = acpi_match_node(hdl); if (acpicpu_once_attach() != 0) { aprint_normal(": failed to initialize\n"); return; } KASSERT(acpi_softc != NULL); KASSERT(acpicpu_sc != NULL); KASSERT(sc->sc_node != NULL); id = sc->sc_ci->ci_acpiid; if (acpicpu_sc[id] != NULL) { aprint_normal(": already attached\n"); return; } aprint_naive("\n"); aprint_normal(": ACPI CPU\n"); rv = acpicpu_object(sc->sc_node->ad_handle, &sc->sc_object); if (ACPI_FAILURE(rv)) aprint_verbose_dev(self, "failed to obtain CPU object\n"); acpicpu_count++; acpicpu_sc[id] = sc; sc->sc_cap = acpicpu_cap(sc); sc->sc_ncpus = acpi_md_ncpus(); sc->sc_flags = acpicpu_md_flags(); KASSERT(acpicpu_count <= sc->sc_ncpus); KASSERT(sc->sc_node->ad_device == NULL); sc->sc_node->ad_device = self; mutex_init(&sc->sc_mtx, MUTEX_DEFAULT, IPL_NONE); acpicpu_cstate_attach(self); acpicpu_pstate_attach(self); acpicpu_tstate_attach(self); acpicpu_debug_print(self); acpicpu_evcnt_attach(self); (void)config_interrupts(self, acpicpu_start); (void)acpi_register_notify(sc->sc_node, acpicpu_notify); (void)pmf_device_register(self, acpicpu_suspend, acpicpu_resume); }
static void thinkpad_attach(device_t parent, device_t self, void *opaque) { thinkpad_softc_t *sc = device_private(self); struct acpi_attach_args *aa = (struct acpi_attach_args *)opaque; struct sysmon_pswitch *psw; device_t curdev; deviter_t di; ACPI_STATUS rv; ACPI_INTEGER val; int i; sc->sc_dev = self; sc->sc_powhdl = NULL; sc->sc_cmoshdl = NULL; sc->sc_node = aa->aa_node; sc->sc_display_state = THINKPAD_DISPLAY_LCD; aprint_naive("\n"); aprint_normal("\n"); sc->sc_ecdev = NULL; for (curdev = deviter_first(&di, DEVITER_F_ROOT_FIRST); curdev != NULL; curdev = deviter_next(&di)) if (device_is_a(curdev, "acpiecdt") || device_is_a(curdev, "acpiec")) { sc->sc_ecdev = curdev; break; } deviter_release(&di); if (sc->sc_ecdev) aprint_debug_dev(self, "using EC at %s\n", device_xname(sc->sc_ecdev)); /* Get the supported event mask */ rv = acpi_eval_integer(sc->sc_node->ad_handle, "MHKA", &val); if (ACPI_FAILURE(rv)) { aprint_error_dev(self, "couldn't evaluate MHKA: %s\n", AcpiFormatException(rv)); goto fail; } /* Enable all supported events */ rv = thinkpad_mask_init(sc, val); if (ACPI_FAILURE(rv)) { aprint_error_dev(self, "couldn't set event mask: %s\n", AcpiFormatException(rv)); goto fail; } (void)acpi_register_notify(sc->sc_node, thinkpad_notify_handler); /* * Obtain a handle for CMOS commands. This is used by T61. */ (void)AcpiGetHandle(NULL, "\\UCMS", &sc->sc_cmoshdl); /* * Obtain a handle to the power resource available on many models. * Since pmf(9) is not yet integrated with the ACPI power resource * code, this must be turned on manually upon resume. Otherwise the * system may, for instance, resume from S3 with usb(4) powered down. */ (void)AcpiGetHandle(NULL, "\\_SB.PCI0.LPC.EC.PUBS", &sc->sc_powhdl); /* Register power switches with sysmon */ psw = sc->sc_smpsw; sc->sc_smpsw_valid = true; psw[TP_PSW_SLEEP].smpsw_name = device_xname(self); psw[TP_PSW_SLEEP].smpsw_type = PSWITCH_TYPE_SLEEP; #if notyet psw[TP_PSW_HIBERNATE].smpsw_name = device_xname(self); mpsw[TP_PSW_HIBERNATE].smpsw_type = PSWITCH_TYPE_HIBERNATE; #endif for (i = TP_PSW_DISPLAY_CYCLE; i < TP_PSW_LAST; i++) sc->sc_smpsw[i].smpsw_type = PSWITCH_TYPE_HOTKEY; psw[TP_PSW_DISPLAY_CYCLE].smpsw_name = PSWITCH_HK_DISPLAY_CYCLE; psw[TP_PSW_LOCK_SCREEN].smpsw_name = PSWITCH_HK_LOCK_SCREEN; psw[TP_PSW_BATTERY_INFO].smpsw_name = PSWITCH_HK_BATTERY_INFO; psw[TP_PSW_EJECT_BUTTON].smpsw_name = PSWITCH_HK_EJECT_BUTTON; psw[TP_PSW_ZOOM_BUTTON].smpsw_name = PSWITCH_HK_ZOOM_BUTTON; psw[TP_PSW_VENDOR_BUTTON].smpsw_name = PSWITCH_HK_VENDOR_BUTTON; #ifndef THINKPAD_NORMAL_HOTKEYS psw[TP_PSW_FNF1_BUTTON].smpsw_name = PSWITCH_HK_FNF1_BUTTON; psw[TP_PSW_WIRELESS_BUTTON].smpsw_name = PSWITCH_HK_WIRELESS_BUTTON; psw[TP_PSW_WWAN_BUTTON].smpsw_name = PSWITCH_HK_WWAN_BUTTON; psw[TP_PSW_POINTER_BUTTON].smpsw_name = PSWITCH_HK_POINTER_BUTTON; psw[TP_PSW_FNF10_BUTTON].smpsw_name = PSWITCH_HK_FNF10_BUTTON; psw[TP_PSW_FNF11_BUTTON].smpsw_name = PSWITCH_HK_FNF11_BUTTON; psw[TP_PSW_BRIGHTNESS_UP].smpsw_name = PSWITCH_HK_BRIGHTNESS_UP; psw[TP_PSW_BRIGHTNESS_DOWN].smpsw_name = PSWITCH_HK_BRIGHTNESS_DOWN; psw[TP_PSW_THINKLIGHT].smpsw_name = PSWITCH_HK_THINKLIGHT; psw[TP_PSW_VOLUME_UP].smpsw_name = PSWITCH_HK_VOLUME_UP; psw[TP_PSW_VOLUME_DOWN].smpsw_name = PSWITCH_HK_VOLUME_DOWN; psw[TP_PSW_VOLUME_MUTE].smpsw_name = PSWITCH_HK_VOLUME_MUTE; #endif /* THINKPAD_NORMAL_HOTKEYS */ for (i = 0; i < TP_PSW_LAST; i++) { /* not supported yet */ if (i == TP_PSW_HIBERNATE) continue; if (sysmon_pswitch_register(&sc->sc_smpsw[i]) != 0) { aprint_error_dev(self, "couldn't register with sysmon\n"); sc->sc_smpsw_valid = false; break; } } /* Register temperature and fan sensors with envsys */ thinkpad_sensors_init(sc); fail: if (!pmf_device_register(self, NULL, thinkpad_resume)) aprint_error_dev(self, "couldn't establish power handler\n"); if (!pmf_event_register(self, PMFE_DISPLAY_BRIGHTNESS_UP, thinkpad_brightness_up, true)) aprint_error_dev(self, "couldn't register event handler\n"); if (!pmf_event_register(self, PMFE_DISPLAY_BRIGHTNESS_DOWN, thinkpad_brightness_down, true)) aprint_error_dev(self, "couldn't register event handler\n"); }