1 /* 2 * Copyright (c) 2013 Google, Inc 3 * 4 * (C) Copyright 2012 5 * Pavel Herrmann <morpheus.ibis@gmail.com> 6 * Marek Vasut <marex@denx.de> 7 * 8 * SPDX-License-Identifier: GPL-2.0+ 9 */ 10 11 #ifndef _DM_DEVICE_H 12 #define _DM_DEVICE_H 13 14 #include <dm/uclass-id.h> 15 #include <fdtdec.h> 16 #include <linker_lists.h> 17 #include <linux/compat.h> 18 #include <linux/kernel.h> 19 #include <linux/list.h> 20 21 struct driver_info; 22 23 /* Driver is active (probed). Cleared when it is removed */ 24 #define DM_FLAG_ACTIVATED (1 << 0) 25 26 /* DM is responsible for allocating and freeing platdata */ 27 #define DM_FLAG_ALLOC_PDATA (1 << 1) 28 29 /* DM should init this device prior to relocation */ 30 #define DM_FLAG_PRE_RELOC (1 << 2) 31 32 /* DM is responsible for allocating and freeing parent_platdata */ 33 #define DM_FLAG_ALLOC_PARENT_PDATA (1 << 3) 34 35 /* DM is responsible for allocating and freeing uclass_platdata */ 36 #define DM_FLAG_ALLOC_UCLASS_PDATA (1 << 4) 37 38 /* Allocate driver private data on a DMA boundary */ 39 #define DM_FLAG_ALLOC_PRIV_DMA (1 << 5) 40 41 /* Device is bound */ 42 #define DM_FLAG_BOUND (1 << 6) 43 44 /* Device name is allocated and should be freed on unbind() */ 45 #define DM_FLAG_NAME_ALLOCED (1 << 7) 46 47 #define DM_FLAG_OF_PLATDATA (1 << 8) 48 49 /** 50 * struct udevice - An instance of a driver 51 * 52 * This holds information about a device, which is a driver bound to a 53 * particular port or peripheral (essentially a driver instance). 54 * 55 * A device will come into existence through a 'bind' call, either due to 56 * a U_BOOT_DEVICE() macro (in which case platdata is non-NULL) or a node 57 * in the device tree (in which case of_offset is >= 0). In the latter case 58 * we translate the device tree information into platdata in a function 59 * implemented by the driver ofdata_to_platdata method (called just before the 60 * probe method if the device has a device tree node. 61 * 62 * All three of platdata, priv and uclass_priv can be allocated by the 63 * driver, or you can use the auto_alloc_size members of struct driver and 64 * struct uclass_driver to have driver model do this automatically. 65 * 66 * @driver: The driver used by this device 67 * @name: Name of device, typically the FDT node name 68 * @platdata: Configuration data for this device 69 * @parent_platdata: The parent bus's configuration data for this device 70 * @uclass_platdata: The uclass's configuration data for this device 71 * @of_offset: Device tree node offset for this device (- for none) 72 * @driver_data: Driver data word for the entry that matched this device with 73 * its driver 74 * @parent: Parent of this device, or NULL for the top level device 75 * @priv: Private data for this device 76 * @uclass: Pointer to uclass for this device 77 * @uclass_priv: The uclass's private data for this device 78 * @parent_priv: The parent's private data for this device 79 * @uclass_node: Used by uclass to link its devices 80 * @child_head: List of children of this device 81 * @sibling_node: Next device in list of all devices 82 * @flags: Flags for this device DM_FLAG_... 83 * @req_seq: Requested sequence number for this device (-1 = any) 84 * @seq: Allocated sequence number for this device (-1 = none). This is set up 85 * when the device is probed and will be unique within the device's uclass. 86 * @devres_head: List of memory allocations associated with this device. 87 * When CONFIG_DEVRES is enabled, devm_kmalloc() and friends will 88 * add to this list. Memory so-allocated will be freed 89 * automatically when the device is removed / unbound 90 */ 91 struct udevice { 92 const struct driver *driver; 93 const char *name; 94 void *platdata; 95 void *parent_platdata; 96 void *uclass_platdata; 97 int of_offset; 98 ulong driver_data; 99 struct udevice *parent; 100 void *priv; 101 struct uclass *uclass; 102 void *uclass_priv; 103 void *parent_priv; 104 struct list_head uclass_node; 105 struct list_head child_head; 106 struct list_head sibling_node; 107 uint32_t flags; 108 int req_seq; 109 int seq; 110 #ifdef CONFIG_DEVRES 111 struct list_head devres_head; 112 #endif 113 }; 114 115 /* Maximum sequence number supported */ 116 #define DM_MAX_SEQ 999 117 118 /* Returns the operations for a device */ 119 #define device_get_ops(dev) (dev->driver->ops) 120 121 /* Returns non-zero if the device is active (probed and not removed) */ 122 #define device_active(dev) ((dev)->flags & DM_FLAG_ACTIVATED) 123 124 /** 125 * struct udevice_id - Lists the compatible strings supported by a driver 126 * @compatible: Compatible string 127 * @data: Data for this compatible string 128 */ 129 struct udevice_id { 130 const char *compatible; 131 ulong data; 132 }; 133 134 #if CONFIG_IS_ENABLED(OF_CONTROL) 135 #define of_match_ptr(_ptr) (_ptr) 136 #else 137 #define of_match_ptr(_ptr) NULL 138 #endif /* CONFIG_IS_ENABLED(OF_CONTROL) */ 139 140 /** 141 * struct driver - A driver for a feature or peripheral 142 * 143 * This holds methods for setting up a new device, and also removing it. 144 * The device needs information to set itself up - this is provided either 145 * by platdata or a device tree node (which we find by looking up 146 * matching compatible strings with of_match). 147 * 148 * Drivers all belong to a uclass, representing a class of devices of the 149 * same type. Common elements of the drivers can be implemented in the uclass, 150 * or the uclass can provide a consistent interface to the drivers within 151 * it. 152 * 153 * @name: Device name 154 * @id: Identiies the uclass we belong to 155 * @of_match: List of compatible strings to match, and any identifying data 156 * for each. 157 * @bind: Called to bind a device to its driver 158 * @probe: Called to probe a device, i.e. activate it 159 * @remove: Called to remove a device, i.e. de-activate it 160 * @unbind: Called to unbind a device from its driver 161 * @ofdata_to_platdata: Called before probe to decode device tree data 162 * @child_post_bind: Called after a new child has been bound 163 * @child_pre_probe: Called before a child device is probed. The device has 164 * memory allocated but it has not yet been probed. 165 * @child_post_remove: Called after a child device is removed. The device 166 * has memory allocated but its device_remove() method has been called. 167 * @priv_auto_alloc_size: If non-zero this is the size of the private data 168 * to be allocated in the device's ->priv pointer. If zero, then the driver 169 * is responsible for allocating any data required. 170 * @platdata_auto_alloc_size: If non-zero this is the size of the 171 * platform data to be allocated in the device's ->platdata pointer. 172 * This is typically only useful for device-tree-aware drivers (those with 173 * an of_match), since drivers which use platdata will have the data 174 * provided in the U_BOOT_DEVICE() instantiation. 175 * @per_child_auto_alloc_size: Each device can hold private data owned by 176 * its parent. If required this will be automatically allocated if this 177 * value is non-zero. 178 * @per_child_platdata_auto_alloc_size: A bus likes to store information about 179 * its children. If non-zero this is the size of this data, to be allocated 180 * in the child's parent_platdata pointer. 181 * @ops: Driver-specific operations. This is typically a list of function 182 * pointers defined by the driver, to implement driver functions required by 183 * the uclass. 184 * @flags: driver flags - see DM_FLAGS_... 185 */ 186 struct driver { 187 char *name; 188 enum uclass_id id; 189 const struct udevice_id *of_match; 190 int (*bind)(struct udevice *dev); 191 int (*probe)(struct udevice *dev); 192 int (*remove)(struct udevice *dev); 193 int (*unbind)(struct udevice *dev); 194 int (*ofdata_to_platdata)(struct udevice *dev); 195 int (*child_post_bind)(struct udevice *dev); 196 int (*child_pre_probe)(struct udevice *dev); 197 int (*child_post_remove)(struct udevice *dev); 198 int priv_auto_alloc_size; 199 int platdata_auto_alloc_size; 200 int per_child_auto_alloc_size; 201 int per_child_platdata_auto_alloc_size; 202 const void *ops; /* driver-specific operations */ 203 uint32_t flags; 204 }; 205 206 /* Declare a new U-Boot driver */ 207 #define U_BOOT_DRIVER(__name) \ 208 ll_entry_declare(struct driver, __name, driver) 209 210 /** 211 * dev_get_platdata() - Get the platform data for a device 212 * 213 * This checks that dev is not NULL, but no other checks for now 214 * 215 * @dev Device to check 216 * @return platform data, or NULL if none 217 */ 218 void *dev_get_platdata(struct udevice *dev); 219 220 /** 221 * dev_get_parent_platdata() - Get the parent platform data for a device 222 * 223 * This checks that dev is not NULL, but no other checks for now 224 * 225 * @dev Device to check 226 * @return parent's platform data, or NULL if none 227 */ 228 void *dev_get_parent_platdata(struct udevice *dev); 229 230 /** 231 * dev_get_uclass_platdata() - Get the uclass platform data for a device 232 * 233 * This checks that dev is not NULL, but no other checks for now 234 * 235 * @dev Device to check 236 * @return uclass's platform data, or NULL if none 237 */ 238 void *dev_get_uclass_platdata(struct udevice *dev); 239 240 /** 241 * dev_get_priv() - Get the private data for a device 242 * 243 * This checks that dev is not NULL, but no other checks for now 244 * 245 * @dev Device to check 246 * @return private data, or NULL if none 247 */ 248 void *dev_get_priv(struct udevice *dev); 249 250 /** 251 * dev_get_parent_priv() - Get the parent private data for a device 252 * 253 * The parent private data is data stored in the device but owned by the 254 * parent. For example, a USB device may have parent data which contains 255 * information about how to talk to the device over USB. 256 * 257 * This checks that dev is not NULL, but no other checks for now 258 * 259 * @dev Device to check 260 * @return parent data, or NULL if none 261 */ 262 void *dev_get_parent_priv(struct udevice *dev); 263 264 /** 265 * dev_get_uclass_priv() - Get the private uclass data for a device 266 * 267 * This checks that dev is not NULL, but no other checks for now 268 * 269 * @dev Device to check 270 * @return private uclass data for this device, or NULL if none 271 */ 272 void *dev_get_uclass_priv(struct udevice *dev); 273 274 /** 275 * struct dev_get_parent() - Get the parent of a device 276 * 277 * @child: Child to check 278 * @return parent of child, or NULL if this is the root device 279 */ 280 struct udevice *dev_get_parent(struct udevice *child); 281 282 /** 283 * dev_get_driver_data() - get the driver data used to bind a device 284 * 285 * When a device is bound using a device tree node, it matches a 286 * particular compatible string in struct udevice_id. This function 287 * returns the associated data value for that compatible string. This is 288 * the 'data' field in struct udevice_id. 289 * 290 * As an example, consider this structure: 291 * static const struct udevice_id tegra_i2c_ids[] = { 292 * { .compatible = "nvidia,tegra114-i2c", .data = TYPE_114 }, 293 * { .compatible = "nvidia,tegra20-i2c", .data = TYPE_STD }, 294 * { .compatible = "nvidia,tegra20-i2c-dvc", .data = TYPE_DVC }, 295 * { } 296 * }; 297 * 298 * When driver model finds a driver for this it will store the 'data' value 299 * corresponding to the compatible string it matches. This function returns 300 * that value. This allows the driver to handle several variants of a device. 301 * 302 * For USB devices, this is the driver_info field in struct usb_device_id. 303 * 304 * @dev: Device to check 305 * @return driver data (0 if none is provided) 306 */ 307 ulong dev_get_driver_data(struct udevice *dev); 308 309 /** 310 * dev_get_driver_ops() - get the device's driver's operations 311 * 312 * This checks that dev is not NULL, and returns the pointer to device's 313 * driver's operations. 314 * 315 * @dev: Device to check 316 * @return void pointer to driver's operations or NULL for NULL-dev or NULL-ops 317 */ 318 const void *dev_get_driver_ops(struct udevice *dev); 319 320 /** 321 * device_get_uclass_id() - return the uclass ID of a device 322 * 323 * @dev: Device to check 324 * @return uclass ID for the device 325 */ 326 enum uclass_id device_get_uclass_id(struct udevice *dev); 327 328 /** 329 * dev_get_uclass_name() - return the uclass name of a device 330 * 331 * This checks that dev is not NULL. 332 * 333 * @dev: Device to check 334 * @return pointer to the uclass name for the device 335 */ 336 const char *dev_get_uclass_name(struct udevice *dev); 337 338 /** 339 * device_get_child() - Get the child of a device by index 340 * 341 * Returns the numbered child, 0 being the first. This does not use 342 * sequence numbers, only the natural order. 343 * 344 * @dev: Parent device to check 345 * @index: Child index 346 * @devp: Returns pointer to device 347 * @return 0 if OK, -ENODEV if no such device, other error if the device fails 348 * to probe 349 */ 350 int device_get_child(struct udevice *parent, int index, struct udevice **devp); 351 352 /** 353 * device_find_child_by_seq() - Find a child device based on a sequence 354 * 355 * This searches for a device with the given seq or req_seq. 356 * 357 * For seq, if an active device has this sequence it will be returned. 358 * If there is no such device then this will return -ENODEV. 359 * 360 * For req_seq, if a device (whether activated or not) has this req_seq 361 * value, that device will be returned. This is a strong indication that 362 * the device will receive that sequence when activated. 363 * 364 * @parent: Parent device 365 * @seq_or_req_seq: Sequence number to find (0=first) 366 * @find_req_seq: true to find req_seq, false to find seq 367 * @devp: Returns pointer to device (there is only one per for each seq). 368 * Set to NULL if none is found 369 * @return 0 if OK, -ve on error 370 */ 371 int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq, 372 bool find_req_seq, struct udevice **devp); 373 374 /** 375 * device_get_child_by_seq() - Get a child device based on a sequence 376 * 377 * If an active device has this sequence it will be returned. If there is no 378 * such device then this will check for a device that is requesting this 379 * sequence. 380 * 381 * The device is probed to activate it ready for use. 382 * 383 * @parent: Parent device 384 * @seq: Sequence number to find (0=first) 385 * @devp: Returns pointer to device (there is only one per for each seq) 386 * Set to NULL if none is found 387 * @return 0 if OK, -ve on error 388 */ 389 int device_get_child_by_seq(struct udevice *parent, int seq, 390 struct udevice **devp); 391 392 /** 393 * device_find_child_by_of_offset() - Find a child device based on FDT offset 394 * 395 * Locates a child device by its device tree offset. 396 * 397 * @parent: Parent device 398 * @of_offset: Device tree offset to find 399 * @devp: Returns pointer to device if found, otherwise this is set to NULL 400 * @return 0 if OK, -ve on error 401 */ 402 int device_find_child_by_of_offset(struct udevice *parent, int of_offset, 403 struct udevice **devp); 404 405 /** 406 * device_get_child_by_of_offset() - Get a child device based on FDT offset 407 * 408 * Locates a child device by its device tree offset. 409 * 410 * The device is probed to activate it ready for use. 411 * 412 * @parent: Parent device 413 * @of_offset: Device tree offset to find 414 * @devp: Returns pointer to device if found, otherwise this is set to NULL 415 * @return 0 if OK, -ve on error 416 */ 417 int device_get_child_by_of_offset(struct udevice *parent, int of_offset, 418 struct udevice **devp); 419 420 /** 421 * device_get_global_by_of_offset() - Get a device based on FDT offset 422 * 423 * Locates a device by its device tree offset, searching globally throughout 424 * the all driver model devices. 425 * 426 * The device is probed to activate it ready for use. 427 * 428 * @of_offset: Device tree offset to find 429 * @devp: Returns pointer to device if found, otherwise this is set to NULL 430 * @return 0 if OK, -ve on error 431 */ 432 int device_get_global_by_of_offset(int of_offset, struct udevice **devp); 433 434 /** 435 * device_find_first_child() - Find the first child of a device 436 * 437 * @parent: Parent device to search 438 * @devp: Returns first child device, or NULL if none 439 * @return 0 440 */ 441 int device_find_first_child(struct udevice *parent, struct udevice **devp); 442 443 /** 444 * device_find_next_child() - Find the next child of a device 445 * 446 * @devp: Pointer to previous child device on entry. Returns pointer to next 447 * child device, or NULL if none 448 * @return 0 449 */ 450 int device_find_next_child(struct udevice **devp); 451 452 /** 453 * dev_get_addr() - Get the reg property of a device 454 * 455 * @dev: Pointer to a device 456 * 457 * @return addr 458 */ 459 fdt_addr_t dev_get_addr(struct udevice *dev); 460 461 /** 462 * dev_get_addr_ptr() - Return pointer to the address of the reg property 463 * of a device 464 * 465 * @dev: Pointer to a device 466 * 467 * @return Pointer to addr, or NULL if there is no such property 468 */ 469 void *dev_get_addr_ptr(struct udevice *dev); 470 471 /** 472 * dev_map_physmem() - Read device address from reg property of the 473 * device node and map the address into CPU address 474 * space. 475 * 476 * @dev: Pointer to device 477 * @size: size of the memory to map 478 * 479 * @return mapped address, or NULL if the device does not have reg 480 * property. 481 */ 482 void *dev_map_physmem(struct udevice *dev, unsigned long size); 483 484 /** 485 * dev_get_addr_index() - Get the indexed reg property of a device 486 * 487 * @dev: Pointer to a device 488 * @index: the 'reg' property can hold a list of <addr, size> pairs 489 * and @index is used to select which one is required 490 * 491 * @return addr 492 */ 493 fdt_addr_t dev_get_addr_index(struct udevice *dev, int index); 494 495 /** 496 * dev_get_addr_name() - Get the reg property of a device, indexed by name 497 * 498 * @dev: Pointer to a device 499 * @name: the 'reg' property can hold a list of <addr, size> pairs, with the 500 * 'reg-names' property providing named-based identification. @index 501 * indicates the value to search for in 'reg-names'. 502 * 503 * @return addr 504 */ 505 fdt_addr_t dev_get_addr_name(struct udevice *dev, const char *name); 506 507 /** 508 * device_has_children() - check if a device has any children 509 * 510 * @dev: Device to check 511 * @return true if the device has one or more children 512 */ 513 bool device_has_children(struct udevice *dev); 514 515 /** 516 * device_has_active_children() - check if a device has any active children 517 * 518 * @dev: Device to check 519 * @return true if the device has one or more children and at least one of 520 * them is active (probed). 521 */ 522 bool device_has_active_children(struct udevice *dev); 523 524 /** 525 * device_is_last_sibling() - check if a device is the last sibling 526 * 527 * This function can be useful for display purposes, when special action needs 528 * to be taken when displaying the last sibling. This can happen when a tree 529 * view of devices is being displayed. 530 * 531 * @dev: Device to check 532 * @return true if there are no more siblings after this one - i.e. is it 533 * last in the list. 534 */ 535 bool device_is_last_sibling(struct udevice *dev); 536 537 /** 538 * device_set_name() - set the name of a device 539 * 540 * This must be called in the device's bind() method and no later. Normally 541 * this is unnecessary but for probed devices which don't get a useful name 542 * this function can be helpful. 543 * 544 * The name is allocated and will be freed automatically when the device is 545 * unbound. 546 * 547 * @dev: Device to update 548 * @name: New name (this string is allocated new memory and attached to 549 * the device) 550 * @return 0 if OK, -ENOMEM if there is not enough memory to allocate the 551 * string 552 */ 553 int device_set_name(struct udevice *dev, const char *name); 554 555 /** 556 * device_set_name_alloced() - note that a device name is allocated 557 * 558 * This sets the DM_FLAG_NAME_ALLOCED flag for the device, so that when it is 559 * unbound the name will be freed. This avoids memory leaks. 560 * 561 * @dev: Device to update 562 */ 563 void device_set_name_alloced(struct udevice *dev); 564 565 /** 566 * of_device_is_compatible() - check if the device is compatible with the compat 567 * 568 * This allows to check whether the device is comaptible with the compat. 569 * 570 * @dev: udevice pointer for which compatible needs to be verified. 571 * @compat: Compatible string which needs to verified in the given 572 * device 573 * @return true if OK, false if the compatible is not found 574 */ 575 bool of_device_is_compatible(struct udevice *dev, const char *compat); 576 577 /** 578 * of_machine_is_compatible() - check if the machine is compatible with 579 * the compat 580 * 581 * This allows to check whether the machine is comaptible with the compat. 582 * 583 * @compat: Compatible string which needs to verified 584 * @return true if OK, false if the compatible is not found 585 */ 586 bool of_machine_is_compatible(const char *compat); 587 588 /** 589 * device_is_on_pci_bus - Test if a device is on a PCI bus 590 * 591 * @dev: device to test 592 * @return: true if it is on a PCI bus, false otherwise 593 */ 594 static inline bool device_is_on_pci_bus(struct udevice *dev) 595 { 596 return device_get_uclass_id(dev->parent) == UCLASS_PCI; 597 } 598 599 /** 600 * device_foreach_child_safe() - iterate through child devices safely 601 * 602 * This allows the @pos child to be removed in the loop if required. 603 * 604 * @pos: struct udevice * for the current device 605 * @next: struct udevice * for the next device 606 * @parent: parent device to scan 607 */ 608 #define device_foreach_child_safe(pos, next, parent) \ 609 list_for_each_entry_safe(pos, next, &parent->child_head, sibling_node) 610 611 /* device resource management */ 612 typedef void (*dr_release_t)(struct udevice *dev, void *res); 613 typedef int (*dr_match_t)(struct udevice *dev, void *res, void *match_data); 614 615 #ifdef CONFIG_DEVRES 616 617 #ifdef CONFIG_DEBUG_DEVRES 618 void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp, 619 const char *name); 620 #define _devres_alloc(release, size, gfp) \ 621 __devres_alloc(release, size, gfp, #release) 622 #else 623 void *_devres_alloc(dr_release_t release, size_t size, gfp_t gfp); 624 #endif 625 626 /** 627 * devres_alloc() - Allocate device resource data 628 * @release: Release function devres will be associated with 629 * @size: Allocation size 630 * @gfp: Allocation flags 631 * 632 * Allocate devres of @size bytes. The allocated area is associated 633 * with @release. The returned pointer can be passed to 634 * other devres_*() functions. 635 * 636 * RETURNS: 637 * Pointer to allocated devres on success, NULL on failure. 638 */ 639 #define devres_alloc(release, size, gfp) \ 640 _devres_alloc(release, size, gfp | __GFP_ZERO) 641 642 /** 643 * devres_free() - Free device resource data 644 * @res: Pointer to devres data to free 645 * 646 * Free devres created with devres_alloc(). 647 */ 648 void devres_free(void *res); 649 650 /** 651 * devres_add() - Register device resource 652 * @dev: Device to add resource to 653 * @res: Resource to register 654 * 655 * Register devres @res to @dev. @res should have been allocated 656 * using devres_alloc(). On driver detach, the associated release 657 * function will be invoked and devres will be freed automatically. 658 */ 659 void devres_add(struct udevice *dev, void *res); 660 661 /** 662 * devres_find() - Find device resource 663 * @dev: Device to lookup resource from 664 * @release: Look for resources associated with this release function 665 * @match: Match function (optional) 666 * @match_data: Data for the match function 667 * 668 * Find the latest devres of @dev which is associated with @release 669 * and for which @match returns 1. If @match is NULL, it's considered 670 * to match all. 671 * 672 * @return pointer to found devres, NULL if not found. 673 */ 674 void *devres_find(struct udevice *dev, dr_release_t release, 675 dr_match_t match, void *match_data); 676 677 /** 678 * devres_get() - Find devres, if non-existent, add one atomically 679 * @dev: Device to lookup or add devres for 680 * @new_res: Pointer to new initialized devres to add if not found 681 * @match: Match function (optional) 682 * @match_data: Data for the match function 683 * 684 * Find the latest devres of @dev which has the same release function 685 * as @new_res and for which @match return 1. If found, @new_res is 686 * freed; otherwise, @new_res is added atomically. 687 * 688 * @return ointer to found or added devres. 689 */ 690 void *devres_get(struct udevice *dev, void *new_res, 691 dr_match_t match, void *match_data); 692 693 /** 694 * devres_remove() - Find a device resource and remove it 695 * @dev: Device to find resource from 696 * @release: Look for resources associated with this release function 697 * @match: Match function (optional) 698 * @match_data: Data for the match function 699 * 700 * Find the latest devres of @dev associated with @release and for 701 * which @match returns 1. If @match is NULL, it's considered to 702 * match all. If found, the resource is removed atomically and 703 * returned. 704 * 705 * @return ointer to removed devres on success, NULL if not found. 706 */ 707 void *devres_remove(struct udevice *dev, dr_release_t release, 708 dr_match_t match, void *match_data); 709 710 /** 711 * devres_destroy() - Find a device resource and destroy it 712 * @dev: Device to find resource from 713 * @release: Look for resources associated with this release function 714 * @match: Match function (optional) 715 * @match_data: Data for the match function 716 * 717 * Find the latest devres of @dev associated with @release and for 718 * which @match returns 1. If @match is NULL, it's considered to 719 * match all. If found, the resource is removed atomically and freed. 720 * 721 * Note that the release function for the resource will not be called, 722 * only the devres-allocated data will be freed. The caller becomes 723 * responsible for freeing any other data. 724 * 725 * @return 0 if devres is found and freed, -ENOENT if not found. 726 */ 727 int devres_destroy(struct udevice *dev, dr_release_t release, 728 dr_match_t match, void *match_data); 729 730 /** 731 * devres_release() - Find a device resource and destroy it, calling release 732 * @dev: Device to find resource from 733 * @release: Look for resources associated with this release function 734 * @match: Match function (optional) 735 * @match_data: Data for the match function 736 * 737 * Find the latest devres of @dev associated with @release and for 738 * which @match returns 1. If @match is NULL, it's considered to 739 * match all. If found, the resource is removed atomically, the 740 * release function called and the resource freed. 741 * 742 * @return 0 if devres is found and freed, -ENOENT if not found. 743 */ 744 int devres_release(struct udevice *dev, dr_release_t release, 745 dr_match_t match, void *match_data); 746 747 /* managed devm_k.alloc/kfree for device drivers */ 748 /** 749 * devm_kmalloc() - Resource-managed kmalloc 750 * @dev: Device to allocate memory for 751 * @size: Allocation size 752 * @gfp: Allocation gfp flags 753 * 754 * Managed kmalloc. Memory allocated with this function is 755 * automatically freed on driver detach. Like all other devres 756 * resources, guaranteed alignment is unsigned long long. 757 * 758 * @return pointer to allocated memory on success, NULL on failure. 759 */ 760 void *devm_kmalloc(struct udevice *dev, size_t size, gfp_t gfp); 761 static inline void *devm_kzalloc(struct udevice *dev, size_t size, gfp_t gfp) 762 { 763 return devm_kmalloc(dev, size, gfp | __GFP_ZERO); 764 } 765 static inline void *devm_kmalloc_array(struct udevice *dev, 766 size_t n, size_t size, gfp_t flags) 767 { 768 if (size != 0 && n > SIZE_MAX / size) 769 return NULL; 770 return devm_kmalloc(dev, n * size, flags); 771 } 772 static inline void *devm_kcalloc(struct udevice *dev, 773 size_t n, size_t size, gfp_t flags) 774 { 775 return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO); 776 } 777 778 /** 779 * devm_kfree() - Resource-managed kfree 780 * @dev: Device this memory belongs to 781 * @ptr: Memory to free 782 * 783 * Free memory allocated with devm_kmalloc(). 784 */ 785 void devm_kfree(struct udevice *dev, void *ptr); 786 787 #else /* ! CONFIG_DEVRES */ 788 789 static inline void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp) 790 { 791 return kzalloc(size, gfp); 792 } 793 794 static inline void devres_free(void *res) 795 { 796 kfree(res); 797 } 798 799 static inline void devres_add(struct udevice *dev, void *res) 800 { 801 } 802 803 static inline void *devres_find(struct udevice *dev, dr_release_t release, 804 dr_match_t match, void *match_data) 805 { 806 return NULL; 807 } 808 809 static inline void *devres_get(struct udevice *dev, void *new_res, 810 dr_match_t match, void *match_data) 811 { 812 return NULL; 813 } 814 815 static inline void *devres_remove(struct udevice *dev, dr_release_t release, 816 dr_match_t match, void *match_data) 817 { 818 return NULL; 819 } 820 821 static inline int devres_destroy(struct udevice *dev, dr_release_t release, 822 dr_match_t match, void *match_data) 823 { 824 return 0; 825 } 826 827 static inline int devres_release(struct udevice *dev, dr_release_t release, 828 dr_match_t match, void *match_data) 829 { 830 return 0; 831 } 832 833 static inline void *devm_kmalloc(struct udevice *dev, size_t size, gfp_t gfp) 834 { 835 return kmalloc(size, gfp); 836 } 837 838 static inline void *devm_kzalloc(struct udevice *dev, size_t size, gfp_t gfp) 839 { 840 return kzalloc(size, gfp); 841 } 842 843 static inline void *devm_kmaloc_array(struct udevice *dev, 844 size_t n, size_t size, gfp_t flags) 845 { 846 /* TODO: add kmalloc_array() to linux/compat.h */ 847 if (size != 0 && n > SIZE_MAX / size) 848 return NULL; 849 return kmalloc(n * size, flags); 850 } 851 852 static inline void *devm_kcalloc(struct udevice *dev, 853 size_t n, size_t size, gfp_t flags) 854 { 855 /* TODO: add kcalloc() to linux/compat.h */ 856 return kmalloc(n * size, flags | __GFP_ZERO); 857 } 858 859 static inline void devm_kfree(struct udevice *dev, void *ptr) 860 { 861 kfree(ptr); 862 } 863 864 #endif /* ! CONFIG_DEVRES */ 865 866 /** 867 * dm_set_translation_offset() - Set translation offset 868 * @offs: Translation offset 869 * 870 * Some platforms need a special address translation. Those 871 * platforms (e.g. mvebu in SPL) can configure a translation 872 * offset in the DM by calling this function. It will be 873 * added to all addresses returned in dev_get_addr(). 874 */ 875 void dm_set_translation_offset(fdt_addr_t offs); 876 877 /** 878 * dm_get_translation_offset() - Get translation offset 879 * 880 * This function returns the translation offset that can 881 * be configured by calling dm_set_translation_offset(). 882 * 883 * @return translation offset for the device address (0 as default). 884 */ 885 fdt_addr_t dm_get_translation_offset(void); 886 887 #endif 888