1/* 2 * drivers/base/devres.c - device resource management 3 * 4 * Copyright (c) 2006 SUSE Linux Products GmbH 5 * Copyright (c) 2006 Tejun Heo <teheo@suse.de> 6 * 7 * This file is released under the GPLv2. 8 */ 9 10#include <linux/device.h> 11#include <linux/module.h> 12#include <linux/slab.h> 13 14#include "base.h" 15 16struct devres_node { 17 struct list_head entry; 18 dr_release_t release; 19#ifdef CONFIG_DEBUG_DEVRES 20 const char *name; 21 size_t size; 22#endif 23}; 24 25struct devres { 26 struct devres_node node; 27 /* -- 3 pointers */ 28 unsigned long long data[]; /* guarantee ull alignment */ 29}; 30 31struct devres_group { 32 struct devres_node node[2]; 33 void *id; 34 int color; 35 /* -- 8 pointers */ 36}; 37 38#ifdef CONFIG_DEBUG_DEVRES 39static int log_devres = 0; 40module_param_named(log, log_devres, int, S_IRUGO | S_IWUSR); 41 42static void set_node_dbginfo(struct devres_node *node, const char *name, 43 size_t size) 44{ 45 node->name = name; 46 node->size = size; 47} 48 49static void devres_log(struct device *dev, struct devres_node *node, 50 const char *op) 51{ 52 if (unlikely(log_devres)) 53 dev_printk(KERN_ERR, dev, "DEVRES %3s %p %s (%lu bytes)\n", 54 op, node, node->name, (unsigned long)node->size); 55} 56#else /* CONFIG_DEBUG_DEVRES */ 57#define set_node_dbginfo(node, n, s) do {} while (0) 58#define devres_log(dev, node, op) do {} while (0) 59#endif /* CONFIG_DEBUG_DEVRES */ 60 61/* 62 * Release functions for devres group. These callbacks are used only 63 * for identification. 64 */ 65static void group_open_release(struct device *dev, void *res) 66{ 67 /* noop */ 68} 69 70static void group_close_release(struct device *dev, void *res) 71{ 72 /* noop */ 73} 74 75static struct devres_group * node_to_group(struct devres_node *node) 76{ 77 if (node->release == &group_open_release) 78 return container_of(node, struct devres_group, node[0]); 79 if (node->release == &group_close_release) 80 return container_of(node, struct devres_group, node[1]); 81 return NULL; 82} 83 84static __always_inline struct devres * alloc_dr(dr_release_t release, 85 size_t size, gfp_t gfp) 86{ 87 size_t tot_size = sizeof(struct devres) + size; 88 struct devres *dr; 89 90 dr = kmalloc_track_caller(tot_size, gfp); 91 if (unlikely(!dr)) 92 return NULL; 93 94 memset(dr, 0, tot_size); 95 INIT_LIST_HEAD(&dr->node.entry); 96 dr->node.release = release; 97 return dr; 98} 99 100static void add_dr(struct device *dev, struct devres_node *node) 101{ 102 devres_log(dev, node, "ADD"); 103 BUG_ON(!list_empty(&node->entry)); 104 list_add_tail(&node->entry, &dev->devres_head); 105} 106 107#ifdef CONFIG_DEBUG_DEVRES 108void * __devres_alloc(dr_release_t release, size_t size, gfp_t gfp, 109 const char *name) 110{ 111 struct devres *dr; 112 113 dr = alloc_dr(release, size, gfp); 114 if (unlikely(!dr)) 115 return NULL; 116 set_node_dbginfo(&dr->node, name, size); 117 return dr->data; 118} 119EXPORT_SYMBOL_GPL(__devres_alloc); 120#else 121/** 122 * devres_alloc - Allocate device resource data 123 * @release: Release function devres will be associated with 124 * @size: Allocation size 125 * @gfp: Allocation flags 126 * 127 * Allocate devres of @size bytes. The allocated area is zeroed, then 128 * associated with @release. The returned pointer can be passed to 129 * other devres_*() functions. 130 * 131 * RETURNS: 132 * Pointer to allocated devres on success, NULL on failure. 133 */ 134void * devres_alloc(dr_release_t release, size_t size, gfp_t gfp) 135{ 136 struct devres *dr; 137 138 dr = alloc_dr(release, size, gfp); 139 if (unlikely(!dr)) 140 return NULL; 141 return dr->data; 142} 143EXPORT_SYMBOL_GPL(devres_alloc); 144#endif 145 146/** 147 * devres_free - Free device resource data 148 * @res: Pointer to devres data to free 149 * 150 * Free devres created with devres_alloc(). 151 */ 152void devres_free(void *res) 153{ 154 if (res) { 155 struct devres *dr = container_of(res, struct devres, data); 156 157 BUG_ON(!list_empty(&dr->node.entry)); 158 kfree(dr); 159 } 160} 161EXPORT_SYMBOL_GPL(devres_free); 162 163/** 164 * devres_add - Register device resource 165 * @dev: Device to add resource to 166 * @res: Resource to register 167 * 168 * Register devres @res to @dev. @res should have been allocated 169 * using devres_alloc(). On driver detach, the associated release 170 * function will be invoked and devres will be freed automatically. 171 */ 172void devres_add(struct device *dev, void *res) 173{ 174 struct devres *dr = container_of(res, struct devres, data); 175 unsigned long flags; 176 177 spin_lock_irqsave(&dev->devres_lock, flags); 178 add_dr(dev, &dr->node); 179 spin_unlock_irqrestore(&dev->devres_lock, flags); 180} 181EXPORT_SYMBOL_GPL(devres_add); 182 183static struct devres *find_dr(struct device *dev, dr_release_t release, 184 dr_match_t match, void *match_data) 185{ 186 struct devres_node *node; 187 188 list_for_each_entry_reverse(node, &dev->devres_head, entry) { 189 struct devres *dr = container_of(node, struct devres, node); 190 191 if (node->release != release) 192 continue; 193 if (match && !match(dev, dr->data, match_data)) 194 continue; 195 return dr; 196 } 197 198 return NULL; 199} 200 201/** 202 * devres_find - Find device resource 203 * @dev: Device to lookup resource from 204 * @release: Look for resources associated with this release function 205 * @match: Match function (optional) 206 * @match_data: Data for the match function 207 * 208 * Find the latest devres of @dev which is associated with @release 209 * and for which @match returns 1. If @match is NULL, it's considered 210 * to match all. 211 * 212 * RETURNS: 213 * Pointer to found devres, NULL if not found. 214 */ 215void * devres_find(struct device *dev, dr_release_t release, 216 dr_match_t match, void *match_data) 217{ 218 struct devres *dr; 219 unsigned long flags; 220 221 spin_lock_irqsave(&dev->devres_lock, flags); 222 dr = find_dr(dev, release, match, match_data); 223 spin_unlock_irqrestore(&dev->devres_lock, flags); 224 225 if (dr) 226 return dr->data; 227 return NULL; 228} 229EXPORT_SYMBOL_GPL(devres_find); 230 231/** 232 * devres_get - Find devres, if non-existent, add one atomically 233 * @dev: Device to lookup or add devres for 234 * @new_res: Pointer to new initialized devres to add if not found 235 * @match: Match function (optional) 236 * @match_data: Data for the match function 237 * 238 * Find the latest devres of @dev which has the same release function 239 * as @new_res and for which @match return 1. If found, @new_res is 240 * freed; otherwise, @new_res is added atomically. 241 * 242 * RETURNS: 243 * Pointer to found or added devres. 244 */ 245void * devres_get(struct device *dev, void *new_res, 246 dr_match_t match, void *match_data) 247{ 248 struct devres *new_dr = container_of(new_res, struct devres, data); 249 struct devres *dr; 250 unsigned long flags; 251 252 spin_lock_irqsave(&dev->devres_lock, flags); 253 dr = find_dr(dev, new_dr->node.release, match, match_data); 254 if (!dr) { 255 add_dr(dev, &new_dr->node); 256 dr = new_dr; 257 new_dr = NULL; 258 } 259 spin_unlock_irqrestore(&dev->devres_lock, flags); 260 devres_free(new_dr); 261 262 return dr->data; 263} 264EXPORT_SYMBOL_GPL(devres_get); 265 266/** 267 * devres_remove - Find a device resource and remove it 268 * @dev: Device to find resource from 269 * @release: Look for resources associated with this release function 270 * @match: Match function (optional) 271 * @match_data: Data for the match function 272 * 273 * Find the latest devres of @dev associated with @release and for 274 * which @match returns 1. If @match is NULL, it's considered to 275 * match all. If found, the resource is removed atomically and 276 * returned. 277 * 278 * RETURNS: 279 * Pointer to removed devres on success, NULL if not found. 280 */ 281void * devres_remove(struct device *dev, dr_release_t release, 282 dr_match_t match, void *match_data) 283{ 284 struct devres *dr; 285 unsigned long flags; 286 287 spin_lock_irqsave(&dev->devres_lock, flags); 288 dr = find_dr(dev, release, match, match_data); 289 if (dr) { 290 list_del_init(&dr->node.entry); 291 devres_log(dev, &dr->node, "REM"); 292 } 293 spin_unlock_irqrestore(&dev->devres_lock, flags); 294 295 if (dr) 296 return dr->data; 297 return NULL; 298} 299EXPORT_SYMBOL_GPL(devres_remove); 300 301/** 302 * devres_destroy - Find a device resource and destroy it 303 * @dev: Device to find resource from 304 * @release: Look for resources associated with this release function 305 * @match: Match function (optional) 306 * @match_data: Data for the match function 307 * 308 * Find the latest devres of @dev associated with @release and for 309 * which @match returns 1. If @match is NULL, it's considered to 310 * match all. If found, the resource is removed atomically and freed. 311 * 312 * RETURNS: 313 * 0 if devres is found and freed, -ENOENT if not found. 314 */ 315int devres_destroy(struct device *dev, dr_release_t release, 316 dr_match_t match, void *match_data) 317{ 318 void *res; 319 320 res = devres_remove(dev, release, match, match_data); 321 if (unlikely(!res)) 322 return -ENOENT; 323 324 devres_free(res); 325 return 0; 326} 327EXPORT_SYMBOL_GPL(devres_destroy); 328 329static int remove_nodes(struct device *dev, 330 struct list_head *first, struct list_head *end, 331 struct list_head *todo) 332{ 333 int cnt = 0, nr_groups = 0; 334 struct list_head *cur; 335 336 /* First pass - move normal devres entries to @todo and clear 337 * devres_group colors. 338 */ 339 cur = first; 340 while (cur != end) { 341 struct devres_node *node; 342 struct devres_group *grp; 343 344 node = list_entry(cur, struct devres_node, entry); 345 cur = cur->next; 346 347 grp = node_to_group(node); 348 if (grp) { 349 /* clear color of group markers in the first pass */ 350 grp->color = 0; 351 nr_groups++; 352 } else { 353 /* regular devres entry */ 354 if (&node->entry == first) 355 first = first->next; 356 list_move_tail(&node->entry, todo); 357 cnt++; 358 } 359 } 360 361 if (!nr_groups) 362 return cnt; 363 364 /* Second pass - Scan groups and color them. A group gets 365 * color value of two iff the group is wholly contained in 366 * [cur, end). That is, for a closed group, both opening and 367 * closing markers should be in the range, while just the 368 * opening marker is enough for an open group. 369 */ 370 cur = first; 371 while (cur != end) { 372 struct devres_node *node; 373 struct devres_group *grp; 374 375 node = list_entry(cur, struct devres_node, entry); 376 cur = cur->next; 377 378 grp = node_to_group(node); 379 BUG_ON(!grp || list_empty(&grp->node[0].entry)); 380 381 grp->color++; 382 if (list_empty(&grp->node[1].entry)) 383 grp->color++; 384 385 BUG_ON(grp->color <= 0 || grp->color > 2); 386 if (grp->color == 2) { 387 /* No need to update cur or end. The removed 388 * nodes are always before both. 389 */ 390 list_move_tail(&grp->node[0].entry, todo); 391 list_del_init(&grp->node[1].entry); 392 } 393 } 394 395 return cnt; 396} 397 398static int release_nodes(struct device *dev, struct list_head *first, 399 struct list_head *end, unsigned long flags) 400{ 401 LIST_HEAD(todo); 402 int cnt; 403 struct devres *dr, *tmp; 404 405 cnt = remove_nodes(dev, first, end, &todo); 406 407 spin_unlock_irqrestore(&dev->devres_lock, flags); 408 409 /* Release. Note that both devres and devres_group are 410 * handled as devres in the following loop. This is safe. 411 */ 412 list_for_each_entry_safe_reverse(dr, tmp, &todo, node.entry) { 413 devres_log(dev, &dr->node, "REL"); 414 dr->node.release(dev, dr->data); 415 kfree(dr); 416 } 417 418 return cnt; 419} 420 421/** 422 * devres_release_all - Release all managed resources 423 * @dev: Device to release resources for 424 * 425 * Release all resources associated with @dev. This function is 426 * called on driver detach. 427 */ 428int devres_release_all(struct device *dev) 429{ 430 unsigned long flags; 431 432 /* Looks like an uninitialized device structure */ 433 if (WARN_ON(dev->devres_head.next == NULL)) 434 return -ENODEV; 435 spin_lock_irqsave(&dev->devres_lock, flags); 436 return release_nodes(dev, dev->devres_head.next, &dev->devres_head, 437 flags); 438} 439 440/** 441 * devres_open_group - Open a new devres group 442 * @dev: Device to open devres group for 443 * @id: Separator ID 444 * @gfp: Allocation flags 445 * 446 * Open a new devres group for @dev with @id. For @id, using a 447 * pointer to an object which won't be used for another group is 448 * recommended. If @id is NULL, address-wise unique ID is created. 449 * 450 * RETURNS: 451 * ID of the new group, NULL on failure. 452 */ 453void * devres_open_group(struct device *dev, void *id, gfp_t gfp) 454{ 455 struct devres_group *grp; 456 unsigned long flags; 457 458 grp = kmalloc(sizeof(*grp), gfp); 459 if (unlikely(!grp)) 460 return NULL; 461 462 grp->node[0].release = &group_open_release; 463 grp->node[1].release = &group_close_release; 464 INIT_LIST_HEAD(&grp->node[0].entry); 465 INIT_LIST_HEAD(&grp->node[1].entry); 466 set_node_dbginfo(&grp->node[0], "grp<", 0); 467 set_node_dbginfo(&grp->node[1], "grp>", 0); 468 grp->id = grp; 469 if (id) 470 grp->id = id; 471 472 spin_lock_irqsave(&dev->devres_lock, flags); 473 add_dr(dev, &grp->node[0]); 474 spin_unlock_irqrestore(&dev->devres_lock, flags); 475 return grp->id; 476} 477EXPORT_SYMBOL_GPL(devres_open_group); 478 479/* Find devres group with ID @id. If @id is NULL, look for the latest. */ 480static struct devres_group * find_group(struct device *dev, void *id) 481{ 482 struct devres_node *node; 483 484 list_for_each_entry_reverse(node, &dev->devres_head, entry) { 485 struct devres_group *grp; 486 487 if (node->release != &group_open_release) 488 continue; 489 490 grp = container_of(node, struct devres_group, node[0]); 491 492 if (id) { 493 if (grp->id == id) 494 return grp; 495 } else if (list_empty(&grp->node[1].entry)) 496 return grp; 497 } 498 499 return NULL; 500} 501 502/** 503 * devres_close_group - Close a devres group 504 * @dev: Device to close devres group for 505 * @id: ID of target group, can be NULL 506 * 507 * Close the group identified by @id. If @id is NULL, the latest open 508 * group is selected. 509 */ 510void devres_close_group(struct device *dev, void *id) 511{ 512 struct devres_group *grp; 513 unsigned long flags; 514 515 spin_lock_irqsave(&dev->devres_lock, flags); 516 517 grp = find_group(dev, id); 518 if (grp) 519 add_dr(dev, &grp->node[1]); 520 else 521 WARN_ON(1); 522 523 spin_unlock_irqrestore(&dev->devres_lock, flags); 524} 525EXPORT_SYMBOL_GPL(devres_close_group); 526 527/** 528 * devres_remove_group - Remove a devres group 529 * @dev: Device to remove group for 530 * @id: ID of target group, can be NULL 531 * 532 * Remove the group identified by @id. If @id is NULL, the latest 533 * open group is selected. Note that removing a group doesn't affect 534 * any other resources. 535 */ 536void devres_remove_group(struct device *dev, void *id) 537{ 538 struct devres_group *grp; 539 unsigned long flags; 540 541 spin_lock_irqsave(&dev->devres_lock, flags); 542 543 grp = find_group(dev, id); 544 if (grp) { 545 list_del_init(&grp->node[0].entry); 546 list_del_init(&grp->node[1].entry); 547 devres_log(dev, &grp->node[0], "REM"); 548 } else 549 WARN_ON(1); 550 551 spin_unlock_irqrestore(&dev->devres_lock, flags); 552 553 kfree(grp); 554} 555EXPORT_SYMBOL_GPL(devres_remove_group); 556 557/** 558 * devres_release_group - Release resources in a devres group 559 * @dev: Device to release group for 560 * @id: ID of target group, can be NULL 561 * 562 * Release all resources in the group identified by @id. If @id is 563 * NULL, the latest open group is selected. The selected group and 564 * groups properly nested inside the selected group are removed. 565 * 566 * RETURNS: 567 * The number of released non-group resources. 568 */ 569int devres_release_group(struct device *dev, void *id) 570{ 571 struct devres_group *grp; 572 unsigned long flags; 573 int cnt = 0; 574 575 spin_lock_irqsave(&dev->devres_lock, flags); 576 577 grp = find_group(dev, id); 578 if (grp) { 579 struct list_head *first = &grp->node[0].entry; 580 struct list_head *end = &dev->devres_head; 581 582 if (!list_empty(&grp->node[1].entry)) 583 end = grp->node[1].entry.next; 584 585 cnt = release_nodes(dev, first, end, flags); 586 } else { 587 WARN_ON(1); 588 spin_unlock_irqrestore(&dev->devres_lock, flags); 589 } 590 591 return cnt; 592} 593EXPORT_SYMBOL_GPL(devres_release_group); 594 595/* 596 * Managed kzalloc/kfree 597 */ 598static void devm_kzalloc_release(struct device *dev, void *res) 599{ 600 /* noop */ 601} 602 603static int devm_kzalloc_match(struct device *dev, void *res, void *data) 604{ 605 return res == data; 606} 607 608/** 609 * devm_kzalloc - Resource-managed kzalloc 610 * @dev: Device to allocate memory for 611 * @size: Allocation size 612 * @gfp: Allocation gfp flags 613 * 614 * Managed kzalloc. Memory allocated with this function is 615 * automatically freed on driver detach. Like all other devres 616 * resources, guaranteed alignment is unsigned long long. 617 * 618 * RETURNS: 619 * Pointer to allocated memory on success, NULL on failure. 620 */ 621void * devm_kzalloc(struct device *dev, size_t size, gfp_t gfp) 622{ 623 struct devres *dr; 624 625 /* use raw alloc_dr for kmalloc caller tracing */ 626 dr = alloc_dr(devm_kzalloc_release, size, gfp); 627 if (unlikely(!dr)) 628 return NULL; 629 630 set_node_dbginfo(&dr->node, "devm_kzalloc_release", size); 631 devres_add(dev, dr->data); 632 return dr->data; 633} 634EXPORT_SYMBOL_GPL(devm_kzalloc); 635 636/** 637 * devm_kfree - Resource-managed kfree 638 * @dev: Device this memory belongs to 639 * @p: Memory to free 640 * 641 * Free memory allocated with dev_kzalloc(). 642 */ 643void devm_kfree(struct device *dev, void *p) 644{ 645 int rc; 646 647 rc = devres_destroy(dev, devm_kzalloc_release, devm_kzalloc_match, p); 648 WARN_ON(rc); 649} 650EXPORT_SYMBOL_GPL(devm_kfree); 651