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