Commit | Line | Data |
---|---|---|
989d42e8 | 1 | // SPDX-License-Identifier: GPL-2.0 |
74d1d82c LJ |
2 | /* |
3 | * Copyright (C) ST-Ericsson SA 2011 | |
4 | * | |
5 | * Author: Lee Jones <lee.jones@linaro.org> for ST-Ericsson. | |
74d1d82c LJ |
6 | */ |
7 | ||
8 | #include <linux/sysfs.h> | |
74d1d82c LJ |
9 | #include <linux/init.h> |
10 | #include <linux/stat.h> | |
11 | #include <linux/slab.h> | |
12 | #include <linux/idr.h> | |
13 | #include <linux/spinlock.h> | |
14 | #include <linux/sys_soc.h> | |
15 | #include <linux/err.h> | |
c97db7cc | 16 | #include <linux/glob.h> |
74d1d82c | 17 | |
3a4ffe93 | 18 | static DEFINE_IDA(soc_ida); |
74d1d82c | 19 | |
948b3edb JP |
20 | /* Prototype to allow declarations of DEVICE_ATTR(<foo>) before soc_info_show */ |
21 | static ssize_t soc_info_show(struct device *dev, struct device_attribute *attr, | |
22 | char *buf); | |
74d1d82c LJ |
23 | |
24 | struct soc_device { | |
25 | struct device dev; | |
26 | struct soc_device_attribute *attr; | |
27 | int soc_dev_num; | |
28 | }; | |
29 | ||
30 | static struct bus_type soc_bus_type = { | |
31 | .name = "soc", | |
32 | }; | |
33 | ||
948b3edb JP |
34 | static DEVICE_ATTR(machine, 0444, soc_info_show, NULL); |
35 | static DEVICE_ATTR(family, 0444, soc_info_show, NULL); | |
36 | static DEVICE_ATTR(serial_number, 0444, soc_info_show, NULL); | |
37 | static DEVICE_ATTR(soc_id, 0444, soc_info_show, NULL); | |
38 | static DEVICE_ATTR(revision, 0444, soc_info_show, NULL); | |
74d1d82c LJ |
39 | |
40 | struct device *soc_device_to_device(struct soc_device *soc_dev) | |
41 | { | |
42 | return &soc_dev->dev; | |
43 | } | |
44 | ||
726592a9 | 45 | static umode_t soc_attribute_mode(struct kobject *kobj, |
2071b950 LT |
46 | struct attribute *attr, |
47 | int index) | |
74d1d82c | 48 | { |
baf1d9c1 | 49 | struct device *dev = kobj_to_dev(kobj); |
74d1d82c LJ |
50 | struct soc_device *soc_dev = container_of(dev, struct soc_device, dev); |
51 | ||
948b3edb | 52 | if ((attr == &dev_attr_machine.attr) && soc_dev->attr->machine) |
74d1d82c | 53 | return attr->mode; |
948b3edb | 54 | if ((attr == &dev_attr_family.attr) && soc_dev->attr->family) |
74d1d82c | 55 | return attr->mode; |
948b3edb | 56 | if ((attr == &dev_attr_revision.attr) && soc_dev->attr->revision) |
74d1d82c | 57 | return attr->mode; |
948b3edb | 58 | if ((attr == &dev_attr_serial_number.attr) && soc_dev->attr->serial_number) |
9aebf4de | 59 | return attr->mode; |
948b3edb | 60 | if ((attr == &dev_attr_soc_id.attr) && soc_dev->attr->soc_id) |
2071b950 | 61 | return attr->mode; |
74d1d82c | 62 | |
948b3edb | 63 | /* Unknown or unfilled attribute */ |
74d1d82c LJ |
64 | return 0; |
65 | } | |
66 | ||
948b3edb JP |
67 | static ssize_t soc_info_show(struct device *dev, struct device_attribute *attr, |
68 | char *buf) | |
74d1d82c LJ |
69 | { |
70 | struct soc_device *soc_dev = container_of(dev, struct soc_device, dev); | |
948b3edb | 71 | const char *output; |
74d1d82c LJ |
72 | |
73 | if (attr == &dev_attr_machine) | |
948b3edb JP |
74 | output = soc_dev->attr->machine; |
75 | else if (attr == &dev_attr_family) | |
76 | output = soc_dev->attr->family; | |
77 | else if (attr == &dev_attr_revision) | |
78 | output = soc_dev->attr->revision; | |
79 | else if (attr == &dev_attr_serial_number) | |
80 | output = soc_dev->attr->serial_number; | |
81 | else if (attr == &dev_attr_soc_id) | |
82 | output = soc_dev->attr->soc_id; | |
83 | else | |
84 | return -EINVAL; | |
85 | ||
86 | return sysfs_emit(buf, "%s\n", output); | |
74d1d82c LJ |
87 | } |
88 | ||
89 | static struct attribute *soc_attr[] = { | |
90 | &dev_attr_machine.attr, | |
91 | &dev_attr_family.attr, | |
9aebf4de | 92 | &dev_attr_serial_number.attr, |
74d1d82c LJ |
93 | &dev_attr_soc_id.attr, |
94 | &dev_attr_revision.attr, | |
95 | NULL, | |
96 | }; | |
97 | ||
98 | static const struct attribute_group soc_attr_group = { | |
99 | .attrs = soc_attr, | |
100 | .is_visible = soc_attribute_mode, | |
101 | }; | |
102 | ||
74d1d82c LJ |
103 | static void soc_release(struct device *dev) |
104 | { | |
105 | struct soc_device *soc_dev = container_of(dev, struct soc_device, dev); | |
106 | ||
c31e7312 MN |
107 | ida_simple_remove(&soc_ida, soc_dev->soc_dev_num); |
108 | kfree(soc_dev->dev.groups); | |
74d1d82c LJ |
109 | kfree(soc_dev); |
110 | } | |
111 | ||
6e12db37 GU |
112 | static struct soc_device_attribute *early_soc_dev_attr; |
113 | ||
74d1d82c LJ |
114 | struct soc_device *soc_device_register(struct soc_device_attribute *soc_dev_attr) |
115 | { | |
116 | struct soc_device *soc_dev; | |
c31e7312 | 117 | const struct attribute_group **soc_attr_groups; |
74d1d82c LJ |
118 | int ret; |
119 | ||
1da1b362 | 120 | if (!soc_bus_type.p) { |
6e12db37 GU |
121 | if (early_soc_dev_attr) |
122 | return ERR_PTR(-EBUSY); | |
123 | early_soc_dev_attr = soc_dev_attr; | |
124 | return NULL; | |
1da1b362 GU |
125 | } |
126 | ||
74d1d82c LJ |
127 | soc_dev = kzalloc(sizeof(*soc_dev), GFP_KERNEL); |
128 | if (!soc_dev) { | |
2071b950 | 129 | ret = -ENOMEM; |
74d1d82c LJ |
130 | goto out1; |
131 | } | |
132 | ||
c31e7312 MN |
133 | soc_attr_groups = kcalloc(3, sizeof(*soc_attr_groups), GFP_KERNEL); |
134 | if (!soc_attr_groups) { | |
135 | ret = -ENOMEM; | |
136 | goto out2; | |
137 | } | |
138 | soc_attr_groups[0] = &soc_attr_group; | |
139 | soc_attr_groups[1] = soc_dev_attr->custom_attr_group; | |
140 | ||
74d1d82c | 141 | /* Fetch a unique (reclaimable) SOC ID. */ |
cfcf6a91 LD |
142 | ret = ida_simple_get(&soc_ida, 0, 0, GFP_KERNEL); |
143 | if (ret < 0) | |
c31e7312 | 144 | goto out3; |
cfcf6a91 | 145 | soc_dev->soc_dev_num = ret; |
74d1d82c LJ |
146 | |
147 | soc_dev->attr = soc_dev_attr; | |
148 | soc_dev->dev.bus = &soc_bus_type; | |
149 | soc_dev->dev.groups = soc_attr_groups; | |
150 | soc_dev->dev.release = soc_release; | |
151 | ||
152 | dev_set_name(&soc_dev->dev, "soc%d", soc_dev->soc_dev_num); | |
153 | ||
154 | ret = device_register(&soc_dev->dev); | |
c31e7312 MN |
155 | if (ret) { |
156 | put_device(&soc_dev->dev); | |
157 | return ERR_PTR(ret); | |
158 | } | |
74d1d82c LJ |
159 | |
160 | return soc_dev; | |
161 | ||
162 | out3: | |
c31e7312 | 163 | kfree(soc_attr_groups); |
74d1d82c LJ |
164 | out2: |
165 | kfree(soc_dev); | |
166 | out1: | |
167 | return ERR_PTR(ret); | |
168 | } | |
f7ccc7a3 | 169 | EXPORT_SYMBOL_GPL(soc_device_register); |
74d1d82c | 170 | |
0b81144a | 171 | /* Ensure soc_dev->attr is freed after calling soc_device_unregister. */ |
74d1d82c LJ |
172 | void soc_device_unregister(struct soc_device *soc_dev) |
173 | { | |
74d1d82c | 174 | device_unregister(&soc_dev->dev); |
6e12db37 | 175 | early_soc_dev_attr = NULL; |
74d1d82c | 176 | } |
f7ccc7a3 | 177 | EXPORT_SYMBOL_GPL(soc_device_unregister); |
74d1d82c LJ |
178 | |
179 | static int __init soc_bus_register(void) | |
180 | { | |
6e12db37 | 181 | int ret; |
1da1b362 | 182 | |
6e12db37 GU |
183 | ret = bus_register(&soc_bus_type); |
184 | if (ret) | |
185 | return ret; | |
186 | ||
187 | if (early_soc_dev_attr) | |
188 | return PTR_ERR(soc_device_register(early_soc_dev_attr)); | |
189 | ||
190 | return 0; | |
74d1d82c LJ |
191 | } |
192 | core_initcall(soc_bus_register); | |
c97db7cc | 193 | |
6e12db37 GU |
194 | static int soc_device_match_attr(const struct soc_device_attribute *attr, |
195 | const struct soc_device_attribute *match) | |
c97db7cc | 196 | { |
c97db7cc | 197 | if (match->machine && |
6e12db37 | 198 | (!attr->machine || !glob_match(match->machine, attr->machine))) |
c97db7cc AB |
199 | return 0; |
200 | ||
201 | if (match->family && | |
6e12db37 | 202 | (!attr->family || !glob_match(match->family, attr->family))) |
c97db7cc AB |
203 | return 0; |
204 | ||
205 | if (match->revision && | |
6e12db37 | 206 | (!attr->revision || !glob_match(match->revision, attr->revision))) |
c97db7cc AB |
207 | return 0; |
208 | ||
209 | if (match->soc_id && | |
6e12db37 | 210 | (!attr->soc_id || !glob_match(match->soc_id, attr->soc_id))) |
c97db7cc AB |
211 | return 0; |
212 | ||
213 | return 1; | |
214 | } | |
215 | ||
6e12db37 GU |
216 | static int soc_device_match_one(struct device *dev, void *arg) |
217 | { | |
218 | struct soc_device *soc_dev = container_of(dev, struct soc_device, dev); | |
219 | ||
220 | return soc_device_match_attr(soc_dev->attr, arg); | |
221 | } | |
222 | ||
c97db7cc AB |
223 | /* |
224 | * soc_device_match - identify the SoC in the machine | |
225 | * @matches: zero-terminated array of possible matches | |
226 | * | |
227 | * returns the first matching entry of the argument array, or NULL | |
228 | * if none of them match. | |
229 | * | |
230 | * This function is meant as a helper in place of of_match_node() | |
231 | * in cases where either no device tree is available or the information | |
232 | * in a device node is insufficient to identify a particular variant | |
233 | * by its compatible strings or other properties. For new devices, | |
234 | * the DT binding should always provide unique compatible strings | |
235 | * that allow the use of of_match_node() instead. | |
236 | * | |
237 | * The calling function can use the .data entry of the | |
238 | * soc_device_attribute to pass a structure or function pointer for | |
239 | * each entry. | |
240 | */ | |
241 | const struct soc_device_attribute *soc_device_match( | |
242 | const struct soc_device_attribute *matches) | |
243 | { | |
b0f6807d | 244 | int ret; |
c97db7cc AB |
245 | |
246 | if (!matches) | |
247 | return NULL; | |
248 | ||
b0f6807d GU |
249 | while (matches->machine || matches->family || matches->revision || |
250 | matches->soc_id) { | |
c97db7cc AB |
251 | ret = bus_for_each_dev(&soc_bus_type, NULL, (void *)matches, |
252 | soc_device_match_one); | |
6e12db37 GU |
253 | if (ret < 0 && early_soc_dev_attr) |
254 | ret = soc_device_match_attr(early_soc_dev_attr, | |
255 | matches); | |
0656db9e GU |
256 | if (ret < 0) |
257 | return NULL; | |
b0f6807d | 258 | if (ret) |
c97db7cc | 259 | return matches; |
b0f6807d GU |
260 | |
261 | matches++; | |
c97db7cc AB |
262 | } |
263 | return NULL; | |
264 | } | |
265 | EXPORT_SYMBOL_GPL(soc_device_match); |