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