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