tools/testing/nvdimm/test/ndtest.c

   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 = 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");