static int __init acpi_bus_init_irq (void) { acpi_status status = AE_OK; union acpi_object arg = {ACPI_TYPE_INTEGER}; struct acpi_object_list arg_list = {1, &arg}; char *message = NULL; ACPI_FUNCTION_TRACE("acpi_bus_init_irq"); /* * Let the system know what interrupt model we are using by * evaluating the \_PIC object, if exists. */ switch (acpi_irq_model) { case ACPI_IRQ_MODEL_PIC: message = "PIC"; break; case ACPI_IRQ_MODEL_IOAPIC: message = "IOAPIC"; break; case ACPI_IRQ_MODEL_IOSAPIC: message = "IOSAPIC"; break; default: printk(KERN_WARNING PREFIX "Unknown interrupt routing model\n"); return_VALUE(-ENODEV); } printk(KERN_INFO PREFIX "Using %s for interrupt routing\n", message); arg.integer.value = acpi_irq_model; status = acpi_evaluate_object(NULL, "\\_PIC", &arg_list, NULL); if (ACPI_FAILURE(status) && (status != AE_NOT_FOUND)) { ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "Error evaluating _PIC\n")); return_VALUE(-ENODEV); } return_VALUE(0); }
acpi_status acpi_evaluate_string(acpi_handle handle, acpi_string pathname, acpi_object_list * arguments, acpi_string * data) { acpi_status status = AE_OK; acpi_object *element = NULL; acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; if (!data) return AE_BAD_PARAMETER; status = acpi_evaluate_object(handle, pathname, arguments, &buffer); if (ACPI_FAILURE(status)) { acpi_util_eval_error(handle, pathname, status); return status; } element = (acpi_object *) buffer.pointer; if ((element->type != ACPI_TYPE_STRING) || (element->type != ACPI_TYPE_BUFFER) || !element->string.length) { acpi_util_eval_error(handle, pathname, AE_BAD_DATA); return AE_BAD_DATA; } *data = kzalloc(element->string.length + 1, GFP_KERNEL); if (!data) { printk(KERN_ERR PREFIX "Memory allocation\n"); return -ENOMEM; } memcpy(*data, element->string.pointer, element->string.length); ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%s]\n", *data)); kfree(buffer.pointer); return AE_OK; }
/** * ide_acpi_push_timing - set the channel (controller) timings * @hwif: target IDE interface (channel) * * This function executes the _STM ACPI method for the target channel. * * _STM requires Identify Drive data, which has to passed as an argument. * Unfortunately hd_driveid is a mangled version which we can't readily * use; hence we'll get the information afresh. */ void ide_acpi_push_timing(ide_hwif_t *hwif) { acpi_status status; struct acpi_object_list input; union acpi_object in_params[3]; struct ide_acpi_drive_link *master = &hwif->acpidata->master; struct ide_acpi_drive_link *slave = &hwif->acpidata->slave; if (ide_noacpi) return; DEBPRINT("ENTER:\n"); if (!hwif->acpidata) { DEBPRINT("no ACPI data for %s\n", hwif->name); return; } /* Give the GTM buffer + drive Identify data to the channel via the * _STM method: */ /* setup input parameters buffer for _STM */ input.count = 3; input.pointer = in_params; in_params[0].type = ACPI_TYPE_BUFFER; in_params[0].buffer.length = sizeof(struct GTM_buffer); in_params[0].buffer.pointer = (u8 *)&hwif->acpidata->gtm; in_params[1].type = ACPI_TYPE_BUFFER; in_params[1].buffer.length = sizeof(struct hd_driveid); in_params[1].buffer.pointer = (u8 *)&master->idbuff; in_params[2].type = ACPI_TYPE_BUFFER; in_params[2].buffer.length = sizeof(struct hd_driveid); in_params[2].buffer.pointer = (u8 *)&slave->idbuff; /* Output buffer: _STM has no output */ status = acpi_evaluate_object(hwif->acpidata->obj_handle, "_STM", &input, NULL); if (ACPI_FAILURE(status)) { DEBPRINT("Run _STM error: status = 0x%x\n", status); } DEBPRINT("_STM status: %d\n", status); }
static void keyboard_led_set_brightness(struct led_classdev *cdev, enum led_brightness brightness) { union acpi_object param; struct acpi_object_list input; acpi_status status; if (!(cdev->flags & LED_SUSPENDED)) cdev->brightness = brightness; param.type = ACPI_TYPE_INTEGER; param.integer.value = brightness; input.count = 1; input.pointer = ¶m; status = acpi_evaluate_object(NULL, ACPI_KEYBOARD_BACKLIGHT_WRITE, &input, NULL); if (ACPI_FAILURE(status)) dev_err(cdev->dev, "Error setting keyboard LED value"); }
static ssize_t acpi_video_write_brightness(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { acpi_status status; union acpi_object arg0 = { ACPI_TYPE_INTEGER }; struct acpi_object_list args = { 1, &arg0 }; if (!video_device) { printk("acpi_video device is not specified!\n"); return count; } arg0.integer.value = simple_strtoul(buf, NULL, 10); status = acpi_evaluate_object(video_device, "_BCM", &args, NULL); if (!ACPI_SUCCESS(status)) printk("Failed to set brightness level!\n"); return count; }
static int acpi_thermal_set_cooling_mode ( struct acpi_thermal *tz, int mode) { acpi_status status = AE_OK; union acpi_object arg0 = {ACPI_TYPE_INTEGER}; struct acpi_object_list arg_list = {1, &arg0}; acpi_handle handle = NULL; ACPI_FUNCTION_TRACE("acpi_thermal_set_cooling_mode"); if (!tz) return_VALUE(-EINVAL); status = acpi_get_handle(tz->handle, "_SCP", &handle); if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_INFO, "_SCP not present\n")); status = acpi_get_handle(tz->handle, "_PSV", &handle); if(!ACPI_FAILURE(status)) { tz->cooling_mode = 1; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cooling mode [%s]\n", mode?"passive":"active")); return_VALUE(0); } return_VALUE(-ENODEV); } arg0.integer.value = mode; status = acpi_evaluate_object(handle, NULL, &arg_list, NULL); if (ACPI_FAILURE(status)) return_VALUE(-ENODEV); tz->cooling_mode = mode; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Cooling mode [%s]\n", mode?"passive":"active")); return_VALUE(0); }
/* * The normal ACPI LID wakeup behavior is wake-on-open, but not * wake-on-close. This is implemented as standard by the XO-1.5 DSDT. * * We provide here a sysfs attribute that will additionally enable * wake-on-close behavior. This is useful (e.g.) when we oportunistically * suspend with the display running; if the lid is then closed, we want to * wake up to turn the display off. * * This is controlled through a custom method in the XO-1.5 DSDT. */ static int set_lid_wake_behavior(bool wake_on_close) { struct acpi_object_list arg_list; union acpi_object arg; acpi_status status; arg_list.count = 1; arg_list.pointer = &arg; arg.type = ACPI_TYPE_INTEGER; arg.integer.value = wake_on_close; status = acpi_evaluate_object(NULL, "\\_SB.PCI0.LID.LIDW", &arg_list, NULL); if (ACPI_FAILURE(status)) { pr_warning(PFX "failed to set lid behavior\n"); return 1; } lid_wake_on_close = wake_on_close; return 0; }
/* * This function evaluates an ACPI method, given an int as parameter, the * method is searched within the scope of the handle, can be NULL. The output * of the method is written is output, which can also be NULL * * returns 0 if write is successful, -1 else. */ static int write_acpi_int_ret(acpi_handle handle, const char *method, int val, struct acpi_buffer *output) { struct acpi_object_list params; /* list of input parameters (an int) */ union acpi_object in_obj; /* the only param we use */ acpi_status status; if (!handle) return -1; params.count = 1; params.pointer = &in_obj; in_obj.type = ACPI_TYPE_INTEGER; in_obj.integer.value = val; status = acpi_evaluate_object(handle, (char *)method, ¶ms, output); if (status == AE_OK) return 0; else return -1; }
acpi_status tz_set_cooling_preference ( TZ_CONTEXT *tz, TZ_COOLING_MODE cooling_mode) { acpi_status status = AE_OK; acpi_object_list arg_list; acpi_object arg0; FUNCTION_TRACE("tz_set_cooling_preference"); if (!tz || ((cooling_mode != TZ_COOLING_MODE_ACTIVE) && (cooling_mode != TZ_COOLING_MODE_PASSIVE))) { return_ACPI_STATUS(AE_BAD_PARAMETER); } /* * Build the argument list, which simply consists of the current * cooling preference. */ memset(&arg_list, 0, sizeof(acpi_object)); arg_list.count = 1; arg_list.pointer = &arg0; memset(&arg0, 0, sizeof(acpi_object)); arg0.type = ACPI_TYPE_INTEGER; arg0.integer.value = cooling_mode; /* * Evaluate "_SCP" - setting the new cooling preference. */ status = acpi_evaluate_object(tz->acpi_handle, "_SCP", &arg_list, NULL); if (ACPI_FAILURE(status)) { tz->policy.cooling_mode = -1; return_ACPI_STATUS(status); } tz->policy.cooling_mode = cooling_mode; return_ACPI_STATUS(status); }
static acpi_status acpi_run_hpp(acpi_handle handle, struct hotplug_params *hpp) { acpi_status status; struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; union acpi_object *package, *fields; int i; memset(hpp, 0, sizeof(struct hotplug_params)); status = acpi_evaluate_object(handle, "_HPP", NULL, &buffer); if (ACPI_FAILURE(status)) return status; package = (union acpi_object *) buffer.pointer; if (package->type != ACPI_TYPE_PACKAGE || package->package.count != 4) { status = AE_ERROR; goto exit; } fields = package->package.elements; for (i = 0; i < 4; i++) { if (fields[i].type != ACPI_TYPE_INTEGER) { status = AE_ERROR; goto exit; } } hpp->t0 = &hpp->type0_data; hpp->t0->revision = 1; hpp->t0->cache_line_size = fields[0].integer.value; hpp->t0->latency_timer = fields[1].integer.value; hpp->t0->enable_serr = fields[2].integer.value; hpp->t0->enable_perr = fields[3].integer.value; exit: kfree(buffer.pointer); return status; }
acpi_status acpi_evaluate_integer(acpi_handle handle, acpi_string pathname, struct acpi_object_list *arguments, unsigned long *data) { acpi_status status = AE_OK; union acpi_object *element; struct acpi_buffer buffer = { 0, NULL }; if (!data) return AE_BAD_PARAMETER; element = kmalloc(sizeof(union acpi_object), irqs_disabled() ? GFP_ATOMIC: GFP_KERNEL); if (!element) return AE_NO_MEMORY; memset(element, 0, sizeof(union acpi_object)); buffer.length = sizeof(union acpi_object); buffer.pointer = element; status = acpi_evaluate_object(handle, pathname, arguments, &buffer); if (ACPI_FAILURE(status)) { acpi_util_eval_error(handle, pathname, status); kfree(element); return status; } if (element->type != ACPI_TYPE_INTEGER) { acpi_util_eval_error(handle, pathname, AE_BAD_DATA); kfree(element); return AE_BAD_DATA; } *data = element->integer.value; kfree(element); ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Return value [%lu]\n", *data)); return AE_OK; }
static int asus_acpi_get_sensor_info(struct acpi_device *adev, struct i2c_client *client, struct i2c_board_info *info) { struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; int i; acpi_status status; union acpi_object *cpm; int ret; status = acpi_evaluate_object(adev->handle, "CNF0", NULL, &buffer); if (ACPI_FAILURE(status)) return -ENODEV; cpm = buffer.pointer; for (i = 0; i < cpm->package.count; ++i) { union acpi_object *elem; int j; elem = &cpm->package.elements[i]; for (j = 0; j < elem->package.count; ++j) { union acpi_object *sub_elem; sub_elem = &elem->package.elements[j]; if (sub_elem->type == ACPI_TYPE_STRING) strlcpy(info->type, sub_elem->string.pointer, sizeof(info->type)); else if (sub_elem->type == ACPI_TYPE_INTEGER) { if (sub_elem->integer.value != client->addr) { info->addr = sub_elem->integer.value; break; /* Not a MPU6500 primary */ } } } } ret = cpm->package.count; kfree(buffer.pointer); return ret; }
static int extlog_get_dsm(acpi_handle handle, int rev, int func, u64 *ret) { struct acpi_buffer buf = {ACPI_ALLOCATE_BUFFER, NULL}; struct acpi_object_list input; union acpi_object params[4], *obj; u8 uuid[16]; int i; acpi_str_to_uuid(extlog_dsm_uuid, uuid); input.count = 4; input.pointer = params; params[0].type = ACPI_TYPE_BUFFER; params[0].buffer.length = 16; params[0].buffer.pointer = uuid; params[1].type = ACPI_TYPE_INTEGER; params[1].integer.value = rev; params[2].type = ACPI_TYPE_INTEGER; params[2].integer.value = func; params[3].type = ACPI_TYPE_PACKAGE; params[3].package.count = 0; params[3].package.elements = NULL; if (ACPI_FAILURE(acpi_evaluate_object(handle, "_DSM", &input, &buf))) return -1; *ret = 0; obj = (union acpi_object *)buf.pointer; if (obj->type == ACPI_TYPE_INTEGER) { *ret = obj->integer.value; } else if (obj->type == ACPI_TYPE_BUFFER) { if (obj->buffer.length <= 8) { for (i = 0; i < obj->buffer.length; i++) *ret |= (obj->buffer.pointer[i] << (i * 8)); } } kfree(buf.pointer); return 0; }
/* * Query firmware how many CPUs should be idle * return -1 on failure */ static int acpi_pad_pur(acpi_handle handle) { struct acpi_buffer buffer = {ACPI_ALLOCATE_BUFFER, NULL}; union acpi_object *package; int num = -1; if (ACPI_FAILURE(acpi_evaluate_object(handle, "_PUR", NULL, &buffer))) return num; if (!buffer.length || !buffer.pointer) return num; package = buffer.pointer; if (package->type == ACPI_TYPE_PACKAGE && package->package.count == 2 && package->package.elements[0].integer.value == 1) /* rev 1 */ num = package->package.elements[1].integer.value; kfree(buffer.pointer); return num; }
static void dw_i2c_acpi_params(struct platform_device *pdev, char method[], u16 *hcnt, u16 *lcnt, u32 *sda_hold) { struct acpi_buffer buf = { ACPI_ALLOCATE_BUFFER }; acpi_handle handle = ACPI_HANDLE(&pdev->dev); union acpi_object *obj; if (ACPI_FAILURE(acpi_evaluate_object(handle, method, NULL, &buf))) return; obj = (union acpi_object *)buf.pointer; if (obj->type == ACPI_TYPE_PACKAGE && obj->package.count == 3) { const union acpi_object *objs = obj->package.elements; *hcnt = (u16)objs[0].integer.value; *lcnt = (u16)objs[1].integer.value; if (sda_hold) *sda_hold = (u32)objs[2].integer.value; } kfree(buf.pointer); }
static bool processor_physically_present(acpi_handle handle) { int cpuid, type; u32 acpi_id; acpi_status status; acpi_object_type acpi_type; unsigned long long tmp; union acpi_object object = { 0 }; struct acpi_buffer buffer = { sizeof(union acpi_object), &object }; status = acpi_get_type(handle, &acpi_type); if (ACPI_FAILURE(status)) return false; switch (acpi_type) { case ACPI_TYPE_PROCESSOR: status = acpi_evaluate_object(handle, NULL, NULL, &buffer); if (ACPI_FAILURE(status)) return false; acpi_id = object.processor.proc_id; break; case ACPI_TYPE_DEVICE: status = acpi_evaluate_integer(handle, "_UID", NULL, &tmp); if (ACPI_FAILURE(status)) return false; acpi_id = tmp; break; default: return false; } type = (acpi_type == ACPI_TYPE_DEVICE) ? 1 : 0; cpuid = acpi_get_cpuid(handle, type, acpi_id); if (cpuid == -1) return false; return true; }
static int __cpuinit acpi_processor_eval_pdc(acpi_handle handle, struct acpi_object_list *pdc_in) { acpi_status status = AE_OK; if (boot_option_idle_override == IDLE_NOMWAIT) { union acpi_object *obj; u32 *buffer = NULL; obj = pdc_in->pointer; buffer = (u32 *)(obj->buffer.pointer); buffer[2] &= ~(ACPI_PDC_C_C2C3_FFH | ACPI_PDC_C_C1_FFH); } status = acpi_evaluate_object(handle, "_PDC", pdc_in, NULL); if (ACPI_FAILURE(status)) ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Could not evaluate _PDC, using legacy perf. control.\n")); return status; }
static void do_acpi_call(const char * method) { acpi_status status; acpi_handle handle; union acpi_object atpx_arg_elements[1]; struct acpi_object_list atpx_arg; struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; printk(KERN_INFO "acpi_call: Calling %s\n", method); status = acpi_get_handle(root_handle, (acpi_string) method, &handle); last_result = 0; if (ACPI_FAILURE(status)) { printk(KERN_ERR "acpi_call: Cannot get handle: %s\n", acpi_format_exception(status)); return; } // for now, parameterless functions only atpx_arg.count = 0; atpx_arg.pointer = &atpx_arg_elements[0]; // just to be sure atpx_arg_elements[0].type = ACPI_TYPE_INTEGER; atpx_arg_elements[0].integer.value = 0; status = acpi_evaluate_object(handle, NULL, &atpx_arg, &buffer); if (ACPI_FAILURE(status)) { printk(KERN_ERR "acpi_call: ATPX method call failed: %s\n", acpi_format_exception(status)); return; } kfree(buffer.pointer); last_result = 1; printk(KERN_INFO "acpi_call: Call successful\n"); }
/******************************************************************************* * * FUNCTION: acpi_hw_execute_sleep_method * * PARAMETERS: method_pathname - Pathname of method to execute * integer_argument - Argument to pass to the method * * RETURN: None * * DESCRIPTION: Execute a sleep/wake related method with one integer argument * and no return value. * ******************************************************************************/ void acpi_hw_execute_sleep_method(char *method_pathname, u32 integer_argument) { struct acpi_object_list arg_list; union acpi_object arg; acpi_status status; ACPI_FUNCTION_TRACE(hw_execute_sleep_method); /* One argument, integer_argument; No return value expected */ arg_list.count = 1; arg_list.pointer = &arg; arg.type = ACPI_TYPE_INTEGER; arg.integer.value = (u64)integer_argument; status = acpi_evaluate_object(NULL, method_pathname, &arg_list, NULL); if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { ACPI_EXCEPTION((AE_INFO, status, "While executing method %s", method_pathname)); } return_VOID; }
/* acpi_run_oshp - get control of hotplug from the firmware * * @handle - the handle of the hotplug controller. */ acpi_status acpi_run_oshp(acpi_handle handle) { acpi_status status; struct acpi_buffer string = { ACPI_ALLOCATE_BUFFER, NULL }; acpi_get_name(handle, ACPI_FULL_PATHNAME, &string); /* run OSHP */ status = acpi_evaluate_object(handle, METHOD_NAME_OSHP, NULL, NULL); if (ACPI_FAILURE(status)) if (status != AE_NOT_FOUND) printk(KERN_ERR "%s:%s OSHP fails=0x%x\n", __func__, (char *)string.pointer, status); else dbg("%s:%s OSHP not found\n", __func__, (char *)string.pointer); else pr_debug("%s:%s OSHP passes\n", __func__, (char *)string.pointer); kfree(string.pointer); return status; }
static int __acpi_power_on(struct acpi_power_resource *resource) { struct acpi_power_resource_device *device_list = resource->devices; acpi_status status = AE_OK; status = acpi_evaluate_object(resource->device->handle, "_ON", NULL, NULL); if (ACPI_FAILURE(status)) return -ENODEV; /* Update the power resource's _device_ power state */ resource->device->power.state = ACPI_STATE_D0; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned on\n", resource->name)); while (device_list) { acpi_power_on_device(device_list->device); device_list = device_list->next; } return 0; }
static int fjes_acpi_add(struct acpi_device *device) { struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL}; char str_buf[sizeof(FJES_ACPI_SYMBOL) + 1]; struct platform_device *plat_dev; union acpi_object *str; acpi_status status; int result; status = acpi_evaluate_object(device->handle, "_STR", NULL, &buffer); if (ACPI_FAILURE(status)) return -ENODEV; str = buffer.pointer; result = utf16s_to_utf8s((wchar_t *)str->string.pointer, str->string.length, UTF16_LITTLE_ENDIAN, str_buf, sizeof(str_buf) - 1); str_buf[result] = 0; if (strncmp(FJES_ACPI_SYMBOL, str_buf, strlen(FJES_ACPI_SYMBOL)) != 0) { kfree(buffer.pointer); return -ENODEV; } kfree(buffer.pointer); status = acpi_walk_resources(device->handle, METHOD_NAME__CRS, fjes_get_acpi_resource, fjes_resource); if (ACPI_FAILURE(status)) return -ENODEV; /* create platform_device */ plat_dev = platform_device_register_simple(DRV_NAME, 0, fjes_resource, ARRAY_SIZE(fjes_resource)); device->driver_data = plat_dev; return 0; }
static void set_dflt_pwr_limit(struct iwl_trans *trans, struct pci_dev *pdev) { acpi_handle pxsx_handle; acpi_handle handle; struct acpi_buffer splx = {ACPI_ALLOCATE_BUFFER, NULL}; acpi_status status; #if 0 /* Not in RHEL */ pxsx_handle = ACPI_HANDLE(&pdev->dev); #else pxsx_handle = DEVICE_ACPI_HANDLE(&pdev->dev); #endif if (!pxsx_handle) { IWL_DEBUG_INFO(trans, "Could not retrieve root port ACPI handle\n"); return; } /* Get the method's handle */ status = acpi_get_handle(pxsx_handle, (acpi_string)SPL_METHOD, &handle); if (ACPI_FAILURE(status)) { IWL_DEBUG_INFO(trans, "SPL method not found\n"); return; } /* Call SPLC with no arguments */ status = acpi_evaluate_object(handle, NULL, NULL, &splx); if (ACPI_FAILURE(status)) { IWL_ERR(trans, "SPLC invocation failed (0x%x)\n", status); return; } trans->dflt_pwr_limit = splx_get_pwr_limit(trans, splx.pointer); IWL_DEBUG_INFO(trans, "Default power limit set to %lld\n", trans->dflt_pwr_limit); kfree(splx.pointer); }
static int asus_lcd_set(struct asus_laptop *asus, int value) { int lcd = 0; acpi_status status = 0; lcd = !!value; if (lcd == asus_lcd_status(asus)) return 0; if (!lcd_switch_handle) return -ENODEV; status = acpi_evaluate_object(lcd_switch_handle, NULL, NULL, NULL); if (ACPI_FAILURE(status)) { pr_warning("Error switching LCD\n"); return -ENODEV; } asus->lcd_state = lcd; return 0; }
/** * radeon_atpx_call - call an ATPX method * * @handle: acpi handle * @function: the ATPX function to execute * @params: ATPX function params * * Executes the requested ATPX function (all asics). * Returns a pointer to the acpi output buffer. */ static union acpi_object *radeon_atpx_call(acpi_handle handle, int function, struct acpi_buffer *params) { acpi_status status; union acpi_object atpx_arg_elements[2]; struct acpi_object_list atpx_arg; struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; atpx_arg.count = 2; atpx_arg.pointer = &atpx_arg_elements[0]; atpx_arg_elements[0].type = ACPI_TYPE_INTEGER; atpx_arg_elements[0].integer.value = function; if (params) { atpx_arg_elements[1].type = ACPI_TYPE_BUFFER; atpx_arg_elements[1].buffer.length = params->length; atpx_arg_elements[1].buffer.pointer = params->pointer; } else { /* We need a second fake parameter */ atpx_arg_elements[1].type = ACPI_TYPE_INTEGER; atpx_arg_elements[1].integer.value = 0; } status = acpi_evaluate_object(handle, NULL, &atpx_arg, &buffer); /* Fail only if calling the method fails and ATPX is supported */ if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { printk("failed to evaluate ATPX got %s\n", acpi_format_exception(status)); kfree(buffer.pointer); return NULL; } return buffer.pointer; }
static ssize_t acpi_method_0_0_write(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { acpi_handle device; acpi_status status; char path[255]; acpi_device_path(buf, path); status = acpi_get_handle(NULL, path, &device); if (!ACPI_SUCCESS(status)) { printk("Failed to find acpi method: %s\n", path); goto err; } status = acpi_evaluate_object(NULL, path, NULL, NULL); if (ACPI_SUCCESS(status)) printk("Executed %s\n", path); else printk("Failed to execute %s\n", path); err: return count; }
static int intel_vbtn_probe(struct platform_device *device) { acpi_handle handle = ACPI_HANDLE(&device->dev); struct intel_vbtn_priv *priv; acpi_status status; int err; status = acpi_evaluate_object(handle, "VBDL", NULL, NULL); if (ACPI_FAILURE(status)) { dev_warn(&device->dev, "failed to read Intel Virtual Button driver\n"); return -ENODEV; } priv = devm_kzalloc(&device->dev, sizeof(*priv), GFP_KERNEL); if (!priv) return -ENOMEM; dev_set_drvdata(&device->dev, priv); err = intel_vbtn_input_setup(device); if (err) { pr_err("Failed to setup Intel Virtual Button\n"); return err; } detect_tablet_mode(device); status = acpi_install_notify_handler(handle, ACPI_DEVICE_NOTIFY, notify_handler, device); if (ACPI_FAILURE(status)) return -EBUSY; device_init_wakeup(&device->dev, true); return 0; }
int acpi_bus_set_power(acpi_handle handle, int state) { int result = 0; acpi_status status = AE_OK; struct acpi_device *device = NULL; char object_name[5] = { '_', 'P', 'S', '0' + state, '\0' }; result = acpi_bus_get_device(handle, &device); if (result) return result; if ((state < ACPI_STATE_D0) || (state > ACPI_STATE_D3)) return -EINVAL; /* Make sure this is a valid target state */ if (!device->flags.power_manageable) { ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device `[%s]' is not power manageable\n", kobject_name(&device->dev.kobj))); return -ENODEV; } /* * Get device's current power state */ if (!acpi_power_nocheck) { /* * Maybe the incorrect power state is returned on the bogus * bios, which is different with the real power state. * For example: the bios returns D0 state and the real power * state is D3. OS expects to set the device to D0 state. In * such case if OS uses the power state returned by the BIOS, * the device can't be transisted to the correct power state. * So if the acpi_power_nocheck is set, it is unnecessary to * get the power state by calling acpi_bus_get_power. */ acpi_bus_get_power(device->handle, &device->power.state); } if ((state == device->power.state) && !device->flags.force_power_state) { ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device is already at D%d\n", state)); return 0; } if (!device->power.states[state].flags.valid) { printk(KERN_WARNING PREFIX "Device does not support D%d\n", state); return -ENODEV; } if (device->parent && (state < device->parent->power.state)) { printk(KERN_WARNING PREFIX "Cannot set device to a higher-powered" " state than parent\n"); return -ENODEV; } /* * Transition Power * ---------------- * On transitions to a high-powered state we first apply power (via * power resources) then evalute _PSx. Conversly for transitions to * a lower-powered state. */ if (state < device->power.state) { if (device->power.flags.power_resources) { result = acpi_power_transition(device, state); if (result) goto end; } if (device->power.states[state].flags.explicit_set) { status = acpi_evaluate_object(device->handle, object_name, NULL, NULL); if (ACPI_FAILURE(status)) { result = -ENODEV; goto end; } } } else { if (device->power.states[state].flags.explicit_set) { status = acpi_evaluate_object(device->handle, object_name, NULL, NULL); if (ACPI_FAILURE(status)) { result = -ENODEV; goto end; } } if (device->power.flags.power_resources) { result = acpi_power_transition(device, state); if (result) goto end; } } end: if (result) printk(KERN_WARNING PREFIX "Transitioning device [%s] to D%d\n", device->pnp.bus_id, state); else { device->power.state = state; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Device [%s] transitioned to D%d\n", device->pnp.bus_id, state)); } return result; }
acpi_status acpi_enter_sleep_state_prep(u8 sleep_state) { acpi_status status; struct acpi_object_list arg_list; union acpi_object arg; u32 sst_value; ACPI_FUNCTION_TRACE(acpi_enter_sleep_state_prep); status = acpi_get_sleep_type_data(sleep_state, &acpi_gbl_sleep_type_a, &acpi_gbl_sleep_type_b); if (ACPI_FAILURE(status)) { return_ACPI_STATUS(status); } /* Execute the _PTS method (Prepare To Sleep) */ arg_list.count = 1; arg_list.pointer = &arg; arg.type = ACPI_TYPE_INTEGER; arg.integer.value = sleep_state; status = acpi_evaluate_object(NULL, METHOD_PATHNAME__PTS, &arg_list, NULL); if (ACPI_FAILURE(status) && status != AE_NOT_FOUND) { return_ACPI_STATUS(status); } /* Setup the argument to the _SST method (System STatus) */ switch (sleep_state) { case ACPI_STATE_S0: sst_value = ACPI_SST_WORKING; break; case ACPI_STATE_S1: case ACPI_STATE_S2: case ACPI_STATE_S3: sst_value = ACPI_SST_SLEEPING; break; case ACPI_STATE_S4: sst_value = ACPI_SST_SLEEP_CONTEXT; break; default: sst_value = ACPI_SST_INDICATOR_OFF; /* Default is off */ break; } /* * Set the system indicators to show the desired sleep state. * _SST is an optional method (return no error if not found) */ acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, sst_value); return_ACPI_STATUS(AE_OK); }
static int acpi_processor_get_info(struct acpi_device *device) { union acpi_object object = { 0 }; struct acpi_buffer buffer = { sizeof(union acpi_object), &object }; struct acpi_processor *pr = acpi_driver_data(device); int cpu_index, device_declaration = 0; acpi_status status = AE_OK; static int cpu0_initialized; unsigned long long value; acpi_processor_errata(); /* * Check to see if we have bus mastering arbitration control. This * is required for proper C3 usage (to maintain cache coherency). */ if (acpi_gbl_FADT.pm2_control_block && acpi_gbl_FADT.pm2_control_length) { pr->flags.bm_control = 1; ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Bus mastering arbitration control present\n")); } else ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No bus mastering arbitration control\n")); 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)) { dev_err(&device->dev, "Failed to evaluate processor object (0x%x)\n", status); return -ENODEV; } pr->acpi_id = object.processor.proc_id; } else { /* * Declared with "Device" statement; match _UID. * Note that we don't handle string _UIDs yet. */ status = acpi_evaluate_integer(pr->handle, METHOD_NAME__UID, NULL, &value); if (ACPI_FAILURE(status)) { dev_err(&device->dev, "Failed to evaluate processor _UID (0x%x)\n", status); return -ENODEV; } device_declaration = 1; pr->acpi_id = value; } pr->apic_id = acpi_get_apicid(pr->handle, device_declaration, pr->acpi_id); cpu_index = acpi_map_cpuid(pr->apic_id, pr->acpi_id); /* Handle UP system running SMP kernel, with no LAPIC in MADT */ if (!cpu0_initialized && (cpu_index == -1) && (num_online_cpus() == 1)) { cpu_index = 0; } cpu0_initialized = 1; pr->id = cpu_index; /* * Extra Processor objects may be enumerated on MP systems with * less than the max # of CPUs. They should be ignored _iff * they are physically not present. */ if (pr->id == -1) { int ret = acpi_processor_hotadd_init(pr); if (ret) return ret; } /* * On some boxes several processors use the same processor bus id. * But they are located in different scope. For example: * \_SB.SCK0.CPU0 * \_SB.SCK1.CPU0 * Rename the processor device bus id. And the new bus id will be * generated as the following format: * CPU+CPU ID. */ sprintf(acpi_device_bid(device), "CPU%X", pr->id); ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Processor [%d:%d]\n", pr->id, pr->acpi_id)); if (!object.processor.pblk_address) ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No PBLK (NULL address)\n")); else if (object.processor.pblk_length != 6) dev_err(&device->dev, "Invalid PBLK length [%d]\n", object.processor.pblk_length); else { pr->throttling.address = object.processor.pblk_address; pr->throttling.duty_offset = acpi_gbl_FADT.duty_offset; pr->throttling.duty_width = acpi_gbl_FADT.duty_width; pr->pblk = object.processor.pblk_address; /* * We don't care about error returns - we just try to mark * these reserved so that nobody else is confused into thinking * that this region might be unused.. * * (In particular, allocating the IO range for Cardbus) */ request_region(pr->throttling.address, 6, "ACPI CPU throttle"); } /* * If ACPI describes a slot number for this CPU, we can use it to * ensure we get the right value in the "physical id" field * of /proc/cpuinfo */ status = acpi_evaluate_integer(pr->handle, "_SUN", NULL, &value); if (ACPI_SUCCESS(status)) arch_fix_phys_package_id(pr->id, value); return 0; }