1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright (C) ST-Ericsson SA 2011
5 * Author: Lee Jones <lee.jones@linaro.org> for ST-Ericsson.
8 #include <linux/sysfs.h>
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>
16 #include <linux/glob.h>
18 static DEFINE_IDA(soc_ida
);
20 static ssize_t
soc_info_get(struct device
*dev
,
21 struct device_attribute
*attr
,
26 struct soc_device_attribute
*attr
;
30 static struct bus_type soc_bus_type
= {
34 static DEVICE_ATTR(machine
, S_IRUGO
, soc_info_get
, NULL
);
35 static DEVICE_ATTR(family
, S_IRUGO
, soc_info_get
, NULL
);
36 static DEVICE_ATTR(soc_id
, S_IRUGO
, soc_info_get
, NULL
);
37 static DEVICE_ATTR(revision
, S_IRUGO
, soc_info_get
, NULL
);
39 struct device
*soc_device_to_device(struct soc_device
*soc_dev
)
44 static umode_t
soc_attribute_mode(struct kobject
*kobj
,
45 struct attribute
*attr
,
48 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
49 struct soc_device
*soc_dev
= container_of(dev
, struct soc_device
, dev
);
51 if ((attr
== &dev_attr_machine
.attr
)
52 && (soc_dev
->attr
->machine
!= NULL
))
54 if ((attr
== &dev_attr_family
.attr
)
55 && (soc_dev
->attr
->family
!= NULL
))
57 if ((attr
== &dev_attr_revision
.attr
)
58 && (soc_dev
->attr
->revision
!= NULL
))
60 if ((attr
== &dev_attr_soc_id
.attr
)
61 && (soc_dev
->attr
->soc_id
!= NULL
))
64 /* Unknown or unfilled attribute. */
68 static ssize_t
soc_info_get(struct device
*dev
,
69 struct device_attribute
*attr
,
72 struct soc_device
*soc_dev
= container_of(dev
, struct soc_device
, dev
);
74 if (attr
== &dev_attr_machine
)
75 return sprintf(buf
, "%s\n", soc_dev
->attr
->machine
);
76 if (attr
== &dev_attr_family
)
77 return sprintf(buf
, "%s\n", soc_dev
->attr
->family
);
78 if (attr
== &dev_attr_revision
)
79 return sprintf(buf
, "%s\n", soc_dev
->attr
->revision
);
80 if (attr
== &dev_attr_soc_id
)
81 return sprintf(buf
, "%s\n", soc_dev
->attr
->soc_id
);
87 static struct attribute
*soc_attr
[] = {
88 &dev_attr_machine
.attr
,
89 &dev_attr_family
.attr
,
90 &dev_attr_soc_id
.attr
,
91 &dev_attr_revision
.attr
,
95 static const struct attribute_group soc_attr_group
= {
97 .is_visible
= soc_attribute_mode
,
100 static const struct attribute_group
*soc_attr_groups
[] = {
105 static void soc_release(struct device
*dev
)
107 struct soc_device
*soc_dev
= container_of(dev
, struct soc_device
, dev
);
112 static struct soc_device_attribute
*early_soc_dev_attr
;
114 struct soc_device
*soc_device_register(struct soc_device_attribute
*soc_dev_attr
)
116 struct soc_device
*soc_dev
;
119 if (!soc_bus_type
.p
) {
120 if (early_soc_dev_attr
)
121 return ERR_PTR(-EBUSY
);
122 early_soc_dev_attr
= soc_dev_attr
;
126 soc_dev
= kzalloc(sizeof(*soc_dev
), GFP_KERNEL
);
132 /* Fetch a unique (reclaimable) SOC ID. */
133 ret
= ida_simple_get(&soc_ida
, 0, 0, GFP_KERNEL
);
136 soc_dev
->soc_dev_num
= ret
;
138 soc_dev
->attr
= soc_dev_attr
;
139 soc_dev
->dev
.bus
= &soc_bus_type
;
140 soc_dev
->dev
.groups
= soc_attr_groups
;
141 soc_dev
->dev
.release
= soc_release
;
143 dev_set_name(&soc_dev
->dev
, "soc%d", soc_dev
->soc_dev_num
);
145 ret
= device_register(&soc_dev
->dev
);
152 ida_simple_remove(&soc_ida
, soc_dev
->soc_dev_num
);
159 /* Ensure soc_dev->attr is freed prior to calling soc_device_unregister. */
160 void soc_device_unregister(struct soc_device
*soc_dev
)
162 ida_simple_remove(&soc_ida
, soc_dev
->soc_dev_num
);
164 device_unregister(&soc_dev
->dev
);
165 early_soc_dev_attr
= NULL
;
168 static int __init
soc_bus_register(void)
172 ret
= bus_register(&soc_bus_type
);
176 if (early_soc_dev_attr
)
177 return PTR_ERR(soc_device_register(early_soc_dev_attr
));
181 core_initcall(soc_bus_register
);
183 static int soc_device_match_attr(const struct soc_device_attribute
*attr
,
184 const struct soc_device_attribute
*match
)
186 if (match
->machine
&&
187 (!attr
->machine
|| !glob_match(match
->machine
, attr
->machine
)))
191 (!attr
->family
|| !glob_match(match
->family
, attr
->family
)))
194 if (match
->revision
&&
195 (!attr
->revision
|| !glob_match(match
->revision
, attr
->revision
)))
199 (!attr
->soc_id
|| !glob_match(match
->soc_id
, attr
->soc_id
)))
205 static int soc_device_match_one(struct device
*dev
, void *arg
)
207 struct soc_device
*soc_dev
= container_of(dev
, struct soc_device
, dev
);
209 return soc_device_match_attr(soc_dev
->attr
, arg
);
213 * soc_device_match - identify the SoC in the machine
214 * @matches: zero-terminated array of possible matches
216 * returns the first matching entry of the argument array, or NULL
217 * if none of them match.
219 * This function is meant as a helper in place of of_match_node()
220 * in cases where either no device tree is available or the information
221 * in a device node is insufficient to identify a particular variant
222 * by its compatible strings or other properties. For new devices,
223 * the DT binding should always provide unique compatible strings
224 * that allow the use of of_match_node() instead.
226 * The calling function can use the .data entry of the
227 * soc_device_attribute to pass a structure or function pointer for
230 const struct soc_device_attribute
*soc_device_match(
231 const struct soc_device_attribute
*matches
)
239 if (!(matches
->machine
|| matches
->family
||
240 matches
->revision
|| matches
->soc_id
))
242 ret
= bus_for_each_dev(&soc_bus_type
, NULL
, (void *)matches
,
243 soc_device_match_one
);
244 if (ret
< 0 && early_soc_dev_attr
)
245 ret
= soc_device_match_attr(early_soc_dev_attr
,
256 EXPORT_SYMBOL_GPL(soc_device_match
);