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;
91 struct acpi_power_resource *resource = acpi_power_get_context(handle);
94 if (!resource || !list)
101 entry->resource = resource;
106 if (e->resource->order > resource->order) {
162 /* Some ACPI tables contain duplicate power resource references */
218 struct acpi_power_resource *resource = entry->resource;
219 acpi_handle handle = resource->device.handle;
222 mutex_lock(&resource->resource_lock);
224 mutex_unlock(&resource->resource_lock);
240 acpi_power_resource_add_dependent(struct acpi_power_resource *resource,
246 mutex_lock(&resource->resource_lock);
247 list_for_each_entry(dep, &resource->dependents, node) {
260 list_add_tail(&dep->node, &resource->dependents);
261 dev_dbg(dev, "added power dependency to [%s]\n", resource->name);
264 mutex_unlock(&resource->resource_lock);
269 acpi_power_resource_remove_dependent(struct acpi_power_resource *resource,
274 mutex_lock(&resource->resource_lock);
275 list_for_each_entry(dep, &resource->dependents, node) {
280 resource->name);
284 mutex_unlock(&resource->resource_lock);
314 ret = acpi_power_resource_add_dependent(entry->resource, dev);
323 acpi_power_resource_remove_dependent(entry->resource, dev);
348 acpi_power_resource_remove_dependent(entry->resource, dev);
351 static int __acpi_power_on(struct acpi_power_resource *resource)
356 status = acpi_evaluate_object(resource->device.handle, "_ON", NULL, NULL);
360 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned on\n",
361 resource->name));
364 * If there are other dependents on this power resource we need to
368 if (list_empty(&resource->dependents) ||
369 list_is_singular(&resource->dependents))
372 list_for_each_entry(dep, &resource->dependents, node) {
374 resource->name);
381 static int acpi_power_on_unlocked(struct acpi_power_resource *resource)
385 if (resource->ref_count++) {
387 "Power resource [%s] already on\n",
388 resource->name));
390 result = __acpi_power_on(resource);
392 resource->ref_count--;
397 static int acpi_power_on(struct acpi_power_resource *resource)
401 mutex_lock(&resource->resource_lock);
402 result = acpi_power_on_unlocked(resource);
403 mutex_unlock(&resource->resource_lock);
407 static int __acpi_power_off(struct acpi_power_resource *resource)
411 status = acpi_evaluate_object(resource->device.handle, "_OFF",
416 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Power resource [%s] turned off\n",
417 resource->name));
421 static int acpi_power_off_unlocked(struct acpi_power_resource *resource)
425 if (!resource->ref_count) {
427 "Power resource [%s] already off\n",
428 resource->name));
432 if (--resource->ref_count) {
434 "Power resource [%s] still in use\n",
435 resource->name));
437 result = __acpi_power_off(resource);
439 resource->ref_count++;
444 static int acpi_power_off(struct acpi_power_resource *resource)
448 mutex_lock(&resource->resource_lock);
449 result = acpi_power_off_unlocked(resource);
450 mutex_unlock(&resource->resource_lock);
460 result = acpi_power_off(entry->resource);
468 acpi_power_on(entry->resource);
479 result = acpi_power_on(entry->resource);
487 acpi_power_off(entry->resource);
530 struct acpi_device *res_dev = &entry->resource->device;
554 struct acpi_device *res_dev = &entry->resource->device;
601 struct acpi_power_resource *resource = entry->resource;
602 acpi_handle handle = resource->device.handle;
606 mutex_lock(&resource->resource_lock);
610 mutex_unlock(&resource->resource_lock);
614 resource->ref_count++;
615 resource->wakeup_enabled = true;
617 if (system_level > resource->system_level)
618 system_level = resource->system_level;
620 mutex_unlock(&resource->resource_lock);
711 struct acpi_power_resource *resource = entry->resource;
713 mutex_lock(&resource->resource_lock);
715 if (!resource->wakeup_enabled) {
716 err = acpi_power_on_unlocked(resource);
718 resource->wakeup_enabled = true;
721 mutex_unlock(&resource->resource_lock);
774 struct acpi_power_resource *resource = entry->resource;
776 mutex_lock(&resource->resource_lock);
778 if (resource->wakeup_enabled) {
779 err = acpi_power_off_unlocked(resource);
781 resource->wakeup_enabled = false;
784 mutex_unlock(&resource->resource_lock);
877 struct acpi_power_resource *resource;
879 resource = container_of(device, struct acpi_power_resource, device);
882 list_del(&resource->list_node);
886 kfree(resource);
893 struct acpi_power_resource *resource;
895 resource = to_power_resource(to_acpi_device(dev));
896 return sprintf(buf, "%u\n", !!resource->ref_count);
905 static void acpi_power_add_resource_to_list(struct acpi_power_resource *resource)
913 if (r->order > resource->order) {
914 list_add_tail(&resource->list_node, &r->list_node);
918 list_add_tail(&resource->list_node, &acpi_power_resource_list);
926 struct acpi_power_resource *resource;
937 resource = kzalloc(sizeof(*resource), GFP_KERNEL);
938 if (!resource)
941 device = &resource->device;
944 mutex_init(&resource->resource_lock);
945 INIT_LIST_HEAD(&resource->list_node);
946 INIT_LIST_HEAD(&resource->dependents);
947 resource->name = device->pnp.bus_id;
952 /* Evalute the object to get the system level and resource order. */
957 resource->system_level = acpi_object.power_resource.system_level;
958 resource->order = acpi_object.power_resource.resource_order;
975 acpi_power_add_resource_to_list(resource);
987 struct acpi_power_resource *resource;
991 list_for_each_entry(resource, &acpi_power_resource_list, list_node) {
994 mutex_lock(&resource->resource_lock);
996 result = acpi_power_get_state(resource->device.handle, &state);
998 mutex_unlock(&resource->resource_lock);
1003 && resource->ref_count) {
1004 dev_info(&resource->device.dev, "Turning ON\n");
1005 __acpi_power_on(resource);
1008 mutex_unlock(&resource->resource_lock);
1016 struct acpi_power_resource *resource;
1020 list_for_each_entry_reverse(resource, &acpi_power_resource_list, list_node) {
1023 mutex_lock(&resource->resource_lock);
1025 result = acpi_power_get_state(resource->device.handle, &state);
1027 mutex_unlock(&resource->resource_lock);
1032 && !resource->ref_count) {
1033 dev_info(&resource->device.dev, "Turning OFF\n");
1034 __acpi_power_off(resource);
1037 mutex_unlock(&resource->resource_lock);