]>
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> | |
14 | #include <linux/list.h> | |
15 | ||
16 | /** | |
17 | * struct uclass - a U-Boot drive class, collecting together similar drivers | |
18 | * | |
19 | * A uclass provides an interface to a particular function, which is | |
20 | * implemented by one or more drivers. Every driver belongs to a uclass even | |
21 | * if it is the only driver in that uclass. An example uclass is GPIO, which | |
22 | * provides the ability to change read inputs, set and clear outputs, etc. | |
23 | * There may be drivers for on-chip SoC GPIO banks, I2C GPIO expanders and | |
24 | * PMIC IO lines, all made available in a unified way through the uclass. | |
25 | * | |
26 | * @priv: Private data for this uclass | |
27 | * @uc_drv: The driver for the uclass itself, not to be confused with a | |
28 | * 'struct driver' | |
29 | * dev_head: List of devices in this uclass (devices are attached to their | |
30 | * uclass when their bind method is called) | |
31 | * @sibling_node: Next uclass in the linked list of uclasses | |
32 | */ | |
33 | struct uclass { | |
34 | void *priv; | |
35 | struct uclass_driver *uc_drv; | |
36 | struct list_head dev_head; | |
37 | struct list_head sibling_node; | |
38 | }; | |
39 | ||
40 | struct device; | |
41 | ||
42 | /** | |
43 | * struct uclass_driver - Driver for the uclass | |
44 | * | |
45 | * A uclass_driver provides a consistent interface to a set of related | |
46 | * drivers. | |
47 | * | |
48 | * @name: Name of uclass driver | |
49 | * @id: ID number of this uclass | |
50 | * @post_bind: Called after a new device is bound to this uclass | |
51 | * @pre_unbind: Called before a device is unbound from this uclass | |
52 | * @post_probe: Called after a new device is probed | |
53 | * @pre_remove: Called before a device is removed | |
54 | * @init: Called to set up the uclass | |
55 | * @destroy: Called to destroy the uclass | |
56 | * @priv_auto_alloc_size: If non-zero this is the size of the private data | |
57 | * to be allocated in the uclass's ->priv pointer. If zero, then the uclass | |
58 | * driver is responsible for allocating any data required. | |
59 | * @per_device_auto_alloc_size: Each device can hold private data owned | |
60 | * by the uclass. If required this will be automatically allocated if this | |
61 | * value is non-zero. | |
62 | * @ops: Uclass operations, providing the consistent interface to devices | |
63 | * within the uclass. | |
64 | */ | |
65 | struct uclass_driver { | |
66 | const char *name; | |
67 | enum uclass_id id; | |
68 | int (*post_bind)(struct device *dev); | |
69 | int (*pre_unbind)(struct device *dev); | |
70 | int (*post_probe)(struct device *dev); | |
71 | int (*pre_remove)(struct device *dev); | |
72 | int (*init)(struct uclass *class); | |
73 | int (*destroy)(struct uclass *class); | |
74 | int priv_auto_alloc_size; | |
75 | int per_device_auto_alloc_size; | |
76 | const void *ops; | |
77 | }; | |
78 | ||
79 | /* Declare a new uclass_driver */ | |
80 | #define UCLASS_DRIVER(__name) \ | |
81 | ll_entry_declare(struct uclass_driver, __name, uclass) | |
82 | ||
83 | /** | |
84 | * uclass_get() - Get a uclass based on an ID, creating it if needed | |
85 | * | |
86 | * Every uclass is identified by an ID, a number from 0 to n-1 where n is | |
87 | * the number of uclasses. This function allows looking up a uclass by its | |
88 | * ID. | |
89 | * | |
90 | * @key: ID to look up | |
91 | * @ucp: Returns pointer to uclass (there is only one per ID) | |
92 | * @return 0 if OK, -ve on error | |
93 | */ | |
94 | int uclass_get(enum uclass_id key, struct uclass **ucp); | |
95 | ||
96 | /** | |
97 | * uclass_get_device() - Get a uclass device based on an ID and index | |
98 | * | |
99 | * id: ID to look up | |
100 | * @index: Device number within that uclass (0=first) | |
101 | * @ucp: Returns pointer to uclass (there is only one per for each ID) | |
102 | * @return 0 if OK, -ve on error | |
103 | */ | |
104 | int uclass_get_device(enum uclass_id id, int index, struct device **ucp); | |
105 | ||
106 | /** | |
107 | * uclass_first_device() - Get the first device in a uclass | |
108 | * | |
109 | * @id: Uclass ID to look up | |
110 | * @devp: Returns pointer to the first device in that uclass, or NULL if none | |
111 | * @return 0 if OK (found or not found), -1 on error | |
112 | */ | |
113 | int uclass_first_device(enum uclass_id id, struct device **devp); | |
114 | ||
115 | /** | |
116 | * uclass_next_device() - Get the next device in a uclass | |
117 | * | |
118 | * @devp: On entry, pointer to device to lookup. On exit, returns pointer | |
119 | * to the next device in the same uclass, or NULL if none | |
120 | * @return 0 if OK (found or not found), -1 on error | |
121 | */ | |
122 | int uclass_next_device(struct device **devp); | |
123 | ||
124 | /** | |
125 | * uclass_foreach_dev() - Helper function to iteration through devices | |
126 | * | |
127 | * This creates a for() loop which works through the available devices in | |
128 | * a uclass in order from start to end. | |
129 | * | |
130 | * @pos: struct device * to hold the current device. Set to NULL when there | |
131 | * are no more devices. | |
132 | * uc: uclass to scan | |
133 | */ | |
134 | #define uclass_foreach_dev(pos, uc) \ | |
135 | for (pos = list_entry((&(uc)->dev_head)->next, typeof(*pos), \ | |
136 | uclass_node); \ | |
137 | prefetch(pos->uclass_node.next), \ | |
138 | &pos->uclass_node != (&(uc)->dev_head); \ | |
139 | pos = list_entry(pos->uclass_node.next, typeof(*pos), \ | |
140 | uclass_node)) | |
141 | ||
142 | #endif |