xref: /openbmc/linux/kernel/power/qos.c (revision 05bcf503)
1 /*
2  * This module exposes the interface to kernel space for specifying
3  * QoS dependencies.  It provides infrastructure for registration of:
4  *
5  * Dependents on a QoS value : register requests
6  * Watchers of QoS value : get notified when target QoS value changes
7  *
8  * This QoS design is best effort based.  Dependents register their QoS needs.
9  * Watchers register to keep track of the current QoS needs of the system.
10  *
11  * There are 3 basic classes of QoS parameter: latency, timeout, throughput
12  * each have defined units:
13  * latency: usec
14  * timeout: usec <-- currently not used.
15  * throughput: kbs (kilo byte / sec)
16  *
17  * There are lists of pm_qos_objects each one wrapping requests, notifiers
18  *
19  * User mode requests on a QOS parameter register themselves to the
20  * subsystem by opening the device node /dev/... and writing there request to
21  * the node.  As long as the process holds a file handle open to the node the
22  * client continues to be accounted for.  Upon file release the usermode
23  * request is removed and a new qos target is computed.  This way when the
24  * request that the application has is cleaned up when closes the file
25  * pointer or exits the pm_qos_object will get an opportunity to clean up.
26  *
27  * Mark Gross <mgross@linux.intel.com>
28  */
29 
30 /*#define DEBUG*/
31 
32 #include <linux/pm_qos.h>
33 #include <linux/sched.h>
34 #include <linux/spinlock.h>
35 #include <linux/slab.h>
36 #include <linux/time.h>
37 #include <linux/fs.h>
38 #include <linux/device.h>
39 #include <linux/miscdevice.h>
40 #include <linux/string.h>
41 #include <linux/platform_device.h>
42 #include <linux/init.h>
43 #include <linux/kernel.h>
44 
45 #include <linux/uaccess.h>
46 #include <linux/export.h>
47 
48 /*
49  * locking rule: all changes to constraints or notifiers lists
50  * or pm_qos_object list and pm_qos_objects need to happen with pm_qos_lock
51  * held, taken with _irqsave.  One lock to rule them all
52  */
53 struct pm_qos_object {
54 	struct pm_qos_constraints *constraints;
55 	struct miscdevice pm_qos_power_miscdev;
56 	char *name;
57 };
58 
59 static DEFINE_SPINLOCK(pm_qos_lock);
60 
61 static struct pm_qos_object null_pm_qos;
62 
63 static BLOCKING_NOTIFIER_HEAD(cpu_dma_lat_notifier);
64 static struct pm_qos_constraints cpu_dma_constraints = {
65 	.list = PLIST_HEAD_INIT(cpu_dma_constraints.list),
66 	.target_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE,
67 	.default_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE,
68 	.type = PM_QOS_MIN,
69 	.notifiers = &cpu_dma_lat_notifier,
70 };
71 static struct pm_qos_object cpu_dma_pm_qos = {
72 	.constraints = &cpu_dma_constraints,
73 	.name = "cpu_dma_latency",
74 };
75 
76 static BLOCKING_NOTIFIER_HEAD(network_lat_notifier);
77 static struct pm_qos_constraints network_lat_constraints = {
78 	.list = PLIST_HEAD_INIT(network_lat_constraints.list),
79 	.target_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE,
80 	.default_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE,
81 	.type = PM_QOS_MIN,
82 	.notifiers = &network_lat_notifier,
83 };
84 static struct pm_qos_object network_lat_pm_qos = {
85 	.constraints = &network_lat_constraints,
86 	.name = "network_latency",
87 };
88 
89 
90 static BLOCKING_NOTIFIER_HEAD(network_throughput_notifier);
91 static struct pm_qos_constraints network_tput_constraints = {
92 	.list = PLIST_HEAD_INIT(network_tput_constraints.list),
93 	.target_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE,
94 	.default_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE,
95 	.type = PM_QOS_MAX,
96 	.notifiers = &network_throughput_notifier,
97 };
98 static struct pm_qos_object network_throughput_pm_qos = {
99 	.constraints = &network_tput_constraints,
100 	.name = "network_throughput",
101 };
102 
103 
104 static struct pm_qos_object *pm_qos_array[] = {
105 	&null_pm_qos,
106 	&cpu_dma_pm_qos,
107 	&network_lat_pm_qos,
108 	&network_throughput_pm_qos
109 };
110 
111 static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf,
112 		size_t count, loff_t *f_pos);
113 static ssize_t pm_qos_power_read(struct file *filp, char __user *buf,
114 		size_t count, loff_t *f_pos);
115 static int pm_qos_power_open(struct inode *inode, struct file *filp);
116 static int pm_qos_power_release(struct inode *inode, struct file *filp);
117 
118 static const struct file_operations pm_qos_power_fops = {
119 	.write = pm_qos_power_write,
120 	.read = pm_qos_power_read,
121 	.open = pm_qos_power_open,
122 	.release = pm_qos_power_release,
123 	.llseek = noop_llseek,
124 };
125 
126 /* unlocked internal variant */
127 static inline int pm_qos_get_value(struct pm_qos_constraints *c)
128 {
129 	if (plist_head_empty(&c->list))
130 		return c->default_value;
131 
132 	switch (c->type) {
133 	case PM_QOS_MIN:
134 		return plist_first(&c->list)->prio;
135 
136 	case PM_QOS_MAX:
137 		return plist_last(&c->list)->prio;
138 
139 	default:
140 		/* runtime check for not using enum */
141 		BUG();
142 		return PM_QOS_DEFAULT_VALUE;
143 	}
144 }
145 
146 s32 pm_qos_read_value(struct pm_qos_constraints *c)
147 {
148 	return c->target_value;
149 }
150 
151 static inline void pm_qos_set_value(struct pm_qos_constraints *c, s32 value)
152 {
153 	c->target_value = value;
154 }
155 
156 /**
157  * pm_qos_update_target - manages the constraints list and calls the notifiers
158  *  if needed
159  * @c: constraints data struct
160  * @node: request to add to the list, to update or to remove
161  * @action: action to take on the constraints list
162  * @value: value of the request to add or update
163  *
164  * This function returns 1 if the aggregated constraint value has changed, 0
165  *  otherwise.
166  */
167 int pm_qos_update_target(struct pm_qos_constraints *c, struct plist_node *node,
168 			 enum pm_qos_req_action action, int value)
169 {
170 	unsigned long flags;
171 	int prev_value, curr_value, new_value;
172 
173 	spin_lock_irqsave(&pm_qos_lock, flags);
174 	prev_value = pm_qos_get_value(c);
175 	if (value == PM_QOS_DEFAULT_VALUE)
176 		new_value = c->default_value;
177 	else
178 		new_value = value;
179 
180 	switch (action) {
181 	case PM_QOS_REMOVE_REQ:
182 		plist_del(node, &c->list);
183 		break;
184 	case PM_QOS_UPDATE_REQ:
185 		/*
186 		 * to change the list, we atomically remove, reinit
187 		 * with new value and add, then see if the extremal
188 		 * changed
189 		 */
190 		plist_del(node, &c->list);
191 	case PM_QOS_ADD_REQ:
192 		plist_node_init(node, new_value);
193 		plist_add(node, &c->list);
194 		break;
195 	default:
196 		/* no action */
197 		;
198 	}
199 
200 	curr_value = pm_qos_get_value(c);
201 	pm_qos_set_value(c, curr_value);
202 
203 	spin_unlock_irqrestore(&pm_qos_lock, flags);
204 
205 	if (prev_value != curr_value) {
206 		blocking_notifier_call_chain(c->notifiers,
207 					     (unsigned long)curr_value,
208 					     NULL);
209 		return 1;
210 	} else {
211 		return 0;
212 	}
213 }
214 
215 /**
216  * pm_qos_request - returns current system wide qos expectation
217  * @pm_qos_class: identification of which qos value is requested
218  *
219  * This function returns the current target value.
220  */
221 int pm_qos_request(int pm_qos_class)
222 {
223 	return pm_qos_read_value(pm_qos_array[pm_qos_class]->constraints);
224 }
225 EXPORT_SYMBOL_GPL(pm_qos_request);
226 
227 int pm_qos_request_active(struct pm_qos_request *req)
228 {
229 	return req->pm_qos_class != 0;
230 }
231 EXPORT_SYMBOL_GPL(pm_qos_request_active);
232 
233 /**
234  * pm_qos_work_fn - the timeout handler of pm_qos_update_request_timeout
235  * @work: work struct for the delayed work (timeout)
236  *
237  * This cancels the timeout request by falling back to the default at timeout.
238  */
239 static void pm_qos_work_fn(struct work_struct *work)
240 {
241 	struct pm_qos_request *req = container_of(to_delayed_work(work),
242 						  struct pm_qos_request,
243 						  work);
244 
245 	pm_qos_update_request(req, PM_QOS_DEFAULT_VALUE);
246 }
247 
248 /**
249  * pm_qos_add_request - inserts new qos request into the list
250  * @req: pointer to a preallocated handle
251  * @pm_qos_class: identifies which list of qos request to use
252  * @value: defines the qos request
253  *
254  * This function inserts a new entry in the pm_qos_class list of requested qos
255  * performance characteristics.  It recomputes the aggregate QoS expectations
256  * for the pm_qos_class of parameters and initializes the pm_qos_request
257  * handle.  Caller needs to save this handle for later use in updates and
258  * removal.
259  */
260 
261 void pm_qos_add_request(struct pm_qos_request *req,
262 			int pm_qos_class, s32 value)
263 {
264 	if (!req) /*guard against callers passing in null */
265 		return;
266 
267 	if (pm_qos_request_active(req)) {
268 		WARN(1, KERN_ERR "pm_qos_add_request() called for already added request\n");
269 		return;
270 	}
271 	req->pm_qos_class = pm_qos_class;
272 	INIT_DELAYED_WORK(&req->work, pm_qos_work_fn);
273 	pm_qos_update_target(pm_qos_array[pm_qos_class]->constraints,
274 			     &req->node, PM_QOS_ADD_REQ, value);
275 }
276 EXPORT_SYMBOL_GPL(pm_qos_add_request);
277 
278 /**
279  * pm_qos_update_request - modifies an existing qos request
280  * @req : handle to list element holding a pm_qos request to use
281  * @value: defines the qos request
282  *
283  * Updates an existing qos request for the pm_qos_class of parameters along
284  * with updating the target pm_qos_class value.
285  *
286  * Attempts are made to make this code callable on hot code paths.
287  */
288 void pm_qos_update_request(struct pm_qos_request *req,
289 			   s32 new_value)
290 {
291 	if (!req) /*guard against callers passing in null */
292 		return;
293 
294 	if (!pm_qos_request_active(req)) {
295 		WARN(1, KERN_ERR "pm_qos_update_request() called for unknown object\n");
296 		return;
297 	}
298 
299 	if (delayed_work_pending(&req->work))
300 		cancel_delayed_work_sync(&req->work);
301 
302 	if (new_value != req->node.prio)
303 		pm_qos_update_target(
304 			pm_qos_array[req->pm_qos_class]->constraints,
305 			&req->node, PM_QOS_UPDATE_REQ, new_value);
306 }
307 EXPORT_SYMBOL_GPL(pm_qos_update_request);
308 
309 /**
310  * pm_qos_update_request_timeout - modifies an existing qos request temporarily.
311  * @req : handle to list element holding a pm_qos request to use
312  * @new_value: defines the temporal qos request
313  * @timeout_us: the effective duration of this qos request in usecs.
314  *
315  * After timeout_us, this qos request is cancelled automatically.
316  */
317 void pm_qos_update_request_timeout(struct pm_qos_request *req, s32 new_value,
318 				   unsigned long timeout_us)
319 {
320 	if (!req)
321 		return;
322 	if (WARN(!pm_qos_request_active(req),
323 		 "%s called for unknown object.", __func__))
324 		return;
325 
326 	if (delayed_work_pending(&req->work))
327 		cancel_delayed_work_sync(&req->work);
328 
329 	if (new_value != req->node.prio)
330 		pm_qos_update_target(
331 			pm_qos_array[req->pm_qos_class]->constraints,
332 			&req->node, PM_QOS_UPDATE_REQ, new_value);
333 
334 	schedule_delayed_work(&req->work, usecs_to_jiffies(timeout_us));
335 }
336 
337 /**
338  * pm_qos_remove_request - modifies an existing qos request
339  * @req: handle to request list element
340  *
341  * Will remove pm qos request from the list of constraints and
342  * recompute the current target value for the pm_qos_class.  Call this
343  * on slow code paths.
344  */
345 void pm_qos_remove_request(struct pm_qos_request *req)
346 {
347 	if (!req) /*guard against callers passing in null */
348 		return;
349 		/* silent return to keep pcm code cleaner */
350 
351 	if (!pm_qos_request_active(req)) {
352 		WARN(1, KERN_ERR "pm_qos_remove_request() called for unknown object\n");
353 		return;
354 	}
355 
356 	if (delayed_work_pending(&req->work))
357 		cancel_delayed_work_sync(&req->work);
358 
359 	pm_qos_update_target(pm_qos_array[req->pm_qos_class]->constraints,
360 			     &req->node, PM_QOS_REMOVE_REQ,
361 			     PM_QOS_DEFAULT_VALUE);
362 	memset(req, 0, sizeof(*req));
363 }
364 EXPORT_SYMBOL_GPL(pm_qos_remove_request);
365 
366 /**
367  * pm_qos_add_notifier - sets notification entry for changes to target value
368  * @pm_qos_class: identifies which qos target changes should be notified.
369  * @notifier: notifier block managed by caller.
370  *
371  * will register the notifier into a notification chain that gets called
372  * upon changes to the pm_qos_class target value.
373  */
374 int pm_qos_add_notifier(int pm_qos_class, struct notifier_block *notifier)
375 {
376 	int retval;
377 
378 	retval = blocking_notifier_chain_register(
379 			pm_qos_array[pm_qos_class]->constraints->notifiers,
380 			notifier);
381 
382 	return retval;
383 }
384 EXPORT_SYMBOL_GPL(pm_qos_add_notifier);
385 
386 /**
387  * pm_qos_remove_notifier - deletes notification entry from chain.
388  * @pm_qos_class: identifies which qos target changes are notified.
389  * @notifier: notifier block to be removed.
390  *
391  * will remove the notifier from the notification chain that gets called
392  * upon changes to the pm_qos_class target value.
393  */
394 int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier)
395 {
396 	int retval;
397 
398 	retval = blocking_notifier_chain_unregister(
399 			pm_qos_array[pm_qos_class]->constraints->notifiers,
400 			notifier);
401 
402 	return retval;
403 }
404 EXPORT_SYMBOL_GPL(pm_qos_remove_notifier);
405 
406 /* User space interface to PM QoS classes via misc devices */
407 static int register_pm_qos_misc(struct pm_qos_object *qos)
408 {
409 	qos->pm_qos_power_miscdev.minor = MISC_DYNAMIC_MINOR;
410 	qos->pm_qos_power_miscdev.name = qos->name;
411 	qos->pm_qos_power_miscdev.fops = &pm_qos_power_fops;
412 
413 	return misc_register(&qos->pm_qos_power_miscdev);
414 }
415 
416 static int find_pm_qos_object_by_minor(int minor)
417 {
418 	int pm_qos_class;
419 
420 	for (pm_qos_class = 0;
421 		pm_qos_class < PM_QOS_NUM_CLASSES; pm_qos_class++) {
422 		if (minor ==
423 			pm_qos_array[pm_qos_class]->pm_qos_power_miscdev.minor)
424 			return pm_qos_class;
425 	}
426 	return -1;
427 }
428 
429 static int pm_qos_power_open(struct inode *inode, struct file *filp)
430 {
431 	long pm_qos_class;
432 
433 	pm_qos_class = find_pm_qos_object_by_minor(iminor(inode));
434 	if (pm_qos_class >= 0) {
435 		struct pm_qos_request *req = kzalloc(sizeof(*req), GFP_KERNEL);
436 		if (!req)
437 			return -ENOMEM;
438 
439 		pm_qos_add_request(req, pm_qos_class, PM_QOS_DEFAULT_VALUE);
440 		filp->private_data = req;
441 
442 		return 0;
443 	}
444 	return -EPERM;
445 }
446 
447 static int pm_qos_power_release(struct inode *inode, struct file *filp)
448 {
449 	struct pm_qos_request *req;
450 
451 	req = filp->private_data;
452 	pm_qos_remove_request(req);
453 	kfree(req);
454 
455 	return 0;
456 }
457 
458 
459 static ssize_t pm_qos_power_read(struct file *filp, char __user *buf,
460 		size_t count, loff_t *f_pos)
461 {
462 	s32 value;
463 	unsigned long flags;
464 	struct pm_qos_request *req = filp->private_data;
465 
466 	if (!req)
467 		return -EINVAL;
468 	if (!pm_qos_request_active(req))
469 		return -EINVAL;
470 
471 	spin_lock_irqsave(&pm_qos_lock, flags);
472 	value = pm_qos_get_value(pm_qos_array[req->pm_qos_class]->constraints);
473 	spin_unlock_irqrestore(&pm_qos_lock, flags);
474 
475 	return simple_read_from_buffer(buf, count, f_pos, &value, sizeof(s32));
476 }
477 
478 static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf,
479 		size_t count, loff_t *f_pos)
480 {
481 	s32 value;
482 	struct pm_qos_request *req;
483 
484 	if (count == sizeof(s32)) {
485 		if (copy_from_user(&value, buf, sizeof(s32)))
486 			return -EFAULT;
487 	} else if (count <= 11) { /* ASCII perhaps? */
488 		char ascii_value[11];
489 		unsigned long int ulval;
490 		int ret;
491 
492 		if (copy_from_user(ascii_value, buf, count))
493 			return -EFAULT;
494 
495 		if (count > 10) {
496 			if (ascii_value[10] == '\n')
497 				ascii_value[10] = '\0';
498 			else
499 				return -EINVAL;
500 		} else {
501 			ascii_value[count] = '\0';
502 		}
503 		ret = strict_strtoul(ascii_value, 16, &ulval);
504 		if (ret) {
505 			pr_debug("%s, 0x%lx, 0x%x\n", ascii_value, ulval, ret);
506 			return -EINVAL;
507 		}
508 		value = (s32)lower_32_bits(ulval);
509 	} else {
510 		return -EINVAL;
511 	}
512 
513 	req = filp->private_data;
514 	pm_qos_update_request(req, value);
515 
516 	return count;
517 }
518 
519 
520 static int __init pm_qos_power_init(void)
521 {
522 	int ret = 0;
523 	int i;
524 
525 	BUILD_BUG_ON(ARRAY_SIZE(pm_qos_array) != PM_QOS_NUM_CLASSES);
526 
527 	for (i = 1; i < PM_QOS_NUM_CLASSES; i++) {
528 		ret = register_pm_qos_misc(pm_qos_array[i]);
529 		if (ret < 0) {
530 			printk(KERN_ERR "pm_qos_param: %s setup failed\n",
531 			       pm_qos_array[i]->name);
532 			return ret;
533 		}
534 	}
535 
536 	return ret;
537 }
538 
539 late_initcall(pm_qos_power_init);
540