1 // SPDX-License-Identifier: GPL-2.0-only
2 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
3
4 #include <linux/platform_device.h>
5 #include <linux/device.h>
6 #include <linux/module.h>
7 #include <linux/genalloc.h>
8 #include <linux/vmalloc.h>
9 #include <linux/dma-mapping.h>
10 #include <linux/list_sort.h>
11 #include <linux/libnvdimm.h>
12 #include <linux/ndctl.h>
13 #include <nd-core.h>
14 #include <linux/printk.h>
15 #include <linux/seq_buf.h>
16 #include <linux/papr_scm.h>
17 #include <uapi/linux/papr_pdsm.h>
18
19 #include "../watermark.h"
20 #include "nfit_test.h"
21 #include "ndtest.h"
22
23 enum {
24 DIMM_SIZE = SZ_32M,
25 LABEL_SIZE = SZ_128K,
26 NUM_INSTANCES = 2,
27 NUM_DCR = 4,
28 NDTEST_MAX_MAPPING = 6,
29 };
30
31 #define NDTEST_SCM_DIMM_CMD_MASK \
32 ((1ul << ND_CMD_GET_CONFIG_SIZE) | \
33 (1ul << ND_CMD_GET_CONFIG_DATA) | \
34 (1ul << ND_CMD_SET_CONFIG_DATA) | \
35 (1ul << ND_CMD_CALL))
36
37 #define NFIT_DIMM_HANDLE(node, socket, imc, chan, dimm) \
38 (((node & 0xfff) << 16) | ((socket & 0xf) << 12) \
39 | ((imc & 0xf) << 8) | ((chan & 0xf) << 4) | (dimm & 0xf))
40
41 static DEFINE_SPINLOCK(ndtest_lock);
42 static struct ndtest_priv *instances[NUM_INSTANCES];
43
44 static const struct class ndtest_dimm_class = {
45 .name = "nfit_test_dimm",
46 };
47
48 static struct gen_pool *ndtest_pool;
49
50 static struct ndtest_dimm dimm_group1[] = {
51 {
52 .size = DIMM_SIZE,
53 .handle = NFIT_DIMM_HANDLE(0, 0, 0, 0, 0),
54 .uuid_str = "1e5c75d2-b618-11ea-9aa3-507b9ddc0f72",
55 .physical_id = 0,
56 .num_formats = 2,
57 },
58 {
59 .size = DIMM_SIZE,
60 .handle = NFIT_DIMM_HANDLE(0, 0, 0, 0, 1),
61 .uuid_str = "1c4d43ac-b618-11ea-be80-507b9ddc0f72",
62 .physical_id = 1,
63 .num_formats = 2,
64 },
65 {
66 .size = DIMM_SIZE,
67 .handle = NFIT_DIMM_HANDLE(0, 0, 1, 0, 0),
68 .uuid_str = "a9f17ffc-b618-11ea-b36d-507b9ddc0f72",
69 .physical_id = 2,
70 .num_formats = 2,
71 },
72 {
73 .size = DIMM_SIZE,
74 .handle = NFIT_DIMM_HANDLE(0, 0, 1, 0, 1),
75 .uuid_str = "b6b83b22-b618-11ea-8aae-507b9ddc0f72",
76 .physical_id = 3,
77 .num_formats = 2,
78 },
79 {
80 .size = DIMM_SIZE,
81 .handle = NFIT_DIMM_HANDLE(0, 1, 0, 0, 0),
82 .uuid_str = "bf9baaee-b618-11ea-b181-507b9ddc0f72",
83 .physical_id = 4,
84 .num_formats = 2,
85 },
86 };
87
88 static struct ndtest_dimm dimm_group2[] = {
89 {
90 .size = DIMM_SIZE,
91 .handle = NFIT_DIMM_HANDLE(1, 0, 0, 0, 0),
92 .uuid_str = "ca0817e2-b618-11ea-9db3-507b9ddc0f72",
93 .physical_id = 0,
94 .num_formats = 1,
95 .flags = PAPR_PMEM_UNARMED | PAPR_PMEM_EMPTY |
96 PAPR_PMEM_SAVE_FAILED | PAPR_PMEM_SHUTDOWN_DIRTY |
97 PAPR_PMEM_HEALTH_FATAL,
98 },
99 };
100
101 static struct ndtest_mapping region0_mapping[] = {
102 {
103 .dimm = 0,
104 .position = 0,
105 .start = 0,
106 .size = SZ_16M,
107 },
108 {
109 .dimm = 1,
110 .position = 1,
111 .start = 0,
112 .size = SZ_16M,
113 }
114 };
115
116 static struct ndtest_mapping region1_mapping[] = {
117 {
118 .dimm = 0,
119 .position = 0,
120 .start = SZ_16M,
121 .size = SZ_16M,
122 },
123 {
124 .dimm = 1,
125 .position = 1,
126 .start = SZ_16M,
127 .size = SZ_16M,
128 },
129 {
130 .dimm = 2,
131 .position = 2,
132 .start = SZ_16M,
133 .size = SZ_16M,
134 },
135 {
136 .dimm = 3,
137 .position = 3,
138 .start = SZ_16M,
139 .size = SZ_16M,
140 },
141 };
142
143 static struct ndtest_region bus0_regions[] = {
144 {
145 .type = ND_DEVICE_NAMESPACE_PMEM,
146 .num_mappings = ARRAY_SIZE(region0_mapping),
147 .mapping = region0_mapping,
148 .size = DIMM_SIZE,
149 .range_index = 1,
150 },
151 {
152 .type = ND_DEVICE_NAMESPACE_PMEM,
153 .num_mappings = ARRAY_SIZE(region1_mapping),
154 .mapping = region1_mapping,
155 .size = DIMM_SIZE * 2,
156 .range_index = 2,
157 },
158 };
159
160 static struct ndtest_mapping region6_mapping[] = {
161 {
162 .dimm = 0,
163 .position = 0,
164 .start = 0,
165 .size = DIMM_SIZE,
166 },
167 };
168
169 static struct ndtest_region bus1_regions[] = {
170 {
171 .type = ND_DEVICE_NAMESPACE_IO,
172 .num_mappings = ARRAY_SIZE(region6_mapping),
173 .mapping = region6_mapping,
174 .size = DIMM_SIZE,
175 .range_index = 1,
176 },
177 };
178
179 static struct ndtest_config bus_configs[NUM_INSTANCES] = {
180 /* bus 1 */
181 {
182 .dimm_start = 0,
183 .dimm_count = ARRAY_SIZE(dimm_group1),
184 .dimms = dimm_group1,
185 .regions = bus0_regions,
186 .num_regions = ARRAY_SIZE(bus0_regions),
187 },
188 /* bus 2 */
189 {
190 .dimm_start = ARRAY_SIZE(dimm_group1),
191 .dimm_count = ARRAY_SIZE(dimm_group2),
192 .dimms = dimm_group2,
193 .regions = bus1_regions,
194 .num_regions = ARRAY_SIZE(bus1_regions),
195 },
196 };
197
198 static inline struct ndtest_priv *to_ndtest_priv(struct device *dev)
199 {
200 struct platform_device *pdev = to_platform_device(dev);
201
202 return container_of(pdev, struct ndtest_priv, pdev);
203 }
204
205 static int ndtest_config_get(struct ndtest_dimm *p, unsigned int buf_len,
206 struct nd_cmd_get_config_data_hdr *hdr)
207 {
208 unsigned int len;
209
210 if ((hdr->in_offset + hdr->in_length) > LABEL_SIZE)
211 return -EINVAL;
212
213 hdr->status = 0;
214 len = min(hdr->in_length, LABEL_SIZE - hdr->in_offset);
215 memcpy(hdr->out_buf, p->label_area + hdr->in_offset, len);
216
217 return buf_len - len;
218 }
219
220 static int ndtest_config_set(struct ndtest_dimm *p, unsigned int buf_len,
221 struct nd_cmd_set_config_hdr *hdr)
222 {
223 unsigned int len;
224
225 if ((hdr->in_offset + hdr->in_length) > LABEL_SIZE)
226 return -EINVAL;
227
228 len = min(hdr->in_length, LABEL_SIZE - hdr->in_offset);
229 memcpy(p->label_area + hdr->in_offset, hdr->in_buf, len);
230
231 return buf_len - len;
232 }
233
234 static int ndtest_get_config_size(struct ndtest_dimm *dimm, unsigned int buf_len,
235 struct nd_cmd_get_config_size *size)
236 {
237 size->status = 0;
238 size->max_xfer = 8;
239 size->config_size = dimm->config_size;
240
241 return 0;
242 }
243
244 static int ndtest_ctl(struct nvdimm_bus_descriptor *nd_desc,
245 struct nvdimm *nvdimm, unsigned int cmd, void *buf,
246 unsigned int buf_len, int *cmd_rc)
247 {
248 struct ndtest_dimm *dimm;
249 int _cmd_rc;
250
251 if (!cmd_rc)
252 cmd_rc = &_cmd_rc;
253
254 *cmd_rc = 0;
255
256 if (!nvdimm)
257 return -EINVAL;
258
259 dimm = nvdimm_provider_data(nvdimm);
260 if (!dimm)
261 return -EINVAL;
262
263 switch (cmd) {
264 case ND_CMD_GET_CONFIG_SIZE:
265 *cmd_rc = ndtest_get_config_size(dimm, buf_len, buf);
266 break;
267 case ND_CMD_GET_CONFIG_DATA:
268 *cmd_rc = ndtest_config_get(dimm, buf_len, buf);
269 break;
270 case ND_CMD_SET_CONFIG_DATA:
271 *cmd_rc = ndtest_config_set(dimm, buf_len, buf);
272 break;
273 default:
274 return -EINVAL;
275 }
276
277 /* Failures for a DIMM can be injected using fail_cmd and
278 * fail_cmd_code, see the device attributes below
279 */
280 if ((1 << cmd) & dimm->fail_cmd)
281 return dimm->fail_cmd_code ? dimm->fail_cmd_code : -EIO;
282
283 return 0;
284 }
285
286 static struct nfit_test_resource *ndtest_resource_lookup(resource_size_t addr)
287 {
288 int i;
289
290 for (i = 0; i < NUM_INSTANCES; i++) {
291 struct nfit_test_resource *n, *nfit_res = NULL;
292 struct ndtest_priv *t = instances[i];
293
294 if (!t)
295 continue;
296 spin_lock(&ndtest_lock);
297 list_for_each_entry(n, &t->resources, list) {
298 if (addr >= n->res.start && (addr < n->res.start
299 + resource_size(&n->res))) {
300 nfit_res = n;
301 break;
302 } else if (addr >= (unsigned long) n->buf
303 && (addr < (unsigned long) n->buf
304 + resource_size(&n->res))) {
305 nfit_res = n;
306 break;
307 }
308 }
309 spin_unlock(&ndtest_lock);
310 if (nfit_res)
311 return nfit_res;
312 }
313
314 pr_warn("Failed to get resource\n");
315
316 return NULL;
317 }
318
319 static void ndtest_release_resource(void *data)
320 {
321 struct nfit_test_resource *res = data;
322
323 spin_lock(&ndtest_lock);
324 list_del(&res->list);
325 spin_unlock(&ndtest_lock);
326
327 if (resource_size(&res->res) >= DIMM_SIZE)
328 gen_pool_free(ndtest_pool, res->res.start,
329 resource_size(&res->res));
330 vfree(res->buf);
331 kfree(res);
332 }
333
334 static void *ndtest_alloc_resource(struct ndtest_priv *p, size_t size,
335 dma_addr_t *dma)
336 {
337 dma_addr_t __dma;
338 void *buf;
339 struct nfit_test_resource *res;
340 struct genpool_data_align data = {
341 .align = SZ_128M,
342 };
343
344 res = kzalloc(sizeof(*res), GFP_KERNEL);
345 if (!res)
346 return NULL;
347
348 buf = vmalloc(size);
349 if (size >= DIMM_SIZE)
350 __dma = gen_pool_alloc_algo(ndtest_pool, size,
351 gen_pool_first_fit_align, &data);
352 else
353 __dma = (unsigned long) buf;
354
355 if (!__dma)
356 goto buf_err;
357
358 INIT_LIST_HEAD(&res->list);
359 res->dev = &p->pdev.dev;
360 res->buf = buf;
361 res->res.start = __dma;
362 res->res.end = __dma + size - 1;
363 res->res.name = "NFIT";
364 spin_lock_init(&res->lock);
365 INIT_LIST_HEAD(&res->requests);
366 spin_lock(&ndtest_lock);
367 list_add(&res->list, &p->resources);
368 spin_unlock(&ndtest_lock);
369
370 if (dma)
371 *dma = __dma;
372
373 if (!devm_add_action(&p->pdev.dev, ndtest_release_resource, res))
374 return res->buf;
375
376 buf_err:
377 if (__dma && size >= DIMM_SIZE)
378 gen_pool_free(ndtest_pool, __dma, size);
379 if (buf)
380 vfree(buf);
381 kfree(res);
382
383 return NULL;
384 }
385
386 static ssize_t range_index_show(struct device *dev,
387 struct device_attribute *attr, char *buf)
388 {
389 struct nd_region *nd_region = to_nd_region(dev);
390 struct ndtest_region *region = nd_region_provider_data(nd_region);
391
392 return sprintf(buf, "%d\n", region->range_index);
393 }
394 static DEVICE_ATTR_RO(range_index);
395
396 static struct attribute *ndtest_region_attributes[] = {
397 &dev_attr_range_index.attr,
398 NULL,
399 };
400
401 static const struct attribute_group ndtest_region_attribute_group = {
402 .name = "papr",
403 .attrs = ndtest_region_attributes,
404 };
405
406 static const struct attribute_group *ndtest_region_attribute_groups[] = {
407 &ndtest_region_attribute_group,
408 NULL,
409 };
410
411 static int ndtest_create_region(struct ndtest_priv *p,
412 struct ndtest_region *region)
413 {
414 struct nd_mapping_desc mappings[NDTEST_MAX_MAPPING];
415 struct nd_region_desc *ndr_desc, _ndr_desc;
416 struct nd_interleave_set *nd_set;
417 struct resource res;
418 int i, ndimm = region->mapping[0].dimm;
419 u64 uuid[2];
420
421 memset(&res, 0, sizeof(res));
422 memset(&mappings, 0, sizeof(mappings));
423 memset(&_ndr_desc, 0, sizeof(_ndr_desc));
424 ndr_desc = &_ndr_desc;
425
426 if (!ndtest_alloc_resource(p, region->size, &res.start))
427 return -ENOMEM;
428
429 res.end = res.start + region->size - 1;
430 ndr_desc->mapping = mappings;
431 ndr_desc->res = &res;
432 ndr_desc->provider_data = region;
433 ndr_desc->attr_groups = ndtest_region_attribute_groups;
434
435 if (uuid_parse(p->config->dimms[ndimm].uuid_str, (uuid_t *)uuid)) {
436 pr_err("failed to parse UUID\n");
437 return -ENXIO;
438 }
439
440 nd_set = devm_kzalloc(&p->pdev.dev, sizeof(*nd_set), GFP_KERNEL);
441 if (!nd_set)
442 return -ENOMEM;
443
444 nd_set->cookie1 = cpu_to_le64(uuid[0]);
445 nd_set->cookie2 = cpu_to_le64(uuid[1]);
446 nd_set->altcookie = nd_set->cookie1;
447 ndr_desc->nd_set = nd_set;
448
449 for (i = 0; i < region->num_mappings; i++) {
450 ndimm = region->mapping[i].dimm;
451 mappings[i].start = region->mapping[i].start;
452 mappings[i].size = region->mapping[i].size;
453 mappings[i].position = region->mapping[i].position;
454 mappings[i].nvdimm = p->config->dimms[ndimm].nvdimm;
455 }
456
457 ndr_desc->num_mappings = region->num_mappings;
458 region->region = nvdimm_pmem_region_create(p->bus, ndr_desc);
459
460 if (!region->region) {
461 dev_err(&p->pdev.dev, "Error registering region %pR\n",
462 ndr_desc->res);
463 return -ENXIO;
464 }
465
466 return 0;
467 }
468
469 static int ndtest_init_regions(struct ndtest_priv *p)
470 {
471 int i, ret = 0;
472
473 for (i = 0; i < p->config->num_regions; i++) {
474 ret = ndtest_create_region(p, &p->config->regions[i]);
475 if (ret)
476 return ret;
477 }
478
479 return 0;
480 }
481
482 static void put_dimms(void *data)
483 {
484 struct ndtest_priv *p = data;
485 int i;
486
487 for (i = 0; i < p->config->dimm_count; i++)
488 if (p->config->dimms[i].dev) {
489 device_unregister(p->config->dimms[i].dev);
490 p->config->dimms[i].dev = NULL;
491 }
492 }
493
494 static ssize_t handle_show(struct device *dev, struct device_attribute *attr,
495 char *buf)
496 {
497 struct ndtest_dimm *dimm = dev_get_drvdata(dev);
498
499 return sprintf(buf, "%#x\n", dimm->handle);
500 }
501 static DEVICE_ATTR_RO(handle);
502
503 static ssize_t fail_cmd_show(struct device *dev, struct device_attribute *attr,
504 char *buf)
505 {
506 struct ndtest_dimm *dimm = dev_get_drvdata(dev);
507
508 return sprintf(buf, "%#x\n", dimm->fail_cmd);
509 }
510
511 static ssize_t fail_cmd_store(struct device *dev, struct device_attribute *attr,
512 const char *buf, size_t size)
513 {
514 struct ndtest_dimm *dimm = dev_get_drvdata(dev);
515 unsigned long val;
516 ssize_t rc;
517
518 rc = kstrtol(buf, 0, &val);
519 if (rc)
520 return rc;
521
522 dimm->fail_cmd = val;
523
524 return size;
525 }
526 static DEVICE_ATTR_RW(fail_cmd);
527
528 static ssize_t fail_cmd_code_show(struct device *dev, struct device_attribute *attr,
529 char *buf)
530 {
531 struct ndtest_dimm *dimm = dev_get_drvdata(dev);
532
533 return sprintf(buf, "%d\n", dimm->fail_cmd_code);
534 }
535
536 static ssize_t fail_cmd_code_store(struct device *dev, struct device_attribute *attr,
537 const char *buf, size_t size)
538 {
539 struct ndtest_dimm *dimm = dev_get_drvdata(dev);
540 unsigned long val;
541 ssize_t rc;
542
543 rc = kstrtol(buf, 0, &val);
544 if (rc)
545 return rc;
546
547 dimm->fail_cmd_code = val;
548 return size;
549 }
550 static DEVICE_ATTR_RW(fail_cmd_code);
551
552 static struct attribute *dimm_attributes[] = {
553 &dev_attr_handle.attr,
554 &dev_attr_fail_cmd.attr,
555 &dev_attr_fail_cmd_code.attr,
556 NULL,
557 };
558
559 static struct attribute_group dimm_attribute_group = {
560 .attrs = dimm_attributes,
561 };
562
563 static const struct attribute_group *dimm_attribute_groups[] = {
564 &dimm_attribute_group,
565 NULL,
566 };
567
568 static ssize_t phys_id_show(struct device *dev,
569 struct device_attribute *attr, char *buf)
570 {
571 struct nvdimm *nvdimm = to_nvdimm(dev);
572 struct ndtest_dimm *dimm = nvdimm_provider_data(nvdimm);
573
574 return sprintf(buf, "%#x\n", dimm->physical_id);
575 }
576 static DEVICE_ATTR_RO(phys_id);
577
578 static ssize_t vendor_show(struct device *dev,
579 struct device_attribute *attr, char *buf)
580 {
581 return sprintf(buf, "0x1234567\n");
582 }
583 static DEVICE_ATTR_RO(vendor);
584
585 static ssize_t id_show(struct device *dev,
586 struct device_attribute *attr, char *buf)
587 {
588 struct nvdimm *nvdimm = to_nvdimm(dev);
589 struct ndtest_dimm *dimm = nvdimm_provider_data(nvdimm);
590
591 return sprintf(buf, "%04x-%02x-%04x-%08x", 0xabcd,
592 0xa, 2016, ~(dimm->handle));
593 }
594 static DEVICE_ATTR_RO(id);
595
596 static ssize_t nvdimm_handle_show(struct device *dev,
597 struct device_attribute *attr, char *buf)
598 {
599 struct nvdimm *nvdimm = to_nvdimm(dev);
600 struct ndtest_dimm *dimm = nvdimm_provider_data(nvdimm);
601
602 return sprintf(buf, "%#x\n", dimm->handle);
603 }
604
605 static struct device_attribute dev_attr_nvdimm_show_handle = {
606 .attr = { .name = "handle", .mode = 0444 },
607 .show = nvdimm_handle_show,
608 };
609
610 static ssize_t subsystem_vendor_show(struct device *dev,
611 struct device_attribute *attr, char *buf)
612 {
613 return sprintf(buf, "0x%04x\n", 0);
614 }
615 static DEVICE_ATTR_RO(subsystem_vendor);
616
617 static ssize_t dirty_shutdown_show(struct device *dev,
618 struct device_attribute *attr, char *buf)
619 {
620 return sprintf(buf, "%d\n", 42);
621 }
622 static DEVICE_ATTR_RO(dirty_shutdown);
623
624 static ssize_t formats_show(struct device *dev,
625 struct device_attribute *attr, char *buf)
626 {
627 struct nvdimm *nvdimm = to_nvdimm(dev);
628 struct ndtest_dimm *dimm = nvdimm_provider_data(nvdimm);
629
630 return sprintf(buf, "%d\n", dimm->num_formats);
631 }
632 static DEVICE_ATTR_RO(formats);
633
634 static ssize_t format_show(struct device *dev,
635 struct device_attribute *attr, char *buf)
636 {
637 struct nvdimm *nvdimm = to_nvdimm(dev);
638 struct ndtest_dimm *dimm = nvdimm_provider_data(nvdimm);
639
640 if (dimm->num_formats > 1)
641 return sprintf(buf, "0x201\n");
642
643 return sprintf(buf, "0x101\n");
644 }
645 static DEVICE_ATTR_RO(format);
646
647 static ssize_t format1_show(struct device *dev, struct device_attribute *attr,
648 char *buf)
649 {
650 return sprintf(buf, "0x301\n");
651 }
652 static DEVICE_ATTR_RO(format1);
653
654 static umode_t ndtest_nvdimm_attr_visible(struct kobject *kobj,
655 struct attribute *a, int n)
656 {
657 struct device *dev = container_of(kobj, struct device, kobj);
658 struct nvdimm *nvdimm = to_nvdimm(dev);
659 struct ndtest_dimm *dimm = nvdimm_provider_data(nvdimm);
660
661 if (a == &dev_attr_format1.attr && dimm->num_formats <= 1)
662 return 0;
663
664 return a->mode;
665 }
666
667 static ssize_t flags_show(struct device *dev,
668 struct device_attribute *attr, char *buf)
669 {
670 struct nvdimm *nvdimm = to_nvdimm(dev);
671 struct ndtest_dimm *dimm = nvdimm_provider_data(nvdimm);
672 struct seq_buf s;
673 u64 flags;
674
675 flags = dimm->flags;
676
677 seq_buf_init(&s, buf, PAGE_SIZE);
678 if (flags & PAPR_PMEM_UNARMED_MASK)
679 seq_buf_printf(&s, "not_armed ");
680
681 if (flags & PAPR_PMEM_BAD_SHUTDOWN_MASK)
682 seq_buf_printf(&s, "flush_fail ");
683
684 if (flags & PAPR_PMEM_BAD_RESTORE_MASK)
685 seq_buf_printf(&s, "restore_fail ");
686
687 if (flags & PAPR_PMEM_SAVE_MASK)
688 seq_buf_printf(&s, "save_fail ");
689
690 if (flags & PAPR_PMEM_SMART_EVENT_MASK)
691 seq_buf_printf(&s, "smart_notify ");
692
693
694 if (seq_buf_used(&s))
695 seq_buf_printf(&s, "\n");
696
697 return seq_buf_used(&s);
698 }
699 static DEVICE_ATTR_RO(flags);
700
701 static struct attribute *ndtest_nvdimm_attributes[] = {
702 &dev_attr_nvdimm_show_handle.attr,
703 &dev_attr_vendor.attr,
704 &dev_attr_id.attr,
705 &dev_attr_phys_id.attr,
706 &dev_attr_subsystem_vendor.attr,
707 &dev_attr_dirty_shutdown.attr,
708 &dev_attr_formats.attr,
709 &dev_attr_format.attr,
710 &dev_attr_format1.attr,
711 &dev_attr_flags.attr,
712 NULL,
713 };
714
715 static const struct attribute_group ndtest_nvdimm_attribute_group = {
716 .name = "papr",
717 .attrs = ndtest_nvdimm_attributes,
718 .is_visible = ndtest_nvdimm_attr_visible,
719 };
720
721 static const struct attribute_group *ndtest_nvdimm_attribute_groups[] = {
722 &ndtest_nvdimm_attribute_group,
723 NULL,
724 };
725
726 static int ndtest_dimm_register(struct ndtest_priv *priv,
727 struct ndtest_dimm *dimm, int id)
728 {
729 struct device *dev = &priv->pdev.dev;
730 unsigned long dimm_flags = dimm->flags;
731
732 if (dimm->num_formats > 1)
733 set_bit(NDD_LABELING, &dimm_flags);
734
735 if (dimm->flags & PAPR_PMEM_UNARMED_MASK)
736 set_bit(NDD_UNARMED, &dimm_flags);
737
738 dimm->nvdimm = nvdimm_create(priv->bus, dimm,
739 ndtest_nvdimm_attribute_groups, dimm_flags,
740 NDTEST_SCM_DIMM_CMD_MASK, 0, NULL);
741 if (!dimm->nvdimm) {
742 dev_err(dev, "Error creating DIMM object for %pOF\n", priv->dn);
743 return -ENXIO;
744 }
745
746 dimm->dev = device_create_with_groups(&ndtest_dimm_class,
747 &priv->pdev.dev,
748 0, dimm, dimm_attribute_groups,
749 "test_dimm%d", id);
750 if (!dimm->dev) {
751 pr_err("Could not create dimm device attributes\n");
752 return -ENOMEM;
753 }
754
755 return 0;
756 }
757
758 static int ndtest_nvdimm_init(struct ndtest_priv *p)
759 {
760 struct ndtest_dimm *d;
761 void *res;
762 int i, id;
763
764 for (i = 0; i < p->config->dimm_count; i++) {
765 d = &p->config->dimms[i];
766 d->id = id = p->config->dimm_start + i;
767 res = ndtest_alloc_resource(p, LABEL_SIZE, NULL);
768 if (!res)
769 return -ENOMEM;
770
771 d->label_area = res;
772 sprintf(d->label_area, "label%d", id);
773 d->config_size = LABEL_SIZE;
774
775 if (!ndtest_alloc_resource(p, d->size,
776 &p->dimm_dma[id]))
777 return -ENOMEM;
778
779 if (!ndtest_alloc_resource(p, LABEL_SIZE,
780 &p->label_dma[id]))
781 return -ENOMEM;
782
783 if (!ndtest_alloc_resource(p, LABEL_SIZE,
784 &p->dcr_dma[id]))
785 return -ENOMEM;
786
787 d->address = p->dimm_dma[id];
788
789 ndtest_dimm_register(p, d, id);
790 }
791
792 return 0;
793 }
794
795 static ssize_t compatible_show(struct device *dev,
796 struct device_attribute *attr, char *buf)
797 {
798 return sprintf(buf, "nvdimm_test");
799 }
800 static DEVICE_ATTR_RO(compatible);
801
802 static struct attribute *of_node_attributes[] = {
803 &dev_attr_compatible.attr,
804 NULL
805 };
806
807 static const struct attribute_group of_node_attribute_group = {
808 .name = "of_node",
809 .attrs = of_node_attributes,
810 };
811
812 static const struct attribute_group *ndtest_attribute_groups[] = {
813 &of_node_attribute_group,
814 NULL,
815 };
816
817 static int ndtest_bus_register(struct ndtest_priv *p)
818 {
819 p->config = &bus_configs[p->pdev.id];
820
821 p->bus_desc.ndctl = ndtest_ctl;
822 p->bus_desc.module = THIS_MODULE;
823 p->bus_desc.provider_name = NULL;
824 p->bus_desc.attr_groups = ndtest_attribute_groups;
825
826 p->bus = nvdimm_bus_register(&p->pdev.dev, &p->bus_desc);
827 if (!p->bus) {
828 dev_err(&p->pdev.dev, "Error creating nvdimm bus %pOF\n", p->dn);
829 return -ENOMEM;
830 }
831
832 return 0;
833 }
834
835 static void ndtest_remove(struct platform_device *pdev)
836 {
837 struct ndtest_priv *p = to_ndtest_priv(&pdev->dev);
838
839 nvdimm_bus_unregister(p->bus);
840 }
841
842 static int ndtest_probe(struct platform_device *pdev)
843 {
844 struct ndtest_priv *p;
845 int rc;
846
847 p = to_ndtest_priv(&pdev->dev);
848 if (ndtest_bus_register(p))
849 return -ENOMEM;
850
851 p->dcr_dma = devm_kcalloc(&p->pdev.dev, NUM_DCR,
852 sizeof(dma_addr_t), GFP_KERNEL);
853 p->label_dma = devm_kcalloc(&p->pdev.dev, NUM_DCR,
854 sizeof(dma_addr_t), GFP_KERNEL);
855 p->dimm_dma = devm_kcalloc(&p->pdev.dev, NUM_DCR,
856 sizeof(dma_addr_t), GFP_KERNEL);
857
858 rc = ndtest_nvdimm_init(p);
859 if (rc)
860 goto err;
861
862 rc = ndtest_init_regions(p);
863 if (rc)
864 goto err;
865
866 rc = devm_add_action_or_reset(&pdev->dev, put_dimms, p);
867 if (rc)
868 goto err;
869
870 platform_set_drvdata(pdev, p);
871
872 return 0;
873
874 err:
875 pr_err("%s:%d Failed nvdimm init\n", __func__, __LINE__);
876 return rc;
877 }
878
879 static const struct platform_device_id ndtest_id[] = {
880 { KBUILD_MODNAME },
881 { },
882 };
883
884 static struct platform_driver ndtest_driver = {
885 .probe = ndtest_probe,
886 .remove_new = ndtest_remove,
887 .driver = {
888 .name = KBUILD_MODNAME,
889 },
890 .id_table = ndtest_id,
891 };
892
893 static void ndtest_release(struct device *dev)
894 {
895 struct ndtest_priv *p = to_ndtest_priv(dev);
896
897 kfree(p);
898 }
899
900 static void cleanup_devices(void)
901 {
902 int i;
903
904 for (i = 0; i < NUM_INSTANCES; i++)
905 if (instances[i])
906 platform_device_unregister(&instances[i]->pdev);
907
908 nfit_test_teardown();
909
910 if (ndtest_pool)
911 gen_pool_destroy(ndtest_pool);
912
913
914 class_unregister(&ndtest_dimm_class);
915 }
916
917 static __init int ndtest_init(void)
918 {
919 int rc, i;
920
921 pmem_test();
922 libnvdimm_test();
923 device_dax_test();
924 dax_pmem_test();
925
926 nfit_test_setup(ndtest_resource_lookup, NULL);
927
928 rc = class_register(&ndtest_dimm_class);
929 if (rc)
930 goto err_register;
931
932 ndtest_pool = gen_pool_create(ilog2(SZ_4M), NUMA_NO_NODE);
933 if (!ndtest_pool) {
934 rc = -ENOMEM;
935 goto err_register;
936 }
937
938 if (gen_pool_add(ndtest_pool, SZ_4G, SZ_4G, NUMA_NO_NODE)) {
939 rc = -ENOMEM;
940 goto err_register;
941 }
942
943 /* Each instance can be taken as a bus, which can have multiple dimms */
944 for (i = 0; i < NUM_INSTANCES; i++) {
945 struct ndtest_priv *priv;
946 struct platform_device *pdev;
947
948 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
949 if (!priv) {
950 rc = -ENOMEM;
951 goto err_register;
952 }
953
954 INIT_LIST_HEAD(&priv->resources);
955 pdev = &priv->pdev;
956 pdev->name = KBUILD_MODNAME;
957 pdev->id = i;
958 pdev->dev.release = ndtest_release;
959 rc = platform_device_register(pdev);
960 if (rc) {
961 put_device(&pdev->dev);
962 goto err_register;
963 }
964 get_device(&pdev->dev);
965
966 instances[i] = priv;
967 }
968
969 rc = platform_driver_register(&ndtest_driver);
970 if (rc)
971 goto err_register;
972
973 return 0;
974
975 err_register:
976 pr_err("Error registering platform device\n");
977 cleanup_devices();
978
979 return rc;
980 }
981
982 static __exit void ndtest_exit(void)
983 {
984 cleanup_devices();
985 platform_driver_unregister(&ndtest_driver);
986 }
987
988 module_init(ndtest_init);
989 module_exit(ndtest_exit);
990 MODULE_DESCRIPTION("Test non-NFIT devices");
991 MODULE_LICENSE("GPL");
992 MODULE_AUTHOR("IBM Corporation");
993
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.