]>
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 | * | |
7 | * SPDX-License-Identifier: GPL-2.0+ | |
8 | */ | |
9 | ||
10 | #ifndef _DM_UCLASS_H | |
11 | #define _DM_UCLASS_H | |
12 | ||
13 | #include <dm/uclass-id.h> | |
42c23dd2 | 14 | #include <linker_lists.h> |
6494d708 SG |
15 | #include <linux/list.h> |
16 | ||
17 | /** | |
18 | * struct uclass - a U-Boot drive class, collecting together similar drivers | |
19 | * | |
20 | * A uclass provides an interface to a particular function, which is | |
21 | * implemented by one or more drivers. Every driver belongs to a uclass even | |
22 | * if it is the only driver in that uclass. An example uclass is GPIO, which | |
23 | * provides the ability to change read inputs, set and clear outputs, etc. | |
24 | * There may be drivers for on-chip SoC GPIO banks, I2C GPIO expanders and | |
25 | * PMIC IO lines, all made available in a unified way through the uclass. | |
26 | * | |
27 | * @priv: Private data for this uclass | |
28 | * @uc_drv: The driver for the uclass itself, not to be confused with a | |
29 | * 'struct driver' | |
f2bc6fc3 | 30 | * @dev_head: List of devices in this uclass (devices are attached to their |
6494d708 SG |
31 | * uclass when their bind method is called) |
32 | * @sibling_node: Next uclass in the linked list of uclasses | |
33 | */ | |
34 | struct uclass { | |
35 | void *priv; | |
36 | struct uclass_driver *uc_drv; | |
37 | struct list_head dev_head; | |
38 | struct list_head sibling_node; | |
39 | }; | |
40 | ||
54c5d08a | 41 | struct udevice; |
6494d708 | 42 | |
9cc36a2b SG |
43 | /* Members of this uclass sequence themselves with aliases */ |
44 | #define DM_UC_FLAG_SEQ_ALIAS (1 << 0) | |
45 | ||
6494d708 SG |
46 | /** |
47 | * struct uclass_driver - Driver for the uclass | |
48 | * | |
49 | * A uclass_driver provides a consistent interface to a set of related | |
50 | * drivers. | |
51 | * | |
52 | * @name: Name of uclass driver | |
53 | * @id: ID number of this uclass | |
54 | * @post_bind: Called after a new device is bound to this uclass | |
55 | * @pre_unbind: Called before a device is unbound from this uclass | |
02c07b37 | 56 | * @pre_probe: Called before a new device is probed |
6494d708 SG |
57 | * @post_probe: Called after a new device is probed |
58 | * @pre_remove: Called before a device is removed | |
081f2fcb | 59 | * @child_post_bind: Called after a child is bound to a device in this uclass |
6494d708 SG |
60 | * @init: Called to set up the uclass |
61 | * @destroy: Called to destroy the uclass | |
62 | * @priv_auto_alloc_size: If non-zero this is the size of the private data | |
63 | * to be allocated in the uclass's ->priv pointer. If zero, then the uclass | |
64 | * driver is responsible for allocating any data required. | |
65 | * @per_device_auto_alloc_size: Each device can hold private data owned | |
66 | * by the uclass. If required this will be automatically allocated if this | |
67 | * value is non-zero. | |
5eaed880 PM |
68 | * @per_device_platdata_auto_alloc_size: Each device can hold platform data |
69 | * owned by the uclass as 'dev->uclass_platdata'. If the value is non-zero, | |
70 | * then this will be automatically allocated. | |
dac8db2c SG |
71 | * @per_child_auto_alloc_size: Each child device (of a parent in this |
72 | * uclass) can hold parent data for the device/uclass. This value is only | |
73 | * used as a falback if this member is 0 in the driver. | |
ba8da9dc SG |
74 | * @per_child_platdata_auto_alloc_size: A bus likes to store information about |
75 | * its children. If non-zero this is the size of this data, to be allocated | |
76 | * in the child device's parent_platdata pointer. This value is only used as | |
77 | * a falback if this member is 0 in the driver. | |
6494d708 SG |
78 | * @ops: Uclass operations, providing the consistent interface to devices |
79 | * within the uclass. | |
9cc36a2b | 80 | * @flags: Flags for this uclass (DM_UC_...) |
6494d708 SG |
81 | */ |
82 | struct uclass_driver { | |
83 | const char *name; | |
84 | enum uclass_id id; | |
54c5d08a HS |
85 | int (*post_bind)(struct udevice *dev); |
86 | int (*pre_unbind)(struct udevice *dev); | |
02c07b37 | 87 | int (*pre_probe)(struct udevice *dev); |
54c5d08a HS |
88 | int (*post_probe)(struct udevice *dev); |
89 | int (*pre_remove)(struct udevice *dev); | |
081f2fcb | 90 | int (*child_post_bind)(struct udevice *dev); |
83c7e434 | 91 | int (*child_pre_probe)(struct udevice *dev); |
6494d708 SG |
92 | int (*init)(struct uclass *class); |
93 | int (*destroy)(struct uclass *class); | |
94 | int priv_auto_alloc_size; | |
95 | int per_device_auto_alloc_size; | |
5eaed880 | 96 | int per_device_platdata_auto_alloc_size; |
dac8db2c | 97 | int per_child_auto_alloc_size; |
ba8da9dc | 98 | int per_child_platdata_auto_alloc_size; |
6494d708 | 99 | const void *ops; |
9cc36a2b | 100 | uint32_t flags; |
6494d708 SG |
101 | }; |
102 | ||
103 | /* Declare a new uclass_driver */ | |
104 | #define UCLASS_DRIVER(__name) \ | |
105 | ll_entry_declare(struct uclass_driver, __name, uclass) | |
106 | ||
107 | /** | |
108 | * uclass_get() - Get a uclass based on an ID, creating it if needed | |
109 | * | |
110 | * Every uclass is identified by an ID, a number from 0 to n-1 where n is | |
111 | * the number of uclasses. This function allows looking up a uclass by its | |
112 | * ID. | |
113 | * | |
114 | * @key: ID to look up | |
115 | * @ucp: Returns pointer to uclass (there is only one per ID) | |
116 | * @return 0 if OK, -ve on error | |
117 | */ | |
118 | int uclass_get(enum uclass_id key, struct uclass **ucp); | |
119 | ||
120 | /** | |
121 | * uclass_get_device() - Get a uclass device based on an ID and index | |
122 | * | |
f2bc6fc3 SG |
123 | * The device is probed to activate it ready for use. |
124 | * | |
0040b944 | 125 | * @id: ID to look up |
6494d708 | 126 | * @index: Device number within that uclass (0=first) |
f2bc6fc3 | 127 | * @devp: Returns pointer to device (there is only one per for each ID) |
6494d708 SG |
128 | * @return 0 if OK, -ve on error |
129 | */ | |
f2bc6fc3 | 130 | int uclass_get_device(enum uclass_id id, int index, struct udevice **devp); |
6494d708 | 131 | |
b7af1a2d PM |
132 | /** |
133 | * uclass_get_device_by_name() - Get a uclass device by it's name | |
134 | * | |
a7b82502 | 135 | * This searches the devices in the uclass for one with the exactly given name. |
b7af1a2d PM |
136 | * |
137 | * The device is probed to activate it ready for use. | |
138 | * | |
139 | * @id: ID to look up | |
140 | * @name: name of a device to get | |
141 | * @devp: Returns pointer to device (the first one with the name) | |
142 | * @return 0 if OK, -ve on error | |
143 | */ | |
144 | int uclass_get_device_by_name(enum uclass_id id, const char *name, | |
145 | struct udevice **devp); | |
146 | ||
5a66a8ff SG |
147 | /** |
148 | * uclass_get_device_by_seq() - Get a uclass device based on an ID and sequence | |
149 | * | |
150 | * If an active device has this sequence it will be returned. If there is no | |
151 | * such device then this will check for a device that is requesting this | |
152 | * sequence. | |
153 | * | |
154 | * The device is probed to activate it ready for use. | |
155 | * | |
156 | * @id: ID to look up | |
157 | * @seq: Sequence number to find (0=first) | |
158 | * @devp: Returns pointer to device (there is only one for each seq) | |
159 | * @return 0 if OK, -ve on error | |
160 | */ | |
161 | int uclass_get_device_by_seq(enum uclass_id id, int seq, struct udevice **devp); | |
162 | ||
f4cdead2 SG |
163 | /** |
164 | * uclass_get_device_by_of_offset() - Get a uclass device by device tree node | |
165 | * | |
166 | * This searches the devices in the uclass for one attached to the given | |
167 | * device tree node. | |
168 | * | |
169 | * The device is probed to activate it ready for use. | |
170 | * | |
171 | * @id: ID to look up | |
172 | * @node: Device tree offset to search for (if -ve then -ENODEV is returned) | |
173 | * @devp: Returns pointer to device (there is only one for each node) | |
174 | * @return 0 if OK, -ve on error | |
175 | */ | |
176 | int uclass_get_device_by_of_offset(enum uclass_id id, int node, | |
177 | struct udevice **devp); | |
178 | ||
6494d708 SG |
179 | /** |
180 | * uclass_first_device() - Get the first device in a uclass | |
181 | * | |
040b69af SG |
182 | * The device returned is probed if necessary, and ready for use |
183 | * | |
6494d708 SG |
184 | * @id: Uclass ID to look up |
185 | * @devp: Returns pointer to the first device in that uclass, or NULL if none | |
186 | * @return 0 if OK (found or not found), -1 on error | |
187 | */ | |
54c5d08a | 188 | int uclass_first_device(enum uclass_id id, struct udevice **devp); |
6494d708 SG |
189 | |
190 | /** | |
191 | * uclass_next_device() - Get the next device in a uclass | |
192 | * | |
040b69af SG |
193 | * The device returned is probed if necessary, and ready for use |
194 | * | |
6494d708 SG |
195 | * @devp: On entry, pointer to device to lookup. On exit, returns pointer |
196 | * to the next device in the same uclass, or NULL if none | |
197 | * @return 0 if OK (found or not found), -1 on error | |
198 | */ | |
54c5d08a | 199 | int uclass_next_device(struct udevice **devp); |
6494d708 | 200 | |
5a66a8ff SG |
201 | /** |
202 | * uclass_resolve_seq() - Resolve a device's sequence number | |
203 | * | |
204 | * On entry dev->seq is -1, and dev->req_seq may be -1 (to allocate a | |
205 | * sequence number automatically, or >= 0 to select a particular number. | |
206 | * If the requested sequence number is in use, then this device will | |
207 | * be allocated another one. | |
208 | * | |
209 | * Note that the device's seq value is not changed by this function. | |
210 | * | |
211 | * @dev: Device for which to allocate sequence number | |
212 | * @return sequence number allocated, or -ve on error | |
213 | */ | |
214 | int uclass_resolve_seq(struct udevice *dev); | |
215 | ||
6494d708 SG |
216 | /** |
217 | * uclass_foreach_dev() - Helper function to iteration through devices | |
218 | * | |
219 | * This creates a for() loop which works through the available devices in | |
220 | * a uclass in order from start to end. | |
221 | * | |
54c5d08a | 222 | * @pos: struct udevice * to hold the current device. Set to NULL when there |
6494d708 | 223 | * are no more devices. |
f2bc6fc3 | 224 | * @uc: uclass to scan |
6494d708 SG |
225 | */ |
226 | #define uclass_foreach_dev(pos, uc) \ | |
227 | for (pos = list_entry((&(uc)->dev_head)->next, typeof(*pos), \ | |
228 | uclass_node); \ | |
229 | prefetch(pos->uclass_node.next), \ | |
230 | &pos->uclass_node != (&(uc)->dev_head); \ | |
231 | pos = list_entry(pos->uclass_node.next, typeof(*pos), \ | |
232 | uclass_node)) | |
233 | ||
234 | #endif |