Lines Matching refs:resource
17 * An ACPI "power resource object" represents a software controllable power
18 * plane, clock plane, or other resource depended on by a device.
20 * A device may rely on multiple power resources, and a power resource
62 struct acpi_power_resource *resource;
96 struct acpi_power_resource *resource = acpi_power_get_context(handle);
99 if (!resource || !list)
106 entry->resource = resource;
111 if (e->resource->order > resource->order) {
168 /* Some ACPI tables contain duplicate power resource references */
199 acpi_handle_debug(handle, "Power resource is %s\n",
206 static int acpi_power_get_state(struct acpi_power_resource *resource, u8 *state)
208 if (resource->state == ACPI_POWER_RESOURCE_STATE_UNKNOWN) {
211 ret = __get_state(resource->device.handle, &resource->state);
216 *state = resource->state;
230 struct acpi_power_resource *resource = entry->resource;
233 mutex_lock(&resource->resource_lock);
234 result = acpi_power_get_state(resource, &cur_state);
235 mutex_unlock(&resource->resource_lock);
243 pr_debug("Power resource list is %s\n", cur_state ? "on" : "off");
250 acpi_power_resource_add_dependent(struct acpi_power_resource *resource,
256 mutex_lock(&resource->resource_lock);
257 list_for_each_entry(dep, &resource->dependents, node) {
270 list_add_tail(&dep->node, &resource->dependents);
272 resource_dev_name(resource));
275 mutex_unlock(&resource->resource_lock);
280 acpi_power_resource_remove_dependent(struct acpi_power_resource *resource,
285 mutex_lock(&resource->resource_lock);
286 list_for_each_entry(dep, &resource->dependents, node) {
291 resource_dev_name(resource));
295 mutex_unlock(&resource->resource_lock);
325 ret = acpi_power_resource_add_dependent(entry->resource, dev);
334 acpi_power_resource_remove_dependent(entry->resource, dev);
359 acpi_power_resource_remove_dependent(entry->resource, dev);
362 static int __acpi_power_on(struct acpi_power_resource *resource)
364 acpi_handle handle = resource->device.handle;
370 resource->state = ACPI_POWER_RESOURCE_STATE_UNKNOWN;
374 resource->state = ACPI_POWER_RESOURCE_STATE_ON;
376 acpi_handle_debug(handle, "Power resource turned on\n");
379 * If there are other dependents on this power resource we need to
383 if (list_empty(&resource->dependents) ||
384 list_is_singular(&resource->dependents))
387 list_for_each_entry(dep, &resource->dependents, node) {
389 resource_dev_name(resource));
396 static int acpi_power_on_unlocked(struct acpi_power_resource *resource)
400 if (resource->ref_count++) {
401 acpi_handle_debug(resource->device.handle,
402 "Power resource already on\n");
404 result = __acpi_power_on(resource);
406 resource->ref_count--;
411 static int acpi_power_on(struct acpi_power_resource *resource)
415 mutex_lock(&resource->resource_lock);
416 result = acpi_power_on_unlocked(resource);
417 mutex_unlock(&resource->resource_lock);
421 static int __acpi_power_off(struct acpi_power_resource *resource)
423 acpi_handle handle = resource->device.handle;
428 resource->state = ACPI_POWER_RESOURCE_STATE_UNKNOWN;
432 resource->state = ACPI_POWER_RESOURCE_STATE_OFF;
434 acpi_handle_debug(handle, "Power resource turned off\n");
439 static int acpi_power_off_unlocked(struct acpi_power_resource *resource)
443 if (!resource->ref_count) {
444 acpi_handle_debug(resource->device.handle,
445 "Power resource already off\n");
449 if (--resource->ref_count) {
450 acpi_handle_debug(resource->device.handle,
451 "Power resource still in use\n");
453 result = __acpi_power_off(resource);
455 resource->ref_count++;
460 static int acpi_power_off(struct acpi_power_resource *resource)
464 mutex_lock(&resource->resource_lock);
465 result = acpi_power_off_unlocked(resource);
466 mutex_unlock(&resource->resource_lock);
476 result = acpi_power_off(entry->resource);
484 acpi_power_on(entry->resource);
495 result = acpi_power_on(entry->resource);
503 acpi_power_off(entry->resource);
546 struct acpi_device *res_dev = &entry->resource->device;
570 struct acpi_device *res_dev = &entry->resource->device;
617 struct acpi_power_resource *resource = entry->resource;
620 mutex_lock(&resource->resource_lock);
623 * Make sure that the power resource state and its reference
626 if (!resource->ref_count &&
627 !acpi_power_get_state(resource, &state) &&
629 __acpi_power_off(resource);
631 if (system_level > resource->system_level)
632 system_level = resource->system_level;
634 mutex_unlock(&resource->resource_lock);
788 ret = acpi_power_off(entry->resource);
883 struct acpi_power_resource *resource;
885 resource = container_of(device, struct acpi_power_resource, device);
888 list_del(&resource->list_node);
892 kfree(resource);
899 struct acpi_power_resource *resource;
901 resource = to_power_resource(to_acpi_device(dev));
902 return sprintf(buf, "%u\n", !!resource->ref_count);
911 static void acpi_power_add_resource_to_list(struct acpi_power_resource *resource)
919 if (r->order > resource->order) {
920 list_add_tail(&resource->list_node, &r->list_node);
924 list_add_tail(&resource->list_node, &acpi_power_resource_list);
933 struct acpi_power_resource *resource;
943 resource = kzalloc(sizeof(*resource), GFP_KERNEL);
944 if (!resource)
947 device = &resource->device;
950 mutex_init(&resource->resource_lock);
951 INIT_LIST_HEAD(&resource->list_node);
952 INIT_LIST_HEAD(&resource->dependents);
958 /* Evaluate the object to get the system level and resource order. */
963 resource->system_level = acpi_object.power_resource.system_level;
964 resource->order = acpi_object.power_resource.resource_order;
965 resource->state = ACPI_POWER_RESOURCE_STATE_UNKNOWN;
968 if (acpi_power_get_state(resource, &state_dummy))
969 __acpi_power_on(resource);
971 acpi_handle_info(handle, "New power resource\n");
984 acpi_power_add_resource_to_list(resource);
996 struct acpi_power_resource *resource;
1000 list_for_each_entry(resource, &acpi_power_resource_list, list_node) {
1004 mutex_lock(&resource->resource_lock);
1006 resource->state = ACPI_POWER_RESOURCE_STATE_UNKNOWN;
1007 result = acpi_power_get_state(resource, &state);
1009 mutex_unlock(&resource->resource_lock);
1014 && resource->ref_count) {
1015 acpi_handle_debug(resource->device.handle, "Turning ON\n");
1016 __acpi_power_on(resource);
1019 mutex_unlock(&resource->resource_lock);
1029 * The Toshiba Click Mini has a CPR3 power-resource which must
1046 struct acpi_power_resource *resource;
1053 list_for_each_entry_reverse(resource, &acpi_power_resource_list, list_node) {
1054 mutex_lock(&resource->resource_lock);
1056 if (!resource->ref_count &&
1057 resource->state == ACPI_POWER_RESOURCE_STATE_ON) {
1058 acpi_handle_debug(resource->device.handle, "Turning OFF\n");
1059 __acpi_power_off(resource);
1062 mutex_unlock(&resource->resource_lock);