]>
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 */ | |
24 | #define DM_FLAG_ACTIVATED (1 << 0) | |
25 | ||
26 | /* DM is responsible for allocating and freeing platdata */ | |
f2bc6fc3 | 27 | #define DM_FLAG_ALLOC_PDATA (1 << 1) |
6494d708 | 28 | |
00606d7e SG |
29 | /* DM should init this device prior to relocation */ |
30 | #define DM_FLAG_PRE_RELOC (1 << 2) | |
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 */ |
5eaed880 | 39 | #define DM_FLAG_ALLOC_PRIV_DMA (1 << 5) |
2c03c463 | 40 | |
aed1a4dd MY |
41 | /* Device is bound */ |
42 | #define DM_FLAG_BOUND (1 << 6) | |
43 | ||
6494d708 | 44 | /** |
54c5d08a | 45 | * struct udevice - An instance of a driver |
6494d708 SG |
46 | * |
47 | * This holds information about a device, which is a driver bound to a | |
48 | * particular port or peripheral (essentially a driver instance). | |
49 | * | |
50 | * A device will come into existence through a 'bind' call, either due to | |
51 | * a U_BOOT_DEVICE() macro (in which case platdata is non-NULL) or a node | |
52 | * in the device tree (in which case of_offset is >= 0). In the latter case | |
53 | * we translate the device tree information into platdata in a function | |
54 | * implemented by the driver ofdata_to_platdata method (called just before the | |
55 | * probe method if the device has a device tree node. | |
56 | * | |
57 | * All three of platdata, priv and uclass_priv can be allocated by the | |
58 | * driver, or you can use the auto_alloc_size members of struct driver and | |
59 | * struct uclass_driver to have driver model do this automatically. | |
60 | * | |
61 | * @driver: The driver used by this device | |
62 | * @name: Name of device, typically the FDT node name | |
63 | * @platdata: Configuration data for this device | |
cdc133bd | 64 | * @parent_platdata: The parent bus's configuration data for this device |
5eaed880 | 65 | * @uclass_platdata: The uclass's configuration data for this device |
6494d708 | 66 | * @of_offset: Device tree node offset for this device (- for none) |
39de8433 SG |
67 | * @driver_data: Driver data word for the entry that matched this device with |
68 | * its driver | |
6494d708 SG |
69 | * @parent: Parent of this device, or NULL for the top level device |
70 | * @priv: Private data for this device | |
71 | * @uclass: Pointer to uclass for this device | |
72 | * @uclass_priv: The uclass's private data for this device | |
e59f458d | 73 | * @parent_priv: The parent's private data for this device |
6494d708 SG |
74 | * @uclass_node: Used by uclass to link its devices |
75 | * @child_head: List of children of this device | |
76 | * @sibling_node: Next device in list of all devices | |
77 | * @flags: Flags for this device DM_FLAG_... | |
5a66a8ff | 78 | * @req_seq: Requested sequence number for this device (-1 = any) |
547cea19 SG |
79 | * @seq: Allocated sequence number for this device (-1 = none). This is set up |
80 | * when the device is probed and will be unique within the device's uclass. | |
6494d708 | 81 | */ |
54c5d08a | 82 | struct udevice { |
3479253d | 83 | const struct driver *driver; |
6494d708 SG |
84 | const char *name; |
85 | void *platdata; | |
cdc133bd | 86 | void *parent_platdata; |
5eaed880 | 87 | void *uclass_platdata; |
6494d708 | 88 | int of_offset; |
39de8433 | 89 | ulong driver_data; |
54c5d08a | 90 | struct udevice *parent; |
6494d708 SG |
91 | void *priv; |
92 | struct uclass *uclass; | |
93 | void *uclass_priv; | |
e59f458d | 94 | void *parent_priv; |
6494d708 SG |
95 | struct list_head uclass_node; |
96 | struct list_head child_head; | |
97 | struct list_head sibling_node; | |
98 | uint32_t flags; | |
5a66a8ff SG |
99 | int req_seq; |
100 | int seq; | |
e2282d70 | 101 | #ifdef CONFIG_DEVRES |
608f26c5 | 102 | struct list_head devres_head; |
e2282d70 | 103 | #endif |
6494d708 SG |
104 | }; |
105 | ||
5a66a8ff SG |
106 | /* Maximum sequence number supported */ |
107 | #define DM_MAX_SEQ 999 | |
108 | ||
6494d708 SG |
109 | /* Returns the operations for a device */ |
110 | #define device_get_ops(dev) (dev->driver->ops) | |
111 | ||
112 | /* Returns non-zero if the device is active (probed and not removed) */ | |
113 | #define device_active(dev) ((dev)->flags & DM_FLAG_ACTIVATED) | |
114 | ||
115 | /** | |
ae7f4513 | 116 | * struct udevice_id - Lists the compatible strings supported by a driver |
6494d708 SG |
117 | * @compatible: Compatible string |
118 | * @data: Data for this compatible string | |
119 | */ | |
ae7f4513 | 120 | struct udevice_id { |
6494d708 SG |
121 | const char *compatible; |
122 | ulong data; | |
123 | }; | |
124 | ||
f887cb6d MY |
125 | #ifdef CONFIG_OF_CONTROL |
126 | #define of_match_ptr(_ptr) (_ptr) | |
127 | #else | |
128 | #define of_match_ptr(_ptr) NULL | |
129 | #endif /* CONFIG_OF_CONTROL */ | |
130 | ||
6494d708 SG |
131 | /** |
132 | * struct driver - A driver for a feature or peripheral | |
133 | * | |
134 | * This holds methods for setting up a new device, and also removing it. | |
135 | * The device needs information to set itself up - this is provided either | |
136 | * by platdata or a device tree node (which we find by looking up | |
137 | * matching compatible strings with of_match). | |
138 | * | |
139 | * Drivers all belong to a uclass, representing a class of devices of the | |
140 | * same type. Common elements of the drivers can be implemented in the uclass, | |
141 | * or the uclass can provide a consistent interface to the drivers within | |
142 | * it. | |
143 | * | |
144 | * @name: Device name | |
145 | * @id: Identiies the uclass we belong to | |
146 | * @of_match: List of compatible strings to match, and any identifying data | |
147 | * for each. | |
148 | * @bind: Called to bind a device to its driver | |
149 | * @probe: Called to probe a device, i.e. activate it | |
150 | * @remove: Called to remove a device, i.e. de-activate it | |
151 | * @unbind: Called to unbind a device from its driver | |
152 | * @ofdata_to_platdata: Called before probe to decode device tree data | |
0118ce79 | 153 | * @child_post_bind: Called after a new child has been bound |
a327dee0 SG |
154 | * @child_pre_probe: Called before a child device is probed. The device has |
155 | * memory allocated but it has not yet been probed. | |
156 | * @child_post_remove: Called after a child device is removed. The device | |
157 | * has memory allocated but its device_remove() method has been called. | |
6494d708 SG |
158 | * @priv_auto_alloc_size: If non-zero this is the size of the private data |
159 | * to be allocated in the device's ->priv pointer. If zero, then the driver | |
160 | * is responsible for allocating any data required. | |
161 | * @platdata_auto_alloc_size: If non-zero this is the size of the | |
162 | * platform data to be allocated in the device's ->platdata pointer. | |
163 | * This is typically only useful for device-tree-aware drivers (those with | |
164 | * an of_match), since drivers which use platdata will have the data | |
165 | * provided in the U_BOOT_DEVICE() instantiation. | |
e59f458d SG |
166 | * @per_child_auto_alloc_size: Each device can hold private data owned by |
167 | * its parent. If required this will be automatically allocated if this | |
168 | * value is non-zero. | |
accd4b19 SG |
169 | * TODO(sjg@chromium.org): I'm considering dropping this, and just having |
170 | * device_probe_child() pass it in. So far the use case for allocating it | |
171 | * is SPI, but I found that unsatisfactory. Since it is here I will leave it | |
172 | * until things are clearer. | |
cdc133bd SG |
173 | * @per_child_platdata_auto_alloc_size: A bus likes to store information about |
174 | * its children. If non-zero this is the size of this data, to be allocated | |
175 | * in the child's parent_platdata pointer. | |
0040b944 | 176 | * @ops: Driver-specific operations. This is typically a list of function |
6494d708 SG |
177 | * pointers defined by the driver, to implement driver functions required by |
178 | * the uclass. | |
00606d7e | 179 | * @flags: driver flags - see DM_FLAGS_... |
6494d708 SG |
180 | */ |
181 | struct driver { | |
182 | char *name; | |
183 | enum uclass_id id; | |
ae7f4513 | 184 | const struct udevice_id *of_match; |
54c5d08a HS |
185 | int (*bind)(struct udevice *dev); |
186 | int (*probe)(struct udevice *dev); | |
187 | int (*remove)(struct udevice *dev); | |
188 | int (*unbind)(struct udevice *dev); | |
189 | int (*ofdata_to_platdata)(struct udevice *dev); | |
0118ce79 | 190 | int (*child_post_bind)(struct udevice *dev); |
a327dee0 SG |
191 | int (*child_pre_probe)(struct udevice *dev); |
192 | int (*child_post_remove)(struct udevice *dev); | |
6494d708 SG |
193 | int priv_auto_alloc_size; |
194 | int platdata_auto_alloc_size; | |
e59f458d | 195 | int per_child_auto_alloc_size; |
cdc133bd | 196 | int per_child_platdata_auto_alloc_size; |
6494d708 | 197 | const void *ops; /* driver-specific operations */ |
00606d7e | 198 | uint32_t flags; |
6494d708 SG |
199 | }; |
200 | ||
201 | /* Declare a new U-Boot driver */ | |
202 | #define U_BOOT_DRIVER(__name) \ | |
203 | ll_entry_declare(struct driver, __name, driver) | |
204 | ||
205 | /** | |
206 | * dev_get_platdata() - Get the platform data for a device | |
207 | * | |
208 | * This checks that dev is not NULL, but no other checks for now | |
209 | * | |
210 | * @dev Device to check | |
211 | * @return platform data, or NULL if none | |
212 | */ | |
54c5d08a | 213 | void *dev_get_platdata(struct udevice *dev); |
6494d708 | 214 | |
cdc133bd SG |
215 | /** |
216 | * dev_get_parent_platdata() - Get the parent platform data for a device | |
217 | * | |
218 | * This checks that dev is not NULL, but no other checks for now | |
219 | * | |
220 | * @dev Device to check | |
221 | * @return parent's platform data, or NULL if none | |
222 | */ | |
223 | void *dev_get_parent_platdata(struct udevice *dev); | |
224 | ||
5eaed880 PM |
225 | /** |
226 | * dev_get_uclass_platdata() - Get the uclass platform data for a device | |
227 | * | |
228 | * This checks that dev is not NULL, but no other checks for now | |
229 | * | |
230 | * @dev Device to check | |
231 | * @return uclass's platform data, or NULL if none | |
232 | */ | |
233 | void *dev_get_uclass_platdata(struct udevice *dev); | |
234 | ||
e59f458d SG |
235 | /** |
236 | * dev_get_parentdata() - Get the parent data for a device | |
237 | * | |
238 | * The parent data is data stored in the device but owned by the parent. | |
239 | * For example, a USB device may have parent data which contains information | |
240 | * about how to talk to the device over USB. | |
241 | * | |
242 | * This checks that dev is not NULL, but no other checks for now | |
243 | * | |
244 | * @dev Device to check | |
245 | * @return parent data, or NULL if none | |
246 | */ | |
247 | void *dev_get_parentdata(struct udevice *dev); | |
248 | ||
6494d708 SG |
249 | /** |
250 | * dev_get_priv() - Get the private data for a device | |
251 | * | |
252 | * This checks that dev is not NULL, but no other checks for now | |
253 | * | |
254 | * @dev Device to check | |
255 | * @return private data, or NULL if none | |
256 | */ | |
54c5d08a | 257 | void *dev_get_priv(struct udevice *dev); |
6494d708 | 258 | |
479728cb SG |
259 | /** |
260 | * struct dev_get_parent() - Get the parent of a device | |
261 | * | |
262 | * @child: Child to check | |
263 | * @return parent of child, or NULL if this is the root device | |
264 | */ | |
265 | struct udevice *dev_get_parent(struct udevice *child); | |
266 | ||
e564f054 SG |
267 | /** |
268 | * dev_get_uclass_priv() - Get the private uclass data for a device | |
269 | * | |
270 | * This checks that dev is not NULL, but no other checks for now | |
271 | * | |
272 | * @dev Device to check | |
273 | * @return private uclass data for this device, or NULL if none | |
274 | */ | |
275 | void *dev_get_uclass_priv(struct udevice *dev); | |
276 | ||
2ef249b4 | 277 | /** |
39de8433 | 278 | * dev_get_driver_data() - get the driver data used to bind a device |
2ef249b4 SG |
279 | * |
280 | * When a device is bound using a device tree node, it matches a | |
281 | * particular compatible string as in struct udevice_id. This function | |
39de8433 SG |
282 | * returns the associated data value for that compatible string. This is |
283 | * the 'data' field in struct udevice_id. | |
284 | * | |
285 | * For USB devices, this is the driver_info field in struct usb_device_id. | |
286 | * | |
287 | * @dev: Device to check | |
2ef249b4 | 288 | */ |
39de8433 | 289 | ulong dev_get_driver_data(struct udevice *dev); |
2ef249b4 | 290 | |
cc73d37b PM |
291 | /** |
292 | * dev_get_driver_ops() - get the device's driver's operations | |
293 | * | |
294 | * This checks that dev is not NULL, and returns the pointer to device's | |
295 | * driver's operations. | |
296 | * | |
297 | * @dev: Device to check | |
298 | * @return void pointer to driver's operations or NULL for NULL-dev or NULL-ops | |
299 | */ | |
300 | const void *dev_get_driver_ops(struct udevice *dev); | |
301 | ||
b3670531 SG |
302 | /* |
303 | * device_get_uclass_id() - return the uclass ID of a device | |
304 | * | |
305 | * @dev: Device to check | |
306 | * @return uclass ID for the device | |
307 | */ | |
308 | enum uclass_id device_get_uclass_id(struct udevice *dev); | |
309 | ||
f9c370dc PM |
310 | /* |
311 | * dev_get_uclass_name() - return the uclass name of a device | |
312 | * | |
313 | * This checks that dev is not NULL. | |
314 | * | |
315 | * @dev: Device to check | |
316 | * @return pointer to the uclass name for the device | |
317 | */ | |
318 | const char *dev_get_uclass_name(struct udevice *dev); | |
319 | ||
997c87bb SG |
320 | /** |
321 | * device_get_child() - Get the child of a device by index | |
322 | * | |
323 | * Returns the numbered child, 0 being the first. This does not use | |
324 | * sequence numbers, only the natural order. | |
325 | * | |
326 | * @dev: Parent device to check | |
327 | * @index: Child index | |
328 | * @devp: Returns pointer to device | |
3f416f33 SG |
329 | * @return 0 if OK, -ENODEV if no such device, other error if the device fails |
330 | * to probe | |
997c87bb SG |
331 | */ |
332 | int device_get_child(struct udevice *parent, int index, struct udevice **devp); | |
333 | ||
5a66a8ff SG |
334 | /** |
335 | * device_find_child_by_seq() - Find a child device based on a sequence | |
336 | * | |
337 | * This searches for a device with the given seq or req_seq. | |
338 | * | |
339 | * For seq, if an active device has this sequence it will be returned. | |
340 | * If there is no such device then this will return -ENODEV. | |
341 | * | |
342 | * For req_seq, if a device (whether activated or not) has this req_seq | |
343 | * value, that device will be returned. This is a strong indication that | |
344 | * the device will receive that sequence when activated. | |
345 | * | |
346 | * @parent: Parent device | |
347 | * @seq_or_req_seq: Sequence number to find (0=first) | |
348 | * @find_req_seq: true to find req_seq, false to find seq | |
349 | * @devp: Returns pointer to device (there is only one per for each seq). | |
350 | * Set to NULL if none is found | |
351 | * @return 0 if OK, -ve on error | |
352 | */ | |
353 | int device_find_child_by_seq(struct udevice *parent, int seq_or_req_seq, | |
354 | bool find_req_seq, struct udevice **devp); | |
355 | ||
997c87bb SG |
356 | /** |
357 | * device_get_child_by_seq() - Get a child device based on a sequence | |
358 | * | |
359 | * If an active device has this sequence it will be returned. If there is no | |
360 | * such device then this will check for a device that is requesting this | |
361 | * sequence. | |
362 | * | |
363 | * The device is probed to activate it ready for use. | |
364 | * | |
365 | * @parent: Parent device | |
366 | * @seq: Sequence number to find (0=first) | |
367 | * @devp: Returns pointer to device (there is only one per for each seq) | |
368 | * Set to NULL if none is found | |
369 | * @return 0 if OK, -ve on error | |
370 | */ | |
371 | int device_get_child_by_seq(struct udevice *parent, int seq, | |
372 | struct udevice **devp); | |
373 | ||
374 | /** | |
375 | * device_find_child_by_of_offset() - Find a child device based on FDT offset | |
376 | * | |
377 | * Locates a child device by its device tree offset. | |
378 | * | |
379 | * @parent: Parent device | |
380 | * @of_offset: Device tree offset to find | |
381 | * @devp: Returns pointer to device if found, otherwise this is set to NULL | |
382 | * @return 0 if OK, -ve on error | |
383 | */ | |
384 | int device_find_child_by_of_offset(struct udevice *parent, int of_offset, | |
385 | struct udevice **devp); | |
386 | ||
387 | /** | |
388 | * device_get_child_by_of_offset() - Get a child device based on FDT offset | |
389 | * | |
390 | * Locates a child device by its device tree offset. | |
391 | * | |
392 | * The device is probed to activate it ready for use. | |
393 | * | |
394 | * @parent: Parent device | |
395 | * @of_offset: Device tree offset to find | |
396 | * @devp: Returns pointer to device if found, otherwise this is set to NULL | |
397 | * @return 0 if OK, -ve on error | |
398 | */ | |
132f9bfc | 399 | int device_get_child_by_of_offset(struct udevice *parent, int of_offset, |
997c87bb SG |
400 | struct udevice **devp); |
401 | ||
2693047a SG |
402 | /** |
403 | * device_get_global_by_of_offset() - Get a device based on FDT offset | |
404 | * | |
405 | * Locates a device by its device tree offset, searching globally throughout | |
406 | * the all driver model devices. | |
407 | * | |
408 | * The device is probed to activate it ready for use. | |
409 | * | |
410 | * @of_offset: Device tree offset to find | |
411 | * @devp: Returns pointer to device if found, otherwise this is set to NULL | |
412 | * @return 0 if OK, -ve on error | |
413 | */ | |
414 | int device_get_global_by_of_offset(int of_offset, struct udevice **devp); | |
415 | ||
a8981d4f SG |
416 | /** |
417 | * device_find_first_child() - Find the first child of a device | |
418 | * | |
419 | * @parent: Parent device to search | |
420 | * @devp: Returns first child device, or NULL if none | |
421 | * @return 0 | |
422 | */ | |
423 | int device_find_first_child(struct udevice *parent, struct udevice **devp); | |
424 | ||
425 | /** | |
3f416f33 | 426 | * device_find_next_child() - Find the next child of a device |
a8981d4f SG |
427 | * |
428 | * @devp: Pointer to previous child device on entry. Returns pointer to next | |
429 | * child device, or NULL if none | |
430 | * @return 0 | |
431 | */ | |
432 | int device_find_next_child(struct udevice **devp); | |
433 | ||
c9cac3f8 PF |
434 | /** |
435 | * dev_get_addr() - Get the reg property of a device | |
436 | * | |
437 | * @dev: Pointer to a device | |
438 | * | |
439 | * @return addr | |
440 | */ | |
441 | fdt_addr_t dev_get_addr(struct udevice *dev); | |
442 | ||
c5785673 SG |
443 | /** |
444 | * device_has_children() - check if a device has any children | |
445 | * | |
446 | * @dev: Device to check | |
447 | * @return true if the device has one or more children | |
448 | */ | |
449 | bool device_has_children(struct udevice *dev); | |
450 | ||
451 | /** | |
452 | * device_has_active_children() - check if a device has any active children | |
453 | * | |
454 | * @dev: Device to check | |
455 | * @return true if the device has one or more children and at least one of | |
456 | * them is active (probed). | |
457 | */ | |
458 | bool device_has_active_children(struct udevice *dev); | |
459 | ||
460 | /** | |
461 | * device_is_last_sibling() - check if a device is the last sibling | |
462 | * | |
463 | * This function can be useful for display purposes, when special action needs | |
464 | * to be taken when displaying the last sibling. This can happen when a tree | |
465 | * view of devices is being displayed. | |
466 | * | |
467 | * @dev: Device to check | |
468 | * @return true if there are no more siblings after this one - i.e. is it | |
469 | * last in the list. | |
470 | */ | |
471 | bool device_is_last_sibling(struct udevice *dev); | |
472 | ||
608f26c5 MY |
473 | /* device resource management */ |
474 | typedef void (*dr_release_t)(struct udevice *dev, void *res); | |
475 | typedef int (*dr_match_t)(struct udevice *dev, void *res, void *match_data); | |
476 | ||
e2282d70 MY |
477 | #ifdef CONFIG_DEVRES |
478 | ||
608f26c5 MY |
479 | #ifdef CONFIG_DEBUG_DEVRES |
480 | void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp, | |
481 | const char *name); | |
482 | #define _devres_alloc(release, size, gfp) \ | |
483 | __devres_alloc(release, size, gfp, #release) | |
484 | #else | |
485 | void *_devres_alloc(dr_release_t release, size_t size, gfp_t gfp); | |
486 | #endif | |
487 | ||
488 | /** | |
489 | * devres_alloc - Allocate device resource data | |
490 | * @release: Release function devres will be associated with | |
491 | * @size: Allocation size | |
492 | * @gfp: Allocation flags | |
493 | * | |
494 | * Allocate devres of @size bytes. The allocated area is associated | |
495 | * with @release. The returned pointer can be passed to | |
496 | * other devres_*() functions. | |
497 | * | |
498 | * RETURNS: | |
499 | * Pointer to allocated devres on success, NULL on failure. | |
500 | */ | |
501 | #define devres_alloc(release, size, gfp) \ | |
502 | _devres_alloc(release, size, gfp | __GFP_ZERO) | |
503 | ||
504 | /** | |
505 | * devres_free - Free device resource data | |
506 | * @res: Pointer to devres data to free | |
507 | * | |
508 | * Free devres created with devres_alloc(). | |
509 | */ | |
510 | void devres_free(void *res); | |
511 | ||
512 | /** | |
513 | * devres_add - Register device resource | |
514 | * @dev: Device to add resource to | |
515 | * @res: Resource to register | |
516 | * | |
517 | * Register devres @res to @dev. @res should have been allocated | |
518 | * using devres_alloc(). On driver detach, the associated release | |
519 | * function will be invoked and devres will be freed automatically. | |
520 | */ | |
521 | void devres_add(struct udevice *dev, void *res); | |
522 | ||
523 | /** | |
524 | * devres_find - Find device resource | |
525 | * @dev: Device to lookup resource from | |
526 | * @release: Look for resources associated with this release function | |
527 | * @match: Match function (optional) | |
528 | * @match_data: Data for the match function | |
529 | * | |
530 | * Find the latest devres of @dev which is associated with @release | |
531 | * and for which @match returns 1. If @match is NULL, it's considered | |
532 | * to match all. | |
533 | * | |
534 | * RETURNS: | |
535 | * Pointer to found devres, NULL if not found. | |
536 | */ | |
537 | void *devres_find(struct udevice *dev, dr_release_t release, | |
538 | dr_match_t match, void *match_data); | |
539 | ||
540 | /** | |
541 | * devres_get - Find devres, if non-existent, add one atomically | |
542 | * @dev: Device to lookup or add devres for | |
543 | * @new_res: Pointer to new initialized devres to add if not found | |
544 | * @match: Match function (optional) | |
545 | * @match_data: Data for the match function | |
546 | * | |
547 | * Find the latest devres of @dev which has the same release function | |
548 | * as @new_res and for which @match return 1. If found, @new_res is | |
549 | * freed; otherwise, @new_res is added atomically. | |
550 | * | |
551 | * RETURNS: | |
552 | * Pointer to found or added devres. | |
553 | */ | |
554 | void *devres_get(struct udevice *dev, void *new_res, | |
555 | dr_match_t match, void *match_data); | |
556 | ||
557 | /** | |
558 | * devres_remove - Find a device resource and remove it | |
559 | * @dev: Device to find resource from | |
560 | * @release: Look for resources associated with this release function | |
561 | * @match: Match function (optional) | |
562 | * @match_data: Data for the match function | |
563 | * | |
564 | * Find the latest devres of @dev associated with @release and for | |
565 | * which @match returns 1. If @match is NULL, it's considered to | |
566 | * match all. If found, the resource is removed atomically and | |
567 | * returned. | |
568 | * | |
569 | * RETURNS: | |
570 | * Pointer to removed devres on success, NULL if not found. | |
571 | */ | |
572 | void *devres_remove(struct udevice *dev, dr_release_t release, | |
573 | dr_match_t match, void *match_data); | |
574 | ||
575 | /** | |
576 | * devres_destroy - Find a device resource and destroy it | |
577 | * @dev: Device to find resource from | |
578 | * @release: Look for resources associated with this release function | |
579 | * @match: Match function (optional) | |
580 | * @match_data: Data for the match function | |
581 | * | |
582 | * Find the latest devres of @dev associated with @release and for | |
583 | * which @match returns 1. If @match is NULL, it's considered to | |
584 | * match all. If found, the resource is removed atomically and freed. | |
585 | * | |
586 | * Note that the release function for the resource will not be called, | |
587 | * only the devres-allocated data will be freed. The caller becomes | |
588 | * responsible for freeing any other data. | |
589 | * | |
590 | * RETURNS: | |
591 | * 0 if devres is found and freed, -ENOENT if not found. | |
592 | */ | |
593 | int devres_destroy(struct udevice *dev, dr_release_t release, | |
594 | dr_match_t match, void *match_data); | |
595 | ||
596 | /** | |
597 | * devres_release - Find a device resource and destroy it, calling release | |
598 | * @dev: Device to find resource from | |
599 | * @release: Look for resources associated with this release function | |
600 | * @match: Match function (optional) | |
601 | * @match_data: Data for the match function | |
602 | * | |
603 | * Find the latest devres of @dev associated with @release and for | |
604 | * which @match returns 1. If @match is NULL, it's considered to | |
605 | * match all. If found, the resource is removed atomically, the | |
606 | * release function called and the resource freed. | |
607 | * | |
608 | * RETURNS: | |
609 | * 0 if devres is found and freed, -ENOENT if not found. | |
610 | */ | |
611 | int devres_release(struct udevice *dev, dr_release_t release, | |
612 | dr_match_t match, void *match_data); | |
613 | ||
2b07f685 MY |
614 | /* managed devm_k.alloc/kfree for device drivers */ |
615 | /** | |
616 | * devm_kmalloc - Resource-managed kmalloc | |
617 | * @dev: Device to allocate memory for | |
618 | * @size: Allocation size | |
619 | * @gfp: Allocation gfp flags | |
620 | * | |
621 | * Managed kmalloc. Memory allocated with this function is | |
622 | * automatically freed on driver detach. Like all other devres | |
623 | * resources, guaranteed alignment is unsigned long long. | |
624 | * | |
625 | * RETURNS: | |
626 | * Pointer to allocated memory on success, NULL on failure. | |
627 | */ | |
628 | void *devm_kmalloc(struct udevice *dev, size_t size, gfp_t gfp); | |
629 | static inline void *devm_kzalloc(struct udevice *dev, size_t size, gfp_t gfp) | |
630 | { | |
631 | return devm_kmalloc(dev, size, gfp | __GFP_ZERO); | |
632 | } | |
633 | static inline void *devm_kmalloc_array(struct udevice *dev, | |
634 | size_t n, size_t size, gfp_t flags) | |
635 | { | |
636 | if (size != 0 && n > SIZE_MAX / size) | |
637 | return NULL; | |
638 | return devm_kmalloc(dev, n * size, flags); | |
639 | } | |
640 | static inline void *devm_kcalloc(struct udevice *dev, | |
641 | size_t n, size_t size, gfp_t flags) | |
642 | { | |
643 | return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO); | |
644 | } | |
645 | ||
646 | /** | |
647 | * devm_kfree - Resource-managed kfree | |
648 | * @dev: Device this memory belongs to | |
649 | * @p: Memory to free | |
650 | * | |
651 | * Free memory allocated with devm_kmalloc(). | |
652 | */ | |
653 | void devm_kfree(struct udevice *dev, void *p); | |
654 | ||
e2282d70 MY |
655 | #else /* ! CONFIG_DEVRES */ |
656 | ||
657 | static inline void *devres_alloc(dr_release_t release, size_t size, gfp_t gfp) | |
658 | { | |
659 | return kzalloc(size, gfp); | |
660 | } | |
661 | ||
662 | static inline void devres_free(void *res) | |
663 | { | |
664 | kfree(res); | |
665 | } | |
666 | ||
667 | static inline void devres_add(struct udevice *dev, void *res) | |
668 | { | |
669 | } | |
670 | ||
671 | static inline void *devres_find(struct udevice *dev, dr_release_t release, | |
672 | dr_match_t match, void *match_data) | |
673 | { | |
674 | return NULL; | |
675 | } | |
676 | ||
677 | static inline void *devres_get(struct udevice *dev, void *new_res, | |
678 | dr_match_t match, void *match_data) | |
679 | { | |
680 | return NULL; | |
681 | } | |
682 | ||
683 | static inline void *devres_remove(struct udevice *dev, dr_release_t release, | |
684 | dr_match_t match, void *match_data) | |
685 | { | |
686 | return NULL; | |
687 | } | |
688 | ||
689 | static inline int devres_destroy(struct udevice *dev, dr_release_t release, | |
690 | dr_match_t match, void *match_data) | |
691 | { | |
692 | return 0; | |
693 | } | |
694 | ||
695 | static inline int devres_release(struct udevice *dev, dr_release_t release, | |
696 | dr_match_t match, void *match_data) | |
697 | { | |
698 | return 0; | |
699 | } | |
700 | ||
701 | static inline void *devm_kmalloc(struct udevice *dev, size_t size, gfp_t gfp) | |
702 | { | |
703 | return kmalloc(size, gfp); | |
704 | } | |
705 | ||
706 | static inline void *devm_kzalloc(struct udevice *dev, size_t size, gfp_t gfp) | |
707 | { | |
708 | return kzalloc(size, gfp); | |
709 | } | |
710 | ||
711 | static inline void *devm_kmaloc_array(struct udevice *dev, | |
712 | size_t n, size_t size, gfp_t flags) | |
713 | { | |
714 | /* TODO: add kmalloc_array() to linux/compat.h */ | |
715 | if (size != 0 && n > SIZE_MAX / size) | |
716 | return NULL; | |
717 | return kmalloc(n * size, flags); | |
718 | } | |
719 | ||
720 | static inline void *devm_kcalloc(struct udevice *dev, | |
721 | size_t n, size_t size, gfp_t flags) | |
722 | { | |
723 | /* TODO: add kcalloc() to linux/compat.h */ | |
724 | return kmalloc(n * size, flags | __GFP_ZERO); | |
725 | } | |
726 | ||
727 | static inline void devm_kfree(struct udevice *dev, void *p) | |
728 | { | |
729 | kfree(p); | |
730 | } | |
731 | ||
732 | #endif /* ! CONFIG_DEVRES */ | |
2b07f685 | 733 | |
6494d708 | 734 | #endif |