]>
Commit | Line | Data |
---|---|---|
6494d708 SG |
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 | ||
4984de2b | 14 | #include <dm/ofnode.h> |
6494d708 | 15 | #include <dm/uclass-id.h> |
c9cac3f8 | 16 | #include <fdtdec.h> |
6494d708 | 17 | #include <linker_lists.h> |
2b07f685 MY |
18 | #include <linux/compat.h> |
19 | #include <linux/kernel.h> | |
6494d708 SG |
20 | #include <linux/list.h> |
21 | ||
22 | struct driver_info; | |
23 | ||
24 | /* Driver is active (probed). Cleared when it is removed */ | |
fb04c9d7 | 25 | #define DM_FLAG_ACTIVATED (1 << 0) |
6494d708 SG |
26 | |
27 | /* DM is responsible for allocating and freeing platdata */ | |
fb04c9d7 | 28 | #define DM_FLAG_ALLOC_PDATA (1 << 1) |
6494d708 | 29 | |
00606d7e | 30 | /* DM should init this device prior to relocation */ |
fb04c9d7 | 31 | #define DM_FLAG_PRE_RELOC (1 << 2) |
00606d7e | 32 | |
cdc133bd SG |
33 | /* DM is responsible for allocating and freeing parent_platdata */ |
34 | #define DM_FLAG_ALLOC_PARENT_PDATA (1 << 3) | |
35 | ||
5eaed880 PM |
36 | /* DM is responsible for allocating and freeing uclass_platdata */ |
37 | #define DM_FLAG_ALLOC_UCLASS_PDATA (1 << 4) | |
38 | ||
2c03c463 | 39 | /* Allocate driver private data on a DMA boundary */ |
fb04c9d7 | 40 | #define DM_FLAG_ALLOC_PRIV_DMA (1 << 5) |
2c03c463 | 41 | |
aed1a4dd | 42 | /* Device is bound */ |
fb04c9d7 | 43 | #define DM_FLAG_BOUND (1 << 6) |
aed1a4dd | 44 | |
a2040fac | 45 | /* Device name is allocated and should be freed on unbind() */ |
fd1c2d9b | 46 | #define DM_FLAG_NAME_ALLOCED (1 << 7) |
a2040fac | 47 | |
9fa28190 SG |
48 | #define DM_FLAG_OF_PLATDATA (1 << 8) |
49 | ||
706865af SR |
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 | ||
426f99fa SR |
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 | ||
706865af SR |
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 | */ | |
69 | enum { | |
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 | ||
426f99fa SR |
76 | /* Remove devices which need some final OS preparation steps */ |
77 | DM_REMOVE_OS_PREPARE = DM_FLAG_OS_PREPARE, | |
78 | ||
706865af SR |
79 | /* Add more use cases here */ |
80 | ||
81 | /* Remove devices with any active flag */ | |
426f99fa | 82 | DM_REMOVE_ACTIVE_ALL = DM_REMOVE_ACTIVE_DMA | DM_REMOVE_OS_PREPARE, |
706865af SR |
83 | }; |
84 | ||
6494d708 | 85 | /** |
54c5d08a | 86 | * struct udevice - An instance of a driver |
6494d708 SG |
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 | |
cdc133bd | 105 | * @parent_platdata: The parent bus's configuration data for this device |
5eaed880 | 106 | * @uclass_platdata: The uclass's configuration data for this device |
4984de2b | 107 | * @node: Reference to device tree node for this device |
39de8433 SG |
108 | * @driver_data: Driver data word for the entry that matched this device with |
109 | * its driver | |
6494d708 SG |
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 | |
e59f458d | 114 | * @parent_priv: The parent's private data for this device |
6494d708 SG |
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_... | |
5a66a8ff | 119 | * @req_seq: Requested sequence number for this device (-1 = any) |
547cea19 SG |
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. | |
93c7fe4a SG |
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 | |
6494d708 | 126 | */ |
54c5d08a | 127 | struct udevice { |
3479253d | 128 | const struct driver *driver; |
6494d708 SG |
129 | const char *name; |
130 | void *platdata; | |
cdc133bd | 131 | void *parent_platdata; |
5eaed880 | 132 | void *uclass_platdata; |
4984de2b | 133 | ofnode node; |
39de8433 | 134 | ulong driver_data; |
54c5d08a | 135 | struct udevice *parent; |
6494d708 SG |
136 | void *priv; |
137 | struct uclass *uclass; | |
138 | void *uclass_priv; | |
e59f458d | 139 | void *parent_priv; |
6494d708 SG |
140 | struct list_head uclass_node; |
141 | struct list_head child_head; | |
142 | struct list_head sibling_node; | |
143 | uint32_t flags; | |
5a66a8ff SG |
144 | int req_seq; |
145 | int seq; | |
e2282d70 | 146 | #ifdef CONFIG_DEVRES |
608f26c5 | 147 | struct list_head devres_head; |
e2282d70 | 148 | #endif |
6494d708 SG |
149 | }; |
150 | ||
5a66a8ff SG |
151 | /* Maximum sequence number supported */ |
152 | #define DM_MAX_SEQ 999 | |
153 | ||
6494d708 SG |
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 | ||
e160f7d4 SG |
160 | static inline int dev_of_offset(const struct udevice *dev) |
161 | { | |
4984de2b | 162 | return ofnode_to_offset(dev->node); |
e160f7d4 SG |
163 | } |
164 | ||
165 | static inline void dev_set_of_offset(struct udevice *dev, int of_offset) | |
166 | { | |
4984de2b SG |
167 | dev->node = offset_to_ofnode(of_offset); |
168 | } | |
169 | ||
170 | static inline bool dev_has_of_node(struct udevice *dev) | |
171 | { | |
172 | return ofnode_valid(dev->node); | |
e160f7d4 SG |
173 | } |
174 | ||
6494d708 | 175 | /** |
ae7f4513 | 176 | * struct udevice_id - Lists the compatible strings supported by a driver |
6494d708 SG |
177 | * @compatible: Compatible string |
178 | * @data: Data for this compatible string | |
179 | */ | |
ae7f4513 | 180 | struct udevice_id { |
6494d708 SG |
181 | const char *compatible; |
182 | ulong data; | |
183 | }; | |
184 | ||
0f925822 | 185 | #if CONFIG_IS_ENABLED(OF_CONTROL) |
f887cb6d MY |
186 | #define of_match_ptr(_ptr) (_ptr) |
187 | #else | |
188 | #define of_match_ptr(_ptr) NULL | |
0f925822 | 189 | #endif /* CONFIG_IS_ENABLED(OF_CONTROL) */ |
f887cb6d | 190 | |
6494d708 SG |
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: Identiies 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 | |
0118ce79 | 213 | * @child_post_bind: Called after a new child has been bound |
a327dee0 SG |
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. | |
6494d708 SG |
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. | |
e59f458d SG |
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. | |
cdc133bd SG |
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. | |
0040b944 | 232 | * @ops: Driver-specific operations. This is typically a list of function |
6494d708 SG |
233 | * pointers defined by the driver, to implement driver functions required by |
234 | * the uclass. | |
00606d7e | 235 | * @flags: driver flags - see DM_FLAGS_... |
6494d708 SG |
236 | */ |
237 | struct driver { | |
238 | char *name; | |
239 | enum uclass_id id; | |
ae7f4513 | 240 | const struct udevice_id *of_match; |
54c5d08a HS |
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); | |
0118ce79 | 246 | int (*child_post_bind)(struct udevice *dev); |
a327dee0 SG |
247 | int (*child_pre_probe)(struct udevice *dev); |
248 | int (*child_post_remove)(struct udevice *dev); | |
6494d708 SG |
249 | int priv_auto_alloc_size; |
250 | int platdata_auto_alloc_size; | |
e59f458d | 251 | int per_child_auto_alloc_size; |
cdc133bd | 252 | int per_child_platdata_auto_alloc_size; |
6494d708 | 253 | const void *ops; /* driver-specific operations */ |
00606d7e | 254 | uint32_t flags; |
6494d708 SG |
255 | }; |
256 | ||
257 | /* Declare a new U-Boot driver */ | |
258 | #define U_BOOT_DRIVER(__name) \ | |
259 | ll_entry_declare(struct driver, __name, driver) | |
260 | ||
c57f806b SG |
261 | /* Get a pointer to a given driver */ |
262 | #define DM_GET_DRIVER(__name) \ | |
263 | ll_entry_get(struct driver, __name, driver) | |
264 | ||
6494d708 SG |
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 | */ | |
54c5d08a | 273 | void *dev_get_platdata(struct udevice *dev); |
6494d708 | 274 | |
cdc133bd SG |
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 | */ | |
283 | void *dev_get_parent_platdata(struct udevice *dev); | |
284 | ||
5eaed880 PM |
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 | */ | |
293 | void *dev_get_uclass_platdata(struct udevice *dev); | |
294 | ||
9a79f6e6 SG |
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 | */ | |
303 | void *dev_get_priv(struct udevice *dev); | |
304 | ||
e59f458d | 305 | /** |
bcbe3d15 | 306 | * dev_get_parent_priv() - Get the parent private data for a device |
e59f458d | 307 | * |
bcbe3d15 SG |
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. | |
e59f458d SG |
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 | */ | |
bcbe3d15 | 317 | void *dev_get_parent_priv(struct udevice *dev); |
e59f458d | 318 | |
6494d708 | 319 | /** |
9a79f6e6 | 320 | * dev_get_uclass_priv() - Get the private uclass data for a device |
6494d708 SG |
321 | * |
322 | * This checks that dev is not NULL, but no other checks for now | |
323 | * | |
324 | * @dev Device to check | |
9a79f6e6 | 325 | * @return private uclass data for this device, or NULL if none |
6494d708 | 326 | */ |
9a79f6e6 | 327 | void *dev_get_uclass_priv(struct udevice *dev); |
6494d708 | 328 | |
479728cb SG |
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 | */ | |
335 | struct udevice *dev_get_parent(struct udevice *child); | |
336 | ||
2ef249b4 | 337 | /** |
39de8433 | 338 | * dev_get_driver_data() - get the driver data used to bind a device |
2ef249b4 SG |
339 | * |
340 | * When a device is bound using a device tree node, it matches a | |
8d1f3a9d | 341 | * particular compatible string in struct udevice_id. This function |
39de8433 SG |
342 | * returns the associated data value for that compatible string. This is |
343 | * the 'data' field in struct udevice_id. | |
344 | * | |
8d1f3a9d SG |
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 | * | |
39de8433 SG |
357 | * For USB devices, this is the driver_info field in struct usb_device_id. |
358 | * | |
359 | * @dev: Device to check | |
8d1f3a9d | 360 | * @return driver data (0 if none is provided) |
2ef249b4 | 361 | */ |
39de8433 | 362 | ulong dev_get_driver_data(struct udevice *dev); |
2ef249b4 | 363 | |
cc73d37b PM |
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 | */ | |
373 | const void *dev_get_driver_ops(struct udevice *dev); | |
374 | ||
8d1f3a9d | 375 | /** |
b3670531 SG |
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 | */ | |
381 | enum uclass_id device_get_uclass_id(struct udevice *dev); | |
382 | ||
8d1f3a9d | 383 | /** |
f9c370dc PM |
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 | */ | |
391 | const char *dev_get_uclass_name(struct udevice *dev); | |
392 | ||
997c87bb SG |
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 | |
3f416f33 SG |
402 | * @return 0 if OK, -ENODEV if no such device, other error if the device fails |
403 | * to probe | |
997c87bb SG |
404 | */ |
405 | int device_get_child(struct udevice *parent, int index, struct udevice **devp); | |
406 | ||
5a66a8ff SG |
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 | */ | |
426 | int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq, | |
427 | bool find_req_seq, struct udevice **devp); | |
428 | ||
997c87bb SG |
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 | */ | |
444 | int 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 | */ | |
457 | int 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 | */ | |
132f9bfc | 472 | int device_get_child_by_of_offset(struct udevice *parent, int of_offset, |
997c87bb SG |
473 | struct udevice **devp); |
474 | ||
2693047a SG |
475 | /** |
476 | * device_get_global_by_of_offset() - Get a device based on FDT offset | |
477 | * | |
478 | * Locates a device by its device tree offset, searching globally throughout | |
479 | * the all driver model devices. | |
480 | * | |
481 | * The device is probed to activate it ready for use. | |
482 | * | |
483 | * @of_offset: Device tree offset 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 | int device_get_global_by_of_offset(int of_offset, struct udevice **devp); | |
488 | ||
a8981d4f SG |
489 | /** |
490 | * device_find_first_child() - Find the first child of a device | |
491 | * | |
492 | * @parent: Parent device to search | |
493 | * @devp: Returns first child device, or NULL if none | |
494 | * @return 0 | |
495 | */ | |
496 | int device_find_first_child(struct udevice *parent, struct udevice **devp); | |
497 | ||
498 | /** | |
3f416f33 | 499 | * device_find_next_child() - Find the next child of a device |
a8981d4f SG |
500 | * |
501 | * @devp: Pointer to previous child device on entry. Returns pointer to next | |
502 | * child device, or NULL if none | |
503 | * @return 0 | |
504 | */ | |
505 | int device_find_next_child(struct udevice **devp); | |
506 | ||
c5785673 SG |
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 | ||
f5c67ea0 SG |
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 | * | |
a2040fac SG |
544 | * The name is allocated and will be freed automatically when the device is |
545 | * unbound. | |
546 | * | |
f5c67ea0 SG |
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 | ||
a2040fac SG |
555 | /** |
556 | * device_set_name_alloced() - note that a device name is allocated | |
557 | * | |
fd1c2d9b | 558 | * This sets the DM_FLAG_NAME_ALLOCED flag for the device, so that when it is |
a2040fac SG |
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 | ||
73443b9e | 565 | /** |
911f3aef | 566 | * device_is_compatible() - check if the device is compatible with the compat |
73443b9e M |
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 | */ | |
911f3aef | 575 | bool device_is_compatible(struct udevice *dev, const char *compat); |
73443b9e M |
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 | ||
1e0f2263 BM |
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 | ||
7aeac5bc SG |
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 | ||
cc7f66f7 SG |
611 | /** |
612 | * dm_scan_fdt_dev() - Bind child device in a the device tree | |
613 | * | |
614 | * This handles device which have sub-nodes in the device tree. It scans all | |
615 | * sub-nodes and binds drivers for each node where a driver can be found. | |
616 | * | |
617 | * If this is called prior to relocation, only pre-relocation devices will be | |
618 | * bound (those marked with u-boot,dm-pre-reloc in the device tree, or where | |
619 | * the driver has the DM_FLAG_PRE_RELOC flag set). Otherwise, all devices will | |
620 | * be bound. | |
621 | * | |
622 | * @dev: Device to scan | |
623 | * @return 0 if OK, -ve on error | |
624 | */ | |
625 | int dm_scan_fdt_dev(struct udevice *dev); | |
626 | ||
608f26c5 MY |
627 | /* device resource management */ |
628 | typedef void (*dr_release_t)(struct udevice *dev, void *res); | |
629 | typedef int (*dr_match_t)(struct udevice *dev, void *res, void *match_data); | |
630 | ||
e2282d70 MY |
631 | #ifdef CONFIG_DEVRES |
632 | ||
608f26c5 MY |
633 | #ifdef CONFIG_DEBUG_DEVRES |
634 | void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp, | |
635 | const char *name); | |
636 | #define _devres_alloc(release, size, gfp) \ | |
637 | __devres_alloc(release, size, gfp, #release) | |
638 | #else | |
639 | void *_devres_alloc(dr_release_t release, size_t size, gfp_t gfp); | |
640 | #endif | |
641 | ||
642 | /** | |
93c7fe4a | 643 | * devres_alloc() - Allocate device resource data |
608f26c5 MY |
644 | * @release: Release function devres will be associated with |
645 | * @size: Allocation size | |
646 | * @gfp: Allocation flags | |
647 | * | |
648 | * Allocate devres of @size bytes. The allocated area is associated | |
649 | * with @release. The returned pointer can be passed to | |
650 | * other devres_*() functions. | |
651 | * | |
652 | * RETURNS: | |
653 | * Pointer to allocated devres on success, NULL on failure. | |
654 | */ | |
655 | #define devres_alloc(release, size, gfp) \ | |
656 | _devres_alloc(release, size, gfp | __GFP_ZERO) | |
657 | ||
658 | /** | |
93c7fe4a | 659 | * devres_free() - Free device resource data |
608f26c5 MY |
660 | * @res: Pointer to devres data to free |
661 | * | |
662 | * Free devres created with devres_alloc(). | |
663 | */ | |
664 | void devres_free(void *res); | |
665 | ||
666 | /** | |
93c7fe4a | 667 | * devres_add() - Register device resource |
608f26c5 MY |
668 | * @dev: Device to add resource to |
669 | * @res: Resource to register | |
670 | * | |
671 | * Register devres @res to @dev. @res should have been allocated | |
672 | * using devres_alloc(). On driver detach, the associated release | |
673 | * function will be invoked and devres will be freed automatically. | |
674 | */ | |
675 | void devres_add(struct udevice *dev, void *res); | |
676 | ||
677 | /** | |
93c7fe4a | 678 | * devres_find() - Find device resource |
608f26c5 MY |
679 | * @dev: Device to lookup resource from |
680 | * @release: Look for resources associated with this release function | |
681 | * @match: Match function (optional) | |
682 | * @match_data: Data for the match function | |
683 | * | |
684 | * Find the latest devres of @dev which is associated with @release | |
685 | * and for which @match returns 1. If @match is NULL, it's considered | |
686 | * to match all. | |
687 | * | |
93c7fe4a | 688 | * @return pointer to found devres, NULL if not found. |
608f26c5 MY |
689 | */ |
690 | void *devres_find(struct udevice *dev, dr_release_t release, | |
691 | dr_match_t match, void *match_data); | |
692 | ||
693 | /** | |
93c7fe4a | 694 | * devres_get() - Find devres, if non-existent, add one atomically |
608f26c5 MY |
695 | * @dev: Device to lookup or add devres for |
696 | * @new_res: Pointer to new initialized devres to add if not found | |
697 | * @match: Match function (optional) | |
698 | * @match_data: Data for the match function | |
699 | * | |
700 | * Find the latest devres of @dev which has the same release function | |
701 | * as @new_res and for which @match return 1. If found, @new_res is | |
702 | * freed; otherwise, @new_res is added atomically. | |
703 | * | |
93c7fe4a | 704 | * @return ointer to found or added devres. |
608f26c5 MY |
705 | */ |
706 | void *devres_get(struct udevice *dev, void *new_res, | |
707 | dr_match_t match, void *match_data); | |
708 | ||
709 | /** | |
93c7fe4a | 710 | * devres_remove() - Find a device resource and remove it |
608f26c5 MY |
711 | * @dev: Device to find resource from |
712 | * @release: Look for resources associated with this release function | |
713 | * @match: Match function (optional) | |
714 | * @match_data: Data for the match function | |
715 | * | |
716 | * Find the latest devres of @dev associated with @release and for | |
717 | * which @match returns 1. If @match is NULL, it's considered to | |
718 | * match all. If found, the resource is removed atomically and | |
719 | * returned. | |
720 | * | |
93c7fe4a | 721 | * @return ointer to removed devres on success, NULL if not found. |
608f26c5 MY |
722 | */ |
723 | void *devres_remove(struct udevice *dev, dr_release_t release, | |
724 | dr_match_t match, void *match_data); | |
725 | ||
726 | /** | |
93c7fe4a | 727 | * devres_destroy() - Find a device resource and destroy it |
608f26c5 MY |
728 | * @dev: Device to find resource from |
729 | * @release: Look for resources associated with this release function | |
730 | * @match: Match function (optional) | |
731 | * @match_data: Data for the match function | |
732 | * | |
733 | * Find the latest devres of @dev associated with @release and for | |
734 | * which @match returns 1. If @match is NULL, it's considered to | |
735 | * match all. If found, the resource is removed atomically and freed. | |
736 | * | |
737 | * Note that the release function for the resource will not be called, | |
738 | * only the devres-allocated data will be freed. The caller becomes | |
739 | * responsible for freeing any other data. | |
740 | * | |
93c7fe4a | 741 | * @return 0 if devres is found and freed, -ENOENT if not found. |
608f26c5 MY |
742 | */ |
743 | int devres_destroy(struct udevice *dev, dr_release_t release, | |
744 | dr_match_t match, void *match_data); | |
745 | ||
746 | /** | |
93c7fe4a | 747 | * devres_release() - Find a device resource and destroy it, calling release |
608f26c5 MY |
748 | * @dev: Device to find resource from |
749 | * @release: Look for resources associated with this release function | |
750 | * @match: Match function (optional) | |
751 | * @match_data: Data for the match function | |
752 | * | |
753 | * Find the latest devres of @dev associated with @release and for | |
754 | * which @match returns 1. If @match is NULL, it's considered to | |
755 | * match all. If found, the resource is removed atomically, the | |
756 | * release function called and the resource freed. | |
757 | * | |
93c7fe4a | 758 | * @return 0 if devres is found and freed, -ENOENT if not found. |
608f26c5 MY |
759 | */ |
760 | int devres_release(struct udevice *dev, dr_release_t release, | |
761 | dr_match_t match, void *match_data); | |
762 | ||
2b07f685 MY |
763 | /* managed devm_k.alloc/kfree for device drivers */ |
764 | /** | |
93c7fe4a | 765 | * devm_kmalloc() - Resource-managed kmalloc |
2b07f685 MY |
766 | * @dev: Device to allocate memory for |
767 | * @size: Allocation size | |
768 | * @gfp: Allocation gfp flags | |
769 | * | |
770 | * Managed kmalloc. Memory allocated with this function is | |
771 | * automatically freed on driver detach. Like all other devres | |
772 | * resources, guaranteed alignment is unsigned long long. | |
773 | * | |
93c7fe4a | 774 | * @return pointer to allocated memory on success, NULL on failure. |
2b07f685 MY |
775 | */ |
776 | void *devm_kmalloc(struct udevice *dev, size_t size, gfp_t gfp); | |
777 | static inline void *devm_kzalloc(struct udevice *dev, size_t size, gfp_t gfp) | |
778 | { | |
779 | return devm_kmalloc(dev, size, gfp | __GFP_ZERO); | |
780 | } | |
781 | static inline void *devm_kmalloc_array(struct udevice *dev, | |
782 | size_t n, size_t size, gfp_t flags) | |
783 | { | |
784 | if (size != 0 && n > SIZE_MAX / size) | |
785 | return NULL; | |
786 | return devm_kmalloc(dev, n * size, flags); | |
787 | } | |
788 | static inline void *devm_kcalloc(struct udevice *dev, | |
789 | size_t n, size_t size, gfp_t flags) | |
790 | { | |
791 | return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO); | |
792 | } | |
793 | ||
794 | /** | |
93c7fe4a | 795 | * devm_kfree() - Resource-managed kfree |
2b07f685 | 796 | * @dev: Device this memory belongs to |
93c7fe4a | 797 | * @ptr: Memory to free |
2b07f685 MY |
798 | * |
799 | * Free memory allocated with devm_kmalloc(). | |
800 | */ | |
93c7fe4a | 801 | void devm_kfree(struct udevice *dev, void *ptr); |
2b07f685 | 802 | |
e2282d70 MY |
803 | #else /* ! CONFIG_DEVRES */ |
804 | ||
805 | static inline void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp) | |
806 | { | |
807 | return kzalloc(size, gfp); | |
808 | } | |
809 | ||
810 | static inline void devres_free(void *res) | |
811 | { | |
812 | kfree(res); | |
813 | } | |
814 | ||
815 | static inline void devres_add(struct udevice *dev, void *res) | |
816 | { | |
817 | } | |
818 | ||
819 | static inline void *devres_find(struct udevice *dev, dr_release_t release, | |
820 | dr_match_t match, void *match_data) | |
821 | { | |
822 | return NULL; | |
823 | } | |
824 | ||
825 | static inline void *devres_get(struct udevice *dev, void *new_res, | |
826 | dr_match_t match, void *match_data) | |
827 | { | |
828 | return NULL; | |
829 | } | |
830 | ||
831 | static inline void *devres_remove(struct udevice *dev, dr_release_t release, | |
832 | dr_match_t match, void *match_data) | |
833 | { | |
834 | return NULL; | |
835 | } | |
836 | ||
837 | static inline int devres_destroy(struct udevice *dev, dr_release_t release, | |
838 | dr_match_t match, void *match_data) | |
839 | { | |
840 | return 0; | |
841 | } | |
842 | ||
843 | static inline int devres_release(struct udevice *dev, dr_release_t release, | |
844 | dr_match_t match, void *match_data) | |
845 | { | |
846 | return 0; | |
847 | } | |
848 | ||
849 | static inline void *devm_kmalloc(struct udevice *dev, size_t size, gfp_t gfp) | |
850 | { | |
851 | return kmalloc(size, gfp); | |
852 | } | |
853 | ||
854 | static inline void *devm_kzalloc(struct udevice *dev, size_t size, gfp_t gfp) | |
855 | { | |
856 | return kzalloc(size, gfp); | |
857 | } | |
858 | ||
859 | static inline void *devm_kmaloc_array(struct udevice *dev, | |
860 | size_t n, size_t size, gfp_t flags) | |
861 | { | |
862 | /* TODO: add kmalloc_array() to linux/compat.h */ | |
863 | if (size != 0 && n > SIZE_MAX / size) | |
864 | return NULL; | |
865 | return kmalloc(n * size, flags); | |
866 | } | |
867 | ||
868 | static inline void *devm_kcalloc(struct udevice *dev, | |
869 | size_t n, size_t size, gfp_t flags) | |
870 | { | |
871 | /* TODO: add kcalloc() to linux/compat.h */ | |
872 | return kmalloc(n * size, flags | __GFP_ZERO); | |
873 | } | |
874 | ||
93c7fe4a | 875 | static inline void devm_kfree(struct udevice *dev, void *ptr) |
e2282d70 | 876 | { |
93c7fe4a | 877 | kfree(ptr); |
e2282d70 MY |
878 | } |
879 | ||
880 | #endif /* ! CONFIG_DEVRES */ | |
2b07f685 | 881 | |
6494d708 | 882 | #endif |