Commit 5af310a8 authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

Merge tag 'ib-mfd-base-acpi-dma-v4.3' of... 

Merge tag 'ib-mfd-base-acpi-dma-v4.3' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd into acpi-pm

Pull MFD-related material including ACPI device power management
changes (in addition to MFD, driver core and DMA changes) for v4.3
from Lee Jones.

* tag 'ib-mfd-base-acpi-dma-v4.3' of git://git.kernel.org/pub/scm/linux/kernel/git/lee/mfd:
  mfd: Add support for Intel Sunrisepoint LPSS devices
  dmaengine: add a driver for Intel integrated DMA 64-bit
  mfd: make mfd_remove_devices() iterate in reverse order
  driver core: implement device_for_each_child_reverse()
  klist: implement klist_prev()
  Driver core: wakeup the parent device before trying probe
  ACPI / PM: Attach ACPI power domain only once
  PM / QoS: Make it possible to expose device latency tolerance to userspace
parents aa57aca8 4b45efe8

drivers/acpi/device_pm.c

+8 −0
Original line number Diff line number Diff line
@@ -1123,6 +1123,14 @@ int acpi_dev_pm_attach(struct device *dev, bool power_on) 
	if (dev->pm_domain)

		return -EEXIST;



	/*

	 * Only attach the power domain to the first device if the

	 * companion is shared by multiple. This is to prevent doing power

	 * management twice.

	 */

	if (!acpi_device_is_first_physical_node(adev, dev))

		return -EBUSY;



	acpi_add_pm_notifier(adev, dev, acpi_pm_notify_work_func);

	dev->pm_domain = &acpi_general_pm_domain;

	if (power_on) {

drivers/acpi/internal.h

+2 −0
Original line number Diff line number Diff line
@@ -97,6 +97,8 @@ void acpi_device_add_finalize(struct acpi_device *device); 
void acpi_free_pnp_ids(struct acpi_device_pnp *pnp);

bool acpi_device_is_present(struct acpi_device *adev);

bool acpi_device_is_battery(struct acpi_device *adev);

bool acpi_device_is_first_physical_node(struct acpi_device *adev,

					const struct device *dev);



/* --------------------------------------------------------------------------

                                  Power Resource

drivers/acpi/scan.c

+30 −16
Original line number Diff line number Diff line
@@ -226,6 +226,35 @@ static int create_of_modalias(struct acpi_device *acpi_dev, char *modalias, 
	return len;

}



/**

 * acpi_device_is_first_physical_node - Is given dev first physical node

 * @adev: ACPI companion device

 * @dev: Physical device to check

 *

 * Function checks if given @dev is the first physical devices attached to

 * the ACPI companion device. This distinction is needed in some cases

 * where the same companion device is shared between many physical devices.

 *

 * Note that the caller have to provide valid @adev pointer.

 */

bool acpi_device_is_first_physical_node(struct acpi_device *adev,

					const struct device *dev)

{

	bool ret = false;



	mutex_lock(&adev->physical_node_lock);

	if (!list_empty(&adev->physical_node_list)) {

		const struct acpi_device_physical_node *node;



		node = list_first_entry(&adev->physical_node_list,

					struct acpi_device_physical_node, node);

		ret = node->dev == dev;

	}

	mutex_unlock(&adev->physical_node_lock);



	return ret;

}



/*

 * acpi_companion_match() - Can we match via ACPI companion device

 * @dev: Device in question
@@ -250,7 +279,6 @@ static int create_of_modalias(struct acpi_device *acpi_dev, char *modalias, 
static struct acpi_device *acpi_companion_match(const struct device *dev)

{

	struct acpi_device *adev;

	struct mutex *physical_node_lock;



	adev = ACPI_COMPANION(dev);

	if (!adev)
@@ -259,21 +287,7 @@ static struct acpi_device *acpi_companion_match(const struct device *dev) 
	if (list_empty(&adev->pnp.ids))

		return NULL;



	physical_node_lock = &adev->physical_node_lock;

	mutex_lock(physical_node_lock);

	if (list_empty(&adev->physical_node_list)) {

		adev = NULL;

	} else {

		const struct acpi_device_physical_node *node;



		node = list_first_entry(&adev->physical_node_list,

					struct acpi_device_physical_node, node);

		if (node->dev != dev)

			adev = NULL;

	}

	mutex_unlock(physical_node_lock);



	return adev;

	return acpi_device_is_first_physical_node(adev, dev) ? adev : NULL;

}



static int __acpi_device_uevent_modalias(struct acpi_device *adev,

drivers/base/core.c

+43 −0
Original line number Diff line number Diff line
@@ -1252,6 +1252,19 @@ void device_unregister(struct device *dev) 
}

EXPORT_SYMBOL_GPL(device_unregister);



static struct device *prev_device(struct klist_iter *i)

{

	struct klist_node *n = klist_prev(i);

	struct device *dev = NULL;

	struct device_private *p;



	if (n) {

		p = to_device_private_parent(n);

		dev = p->device;

	}

	return dev;

}



static struct device *next_device(struct klist_iter *i)

{

	struct klist_node *n = klist_next(i);
@@ -1340,6 +1353,36 @@ int device_for_each_child(struct device *parent, void *data, 
}

EXPORT_SYMBOL_GPL(device_for_each_child);



/**

 * device_for_each_child_reverse - device child iterator in reversed order.

 * @parent: parent struct device.

 * @fn: function to be called for each device.

 * @data: data for the callback.

 *

 * Iterate over @parent's child devices, and call @fn for each,

 * passing it @data.

 *

 * We check the return of @fn each time. If it returns anything

 * other than 0, we break out and return that value.

 */

int device_for_each_child_reverse(struct device *parent, void *data,

				  int (*fn)(struct device *dev, void *data))

{

	struct klist_iter i;

	struct device *child;

	int error = 0;



	if (!parent->p)

		return 0;



	klist_iter_init(&parent->p->klist_children, &i);

	while ((child = prev_device(&i)) && !error)

		error = fn(child, data);

	klist_iter_exit(&i);

	return error;

}

EXPORT_SYMBOL_GPL(device_for_each_child_reverse);



/**

 * device_find_child - device iterator for locating a particular device.

 * @parent: parent struct device

drivers/base/dd.c

+20 −0
Original line number Diff line number Diff line
@@ -399,6 +399,8 @@ EXPORT_SYMBOL_GPL(wait_for_device_probe); 
 *

 * This function must be called with @dev lock held.  When called for a

 * USB interface, @dev->parent lock must be held as well.

 *

 * If the device has a parent, runtime-resume the parent before driver probing.

 */

int driver_probe_device(struct device_driver *drv, struct device *dev)

{
@@ -410,10 +412,16 @@ int driver_probe_device(struct device_driver *drv, struct device *dev) 
	pr_debug("bus: '%s': %s: matched device %s with driver %s\n",

		 drv->bus->name, __func__, dev_name(dev), drv->name);



	if (dev->parent)

		pm_runtime_get_sync(dev->parent);



	pm_runtime_barrier(dev);

	ret = really_probe(dev, drv);

	pm_request_idle(dev);



	if (dev->parent)

		pm_runtime_put(dev->parent);



	return ret;

}
@@ -507,11 +515,17 @@ static void __device_attach_async_helper(void *_dev, async_cookie_t cookie) 


	device_lock(dev);



	if (dev->parent)

		pm_runtime_get_sync(dev->parent);



	bus_for_each_drv(dev->bus, NULL, &data, __device_attach_driver);

	dev_dbg(dev, "async probe completed\n");



	pm_request_idle(dev);



	if (dev->parent)

		pm_runtime_put(dev->parent);



	device_unlock(dev);



	put_device(dev);
@@ -541,6 +555,9 @@ static int __device_attach(struct device *dev, bool allow_async) 
			.want_async = false,

		};



		if (dev->parent)

			pm_runtime_get_sync(dev->parent);



		ret = bus_for_each_drv(dev->bus, NULL, &data,

					__device_attach_driver);

		if (!ret && allow_async && data.have_async) {
@@ -557,6 +574,9 @@ static int __device_attach(struct device *dev, bool allow_async) 
		} else {

			pm_request_idle(dev);

		}



		if (dev->parent)

			pm_runtime_put(dev->parent);

	}

out_unlock:

	device_unlock(dev);

CRA Git | Maintained and supported by SUSTech CRA and CCSE