Commit 918e162e authored by Rafael J. Wysocki's avatar Rafael J. Wysocki
Browse files

Merge branch 'pm-cpufreq' 

* pm-cpufreq:
  cpufreq: Make cpufreq_generic_init() return void
  cpufreq: imx-cpufreq-dt: Add i.MX8MN support
  cpufreq: Add QoS requests for userspace constraints
  cpufreq: intel_pstate: Reuse refresh_frequency_limits()
  cpufreq: Register notifiers with the PM QoS framework
  PM / QoS: Add support for MIN/MAX frequency constraints
  PM / QOS: Pass request type to dev_pm_qos_read_value()
  PM / QOS: Rename __dev_pm_qos_read_value() and dev_pm_qos_raw_read_value()
  PM / QOS: Pass request type to dev_pm_qos_{add|remove}_notifier()
parents 8da04e05 c4dcc8a1

Documentation/power/pm_qos_interface.txt

+7 −5
Original line number Diff line number Diff line
@@ -123,7 +123,7 @@ Will remove the element. After removal it will update the aggregate target and 
call the notification trees if the target was changed as a result of removing

the request.



s32 dev_pm_qos_read_value(device):

s32 dev_pm_qos_read_value(device, type):

Returns the aggregated value for a given device's constraints list.



enum pm_qos_flags_status dev_pm_qos_flags(device, mask)
@@ -164,12 +164,14 @@ directory. 
Notification mechanisms:

The per-device PM QoS framework has a per-device notification tree.



int dev_pm_qos_add_notifier(device, notifier):

Adds a notification callback function for the device.

int dev_pm_qos_add_notifier(device, notifier, type):

Adds a notification callback function for the device for a particular request

type.



The callback is called when the aggregated value of the device constraints list

is changed (for resume latency device PM QoS only).

is changed.



int dev_pm_qos_remove_notifier(device, notifier):

int dev_pm_qos_remove_notifier(device, notifier, type):

Removes the notification callback function for the device.

drivers/base/power/domain.c

+5 −3
Original line number Diff line number Diff line
@@ -1536,7 +1536,8 @@ static int genpd_add_device(struct generic_pm_domain *genpd, struct device *dev, 
	if (ret)

		genpd_free_dev_data(dev, gpd_data);

	else

		dev_pm_qos_add_notifier(dev, &gpd_data->nb);

		dev_pm_qos_add_notifier(dev, &gpd_data->nb,

					DEV_PM_QOS_RESUME_LATENCY);



	return ret;

}
@@ -1569,7 +1570,8 @@ static int genpd_remove_device(struct generic_pm_domain *genpd, 


	pdd = dev->power.subsys_data->domain_data;

	gpd_data = to_gpd_data(pdd);

	dev_pm_qos_remove_notifier(dev, &gpd_data->nb);

	dev_pm_qos_remove_notifier(dev, &gpd_data->nb,

				   DEV_PM_QOS_RESUME_LATENCY);



	genpd_lock(genpd);
@@ -1597,7 +1599,7 @@ static int genpd_remove_device(struct generic_pm_domain *genpd, 


 out:

	genpd_unlock(genpd);

	dev_pm_qos_add_notifier(dev, &gpd_data->nb);

	dev_pm_qos_add_notifier(dev, &gpd_data->nb, DEV_PM_QOS_RESUME_LATENCY);



	return ret;

}

drivers/base/power/domain_governor.c

+2 −2
Original line number Diff line number Diff line
@@ -33,7 +33,7 @@ static int dev_update_qos_constraint(struct device *dev, void *data) 
		 * take its current PM QoS constraint (that's the only thing

		 * known at this point anyway).

		 */

		constraint_ns = dev_pm_qos_read_value(dev);

		constraint_ns = dev_pm_qos_read_value(dev, DEV_PM_QOS_RESUME_LATENCY);

		constraint_ns *= NSEC_PER_USEC;

	}
@@ -66,7 +66,7 @@ static bool default_suspend_ok(struct device *dev) 
	td->constraint_changed = false;

	td->cached_suspend_ok = false;

	td->effective_constraint_ns = 0;

	constraint_ns = __dev_pm_qos_read_value(dev);

	constraint_ns = __dev_pm_qos_resume_latency(dev);



	spin_unlock_irqrestore(&dev->power.lock, flags);

drivers/base/power/qos.c

+120 −15
Original line number Diff line number Diff line
@@ -90,29 +90,49 @@ enum pm_qos_flags_status dev_pm_qos_flags(struct device *dev, s32 mask) 
EXPORT_SYMBOL_GPL(dev_pm_qos_flags);



/**

 * __dev_pm_qos_read_value - Get PM QoS constraint for a given device.

 * __dev_pm_qos_resume_latency - Get resume latency constraint for a given device.

 * @dev: Device to get the PM QoS constraint value for.

 *

 * This routine must be called with dev->power.lock held.

 */

s32 __dev_pm_qos_read_value(struct device *dev)

s32 __dev_pm_qos_resume_latency(struct device *dev)

{

	lockdep_assert_held(&dev->power.lock);



	return dev_pm_qos_raw_read_value(dev);

	return dev_pm_qos_raw_resume_latency(dev);

}



/**

 * dev_pm_qos_read_value - Get PM QoS constraint for a given device (locked).

 * @dev: Device to get the PM QoS constraint value for.

 * @type: QoS request type.

 */

s32 dev_pm_qos_read_value(struct device *dev)

s32 dev_pm_qos_read_value(struct device *dev, enum dev_pm_qos_req_type type)

{

	struct dev_pm_qos *qos = dev->power.qos;

	unsigned long flags;

	s32 ret;



	spin_lock_irqsave(&dev->power.lock, flags);

	ret = __dev_pm_qos_read_value(dev);



	switch (type) {

	case DEV_PM_QOS_RESUME_LATENCY:

		ret = IS_ERR_OR_NULL(qos) ? PM_QOS_RESUME_LATENCY_NO_CONSTRAINT

			: pm_qos_read_value(&qos->resume_latency);

		break;

	case DEV_PM_QOS_MIN_FREQUENCY:

		ret = IS_ERR_OR_NULL(qos) ? PM_QOS_MIN_FREQUENCY_DEFAULT_VALUE

			: pm_qos_read_value(&qos->min_frequency);

		break;

	case DEV_PM_QOS_MAX_FREQUENCY:

		ret = IS_ERR_OR_NULL(qos) ? PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE

			: pm_qos_read_value(&qos->max_frequency);

		break;

	default:

		WARN_ON(1);

		ret = 0;

	}



	spin_unlock_irqrestore(&dev->power.lock, flags);



	return ret;
@@ -149,6 +169,14 @@ static int apply_constraint(struct dev_pm_qos_request *req, 
			req->dev->power.set_latency_tolerance(req->dev, value);

		}

		break;

	case DEV_PM_QOS_MIN_FREQUENCY:

		ret = pm_qos_update_target(&qos->min_frequency,

					   &req->data.pnode, action, value);

		break;

	case DEV_PM_QOS_MAX_FREQUENCY:

		ret = pm_qos_update_target(&qos->max_frequency,

					   &req->data.pnode, action, value);

		break;

	case DEV_PM_QOS_FLAGS:

		ret = pm_qos_update_flags(&qos->flags, &req->data.flr,

					  action, value);
@@ -177,12 +205,11 @@ static int dev_pm_qos_constraints_allocate(struct device *dev) 
	if (!qos)

		return -ENOMEM;



	n = kzalloc(sizeof(*n), GFP_KERNEL);

	n = kzalloc(3 * sizeof(*n), GFP_KERNEL);

	if (!n) {

		kfree(qos);

		return -ENOMEM;

	}

	BLOCKING_INIT_NOTIFIER_HEAD(n);



	c = &qos->resume_latency;

	plist_head_init(&c->list);
@@ -191,6 +218,7 @@ static int dev_pm_qos_constraints_allocate(struct device *dev) 
	c->no_constraint_value = PM_QOS_RESUME_LATENCY_NO_CONSTRAINT;

	c->type = PM_QOS_MIN;

	c->notifiers = n;

	BLOCKING_INIT_NOTIFIER_HEAD(n);



	c = &qos->latency_tolerance;

	plist_head_init(&c->list);
@@ -199,6 +227,24 @@ static int dev_pm_qos_constraints_allocate(struct device *dev) 
	c->no_constraint_value = PM_QOS_LATENCY_TOLERANCE_NO_CONSTRAINT;

	c->type = PM_QOS_MIN;



	c = &qos->min_frequency;

	plist_head_init(&c->list);

	c->target_value = PM_QOS_MIN_FREQUENCY_DEFAULT_VALUE;

	c->default_value = PM_QOS_MIN_FREQUENCY_DEFAULT_VALUE;

	c->no_constraint_value = PM_QOS_MIN_FREQUENCY_DEFAULT_VALUE;

	c->type = PM_QOS_MAX;

	c->notifiers = ++n;

	BLOCKING_INIT_NOTIFIER_HEAD(n);



	c = &qos->max_frequency;

	plist_head_init(&c->list);

	c->target_value = PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE;

	c->default_value = PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE;

	c->no_constraint_value = PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE;

	c->type = PM_QOS_MIN;

	c->notifiers = ++n;

	BLOCKING_INIT_NOTIFIER_HEAD(n);



	INIT_LIST_HEAD(&qos->flags.list);



	spin_lock_irq(&dev->power.lock);
@@ -252,11 +298,25 @@ void dev_pm_qos_constraints_destroy(struct device *dev) 
		apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);

		memset(req, 0, sizeof(*req));

	}



	c = &qos->latency_tolerance;

	plist_for_each_entry_safe(req, tmp, &c->list, data.pnode) {

		apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);

		memset(req, 0, sizeof(*req));

	}



	c = &qos->min_frequency;

	plist_for_each_entry_safe(req, tmp, &c->list, data.pnode) {

		apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_MIN_FREQUENCY_DEFAULT_VALUE);

		memset(req, 0, sizeof(*req));

	}



	c = &qos->max_frequency;

	plist_for_each_entry_safe(req, tmp, &c->list, data.pnode) {

		apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_MAX_FREQUENCY_DEFAULT_VALUE);

		memset(req, 0, sizeof(*req));

	}



	f = &qos->flags;

	list_for_each_entry_safe(req, tmp, &f->list, data.flr.node) {

		apply_constraint(req, PM_QOS_REMOVE_REQ, PM_QOS_DEFAULT_VALUE);
@@ -368,6 +428,8 @@ static int __dev_pm_qos_update_request(struct dev_pm_qos_request *req, 
	switch(req->type) {

	case DEV_PM_QOS_RESUME_LATENCY:

	case DEV_PM_QOS_LATENCY_TOLERANCE:

	case DEV_PM_QOS_MIN_FREQUENCY:

	case DEV_PM_QOS_MAX_FREQUENCY:

		curr_value = req->data.pnode.prio;

		break;

	case DEV_PM_QOS_FLAGS:
@@ -467,6 +529,7 @@ EXPORT_SYMBOL_GPL(dev_pm_qos_remove_request); 
 *

 * @dev: target device for the constraint

 * @notifier: notifier block managed by caller.

 * @type: request type.

 *

 * Will register the notifier into a notification chain that gets called

 * upon changes to the target value for the device.
@@ -474,7 +537,8 @@ EXPORT_SYMBOL_GPL(dev_pm_qos_remove_request); 
 * If the device's constraints object doesn't exist when this routine is called,

 * it will be created (or error code will be returned if that fails).

 */

int dev_pm_qos_add_notifier(struct device *dev, struct notifier_block *notifier)

int dev_pm_qos_add_notifier(struct device *dev, struct notifier_block *notifier,

			    enum dev_pm_qos_req_type type)

{

	int ret = 0;
@@ -485,10 +549,28 @@ int dev_pm_qos_add_notifier(struct device *dev, struct notifier_block *notifier) 
	else if (!dev->power.qos)

		ret = dev_pm_qos_constraints_allocate(dev);



	if (!ret)

	if (ret)

		goto unlock;



	switch (type) {

	case DEV_PM_QOS_RESUME_LATENCY:

		ret = blocking_notifier_chain_register(dev->power.qos->resume_latency.notifiers,

						       notifier);

		break;

	case DEV_PM_QOS_MIN_FREQUENCY:

		ret = blocking_notifier_chain_register(dev->power.qos->min_frequency.notifiers,

						       notifier);

		break;

	case DEV_PM_QOS_MAX_FREQUENCY:

		ret = blocking_notifier_chain_register(dev->power.qos->max_frequency.notifiers,

						       notifier);

		break;

	default:

		WARN_ON(1);

		ret = -EINVAL;

	}



unlock:

	mutex_unlock(&dev_pm_qos_mtx);

	return ret;

}
@@ -500,24 +582,44 @@ EXPORT_SYMBOL_GPL(dev_pm_qos_add_notifier); 
 *

 * @dev: target device for the constraint

 * @notifier: notifier block to be removed.

 * @type: request type.

 *

 * Will remove the notifier from the notification chain that gets called

 * upon changes to the target value.

 */

int dev_pm_qos_remove_notifier(struct device *dev,

			       struct notifier_block *notifier)

			       struct notifier_block *notifier,

			       enum dev_pm_qos_req_type type)

{

	int retval = 0;

	int ret = 0;



	mutex_lock(&dev_pm_qos_mtx);



	/* Silently return if the constraints object is not present. */

	if (!IS_ERR_OR_NULL(dev->power.qos))

		retval = blocking_notifier_chain_unregister(dev->power.qos->resume_latency.notifiers,

	if (IS_ERR_OR_NULL(dev->power.qos))

		goto unlock;



	switch (type) {

	case DEV_PM_QOS_RESUME_LATENCY:

		ret = blocking_notifier_chain_unregister(dev->power.qos->resume_latency.notifiers,

							 notifier);

		break;

	case DEV_PM_QOS_MIN_FREQUENCY:

		ret = blocking_notifier_chain_unregister(dev->power.qos->min_frequency.notifiers,

							 notifier);

		break;

	case DEV_PM_QOS_MAX_FREQUENCY:

		ret = blocking_notifier_chain_unregister(dev->power.qos->max_frequency.notifiers,

							 notifier);

		break;

	default:

		WARN_ON(1);

		ret = -EINVAL;

	}



unlock:

	mutex_unlock(&dev_pm_qos_mtx);

	return retval;

	return ret;

}

EXPORT_SYMBOL_GPL(dev_pm_qos_remove_notifier);
@@ -577,6 +679,9 @@ static void __dev_pm_qos_drop_user_request(struct device *dev, 
		req = dev->power.qos->flags_req;

		dev->power.qos->flags_req = NULL;

		break;

	default:

		WARN_ON(1);

		return;

	}

	__dev_pm_qos_remove_request(req);

	kfree(req);

drivers/base/power/runtime.c

+1 −1
Original line number Diff line number Diff line
@@ -275,7 +275,7 @@ static int rpm_check_suspend_allowed(struct device *dev) 
	    || (dev->power.request_pending

			&& dev->power.request == RPM_REQ_RESUME))

		retval = -EAGAIN;

	else if (__dev_pm_qos_read_value(dev) == 0)

	else if (__dev_pm_qos_resume_latency(dev) == 0)

		retval = -EPERM;

	else if (dev->power.runtime_status == RPM_SUSPENDED)

		retval = 1;

CRA Git | Maintained and supported by SUSTech CRA and CCSE