Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 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> |
Masahiro Yamada | 63b3a8f | 2014-10-07 14:49:13 +0900 | [diff] [blame] | 14 | #include <linker_lists.h> |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 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' |
Simon Glass | 4dbb5cf | 2014-06-11 23:29:54 -0600 | [diff] [blame] | 30 | * @dev_head: List of devices in this uclass (devices are attached to their |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 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 | |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 41 | struct udevice; |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 42 | |
Simon Glass | 0ccb097 | 2015-01-25 08:27:05 -0700 | [diff] [blame] | 43 | /* Members of this uclass sequence themselves with aliases */ |
| 44 | #define DM_UC_FLAG_SEQ_ALIAS (1 << 0) |
| 45 | |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 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 |
Simon Glass | 9c1f382 | 2015-03-05 12:25:22 -0700 | [diff] [blame] | 56 | * @pre_probe: Called before a new device is probed |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 57 | * @post_probe: Called after a new device is probed |
| 58 | * @pre_remove: Called before a device is removed |
Simon Glass | f4c9b3e | 2015-01-25 08:27:08 -0700 | [diff] [blame] | 59 | * @child_post_bind: Called after a child is bound to a device in this uclass |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 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. |
Przemyslaw Marczak | d850e67 | 2015-04-15 13:07:18 +0200 | [diff] [blame] | 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. |
Simon Glass | c23b428 | 2015-01-25 08:27:06 -0700 | [diff] [blame] | 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. |
Simon Glass | 57f9540 | 2015-01-25 08:27:02 -0700 | [diff] [blame] | 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. |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 78 | * @ops: Uclass operations, providing the consistent interface to devices |
| 79 | * within the uclass. |
Simon Glass | 0ccb097 | 2015-01-25 08:27:05 -0700 | [diff] [blame] | 80 | * @flags: Flags for this uclass (DM_UC_...) |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 81 | */ |
| 82 | struct uclass_driver { |
| 83 | const char *name; |
| 84 | enum uclass_id id; |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 85 | int (*post_bind)(struct udevice *dev); |
| 86 | int (*pre_unbind)(struct udevice *dev); |
Simon Glass | 9c1f382 | 2015-03-05 12:25:22 -0700 | [diff] [blame] | 87 | int (*pre_probe)(struct udevice *dev); |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 88 | int (*post_probe)(struct udevice *dev); |
| 89 | int (*pre_remove)(struct udevice *dev); |
Simon Glass | f4c9b3e | 2015-01-25 08:27:08 -0700 | [diff] [blame] | 90 | int (*child_post_bind)(struct udevice *dev); |
Simon Glass | 5104b98 | 2015-01-25 08:27:10 -0700 | [diff] [blame] | 91 | int (*child_pre_probe)(struct udevice *dev); |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 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; |
Przemyslaw Marczak | d850e67 | 2015-04-15 13:07:18 +0200 | [diff] [blame] | 96 | int per_device_platdata_auto_alloc_size; |
Simon Glass | c23b428 | 2015-01-25 08:27:06 -0700 | [diff] [blame] | 97 | int per_child_auto_alloc_size; |
Simon Glass | 57f9540 | 2015-01-25 08:27:02 -0700 | [diff] [blame] | 98 | int per_child_platdata_auto_alloc_size; |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 99 | const void *ops; |
Simon Glass | 0ccb097 | 2015-01-25 08:27:05 -0700 | [diff] [blame] | 100 | uint32_t flags; |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 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 | * |
Simon Glass | 4dbb5cf | 2014-06-11 23:29:54 -0600 | [diff] [blame] | 123 | * The device is probed to activate it ready for use. |
| 124 | * |
Simon Glass | cebcebb | 2014-07-23 06:55:17 -0600 | [diff] [blame] | 125 | * @id: ID to look up |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 126 | * @index: Device number within that uclass (0=first) |
Simon Glass | 4dbb5cf | 2014-06-11 23:29:54 -0600 | [diff] [blame] | 127 | * @devp: Returns pointer to device (there is only one per for each ID) |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 128 | * @return 0 if OK, -ve on error |
| 129 | */ |
Simon Glass | 4dbb5cf | 2014-06-11 23:29:54 -0600 | [diff] [blame] | 130 | int uclass_get_device(enum uclass_id id, int index, struct udevice **devp); |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 131 | |
| 132 | /** |
Przemyslaw Marczak | a12a1f5 | 2015-04-15 13:07:23 +0200 | [diff] [blame] | 133 | * uclass_get_device_by_name() - Get a uclass device by it's name |
| 134 | * |
Przemyslaw Marczak | c917772 | 2015-04-20 13:32:34 +0200 | [diff] [blame] | 135 | * This searches the devices in the uclass for one with the exactly given name. |
Przemyslaw Marczak | a12a1f5 | 2015-04-15 13:07:23 +0200 | [diff] [blame] | 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 | |
| 147 | /** |
Simon Glass | db6f020 | 2014-07-23 06:55:12 -0600 | [diff] [blame] | 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 | |
| 163 | /** |
Simon Glass | c1464ab | 2014-07-23 06:55:14 -0600 | [diff] [blame] | 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 | |
| 179 | /** |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 180 | * uclass_first_device() - Get the first device in a uclass |
| 181 | * |
Simon Glass | 8f5251d | 2015-01-25 08:26:57 -0700 | [diff] [blame] | 182 | * The device returned is probed if necessary, and ready for use |
| 183 | * |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 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 | */ |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 188 | int uclass_first_device(enum uclass_id id, struct udevice **devp); |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 189 | |
| 190 | /** |
| 191 | * uclass_next_device() - Get the next device in a uclass |
| 192 | * |
Simon Glass | 8f5251d | 2015-01-25 08:26:57 -0700 | [diff] [blame] | 193 | * The device returned is probed if necessary, and ready for use |
| 194 | * |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 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 | */ |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 199 | int uclass_next_device(struct udevice **devp); |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 200 | |
| 201 | /** |
Simon Glass | db6f020 | 2014-07-23 06:55:12 -0600 | [diff] [blame] | 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 | |
| 216 | /** |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 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 | * |
Heiko Schocher | b74fcb4 | 2014-05-22 12:43:05 +0200 | [diff] [blame] | 222 | * @pos: struct udevice * to hold the current device. Set to NULL when there |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 223 | * are no more devices. |
Simon Glass | 4dbb5cf | 2014-06-11 23:29:54 -0600 | [diff] [blame] | 224 | * @uc: uclass to scan |
Simon Glass | dd6ab88 | 2014-02-26 15:59:18 -0700 | [diff] [blame] | 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 |