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