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