break;
        }
 
-       adev = acpi_bus_get_acpi_device(handle);
+       adev = acpi_get_acpi_dev(handle);
        if (!adev)
                goto err;
 
        }
 
        if (!hotplug_event) {
-               acpi_bus_put_acpi_device(adev);
+               acpi_put_acpi_dev(adev);
                return;
        }
 
        if (ACPI_SUCCESS(acpi_hotplug_schedule(adev, type)))
                return;
 
-       acpi_bus_put_acpi_device(adev);
+       acpi_put_acpi_dev(adev);
 
  err:
        acpi_evaluate_ost(handle, type, ost_code, NULL);
 
 
        acpi_handle_debug(handle, "Wake notify\n");
 
-       adev = acpi_bus_get_acpi_device(handle);
+       adev = acpi_get_acpi_dev(handle);
        if (!adev)
                return;
 
 
        mutex_unlock(&acpi_pm_notifier_lock);
 
-       acpi_bus_put_acpi_device(adev);
+       acpi_put_acpi_dev(adev);
 }
 
 /**
 
        if (WARN_ON(ACPI_FAILURE(status)))
                return NULL;
 
-       device = acpi_bus_get_acpi_device(handle);
+       device = acpi_get_acpi_dev(handle);
        if (WARN_ON(!device))
                return NULL;
 
        result = &device->fwnode;
-       acpi_bus_put_acpi_device(device);
+       acpi_put_acpi_dev(device);
        return result;
 }
 
 
        acpi_evaluate_ost(adev->handle, src, ost_code, NULL);
 
  out:
-       acpi_bus_put_acpi_device(adev);
+       acpi_put_acpi_dev(adev);
        mutex_unlock(&acpi_scan_lock);
        unlock_device_hotplug();
 }
        acpi_dev_get(dev);
 }
 
-struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle)
+/**
+ * acpi_get_acpi_dev - Retrieve ACPI device object and reference count it.
+ * @handle: ACPI handle associated with the requested ACPI device object.
+ *
+ * Return a pointer to the ACPI device object associated with @handle and bump
+ * up that object's reference counter (under the ACPI Namespace lock), if
+ * present, or return NULL otherwise.
+ *
+ * The ACPI device object reference acquired by this function needs to be
+ * dropped via acpi_dev_put().
+ */
+struct acpi_device *acpi_get_acpi_dev(acpi_handle handle)
 {
        return handle_to_device(handle, get_acpi_device);
 }
-EXPORT_SYMBOL_GPL(acpi_bus_get_acpi_device);
+EXPORT_SYMBOL_GPL(acpi_get_acpi_dev);
 
 static struct acpi_device_bus_id *acpi_device_bus_id_match(const char *dev_id)
 {
 {
        struct acpi_device *adev;
 
-       adev = acpi_bus_get_acpi_device(dep->consumer);
+       adev = acpi_get_acpi_dev(dep->consumer);
        if (adev) {
                *(struct acpi_device **)data = adev;
                return 1;
 
 static int acpi_scan_clear_dep(struct acpi_dep_data *dep, void *data)
 {
-       struct acpi_device *adev = acpi_bus_get_acpi_device(dep->consumer);
+       struct acpi_device *adev = acpi_get_acpi_dev(dep->consumer);
 
        if (adev) {
                adev->dep_unmet--;
 
                        continue;
 
                /* Create a symlink to domain objects */
-               obj = acpi_bus_get_acpi_device(element->reference.handle);
+               obj = acpi_get_acpi_dev(element->reference.handle);
                resource->domain_devices[i] = obj;
                if (!obj)
                        continue;
 
  * External Functions
  */
 
-struct acpi_device *acpi_fetch_acpi_dev(acpi_handle handle);
 acpi_status acpi_bus_get_status_handle(acpi_handle handle,
                                       unsigned long long *sta);
 int acpi_bus_get_status(struct acpi_device *device);
                put_device(&adev->dev);
 }
 
-struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle);
+struct acpi_device *acpi_fetch_acpi_dev(acpi_handle handle);
+struct acpi_device *acpi_get_acpi_dev(acpi_handle handle);
 
-static inline void acpi_bus_put_acpi_device(struct acpi_device *adev)
+static inline void acpi_put_acpi_dev(struct acpi_device *adev)
 {
        acpi_dev_put(adev);
 }