~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/kernel/power/qos.c

Version: ~ [ linux-5.2 ] ~ [ linux-5.1.16 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.57 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.132 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.184 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.184 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.69 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp