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_flags_remove_req - Remove device PM QoS flags request. 217 * @pqf: Device PM QoS flags set to remove the request from. 218 * @req: Request to remove from the set. 219 */ 220 static void pm_qos_flags_remove_req(struct pm_qos_flags *pqf, 221 struct pm_qos_flags_request *req) 222 { 223 s32 val = 0; 224 225 list_del(&req->node); 226 list_for_each_entry(req, &pqf->list, node) 227 val |= req->flags; 228 229 pqf->effective_flags = val; 230 } 231 232 /** 233 * pm_qos_update_flags - Update a set of PM QoS flags. 234 * @pqf: Set of flags to update. 235 * @req: Request to add to the set, to modify, or to remove from the set. 236 * @action: Action to take on the set. 237 * @val: Value of the request to add or modify. 238 * 239 * Update the given set of PM QoS flags and call notifiers if the aggregate 240 * value has changed. Returns 1 if the aggregate constraint value has changed, 241 * 0 otherwise. 242 */ 243 bool pm_qos_update_flags(struct pm_qos_flags *pqf, 244 struct pm_qos_flags_request *req, 245 enum pm_qos_req_action action, s32 val) 246 { 247 unsigned long irqflags; 248 s32 prev_value, curr_value; 249 250 spin_lock_irqsave(&pm_qos_lock, irqflags); 251 252 prev_value = list_empty(&pqf->list) ? 0 : pqf->effective_flags; 253 254 switch (action) { 255 case PM_QOS_REMOVE_REQ: 256 pm_qos_flags_remove_req(pqf, req); 257 break; 258 case PM_QOS_UPDATE_REQ: 259 pm_qos_flags_remove_req(pqf, req); 260 case PM_QOS_ADD_REQ: 261 req->flags = val; 262 INIT_LIST_HEAD(&req->node); 263 list_add_tail(&req->node, &pqf->list); 264 pqf->effective_flags |= val; 265 break; 266 default: 267 /* no action */ 268 ; 269 } 270 271 curr_value = list_empty(&pqf->list) ? 0 : pqf->effective_flags; 272 273 spin_unlock_irqrestore(&pm_qos_lock, irqflags); 274 275 return prev_value != curr_value; 276 } 277 278 /** 279 * pm_qos_request - returns current system wide qos expectation 280 * @pm_qos_class: identification of which qos value is requested 281 * 282 * This function returns the current target value. 283 */ 284 int pm_qos_request(int pm_qos_class) 285 { 286 return pm_qos_read_value(pm_qos_array[pm_qos_class]->constraints); 287 } 288 EXPORT_SYMBOL_GPL(pm_qos_request); 289 290 int pm_qos_request_active(struct pm_qos_request *req) 291 { 292 return req->pm_qos_class != 0; 293 } 294 EXPORT_SYMBOL_GPL(pm_qos_request_active); 295 296 /** 297 * pm_qos_work_fn - the timeout handler of pm_qos_update_request_timeout 298 * @work: work struct for the delayed work (timeout) 299 * 300 * This cancels the timeout request by falling back to the default at timeout. 301 */ 302 static void pm_qos_work_fn(struct work_struct *work) 303 { 304 struct pm_qos_request *req = container_of(to_delayed_work(work), 305 struct pm_qos_request, 306 work); 307 308 pm_qos_update_request(req, PM_QOS_DEFAULT_VALUE); 309 } 310 311 /** 312 * pm_qos_add_request - inserts new qos request into the list 313 * @req: pointer to a preallocated handle 314 * @pm_qos_class: identifies which list of qos request to use 315 * @value: defines the qos request 316 * 317 * This function inserts a new entry in the pm_qos_class list of requested qos 318 * performance characteristics. It recomputes the aggregate QoS expectations 319 * for the pm_qos_class of parameters and initializes the pm_qos_request 320 * handle. Caller needs to save this handle for later use in updates and 321 * removal. 322 */ 323 324 void pm_qos_add_request(struct pm_qos_request *req, 325 int pm_qos_class, s32 value) 326 { 327 if (!req) /*guard against callers passing in null */ 328 return; 329 330 if (pm_qos_request_active(req)) { 331 WARN(1, KERN_ERR "pm_qos_add_request() called for already added request\n"); 332 return; 333 } 334 req->pm_qos_class = pm_qos_class; 335 INIT_DELAYED_WORK(&req->work, pm_qos_work_fn); 336 pm_qos_update_target(pm_qos_array[pm_qos_class]->constraints, 337 &req->node, PM_QOS_ADD_REQ, value); 338 } 339 EXPORT_SYMBOL_GPL(pm_qos_add_request); 340 341 /** 342 * pm_qos_update_request - modifies an existing qos request 343 * @req : handle to list element holding a pm_qos request to use 344 * @value: defines the qos request 345 * 346 * Updates an existing qos request for the pm_qos_class of parameters along 347 * with updating the target pm_qos_class value. 348 * 349 * Attempts are made to make this code callable on hot code paths. 350 */ 351 void pm_qos_update_request(struct pm_qos_request *req, 352 s32 new_value) 353 { 354 if (!req) /*guard against callers passing in null */ 355 return; 356 357 if (!pm_qos_request_active(req)) { 358 WARN(1, KERN_ERR "pm_qos_update_request() called for unknown object\n"); 359 return; 360 } 361 362 cancel_delayed_work_sync(&req->work); 363 364 if (new_value != req->node.prio) 365 pm_qos_update_target( 366 pm_qos_array[req->pm_qos_class]->constraints, 367 &req->node, PM_QOS_UPDATE_REQ, new_value); 368 } 369 EXPORT_SYMBOL_GPL(pm_qos_update_request); 370 371 /** 372 * pm_qos_update_request_timeout - modifies an existing qos request temporarily. 373 * @req : handle to list element holding a pm_qos request to use 374 * @new_value: defines the temporal qos request 375 * @timeout_us: the effective duration of this qos request in usecs. 376 * 377 * After timeout_us, this qos request is cancelled automatically. 378 */ 379 void pm_qos_update_request_timeout(struct pm_qos_request *req, s32 new_value, 380 unsigned long timeout_us) 381 { 382 if (!req) 383 return; 384 if (WARN(!pm_qos_request_active(req), 385 "%s called for unknown object.", __func__)) 386 return; 387 388 cancel_delayed_work_sync(&req->work); 389 390 if (new_value != req->node.prio) 391 pm_qos_update_target( 392 pm_qos_array[req->pm_qos_class]->constraints, 393 &req->node, PM_QOS_UPDATE_REQ, new_value); 394 395 schedule_delayed_work(&req->work, usecs_to_jiffies(timeout_us)); 396 } 397 398 /** 399 * pm_qos_remove_request - modifies an existing qos request 400 * @req: handle to request list element 401 * 402 * Will remove pm qos request from the list of constraints and 403 * recompute the current target value for the pm_qos_class. Call this 404 * on slow code paths. 405 */ 406 void pm_qos_remove_request(struct pm_qos_request *req) 407 { 408 if (!req) /*guard against callers passing in null */ 409 return; 410 /* silent return to keep pcm code cleaner */ 411 412 if (!pm_qos_request_active(req)) { 413 WARN(1, KERN_ERR "pm_qos_remove_request() called for unknown object\n"); 414 return; 415 } 416 417 cancel_delayed_work_sync(&req->work); 418 419 pm_qos_update_target(pm_qos_array[req->pm_qos_class]->constraints, 420 &req->node, PM_QOS_REMOVE_REQ, 421 PM_QOS_DEFAULT_VALUE); 422 memset(req, 0, sizeof(*req)); 423 } 424 EXPORT_SYMBOL_GPL(pm_qos_remove_request); 425 426 /** 427 * pm_qos_add_notifier - sets notification entry for changes to target value 428 * @pm_qos_class: identifies which qos target changes should be notified. 429 * @notifier: notifier block managed by caller. 430 * 431 * will register the notifier into a notification chain that gets called 432 * upon changes to the pm_qos_class target value. 433 */ 434 int pm_qos_add_notifier(int pm_qos_class, struct notifier_block *notifier) 435 { 436 int retval; 437 438 retval = blocking_notifier_chain_register( 439 pm_qos_array[pm_qos_class]->constraints->notifiers, 440 notifier); 441 442 return retval; 443 } 444 EXPORT_SYMBOL_GPL(pm_qos_add_notifier); 445 446 /** 447 * pm_qos_remove_notifier - deletes notification entry from chain. 448 * @pm_qos_class: identifies which qos target changes are notified. 449 * @notifier: notifier block to be removed. 450 * 451 * will remove the notifier from the notification chain that gets called 452 * upon changes to the pm_qos_class target value. 453 */ 454 int pm_qos_remove_notifier(int pm_qos_class, struct notifier_block *notifier) 455 { 456 int retval; 457 458 retval = blocking_notifier_chain_unregister( 459 pm_qos_array[pm_qos_class]->constraints->notifiers, 460 notifier); 461 462 return retval; 463 } 464 EXPORT_SYMBOL_GPL(pm_qos_remove_notifier); 465 466 /* User space interface to PM QoS classes via misc devices */ 467 static int register_pm_qos_misc(struct pm_qos_object *qos) 468 { 469 qos->pm_qos_power_miscdev.minor = MISC_DYNAMIC_MINOR; 470 qos->pm_qos_power_miscdev.name = qos->name; 471 qos->pm_qos_power_miscdev.fops = &pm_qos_power_fops; 472 473 return misc_register(&qos->pm_qos_power_miscdev); 474 } 475 476 static int find_pm_qos_object_by_minor(int minor) 477 { 478 int pm_qos_class; 479 480 for (pm_qos_class = 0; 481 pm_qos_class < PM_QOS_NUM_CLASSES; pm_qos_class++) { 482 if (minor == 483 pm_qos_array[pm_qos_class]->pm_qos_power_miscdev.minor) 484 return pm_qos_class; 485 } 486 return -1; 487 } 488 489 static int pm_qos_power_open(struct inode *inode, struct file *filp) 490 { 491 long pm_qos_class; 492 493 pm_qos_class = find_pm_qos_object_by_minor(iminor(inode)); 494 if (pm_qos_class >= 0) { 495 struct pm_qos_request *req = kzalloc(sizeof(*req), GFP_KERNEL); 496 if (!req) 497 return -ENOMEM; 498 499 pm_qos_add_request(req, pm_qos_class, PM_QOS_DEFAULT_VALUE); 500 filp->private_data = req; 501 502 return 0; 503 } 504 return -EPERM; 505 } 506 507 static int pm_qos_power_release(struct inode *inode, struct file *filp) 508 { 509 struct pm_qos_request *req; 510 511 req = filp->private_data; 512 pm_qos_remove_request(req); 513 kfree(req); 514 515 return 0; 516 } 517 518 519 static ssize_t pm_qos_power_read(struct file *filp, char __user *buf, 520 size_t count, loff_t *f_pos) 521 { 522 s32 value; 523 unsigned long flags; 524 struct pm_qos_request *req = filp->private_data; 525 526 if (!req) 527 return -EINVAL; 528 if (!pm_qos_request_active(req)) 529 return -EINVAL; 530 531 spin_lock_irqsave(&pm_qos_lock, flags); 532 value = pm_qos_get_value(pm_qos_array[req->pm_qos_class]->constraints); 533 spin_unlock_irqrestore(&pm_qos_lock, flags); 534 535 return simple_read_from_buffer(buf, count, f_pos, &value, sizeof(s32)); 536 } 537 538 static ssize_t pm_qos_power_write(struct file *filp, const char __user *buf, 539 size_t count, loff_t *f_pos) 540 { 541 s32 value; 542 struct pm_qos_request *req; 543 544 if (count == sizeof(s32)) { 545 if (copy_from_user(&value, buf, sizeof(s32))) 546 return -EFAULT; 547 } else if (count <= 11) { /* ASCII perhaps? */ 548 char ascii_value[11]; 549 unsigned long int ulval; 550 int ret; 551 552 if (copy_from_user(ascii_value, buf, count)) 553 return -EFAULT; 554 555 if (count > 10) { 556 if (ascii_value[10] == '\n') 557 ascii_value[10] = '\0'; 558 else 559 return -EINVAL; 560 } else { 561 ascii_value[count] = '\0'; 562 } 563 ret = kstrtoul(ascii_value, 16, &ulval); 564 if (ret) { 565 pr_debug("%s, 0x%lx, 0x%x\n", ascii_value, ulval, ret); 566 return -EINVAL; 567 } 568 value = (s32)lower_32_bits(ulval); 569 } else { 570 return -EINVAL; 571 } 572 573 req = filp->private_data; 574 pm_qos_update_request(req, value); 575 576 return count; 577 } 578 579 580 static int __init pm_qos_power_init(void) 581 { 582 int ret = 0; 583 int i; 584 585 BUILD_BUG_ON(ARRAY_SIZE(pm_qos_array) != PM_QOS_NUM_CLASSES); 586 587 for (i = 1; i < PM_QOS_NUM_CLASSES; i++) { 588 ret = register_pm_qos_misc(pm_qos_array[i]); 589 if (ret < 0) { 590 printk(KERN_ERR "pm_qos_param: %s setup failed\n", 591 pm_qos_array[i]->name); 592 return ret; 593 } 594 } 595 596 return ret; 597 } 598 599 late_initcall(pm_qos_power_init); 600