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