GNU Linux-libre 4.19.211-gnu1
[releases.git] / kernel / power / qos.c
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 #include <linux/debugfs.h>
45 #include <linux/seq_file.h>
46
47 #include <linux/uaccess.h>
48 #include <linux/export.h>
49 #include <trace/events/power.h>
50
51 /*
52  * locking rule: all changes to constraints or notifiers lists
53  * or pm_qos_object list and pm_qos_objects need to happen with pm_qos_lock
54  * held, taken with _irqsave.  One lock to rule them all
55  */
56 struct pm_qos_object {
57         struct pm_qos_constraints *constraints;
58         struct miscdevice pm_qos_power_miscdev;
59         char *name;
60 };
61
62 static DEFINE_SPINLOCK(pm_qos_lock);
63
64 static struct pm_qos_object null_pm_qos;
65
66 static BLOCKING_NOTIFIER_HEAD(cpu_dma_lat_notifier);
67 static struct pm_qos_constraints cpu_dma_constraints = {
68         .list = PLIST_HEAD_INIT(cpu_dma_constraints.list),
69         .target_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE,
70         .default_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE,
71         .no_constraint_value = PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE,
72         .type = PM_QOS_MIN,
73         .notifiers = &cpu_dma_lat_notifier,
74 };
75 static struct pm_qos_object cpu_dma_pm_qos = {
76         .constraints = &cpu_dma_constraints,
77         .name = "cpu_dma_latency",
78 };
79
80 static BLOCKING_NOTIFIER_HEAD(network_lat_notifier);
81 static struct pm_qos_constraints network_lat_constraints = {
82         .list = PLIST_HEAD_INIT(network_lat_constraints.list),
83         .target_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE,
84         .default_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE,
85         .no_constraint_value = PM_QOS_NETWORK_LAT_DEFAULT_VALUE,
86         .type = PM_QOS_MIN,
87         .notifiers = &network_lat_notifier,
88 };
89 static struct pm_qos_object network_lat_pm_qos = {
90         .constraints = &network_lat_constraints,
91         .name = "network_latency",
92 };
93
94
95 static BLOCKING_NOTIFIER_HEAD(network_throughput_notifier);
96 static struct pm_qos_constraints network_tput_constraints = {
97         .list = PLIST_HEAD_INIT(network_tput_constraints.list),
98         .target_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE,
99         .default_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE,
100         .no_constraint_value = PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE,
101         .type = PM_QOS_MAX,
102         .notifiers = &network_throughput_notifier,
103 };
104 static struct pm_qos_object network_throughput_pm_qos = {
105         .constraints = &network_tput_constraints,
106         .name = "network_throughput",
107 };
108
109
110 static BLOCKING_NOTIFIER_HEAD(memory_bandwidth_notifier);
111 static struct pm_qos_constraints memory_bw_constraints = {
112         .list = PLIST_HEAD_INIT(memory_bw_constraints.list),
113         .target_value = PM_QOS_MEMORY_BANDWIDTH_DEFAULT_VALUE,
114         .default_value = PM_QOS_MEMORY_BANDWIDTH_DEFAULT_VALUE,
115         .no_constraint_value = PM_QOS_MEMORY_BANDWIDTH_DEFAULT_VALUE,
116         .type = PM_QOS_SUM,
117         .notifiers = &memory_bandwidth_notifier,
118 };
119 static struct pm_qos_object memory_bandwidth_pm_qos = {
120         .constraints = &memory_bw_constraints,
121         .name = "memory_bandwidth",
122 };
123
124
125 static struct pm_qos_object *pm_qos_array[] = {
126         &null_pm_qos,
127         &cpu_dma_pm_qos,
128         &network_lat_pm_qos,
129         &network_throughput_pm_qos,
130         &memory_bandwidth_pm_qos,
131 };
132
133 static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf,
134                 size_t count, loff_t *f_pos);
135 static ssize_t pm_qos_power_read(struct file *filp, char __user *buf,
136                 size_t count, loff_t *f_pos);
137 static int pm_qos_power_open(struct inode *inode, struct file *filp);
138 static int pm_qos_power_release(struct inode *inode, struct file *filp);
139
140 static const struct file_operations pm_qos_power_fops = {
141         .write = pm_qos_power_write,
142         .read = pm_qos_power_read,
143         .open = pm_qos_power_open,
144         .release = pm_qos_power_release,
145         .llseek = noop_llseek,
146 };
147
148 /* unlocked internal variant */
149 static inline int pm_qos_get_value(struct pm_qos_constraints *c)
150 {
151         struct plist_node *node;
152         int total_value = 0;
153
154         if (plist_head_empty(&c->list))
155                 return c->no_constraint_value;
156
157         switch (c->type) {
158         case PM_QOS_MIN:
159                 return plist_first(&c->list)->prio;
160
161         case PM_QOS_MAX:
162                 return plist_last(&c->list)->prio;
163
164         case PM_QOS_SUM:
165                 plist_for_each(node, &c->list)
166                         total_value += node->prio;
167
168                 return total_value;
169
170         default:
171                 /* runtime check for not using enum */
172                 BUG();
173                 return PM_QOS_DEFAULT_VALUE;
174         }
175 }
176
177 s32 pm_qos_read_value(struct pm_qos_constraints *c)
178 {
179         return c->target_value;
180 }
181
182 static inline void pm_qos_set_value(struct pm_qos_constraints *c, s32 value)
183 {
184         c->target_value = value;
185 }
186
187 static int pm_qos_dbg_show_requests(struct seq_file *s, void *unused)
188 {
189         struct pm_qos_object *qos = (struct pm_qos_object *)s->private;
190         struct pm_qos_constraints *c;
191         struct pm_qos_request *req;
192         char *type;
193         unsigned long flags;
194         int tot_reqs = 0;
195         int active_reqs = 0;
196
197         if (IS_ERR_OR_NULL(qos)) {
198                 pr_err("%s: bad qos param!\n", __func__);
199                 return -EINVAL;
200         }
201         c = qos->constraints;
202         if (IS_ERR_OR_NULL(c)) {
203                 pr_err("%s: Bad constraints on qos?\n", __func__);
204                 return -EINVAL;
205         }
206
207         /* Lock to ensure we have a snapshot */
208         spin_lock_irqsave(&pm_qos_lock, flags);
209         if (plist_head_empty(&c->list)) {
210                 seq_puts(s, "Empty!\n");
211                 goto out;
212         }
213
214         switch (c->type) {
215         case PM_QOS_MIN:
216                 type = "Minimum";
217                 break;
218         case PM_QOS_MAX:
219                 type = "Maximum";
220                 break;
221         case PM_QOS_SUM:
222                 type = "Sum";
223                 break;
224         default:
225                 type = "Unknown";
226         }
227
228         plist_for_each_entry(req, &c->list, node) {
229                 char *state = "Default";
230
231                 if ((req->node).prio != c->default_value) {
232                         active_reqs++;
233                         state = "Active";
234                 }
235                 tot_reqs++;
236                 seq_printf(s, "%d: %d: %s\n", tot_reqs,
237                            (req->node).prio, state);
238         }
239
240         seq_printf(s, "Type=%s, Value=%d, Requests: active=%d / total=%d\n",
241                    type, pm_qos_get_value(c), active_reqs, tot_reqs);
242
243 out:
244         spin_unlock_irqrestore(&pm_qos_lock, flags);
245         return 0;
246 }
247
248 static int pm_qos_dbg_open(struct inode *inode, struct file *file)
249 {
250         return single_open(file, pm_qos_dbg_show_requests,
251                            inode->i_private);
252 }
253
254 static const struct file_operations pm_qos_debug_fops = {
255         .open           = pm_qos_dbg_open,
256         .read           = seq_read,
257         .llseek         = seq_lseek,
258         .release        = single_release,
259 };
260
261 /**
262  * pm_qos_update_target - manages the constraints list and calls the notifiers
263  *  if needed
264  * @c: constraints data struct
265  * @node: request to add to the list, to update or to remove
266  * @action: action to take on the constraints list
267  * @value: value of the request to add or update
268  *
269  * This function returns 1 if the aggregated constraint value has changed, 0
270  *  otherwise.
271  */
272 int pm_qos_update_target(struct pm_qos_constraints *c, struct plist_node *node,
273                          enum pm_qos_req_action action, int value)
274 {
275         unsigned long flags;
276         int prev_value, curr_value, new_value;
277         int ret;
278
279         spin_lock_irqsave(&pm_qos_lock, flags);
280         prev_value = pm_qos_get_value(c);
281         if (value == PM_QOS_DEFAULT_VALUE)
282                 new_value = c->default_value;
283         else
284                 new_value = value;
285
286         switch (action) {
287         case PM_QOS_REMOVE_REQ:
288                 plist_del(node, &c->list);
289                 break;
290         case PM_QOS_UPDATE_REQ:
291                 /*
292                  * to change the list, we atomically remove, reinit
293                  * with new value and add, then see if the extremal
294                  * changed
295                  */
296                 plist_del(node, &c->list);
297                 /* fall through */
298         case PM_QOS_ADD_REQ:
299                 plist_node_init(node, new_value);
300                 plist_add(node, &c->list);
301                 break;
302         default:
303                 /* no action */
304                 ;
305         }
306
307         curr_value = pm_qos_get_value(c);
308         pm_qos_set_value(c, curr_value);
309
310         spin_unlock_irqrestore(&pm_qos_lock, flags);
311
312         trace_pm_qos_update_target(action, prev_value, curr_value);
313         if (prev_value != curr_value) {
314                 ret = 1;
315                 if (c->notifiers)
316                         blocking_notifier_call_chain(c->notifiers,
317                                                      (unsigned long)curr_value,
318                                                      NULL);
319         } else {
320                 ret = 0;
321         }
322         return ret;
323 }
324
325 /**
326  * pm_qos_flags_remove_req - Remove device PM QoS flags request.
327  * @pqf: Device PM QoS flags set to remove the request from.
328  * @req: Request to remove from the set.
329  */
330 static void pm_qos_flags_remove_req(struct pm_qos_flags *pqf,
331                                     struct pm_qos_flags_request *req)
332 {
333         s32 val = 0;
334
335         list_del(&req->node);
336         list_for_each_entry(req, &pqf->list, node)
337                 val |= req->flags;
338
339         pqf->effective_flags = val;
340 }
341
342 /**
343  * pm_qos_update_flags - Update a set of PM QoS flags.
344  * @pqf: Set of flags to update.
345  * @req: Request to add to the set, to modify, or to remove from the set.
346  * @action: Action to take on the set.
347  * @val: Value of the request to add or modify.
348  *
349  * Update the given set of PM QoS flags and call notifiers if the aggregate
350  * value has changed.  Returns 1 if the aggregate constraint value has changed,
351  * 0 otherwise.
352  */
353 bool pm_qos_update_flags(struct pm_qos_flags *pqf,
354                          struct pm_qos_flags_request *req,
355                          enum pm_qos_req_action action, s32 val)
356 {
357         unsigned long irqflags;
358         s32 prev_value, curr_value;
359
360         spin_lock_irqsave(&pm_qos_lock, irqflags);
361
362         prev_value = list_empty(&pqf->list) ? 0 : pqf->effective_flags;
363
364         switch (action) {
365         case PM_QOS_REMOVE_REQ:
366                 pm_qos_flags_remove_req(pqf, req);
367                 break;
368         case PM_QOS_UPDATE_REQ:
369                 pm_qos_flags_remove_req(pqf, req);
370                 /* fall through */
371         case PM_QOS_ADD_REQ:
372                 req->flags = val;
373                 INIT_LIST_HEAD(&req->node);
374                 list_add_tail(&req->node, &pqf->list);
375                 pqf->effective_flags |= val;
376                 break;
377         default:
378                 /* no action */
379                 ;
380         }
381
382         curr_value = list_empty(&pqf->list) ? 0 : pqf->effective_flags;
383
384         spin_unlock_irqrestore(&pm_qos_lock, irqflags);
385
386         trace_pm_qos_update_flags(action, prev_value, curr_value);
387         return prev_value != curr_value;
388 }
389
390 /**
391  * pm_qos_request - returns current system wide qos expectation
392  * @pm_qos_class: identification of which qos value is requested
393  *
394  * This function returns the current target value.
395  */
396 int pm_qos_request(int pm_qos_class)
397 {
398         return pm_qos_read_value(pm_qos_array[pm_qos_class]->constraints);
399 }
400 EXPORT_SYMBOL_GPL(pm_qos_request);
401
402 int pm_qos_request_active(struct pm_qos_request *req)
403 {
404         return req->pm_qos_class != 0;
405 }
406 EXPORT_SYMBOL_GPL(pm_qos_request_active);
407
408 static void __pm_qos_update_request(struct pm_qos_request *req,
409                            s32 new_value)
410 {
411         trace_pm_qos_update_request(req->pm_qos_class, new_value);
412
413         if (new_value != req->node.prio)
414                 pm_qos_update_target(
415                         pm_qos_array[req->pm_qos_class]->constraints,
416                         &req->node, PM_QOS_UPDATE_REQ, new_value);
417 }
418
419 /**
420  * pm_qos_work_fn - the timeout handler of pm_qos_update_request_timeout
421  * @work: work struct for the delayed work (timeout)
422  *
423  * This cancels the timeout request by falling back to the default at timeout.
424  */
425 static void pm_qos_work_fn(struct work_struct *work)
426 {
427         struct pm_qos_request *req = container_of(to_delayed_work(work),
428                                                   struct pm_qos_request,
429                                                   work);
430
431         __pm_qos_update_request(req, PM_QOS_DEFAULT_VALUE);
432 }
433
434 /**
435  * pm_qos_add_request - inserts new qos request into the list
436  * @req: pointer to a preallocated handle
437  * @pm_qos_class: identifies which list of qos request to use
438  * @value: defines the qos request
439  *
440  * This function inserts a new entry in the pm_qos_class list of requested qos
441  * performance characteristics.  It recomputes the aggregate QoS expectations
442  * for the pm_qos_class of parameters and initializes the pm_qos_request
443  * handle.  Caller needs to save this handle for later use in updates and
444  * removal.
445  */
446
447 void pm_qos_add_request(struct pm_qos_request *req,
448                         int pm_qos_class, s32 value)
449 {
450         if (!req) /*guard against callers passing in null */
451                 return;
452
453         if (pm_qos_request_active(req)) {
454                 WARN(1, KERN_ERR "pm_qos_add_request() called for already added request\n");
455                 return;
456         }
457         req->pm_qos_class = pm_qos_class;
458         INIT_DELAYED_WORK(&req->work, pm_qos_work_fn);
459         trace_pm_qos_add_request(pm_qos_class, value);
460         pm_qos_update_target(pm_qos_array[pm_qos_class]->constraints,
461                              &req->node, PM_QOS_ADD_REQ, value);
462 }
463 EXPORT_SYMBOL_GPL(pm_qos_add_request);
464
465 /**
466  * pm_qos_update_request - modifies an existing qos request
467  * @req : handle to list element holding a pm_qos request to use
468  * @value: defines the qos request
469  *
470  * Updates an existing qos request for the pm_qos_class of parameters along
471  * with updating the target pm_qos_class value.
472  *
473  * Attempts are made to make this code callable on hot code paths.
474  */
475 void pm_qos_update_request(struct pm_qos_request *req,
476                            s32 new_value)
477 {
478         if (!req) /*guard against callers passing in null */
479                 return;
480
481         if (!pm_qos_request_active(req)) {
482                 WARN(1, KERN_ERR "pm_qos_update_request() called for unknown object\n");
483                 return;
484         }
485
486         cancel_delayed_work_sync(&req->work);
487         __pm_qos_update_request(req, new_value);
488 }
489 EXPORT_SYMBOL_GPL(pm_qos_update_request);
490
491 /**
492  * pm_qos_update_request_timeout - modifies an existing qos request temporarily.
493  * @req : handle to list element holding a pm_qos request to use
494  * @new_value: defines the temporal qos request
495  * @timeout_us: the effective duration of this qos request in usecs.
496  *
497  * After timeout_us, this qos request is cancelled automatically.
498  */
499 void pm_qos_update_request_timeout(struct pm_qos_request *req, s32 new_value,
500                                    unsigned long timeout_us)
501 {
502         if (!req)
503                 return;
504         if (WARN(!pm_qos_request_active(req),
505                  "%s called for unknown object.", __func__))
506                 return;
507
508         cancel_delayed_work_sync(&req->work);
509
510         trace_pm_qos_update_request_timeout(req->pm_qos_class,
511                                             new_value, timeout_us);
512         if (new_value != req->node.prio)
513                 pm_qos_update_target(
514                         pm_qos_array[req->pm_qos_class]->constraints,
515                         &req->node, PM_QOS_UPDATE_REQ, new_value);
516
517         schedule_delayed_work(&req->work, usecs_to_jiffies(timeout_us));
518 }
519
520 /**
521  * pm_qos_remove_request - modifies an existing qos request
522  * @req: handle to request list element
523  *
524  * Will remove pm qos request from the list of constraints and
525  * recompute the current target value for the pm_qos_class.  Call this
526  * on slow code paths.
527  */
528 void pm_qos_remove_request(struct pm_qos_request *req)
529 {
530         if (!req) /*guard against callers passing in null */
531                 return;
532                 /* silent return to keep pcm code cleaner */
533
534         if (!pm_qos_request_active(req)) {
535                 WARN(1, KERN_ERR "pm_qos_remove_request() called for unknown object\n");
536                 return;
537         }
538
539         cancel_delayed_work_sync(&req->work);
540
541         trace_pm_qos_remove_request(req->pm_qos_class, PM_QOS_DEFAULT_VALUE);
542         pm_qos_update_target(pm_qos_array[req->pm_qos_class]->constraints,
543                              &req->node, PM_QOS_REMOVE_REQ,
544                              PM_QOS_DEFAULT_VALUE);
545         memset(req, 0, sizeof(*req));
546 }
547 EXPORT_SYMBOL_GPL(pm_qos_remove_request);
548
549 /**
550  * pm_qos_add_notifier - sets notification entry for changes to target value
551  * @pm_qos_class: identifies which qos target changes should be notified.
552  * @notifier: notifier block managed by caller.
553  *
554  * will register the notifier into a notification chain that gets called
555  * upon changes to the pm_qos_class target value.
556  */
557 int pm_qos_add_notifier(int pm_qos_class, struct notifier_block *notifier)
558 {
559         int retval;
560
561         retval = blocking_notifier_chain_register(
562                         pm_qos_array[pm_qos_class]->constraints->notifiers,
563                         notifier);
564
565         return retval;
566 }
567 EXPORT_SYMBOL_GPL(pm_qos_add_notifier);
568
569 /**
570  * pm_qos_remove_notifier - deletes notification entry from chain.
571  * @pm_qos_class: identifies which qos target changes are notified.
572  * @notifier: notifier block to be removed.
573  *
574  * will remove the notifier from the notification chain that gets called
575  * upon changes to the pm_qos_class target value.
576  */
577 int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier)
578 {
579         int retval;
580
581         retval = blocking_notifier_chain_unregister(
582                         pm_qos_array[pm_qos_class]->constraints->notifiers,
583                         notifier);
584
585         return retval;
586 }
587 EXPORT_SYMBOL_GPL(pm_qos_remove_notifier);
588
589 /* User space interface to PM QoS classes via misc devices */
590 static int register_pm_qos_misc(struct pm_qos_object *qos, struct dentry *d)
591 {
592         qos->pm_qos_power_miscdev.minor = MISC_DYNAMIC_MINOR;
593         qos->pm_qos_power_miscdev.name = qos->name;
594         qos->pm_qos_power_miscdev.fops = &pm_qos_power_fops;
595
596         if (d) {
597                 (void)debugfs_create_file(qos->name, S_IRUGO, d,
598                                           (void *)qos, &pm_qos_debug_fops);
599         }
600
601         return misc_register(&qos->pm_qos_power_miscdev);
602 }
603
604 static int find_pm_qos_object_by_minor(int minor)
605 {
606         int pm_qos_class;
607
608         for (pm_qos_class = PM_QOS_CPU_DMA_LATENCY;
609                 pm_qos_class < PM_QOS_NUM_CLASSES; pm_qos_class++) {
610                 if (minor ==
611                         pm_qos_array[pm_qos_class]->pm_qos_power_miscdev.minor)
612                         return pm_qos_class;
613         }
614         return -1;
615 }
616
617 static int pm_qos_power_open(struct inode *inode, struct file *filp)
618 {
619         long pm_qos_class;
620
621         pm_qos_class = find_pm_qos_object_by_minor(iminor(inode));
622         if (pm_qos_class >= PM_QOS_CPU_DMA_LATENCY) {
623                 struct pm_qos_request *req = kzalloc(sizeof(*req), GFP_KERNEL);
624                 if (!req)
625                         return -ENOMEM;
626
627                 pm_qos_add_request(req, pm_qos_class, PM_QOS_DEFAULT_VALUE);
628                 filp->private_data = req;
629
630                 return 0;
631         }
632         return -EPERM;
633 }
634
635 static int pm_qos_power_release(struct inode *inode, struct file *filp)
636 {
637         struct pm_qos_request *req;
638
639         req = filp->private_data;
640         pm_qos_remove_request(req);
641         kfree(req);
642
643         return 0;
644 }
645
646
647 static ssize_t pm_qos_power_read(struct file *filp, char __user *buf,
648                 size_t count, loff_t *f_pos)
649 {
650         s32 value;
651         unsigned long flags;
652         struct pm_qos_request *req = filp->private_data;
653
654         if (!req)
655                 return -EINVAL;
656         if (!pm_qos_request_active(req))
657                 return -EINVAL;
658
659         spin_lock_irqsave(&pm_qos_lock, flags);
660         value = pm_qos_get_value(pm_qos_array[req->pm_qos_class]->constraints);
661         spin_unlock_irqrestore(&pm_qos_lock, flags);
662
663         return simple_read_from_buffer(buf, count, f_pos, &value, sizeof(s32));
664 }
665
666 static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf,
667                 size_t count, loff_t *f_pos)
668 {
669         s32 value;
670         struct pm_qos_request *req;
671
672         if (count == sizeof(s32)) {
673                 if (copy_from_user(&value, buf, sizeof(s32)))
674                         return -EFAULT;
675         } else {
676                 int ret;
677
678                 ret = kstrtos32_from_user(buf, count, 16, &value);
679                 if (ret)
680                         return ret;
681         }
682
683         req = filp->private_data;
684         pm_qos_update_request(req, value);
685
686         return count;
687 }
688
689
690 static int __init pm_qos_power_init(void)
691 {
692         int ret = 0;
693         int i;
694         struct dentry *d;
695
696         BUILD_BUG_ON(ARRAY_SIZE(pm_qos_array) != PM_QOS_NUM_CLASSES);
697
698         d = debugfs_create_dir("pm_qos", NULL);
699         if (IS_ERR_OR_NULL(d))
700                 d = NULL;
701
702         for (i = PM_QOS_CPU_DMA_LATENCY; i < PM_QOS_NUM_CLASSES; i++) {
703                 ret = register_pm_qos_misc(pm_qos_array[i], d);
704                 if (ret < 0) {
705                         pr_err("%s: %s setup failed\n",
706                                __func__, pm_qos_array[i]->name);
707                         return ret;
708                 }
709         }
710
711         return ret;
712 }
713
714 late_initcall(pm_qos_power_init);