int acpi_get_pxm(acpi_handle h) { unsigned long long pxm; acpi_status status; acpi_handle handle; acpi_handle phandle = h; do { handle = phandle; status = acpi_evaluate_integer(handle, "_PXM", NULL, &pxm); if (ACPI_SUCCESS(status)) return pxm; status = acpi_get_parent(handle, &phandle); } while (ACPI_SUCCESS(status)); return -1; }
/* * Wireless */ static int asus_wireless_status(struct asus_laptop *asus, int mask) { unsigned long long status; acpi_status rv = AE_OK; if (!asus->have_rsts) return (asus->wireless_status & mask) ? 1 : 0; rv = acpi_evaluate_integer(asus->handle, METHOD_WL_STATUS, NULL, &status); if (ACPI_FAILURE(rv)) { pr_warn("Error reading Wireless status\n"); return -EINVAL; } return !!(status & mask); }
acpi_status acpi_bus_get_status_handle(acpi_handle handle, unsigned long long *sta) { acpi_status status; status = acpi_evaluate_integer(handle, "_STA", NULL, sta); if (ACPI_SUCCESS(status)) return AE_OK; if (status == AE_NOT_FOUND) { *sta = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING; return AE_OK; } return status; }
static int xo15_sci_add(struct acpi_device *device) { unsigned long long tmp; acpi_status status; int r; if (!device) return -EINVAL; strcpy(acpi_device_name(device), XO15_SCI_DEVICE_NAME); strcpy(acpi_device_class(device), XO15_SCI_CLASS); /* Get GPE bit assignment (EC events). */ status = acpi_evaluate_integer(device->handle, "_GPE", NULL, &tmp); if (ACPI_FAILURE(status)) return -EINVAL; xo15_sci_gpe = tmp; status = acpi_install_gpe_handler(NULL, xo15_sci_gpe, ACPI_GPE_EDGE_TRIGGERED, xo15_sci_gpe_handler, device); if (ACPI_FAILURE(status)) return -ENODEV; dev_info(&device->dev, "Initialized, GPE = 0x%lx\n", xo15_sci_gpe); r = sysfs_create_file(&device->dev.kobj, &lid_wake_on_close_attr.attr); if (r) goto err_sysfs; /* Flush queue, and enable all SCI events */ process_sci_queue(); olpc_ec_mask_write(EC_SCI_SRC_ALL); acpi_enable_gpe(NULL, xo15_sci_gpe); /* Enable wake-on-EC */ if (device->wakeup.flags.valid) device_init_wakeup(&device->dev, true); return 0; err_sysfs: acpi_remove_gpe_handler(NULL, xo15_sci_gpe, xo15_sci_gpe_handler); cancel_work_sync(&sci_work); return r; }
static int xen_acpi_processor_enable(struct acpi_device *device) { acpi_status status = 0; unsigned long long value; union acpi_object object = { 0 }; struct acpi_buffer buffer = { sizeof(union acpi_object), &object }; struct acpi_processor *pr; pr = acpi_driver_data(device); if (!pr) { pr_err(PREFIX "Cannot find driver data\n"); return -EINVAL; } if (!strcmp(acpi_device_hid(device), ACPI_PROCESSOR_OBJECT_HID)) { /* Declared with "Processor" statement; match ProcessorID */ status = acpi_evaluate_object(pr->handle, NULL, NULL, &buffer); if (ACPI_FAILURE(status)) { pr_err(PREFIX "Evaluating processor object\n"); return -ENODEV; } pr->acpi_id = object.processor.proc_id; } else { /* Declared with "Device" statement; match _UID */ status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID, NULL, &value); if (ACPI_FAILURE(status)) { pr_err(PREFIX "Evaluating processor _UID\n"); return -ENODEV; } pr->acpi_id = value; } pr->id = xen_pcpu_id(pr->acpi_id); if ((int)pr->id < 0) /* This cpu is not presented at hypervisor, try to hotadd it */ if (ACPI_FAILURE(xen_acpi_cpu_hotadd(pr))) { pr_err(PREFIX "Hotadd CPU (acpi_id = %d) failed.\n", pr->acpi_id); return -ENODEV; } return 0; }
static int is_device_present(acpi_handle handle) { acpi_handle temp; acpi_status status; unsigned long long sta; status = acpi_get_handle(handle, "_STA", &temp); if (ACPI_FAILURE(status)) return 1; status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); if (ACPI_FAILURE(status)) return 0; return ((sta & ACPI_STA_DEVICE_PRESENT) == ACPI_STA_DEVICE_PRESENT); }
static acpi_status cmpc_get_rfkill_wlan(acpi_handle handle, unsigned long long *value) { union acpi_object param; struct acpi_object_list input; unsigned long long output; acpi_status status; param.type = ACPI_TYPE_INTEGER; param.integer.value = 0xC1; input.count = 1; input.pointer = ¶m; status = acpi_evaluate_integer(handle, "GRDI", &input, &output); if (ACPI_SUCCESS(status)) *value = output; return status; }
static acpi_status cmpc_set_rfkill_wlan(acpi_handle handle, unsigned long long value) { union acpi_object param[2]; struct acpi_object_list input; acpi_status status; unsigned long long output; param[0].type = ACPI_TYPE_INTEGER; param[0].integer.value = 0xC1; param[1].type = ACPI_TYPE_INTEGER; param[1].integer.value = value; input.count = 2; input.pointer = param; status = acpi_evaluate_integer(handle, "GWRI", &input, &output); return status; }
static int is_device_present(acpi_handle handle) { acpi_handle temp; acpi_status status; unsigned long long sta; status = acpi_get_handle(handle, "_STA", &temp); if (ACPI_FAILURE(status)) return 1; /* _STA not found, assume device present */ status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); if (ACPI_FAILURE(status)) return 0; /* Firmware error */ return ((sta & ACPI_STA_DEVICE_PRESENT) == ACPI_STA_DEVICE_PRESENT); }
static int acpi_check_extended_socket_status(struct acpi_device *device) { unsigned long long sta; acpi_status status; status = acpi_evaluate_integer(device->handle, "_STA", NULL, &sta); if (ACPI_FAILURE(status)) return -ENODEV; if (!((sta & ACPI_STA_DEVICE_PRESENT) && (sta & ACPI_STA_DEVICE_ENABLED) && (sta & ACPI_STA_DEVICE_UI) && (sta & ACPI_STA_DEVICE_FUNCTIONING))) return -ENODEV; return 0; }
int acpi_bus_get_power(acpi_handle handle, int *state) { int result = 0; acpi_status status = 0; struct acpi_device *device = NULL; unsigned long psc = 0; ACPI_FUNCTION_TRACE("acpi_bus_get_power"); result = acpi_bus_get_device(handle, &device); if (result) return_VALUE(result); *state = ACPI_STATE_UNKNOWN; if (!device->flags.power_manageable) { /* TBD: Non-recursive algorithm for walking up hierarchy */ if (device->parent) *state = device->parent->power.state; else *state = ACPI_STATE_D0; } else { /* * Get the device's power state either directly (via _PSC) or * indirectly (via power resources). */ if (device->power.flags.explicit_get) { status = acpi_evaluate_integer(device->handle, "_PSC", NULL, &psc); if (ACPI_FAILURE(status)) return_VALUE(-ENODEV); device->power.state = (int)psc; } else if (device->power.flags.power_resources) { result = acpi_power_get_inferred_state(device); if (result) return_VALUE(result); } *state = device->power.state; } ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] power state is D%d\n", device->pnp.bus_id, device->power.state)); return_VALUE(0); }
static int int3403_add(struct platform_device *pdev) { struct int3403_priv *priv; int result = 0; acpi_status status; priv = devm_kzalloc(&pdev->dev, sizeof(struct int3403_priv), GFP_KERNEL); if (!priv) return -ENOMEM; priv->pdev = pdev; priv->adev = ACPI_COMPANION(&(pdev->dev)); if (!priv->adev) { result = -EINVAL; goto err; } status = acpi_evaluate_integer(priv->adev->handle, "PTYP", NULL, &priv->type); if (ACPI_FAILURE(status)) { result = -EINVAL; goto err; } platform_set_drvdata(pdev, priv); switch (priv->type) { case INT3403_TYPE_SENSOR: result = int3403_sensor_add(priv); break; case INT3403_TYPE_CHARGER: case INT3403_TYPE_BATTERY: result = int3403_cdev_add(priv); break; default: result = -EINVAL; } if (result) goto err; return result; err: return result; }
static ssize_t acpi_method_1_1_read(struct device *dev, struct device_attribute *attr, char *buf) { acpi_status status; unsigned long long output; union acpi_object arg0 = { ACPI_TYPE_INTEGER }; struct acpi_object_list args = { 1, &arg0 }; arg0.integer.value = acpi_arg0; status = acpi_evaluate_integer(NULL, acpi_method, &args, &output); if (ACPI_SUCCESS(status)) printk("Executed %s\n", acpi_method); else printk("Failed to execute %s\n", acpi_method); return sprintf(buf, "0x%08llx\n", output); }
static int acpi_thermal_get_polling_frequency(struct acpi_thermal *tz) { acpi_status status = AE_OK; unsigned long long tmp; if (!tz) return -EINVAL; status = acpi_evaluate_integer(tz->device->handle, "_TZP", NULL, &tmp); if (ACPI_FAILURE(status)) return -ENODEV; tz->polling_frequency = tmp; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n", tz->polling_frequency)); return 0; }
static int is_device_present(acpi_handle handle) { acpi_handle temp; acpi_status status; unsigned long sta; ACPI_FUNCTION_TRACE("is_device_present"); status = acpi_get_handle(handle, "_STA", &temp); if (ACPI_FAILURE(status)) return_VALUE(1); /* _STA not found, assmue device present */ status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); if (ACPI_FAILURE(status)) return_VALUE(0); /* Firmware error */ return_VALUE((sta & ACPI_STA_PRESENT) == ACPI_STA_PRESENT); }
/* Helper function */ static int toshiba_haps_available(acpi_handle handle) { acpi_status status; u64 hdd_present; /* * A non existent device as well as having (only) * Solid State Drives can cause the call to fail. */ status = acpi_evaluate_integer(handle, "_STA", NULL, &hdd_present); if (ACPI_FAILURE(status) || !hdd_present) { pr_info("HDD protection not available or using SSD\n"); return 0; } return 1; }
int acpi_bus_get_status(struct acpi_device *device) { acpi_status status = AE_OK; unsigned long long sta = 0; if (!device) return -EINVAL; /* * Evaluate _STA if present. */ if (device->flags.dynamic_status) { status = acpi_evaluate_integer(device->handle, "_STA", NULL, &sta); if (ACPI_FAILURE(status)) return -ENODEV; STRUCT_TO_INT(device->status) = (int)sta; } /* * According to ACPI spec some device can be present and functional * even if the parent is not present but functional. * In such conditions the child device should not inherit the status * from the parent. */ else STRUCT_TO_INT(device->status) = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING; if (device->status.functional && !device->status.present) { ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]: " "functional but not present;\n", device->pnp.bus_id, (u32) STRUCT_TO_INT(device->status))); } ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n", device->pnp.bus_id, (u32) STRUCT_TO_INT(device->status))); return 0; }
int acpi_bus_get_status(struct acpi_device *device) { acpi_status status = AE_OK; unsigned long sta = 0; if (!device) return -EINVAL; /* * Evaluate _STA if present. */ if (device->flags.dynamic_status) { status = acpi_evaluate_integer(device->handle, "_STA", NULL, &sta); if (ACPI_FAILURE(status)) return -ENODEV; STRUCT_TO_INT(device->status) = (int)sta; } /* * Otherwise we assume the status of our parent (unless we don't * have one, in which case status is implied). */ else if (device->parent) device->status = device->parent->status; else STRUCT_TO_INT(device->status) = ACPI_STA_DEVICE_PRESENT | ACPI_STA_DEVICE_ENABLED | ACPI_STA_DEVICE_UI | ACPI_STA_DEVICE_FUNCTIONING; if (device->status.functional && !device->status.present) { printk(KERN_WARNING PREFIX "Device [%s] status [%08x]: " "functional but not present; setting present\n", device->pnp.bus_id, (u32) STRUCT_TO_INT(device->status)); device->status.present = 1; } ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] status [%08x]\n", device->pnp.bus_id, (u32) STRUCT_TO_INT(device->status))); return 0; }
static int is_processor_present(acpi_handle handle) { acpi_status status; unsigned long long sta = 0; status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); if (ACPI_SUCCESS(status) && (sta & ACPI_STA_DEVICE_PRESENT)) return 1; if (status == AE_NOT_FOUND) ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor does not support hot plug\n")); else ACPI_EXCEPTION((AE_INFO, status, "Processor Device is not present")); return 0; }
static int acpi_thermal_get_polling_frequency ( struct acpi_thermal *tz) { acpi_status status = AE_OK; ACPI_FUNCTION_TRACE("acpi_thermal_get_polling_frequency"); if (!tz) return_VALUE(-EINVAL); status = acpi_evaluate_integer(tz->handle, "_TZP", NULL, &tz->polling_frequency); if (ACPI_FAILURE(status)) return_VALUE(-ENODEV); ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Polling frequency is %lu dS\n", tz->polling_frequency)); return_VALUE(0); }
static int pega_acc_axis(struct asus_laptop *asus, int curr, char *method) { int i, delta; unsigned long long val; for (i = 0; i < PEGA_ACC_RETRIES; i++) { acpi_evaluate_integer(asus->handle, method, NULL, &val); /* The output is noisy. From reading the ASL * dissassembly, timeout errors are returned with 1's * in the high word, and the lack of locking around * thei hi/lo byte reads means that a transition * between (for example) -1 and 0 could be read as * 0xff00 or 0x00ff. */ delta = abs(curr - (short)val); if (delta < 128 && !(val & ~0xffff)) break; } return clamp_val((short)val, -PEGA_ACC_CLAMP, PEGA_ACC_CLAMP); }
static enum rbtn_type rbtn_check(struct acpi_device *device) { unsigned long long output; acpi_status status; status = acpi_evaluate_integer(device->handle, "CRBT", NULL, &output); if (ACPI_FAILURE(status)) return RBTN_UNKNOWN; switch (output) { case 0: case 1: return RBTN_TOGGLE; case 2: case 3: return RBTN_SLIDER; default: return RBTN_UNKNOWN; } }
/* * Keyboard backlight (also a LED) */ static int asus_kled_lvl(struct asus_laptop *asus) { unsigned long long kblv; struct acpi_object_list params; union acpi_object in_obj; acpi_status rv; params.count = 1; params.pointer = &in_obj; in_obj.type = ACPI_TYPE_INTEGER; in_obj.integer.value = 2; rv = acpi_evaluate_integer(asus->handle, METHOD_KBD_LIGHT_GET, ¶ms, &kblv); if (ACPI_FAILURE(rv)) { pr_warning("Error reading kled level\n"); return -ENODEV; } return kblv; }
static int read_display(struct asus_laptop *asus) { unsigned long long value = 0; acpi_status rv = AE_OK; /* * In most of the case, we know how to set the display, but sometime * we can't read it */ if (display_get_handle) { rv = acpi_evaluate_integer(display_get_handle, NULL, NULL, &value); if (ACPI_FAILURE(rv)) pr_warning("Error reading display status\n"); } value &= 0x0F; /* needed for some models, shouldn't hurt others */ return value; }
static int is_processor_present(acpi_handle handle) { acpi_status status; unsigned long long sta = 0; status = acpi_evaluate_integer(handle, "_STA", NULL, &sta); if (ACPI_SUCCESS(status) && (sta & ACPI_STA_DEVICE_PRESENT)) return 1; /* * _STA is mandatory for a processor that supports hot plug */ if (status == AE_NOT_FOUND) pr_info(PREFIX "Processor does not support hot plug\n"); else pr_info(PREFIX "Processor Device is not present"); return 0; }
static int acpi_thermal_get_temperature(struct acpi_thermal *tz) { acpi_status status = AE_OK; unsigned long long tmp; if (!tz) return -EINVAL; tz->last_temperature = tz->temperature; status = acpi_evaluate_integer(tz->device->handle, "_TMP", NULL, &tmp); if (ACPI_FAILURE(status)) return -ENODEV; tz->temperature = tmp; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n", tz->temperature)); return 0; }
static int acpi_ac_get_state ( struct acpi_ac *ac) { acpi_status status = AE_OK; ACPI_FUNCTION_TRACE("acpi_ac_get_state"); if (!ac) return_VALUE(-EINVAL); status = acpi_evaluate_integer(ac->handle, "_PSR", NULL, &ac->state); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error reading AC Adapter state\n")); ac->state = ACPI_AC_STATUS_UNKNOWN; return_VALUE(-ENODEV); } return_VALUE(0); }
static int acpi_thermal_get_temperature ( struct acpi_thermal *tz) { acpi_status status = AE_OK; ACPI_FUNCTION_TRACE("acpi_thermal_get_temperature"); if (!tz) return_VALUE(-EINVAL); tz->last_temperature = tz->temperature; status = acpi_evaluate_integer(tz->handle, "_TMP", NULL, &tz->temperature); if (ACPI_FAILURE(status)) return -ENODEV; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Temperature is %lu dK\n", tz->temperature)); return_VALUE(0); }
static int get_lcd_level(void) { unsigned long state = 0; acpi_status status = AE_OK; // Get the Brightness status = acpi_evaluate_integer(fujitsu->acpi_handle, "GBLL", NULL, &state); if (status < 0) return status; fujitsu->fuj02b1_state = state; fujitsu->brightness_level = state & 0x0fffffff; if (state & 0x80000000) fujitsu->brightness_changed = 1; else fujitsu->brightness_changed = 0; return fujitsu->brightness_level; }
static int acpi_memory_check_device(struct acpi_memory_device *mem_device) { unsigned long current_status; ACPI_FUNCTION_TRACE("acpi_memory_check_device"); /* Get device present/absent information from the _STA */ if (ACPI_FAILURE(acpi_evaluate_integer(mem_device->handle, "_STA", NULL, ¤t_status))) return_VALUE(-ENODEV); /* * Check for device status. Device should be * present/enabled/functioning. */ if (!((current_status & ACPI_MEMORY_STA_PRESENT) && (current_status & ACPI_MEMORY_STA_ENABLED) && (current_status & ACPI_MEMORY_STA_FUNCTIONAL))) return_VALUE(-ENODEV); return_VALUE(0); }