drivers/nvdimm/core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
   4  */
   5 #include <linux/libnvdimm.h>
   6 #include <linux/suspend.h>
   7 #include <linux/export.h>
   8 #include <linux/module.h>
   9 #include <linux/blkdev.h>
  10 #include <linux/device.h>
  11 #include <linux/ctype.h>
  12 #include <linux/ndctl.h>
  13 #include <linux/mutex.h>
  14 #include <linux/slab.h>
  15 #include <linux/io.h>
  16 #include "nd-core.h"
  17 #include "nd.h"
  18
  19 LIST_HEAD(nvdimm_bus_list);
  20 DEFINE_MUTEX(nvdimm_bus_list_mutex);
  21
  22 void nvdimm_bus_lock(struct device *dev)
  23 {
  24         struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
  25
  26         if (!nvdimm_bus)
  27                 return;
  28         mutex_lock(&nvdimm_bus->reconfig_mutex);
  29 }
  30 EXPORT_SYMBOL(nvdimm_bus_lock);
  31
  32 void nvdimm_bus_unlock(struct device *dev)
  33 {
  34         struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
  35
  36         if (!nvdimm_bus)
  37                 return;
  38         mutex_unlock(&nvdimm_bus->reconfig_mutex);
  39 }
  40 EXPORT_SYMBOL(nvdimm_bus_unlock);
  41
  42 bool is_nvdimm_bus_locked(struct device *dev)
  43 {
  44         struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
  45
  46         if (!nvdimm_bus)
  47                 return false;
  48         return mutex_is_locked(&nvdimm_bus->reconfig_mutex);
  49 }
  50 EXPORT_SYMBOL(is_nvdimm_bus_locked);
  51
  52 struct nvdimm_map {
  53         struct nvdimm_bus *nvdimm_bus;
  54         struct list_head list;
  55         resource_size_t offset;
  56         unsigned long flags;
  57         size_t size;
  58         union {
  59                 void *mem;
  60                 void __iomem *iomem;
  61         };
  62         struct kref kref;
  63 };
  64
  65 static struct nvdimm_map *find_nvdimm_map(struct device *dev,
  66                 resource_size_t offset)
  67 {
  68         struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
  69         struct nvdimm_map *nvdimm_map;
  70
  71         list_for_each_entry(nvdimm_map, &nvdimm_bus->mapping_list, list)
  72                 if (nvdimm_map->offset == offset)
  73                         return nvdimm_map;
  74         return NULL;
  75 }
  76
  77 static struct nvdimm_map *alloc_nvdimm_map(struct device *dev,
  78                 resource_size_t offset, size_t size, unsigned long flags)
  79 {
  80         struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);
  81         struct nvdimm_map *nvdimm_map;
  82
  83         nvdimm_map = kzalloc(sizeof(*nvdimm_map), GFP_KERNEL);
  84         if (!nvdimm_map)
  85                 return NULL;
  86
  87         INIT_LIST_HEAD(&nvdimm_map->list);
  88         nvdimm_map->nvdimm_bus = nvdimm_bus;
  89         nvdimm_map->offset = offset;
  90         nvdimm_map->flags = flags;
  91         nvdimm_map->size = size;
  92         kref_init(&nvdimm_map->kref);
  93
  94         if (!request_mem_region(offset, size, dev_name(&nvdimm_bus->dev))) {
  95                 dev_err(&nvdimm_bus->dev, "failed to request %pa + %zd for %s\n",
  96                                 &offset, size, dev_name(dev));
  97                 goto err_request_region;
  98         }
  99
 100         if (flags)
 101                 nvdimm_map->mem = memremap(offset, size, flags);
 102         else
 103                 nvdimm_map->iomem = ioremap(offset, size);
 104
 105         if (!nvdimm_map->mem)
 106                 goto err_map;
 107
 108         dev_WARN_ONCE(dev, !is_nvdimm_bus_locked(dev), "%s: bus unlocked!",
 109                         __func__);
 110         list_add(&nvdimm_map->list, &nvdimm_bus->mapping_list);
 111
 112         return nvdimm_map;
 113
 114  err_map:
 115         release_mem_region(offset, size);
 116  err_request_region:
 117         kfree(nvdimm_map);
 118         return NULL;
 119 }
 120
 121 static void nvdimm_map_release(struct kref *kref)
 122 {
 123         struct nvdimm_bus *nvdimm_bus;
 124         struct nvdimm_map *nvdimm_map;
 125
 126         nvdimm_map = container_of(kref, struct nvdimm_map, kref);
 127         nvdimm_bus = nvdimm_map->nvdimm_bus;
 128
 129         dev_dbg(&nvdimm_bus->dev, "%pa\n", &nvdimm_map->offset);
 130         list_del(&nvdimm_map->list);
 131         if (nvdimm_map->flags)
 132                 memunmap(nvdimm_map->mem);
 133         else
 134                 iounmap(nvdimm_map->iomem);
 135         release_mem_region(nvdimm_map->offset, nvdimm_map->size);
 136         kfree(nvdimm_map);
 137 }
 138
 139 static void nvdimm_map_put(void *data)
 140 {
 141         struct nvdimm_map *nvdimm_map = data;
 142         struct nvdimm_bus *nvdimm_bus = nvdimm_map->nvdimm_bus;
 143
 144         nvdimm_bus_lock(&nvdimm_bus->dev);
 145         kref_put(&nvdimm_map->kref, nvdimm_map_release);
 146         nvdimm_bus_unlock(&nvdimm_bus->dev);
 147 }
 148
 149 /**
 150  * devm_nvdimm_memremap - map a resource that is shared across regions
 151  * @dev: device that will own a reference to the shared mapping
 152  * @offset: physical base address of the mapping
 153  * @size: mapping size
 154  * @flags: memremap flags, or, if zero, perform an ioremap instead
 155  */
 156 void *devm_nvdimm_memremap(struct device *dev, resource_size_t offset,
 157                 size_t size, unsigned long flags)
 158 {
 159         struct nvdimm_map *nvdimm_map;
 160
 161         nvdimm_bus_lock(dev);
 162         nvdimm_map = find_nvdimm_map(dev, offset);
 163         if (!nvdimm_map)
 164                 nvdimm_map = alloc_nvdimm_map(dev, offset, size, flags);
 165         else
 166                 kref_get(&nvdimm_map->kref);
 167         nvdimm_bus_unlock(dev);
 168
 169         if (!nvdimm_map)
 170                 return NULL;
 171
 172         if (devm_add_action_or_reset(dev, nvdimm_map_put, nvdimm_map))
 173                 return NULL;
 174
 175         return nvdimm_map->mem;
 176 }
 177 EXPORT_SYMBOL_GPL(devm_nvdimm_memremap);
 178
 179 u64 nd_fletcher64(void *addr, size_t len, bool le)
 180 {
 181         u32 *buf = addr;
 182         u32 lo32 = 0;
 183         u64 hi32 = 0;
 184         int i;
 185
 186         for (i = 0; i < len / sizeof(u32); i++) {
 187                 lo32 += le ? le32_to_cpu((__le32) buf[i]) : buf[i];
 188                 hi32 += lo32;
 189         }
 190
 191         return hi32 << 32 | lo32;
 192 }
 193 EXPORT_SYMBOL_GPL(nd_fletcher64);
 194
 195 struct nvdimm_bus_descriptor *to_nd_desc(struct nvdimm_bus *nvdimm_bus)
 196 {
 197         /* struct nvdimm_bus definition is private to libnvdimm */
 198         return nvdimm_bus->nd_desc;
 199 }
 200 EXPORT_SYMBOL_GPL(to_nd_desc);
 201
 202 struct device *to_nvdimm_bus_dev(struct nvdimm_bus *nvdimm_bus)
 203 {
 204         /* struct nvdimm_bus definition is private to libnvdimm */
 205         return &nvdimm_bus->dev;
 206 }
 207 EXPORT_SYMBOL_GPL(to_nvdimm_bus_dev);
 208
 209 static bool is_uuid_sep(char sep)
 210 {
 211         if (sep == '\n' || sep == '-' || sep == ':' || sep == '\0')
 212                 return true;
 213         return false;
 214 }
 215
 216 static int nd_uuid_parse(struct device *dev, u8 *uuid_out, const char *buf,
 217                 size_t len)
 218 {
 219         const char *str = buf;
 220         u8 uuid[16];
 221         int i;
 222
 223         for (i = 0; i < 16; i++) {
 224                 if (!isxdigit(str[0]) || !isxdigit(str[1])) {
 225                         dev_dbg(dev, "pos: %d buf[%zd]: %c buf[%zd]: %c\n",
 226                                         i, str - buf, str[0],
 227                                         str + 1 - buf, str[1]);
 228                         return -EINVAL;
 229                 }
 230
 231                 uuid[i] = (hex_to_bin(str[0]) << 4) | hex_to_bin(str[1]);
 232                 str += 2;
 233                 if (is_uuid_sep(*str))
 234                         str++;
 235         }
 236
 237         memcpy(uuid_out, uuid, sizeof(uuid));
 238         return 0;
 239 }
 240
 241 /**
 242  * nd_uuid_store: common implementation for writing 'uuid' sysfs attributes
 243  * @dev: container device for the uuid property
 244  * @uuid_out: uuid buffer to replace
 245  * @buf: raw sysfs buffer to parse
 246  *
 247  * Enforce that uuids can only be changed while the device is disabled
 248  * (driver detached)
 249  * LOCKING: expects nd_device_lock() is held on entry
 250  */
 251 int nd_uuid_store(struct device *dev, u8 **uuid_out, const char *buf,
 252                 size_t len)
 253 {
 254         u8 uuid[16];
 255         int rc;
 256
 257         if (dev->driver)
 258                 return -EBUSY;
 259
 260         rc = nd_uuid_parse(dev, uuid, buf, len);
 261         if (rc)
 262                 return rc;
 263
 264         kfree(*uuid_out);
 265         *uuid_out = kmemdup(uuid, sizeof(uuid), GFP_KERNEL);
 266         if (!(*uuid_out))
 267                 return -ENOMEM;
 268
 269         return 0;
 270 }
 271
 272 ssize_t nd_size_select_show(unsigned long current_size,
 273                 const unsigned long *supported, char *buf)
 274 {
 275         ssize_t len = 0;
 276         int i;
 277
 278         for (i = 0; supported[i]; i++)
 279                 if (current_size == supported[i])
 280                         len += sprintf(buf + len, "[%ld] ", supported[i]);
 281                 else
 282                         len += sprintf(buf + len, "%ld ", supported[i]);
 283         len += sprintf(buf + len, "\n");
 284         return len;
 285 }
 286
 287 ssize_t nd_size_select_store(struct device *dev, const char *buf,
 288                 unsigned long *current_size, const unsigned long *supported)
 289 {
 290         unsigned long lbasize;
 291         int rc, i;
 292
 293         if (dev->driver)
 294                 return -EBUSY;
 295
 296         rc = kstrtoul(buf, 0, &lbasize);
 297         if (rc)
 298                 return rc;
 299
 300         for (i = 0; supported[i]; i++)
 301                 if (lbasize == supported[i])
 302                         break;
 303
 304         if (supported[i]) {
 305                 *current_size = lbasize;
 306                 return 0;
 307         } else {
 308                 return -EINVAL;
 309         }
 310 }
 311
 312 static ssize_t commands_show(struct device *dev,
 313                 struct device_attribute *attr, char *buf)
 314 {
 315         int cmd, len = 0;
 316         struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
 317         struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
 318
 319         for_each_set_bit(cmd, &nd_desc->cmd_mask, BITS_PER_LONG)
 320                 len += sprintf(buf + len, "%s ", nvdimm_bus_cmd_name(cmd));
 321         len += sprintf(buf + len, "\n");
 322         return len;
 323 }
 324 static DEVICE_ATTR_RO(commands);
 325
 326 static const char *nvdimm_bus_provider(struct nvdimm_bus *nvdimm_bus)
 327 {
 328         struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
 329         struct device *parent = nvdimm_bus->dev.parent;
 330
 331         if (nd_desc->provider_name)
 332                 return nd_desc->provider_name;
 333         else if (parent)
 334                 return dev_name(parent);
 335         else
 336                 return "unknown";
 337 }
 338
 339 static ssize_t provider_show(struct device *dev,
 340                 struct device_attribute *attr, char *buf)
 341 {
 342         struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
 343
 344         return sprintf(buf, "%s\n", nvdimm_bus_provider(nvdimm_bus));
 345 }
 346 static DEVICE_ATTR_RO(provider);
 347
 348 static int flush_namespaces(struct device *dev, void *data)
 349 {
 350         nd_device_lock(dev);
 351         nd_device_unlock(dev);
 352         return 0;
 353 }
 354
 355 static int flush_regions_dimms(struct device *dev, void *data)
 356 {
 357         nd_device_lock(dev);
 358         nd_device_unlock(dev);
 359         device_for_each_child(dev, NULL, flush_namespaces);
 360         return 0;
 361 }
 362
 363 static ssize_t wait_probe_show(struct device *dev,
 364                 struct device_attribute *attr, char *buf)
 365 {
 366         struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
 367         struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
 368         int rc;
 369
 370         if (nd_desc->flush_probe) {
 371                 rc = nd_desc->flush_probe(nd_desc);
 372                 if (rc)
 373                         return rc;
 374         }
 375         nd_synchronize();
 376         device_for_each_child(dev, NULL, flush_regions_dimms);
 377         return sprintf(buf, "1\n");
 378 }
 379 static DEVICE_ATTR_RO(wait_probe);
 380
 381 static struct attribute *nvdimm_bus_attributes[] = {
 382         &dev_attr_commands.attr,
 383         &dev_attr_wait_probe.attr,
 384         &dev_attr_provider.attr,
 385         NULL,
 386 };
 387
 388 static const struct attribute_group nvdimm_bus_attribute_group = {
 389         .attrs = nvdimm_bus_attributes,
 390 };
 391
 392 static ssize_t capability_show(struct device *dev,
 393                 struct device_attribute *attr, char *buf)
 394 {
 395         struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
 396         struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
 397         enum nvdimm_fwa_capability cap;
 398
 399         if (!nd_desc->fw_ops)
 400                 return -EOPNOTSUPP;
 401
 402         nvdimm_bus_lock(dev);
 403         cap = nd_desc->fw_ops->capability(nd_desc);
 404         nvdimm_bus_unlock(dev);
 405
 406         switch (cap) {
 407         case NVDIMM_FWA_CAP_QUIESCE:
 408                 return sprintf(buf, "quiesce\n");
 409         case NVDIMM_FWA_CAP_LIVE:
 410                 return sprintf(buf, "live\n");
 411         default:
 412                 return -EOPNOTSUPP;
 413         }
 414 }
 415
 416 static DEVICE_ATTR_RO(capability);
 417
 418 static ssize_t activate_show(struct device *dev,
 419                 struct device_attribute *attr, char *buf)
 420 {
 421         struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
 422         struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
 423         enum nvdimm_fwa_capability cap;
 424         enum nvdimm_fwa_state state;
 425
 426         if (!nd_desc->fw_ops)
 427                 return -EOPNOTSUPP;
 428
 429         nvdimm_bus_lock(dev);
 430         cap = nd_desc->fw_ops->capability(nd_desc);
 431         state = nd_desc->fw_ops->activate_state(nd_desc);
 432         nvdimm_bus_unlock(dev);
 433
 434         if (cap < NVDIMM_FWA_CAP_QUIESCE)
 435                 return -EOPNOTSUPP;
 436
 437         switch (state) {
 438         case NVDIMM_FWA_IDLE:
 439                 return sprintf(buf, "idle\n");
 440         case NVDIMM_FWA_BUSY:
 441                 return sprintf(buf, "busy\n");
 442         case NVDIMM_FWA_ARMED:
 443                 return sprintf(buf, "armed\n");
 444         case NVDIMM_FWA_ARM_OVERFLOW:
 445                 return sprintf(buf, "overflow\n");
 446         default:
 447                 return -ENXIO;
 448         }
 449 }
 450
 451 static int exec_firmware_activate(void *data)
 452 {
 453         struct nvdimm_bus_descriptor *nd_desc = data;
 454
 455         return nd_desc->fw_ops->activate(nd_desc);
 456 }
 457
 458 static ssize_t activate_store(struct device *dev,
 459                 struct device_attribute *attr, const char *buf, size_t len)
 460 {
 461         struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
 462         struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
 463         enum nvdimm_fwa_state state;
 464         bool quiesce;
 465         ssize_t rc;
 466
 467         if (!nd_desc->fw_ops)
 468                 return -EOPNOTSUPP;
 469
 470         if (sysfs_streq(buf, "live"))
 471                 quiesce = false;
 472         else if (sysfs_streq(buf, "quiesce"))
 473                 quiesce = true;
 474         else
 475                 return -EINVAL;
 476
 477         nvdimm_bus_lock(dev);
 478         state = nd_desc->fw_ops->activate_state(nd_desc);
 479
 480         switch (state) {
 481         case NVDIMM_FWA_BUSY:
 482                 rc = -EBUSY;
 483                 break;
 484         case NVDIMM_FWA_ARMED:
 485         case NVDIMM_FWA_ARM_OVERFLOW:
 486                 if (quiesce)
 487                         rc = hibernate_quiet_exec(exec_firmware_activate, nd_desc);
 488                 else
 489                         rc = nd_desc->fw_ops->activate(nd_desc);
 490                 break;
 491         case NVDIMM_FWA_IDLE:
 492         default:
 493                 rc = -ENXIO;
 494         }
 495         nvdimm_bus_unlock(dev);
 496
 497         if (rc == 0)
 498                 rc = len;
 499         return rc;
 500 }
 501
 502 static DEVICE_ATTR_ADMIN_RW(activate);
 503
 504 static umode_t nvdimm_bus_firmware_visible(struct kobject *kobj, struct attribute *a, int n)
 505 {
 506         struct device *dev = container_of(kobj, typeof(*dev), kobj);
 507         struct nvdimm_bus *nvdimm_bus = to_nvdimm_bus(dev);
 508         struct nvdimm_bus_descriptor *nd_desc = nvdimm_bus->nd_desc;
 509         enum nvdimm_fwa_capability cap;
 510
 511         /*
 512          * Both 'activate' and 'capability' disappear when no ops
 513          * detected, or a negative capability is indicated.
 514          */
 515         if (!nd_desc->fw_ops)
 516                 return 0;
 517
 518         nvdimm_bus_lock(dev);
 519         cap = nd_desc->fw_ops->capability(nd_desc);
 520         nvdimm_bus_unlock(dev);
 521
 522         if (cap < NVDIMM_FWA_CAP_QUIESCE)
 523                 return 0;
 524
 525         return a->mode;
 526 }
 527 static struct attribute *nvdimm_bus_firmware_attributes[] = {
 528         &dev_attr_activate.attr,
 529         &dev_attr_capability.attr,
 530         NULL,
 531 };
 532
 533 static const struct attribute_group nvdimm_bus_firmware_attribute_group = {
 534         .name = "firmware",
 535         .attrs = nvdimm_bus_firmware_attributes,
 536         .is_visible = nvdimm_bus_firmware_visible,
 537 };
 538
 539 const struct attribute_group *nvdimm_bus_attribute_groups[] = {
 540         &nvdimm_bus_attribute_group,
 541         &nvdimm_bus_firmware_attribute_group,
 542         NULL,
 543 };
 544
 545 int nvdimm_bus_add_badrange(struct nvdimm_bus *nvdimm_bus, u64 addr, u64 length)
 546 {
 547         return badrange_add(&nvdimm_bus->badrange, addr, length);
 548 }
 549 EXPORT_SYMBOL_GPL(nvdimm_bus_add_badrange);
 550
 551 #ifdef CONFIG_BLK_DEV_INTEGRITY
 552 int nd_integrity_init(struct gendisk *disk, unsigned long meta_size)
 553 {
 554         struct blk_integrity bi;
 555
 556         if (meta_size == 0)
 557                 return 0;
 558
 559         memset(&bi, 0, sizeof(bi));
 560
 561         bi.tuple_size = meta_size;
 562         bi.tag_size = meta_size;
 563
 564         blk_integrity_register(disk, &bi);
 565         blk_queue_max_integrity_segments(disk->queue, 1);
 566
 567         return 0;
 568 }
 569 EXPORT_SYMBOL(nd_integrity_init);
 570
 571 #else /* CONFIG_BLK_DEV_INTEGRITY */
 572 int nd_integrity_init(struct gendisk *disk, unsigned long meta_size)
 573 {
 574         return 0;
 575 }
 576 EXPORT_SYMBOL(nd_integrity_init);
 577
 578 #endif
 579
 580 static __init int libnvdimm_init(void)
 581 {
 582         int rc;
 583
 584         rc = nvdimm_bus_init();
 585         if (rc)
 586                 return rc;
 587         rc = nvdimm_init();
 588         if (rc)
 589                 goto err_dimm;
 590         rc = nd_region_init();
 591         if (rc)
 592                 goto err_region;
 593
 594         nd_label_init();
 595
 596         return 0;
 597  err_region:
 598         nvdimm_exit();
 599  err_dimm:
 600         nvdimm_bus_exit();
 601         return rc;
 602 }
 603
 604 static __exit void libnvdimm_exit(void)
 605 {
 606         WARN_ON(!list_empty(&nvdimm_bus_list));
 607         nd_region_exit();
 608         nvdimm_exit();
 609         nvdimm_bus_exit();
 610         nvdimm_devs_exit();
 611 }
 612
 613 MODULE_LICENSE("GPL v2");
 614 MODULE_AUTHOR("Intel Corporation");
 615 subsys_initcall(libnvdimm_init);
 616 module_exit(libnvdimm_exit);