1
2
3
4
5
6
7
8#include <linux/device.h>
9#include <linux/module.h>
10#include <linux/mutex.h>
11#include <linux/slab.h>
12#include <linux/init.h>
13#include <linux/err.h>
14#include <asm/eadm.h>
15#include "chsc.h"
16
17static struct device *scm_root;
18static struct eadm_ops *eadm_ops;
19static DEFINE_MUTEX(eadm_ops_mutex);
20
21#define to_scm_dev(n) container_of(n, struct scm_device, dev)
22#define to_scm_drv(d) container_of(d, struct scm_driver, drv)
23
24static int scmdev_probe(struct device *dev)
25{
26 struct scm_device *scmdev = to_scm_dev(dev);
27 struct scm_driver *scmdrv = to_scm_drv(dev->driver);
28
29 return scmdrv->probe ? scmdrv->probe(scmdev) : -ENODEV;
30}
31
32static int scmdev_remove(struct device *dev)
33{
34 struct scm_device *scmdev = to_scm_dev(dev);
35 struct scm_driver *scmdrv = to_scm_drv(dev->driver);
36
37 return scmdrv->remove ? scmdrv->remove(scmdev) : -ENODEV;
38}
39
40static int scmdev_uevent(struct device *dev, struct kobj_uevent_env *env)
41{
42 return add_uevent_var(env, "MODALIAS=scm:scmdev");
43}
44
45static struct bus_type scm_bus_type = {
46 .name = "scm",
47 .probe = scmdev_probe,
48 .remove = scmdev_remove,
49 .uevent = scmdev_uevent,
50};
51
52
53
54
55
56int scm_driver_register(struct scm_driver *scmdrv)
57{
58 struct device_driver *drv = &scmdrv->drv;
59
60 drv->bus = &scm_bus_type;
61
62 return driver_register(drv);
63}
64EXPORT_SYMBOL_GPL(scm_driver_register);
65
66
67
68
69
70void scm_driver_unregister(struct scm_driver *scmdrv)
71{
72 driver_unregister(&scmdrv->drv);
73}
74EXPORT_SYMBOL_GPL(scm_driver_unregister);
75
76int scm_get_ref(void)
77{
78 int ret = 0;
79
80 mutex_lock(&eadm_ops_mutex);
81 if (!eadm_ops || !try_module_get(eadm_ops->owner))
82 ret = -ENOENT;
83 mutex_unlock(&eadm_ops_mutex);
84
85 return ret;
86}
87EXPORT_SYMBOL_GPL(scm_get_ref);
88
89void scm_put_ref(void)
90{
91 mutex_lock(&eadm_ops_mutex);
92 module_put(eadm_ops->owner);
93 mutex_unlock(&eadm_ops_mutex);
94}
95EXPORT_SYMBOL_GPL(scm_put_ref);
96
97void register_eadm_ops(struct eadm_ops *ops)
98{
99 mutex_lock(&eadm_ops_mutex);
100 eadm_ops = ops;
101 mutex_unlock(&eadm_ops_mutex);
102}
103EXPORT_SYMBOL_GPL(register_eadm_ops);
104
105void unregister_eadm_ops(struct eadm_ops *ops)
106{
107 mutex_lock(&eadm_ops_mutex);
108 eadm_ops = NULL;
109 mutex_unlock(&eadm_ops_mutex);
110}
111EXPORT_SYMBOL_GPL(unregister_eadm_ops);
112
113int scm_start_aob(struct aob *aob)
114{
115 return eadm_ops->eadm_start(aob);
116}
117EXPORT_SYMBOL_GPL(scm_start_aob);
118
119void scm_irq_handler(struct aob *aob, int error)
120{
121 struct aob_rq_header *aobrq = (void *) aob->request.data;
122 struct scm_device *scmdev = aobrq->scmdev;
123 struct scm_driver *scmdrv = to_scm_drv(scmdev->dev.driver);
124
125 scmdrv->handler(scmdev, aobrq->data, error);
126}
127EXPORT_SYMBOL_GPL(scm_irq_handler);
128
129#define scm_attr(name) \
130static ssize_t show_##name(struct device *dev, \
131 struct device_attribute *attr, char *buf) \
132{ \
133 struct scm_device *scmdev = to_scm_dev(dev); \
134 int ret; \
135 \
136 device_lock(dev); \
137 ret = sprintf(buf, "%u\n", scmdev->attrs.name); \
138 device_unlock(dev); \
139 \
140 return ret; \
141} \
142static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
143
144scm_attr(persistence);
145scm_attr(oper_state);
146scm_attr(data_state);
147scm_attr(rank);
148scm_attr(release);
149scm_attr(res_id);
150
151static struct attribute *scmdev_attrs[] = {
152 &dev_attr_persistence.attr,
153 &dev_attr_oper_state.attr,
154 &dev_attr_data_state.attr,
155 &dev_attr_rank.attr,
156 &dev_attr_release.attr,
157 &dev_attr_res_id.attr,
158 NULL,
159};
160
161static struct attribute_group scmdev_attr_group = {
162 .attrs = scmdev_attrs,
163};
164
165static const struct attribute_group *scmdev_attr_groups[] = {
166 &scmdev_attr_group,
167 NULL,
168};
169
170static void scmdev_release(struct device *dev)
171{
172 struct scm_device *scmdev = to_scm_dev(dev);
173
174 kfree(scmdev);
175}
176
177static void scmdev_setup(struct scm_device *scmdev, struct sale *sale,
178 unsigned int size, unsigned int max_blk_count)
179{
180 dev_set_name(&scmdev->dev, "%016llx", (unsigned long long) sale->sa);
181 scmdev->nr_max_block = max_blk_count;
182 scmdev->address = sale->sa;
183 scmdev->size = 1UL << size;
184 scmdev->attrs.rank = sale->rank;
185 scmdev->attrs.persistence = sale->p;
186 scmdev->attrs.oper_state = sale->op_state;
187 scmdev->attrs.data_state = sale->data_state;
188 scmdev->attrs.rank = sale->rank;
189 scmdev->attrs.release = sale->r;
190 scmdev->attrs.res_id = sale->rid;
191 scmdev->dev.parent = scm_root;
192 scmdev->dev.bus = &scm_bus_type;
193 scmdev->dev.release = scmdev_release;
194 scmdev->dev.groups = scmdev_attr_groups;
195}
196
197
198
199
200static void scmdev_update(struct scm_device *scmdev, struct sale *sale)
201{
202 struct scm_driver *scmdrv;
203 bool changed;
204
205 device_lock(&scmdev->dev);
206 changed = scmdev->attrs.rank != sale->rank ||
207 scmdev->attrs.oper_state != sale->op_state;
208 scmdev->attrs.rank = sale->rank;
209 scmdev->attrs.oper_state = sale->op_state;
210 if (!scmdev->dev.driver)
211 goto out;
212 scmdrv = to_scm_drv(scmdev->dev.driver);
213 if (changed && scmdrv->notify)
214 scmdrv->notify(scmdev, SCM_CHANGE);
215out:
216 device_unlock(&scmdev->dev);
217 if (changed)
218 kobject_uevent(&scmdev->dev.kobj, KOBJ_CHANGE);
219}
220
221static int check_address(struct device *dev, void *data)
222{
223 struct scm_device *scmdev = to_scm_dev(dev);
224 struct sale *sale = data;
225
226 return scmdev->address == sale->sa;
227}
228
229static struct scm_device *scmdev_find(struct sale *sale)
230{
231 struct device *dev;
232
233 dev = bus_find_device(&scm_bus_type, NULL, sale, check_address);
234
235 return dev ? to_scm_dev(dev) : NULL;
236}
237
238static int scm_add(struct chsc_scm_info *scm_info, size_t num)
239{
240 struct sale *sale, *scmal = scm_info->scmal;
241 struct scm_device *scmdev;
242 int ret;
243
244 for (sale = scmal; sale < scmal + num; sale++) {
245 scmdev = scmdev_find(sale);
246 if (scmdev) {
247 scmdev_update(scmdev, sale);
248
249 put_device(&scmdev->dev);
250 continue;
251 }
252 scmdev = kzalloc(sizeof(*scmdev), GFP_KERNEL);
253 if (!scmdev)
254 return -ENODEV;
255 scmdev_setup(scmdev, sale, scm_info->is, scm_info->mbc);
256 ret = device_register(&scmdev->dev);
257 if (ret) {
258
259 put_device(&scmdev->dev);
260 return ret;
261 }
262 }
263
264 return 0;
265}
266
267int scm_update_information(void)
268{
269 struct chsc_scm_info *scm_info;
270 u64 token = 0;
271 size_t num;
272 int ret;
273
274 scm_info = (void *)__get_free_page(GFP_KERNEL | GFP_DMA);
275 if (!scm_info)
276 return -ENOMEM;
277
278 do {
279 ret = chsc_scm_info(scm_info, token);
280 if (ret)
281 break;
282
283 num = (scm_info->response.length -
284 (offsetof(struct chsc_scm_info, scmal) -
285 offsetof(struct chsc_scm_info, response))
286 ) / sizeof(struct sale);
287
288 ret = scm_add(scm_info, num);
289 if (ret)
290 break;
291
292 token = scm_info->restok;
293 } while (token);
294
295 free_page((unsigned long)scm_info);
296
297 return ret;
298}
299
300static int scm_dev_avail(struct device *dev, void *unused)
301{
302 struct scm_driver *scmdrv = to_scm_drv(dev->driver);
303 struct scm_device *scmdev = to_scm_dev(dev);
304
305 if (dev->driver && scmdrv->notify)
306 scmdrv->notify(scmdev, SCM_AVAIL);
307
308 return 0;
309}
310
311int scm_process_availability_information(void)
312{
313 return bus_for_each_dev(&scm_bus_type, NULL, NULL, scm_dev_avail);
314}
315
316static int __init scm_init(void)
317{
318 int ret;
319
320 ret = bus_register(&scm_bus_type);
321 if (ret)
322 return ret;
323
324 scm_root = root_device_register("scm");
325 if (IS_ERR(scm_root)) {
326 bus_unregister(&scm_bus_type);
327 return PTR_ERR(scm_root);
328 }
329
330 scm_update_information();
331 return 0;
332}
333subsys_initcall_sync(scm_init);
334
