drivers/nvdimm/nd.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
   4  */
   5 #ifndef __ND_H__
   6 #define __ND_H__
   7 #include <linux/libnvdimm.h>
   8 #include <linux/badblocks.h>
   9 #include <linux/blkdev.h>
  10 #include <linux/device.h>
  11 #include <linux/mutex.h>
  12 #include <linux/ndctl.h>
  13 #include <linux/types.h>
  14 #include <linux/nd.h>
  15 #include "label.h"
  16
  17 enum {
  18         /*
  19          * Limits the maximum number of block apertures a dimm can
  20          * support and is an input to the geometry/on-disk-format of a
  21          * BTT instance
  22          */
  23         ND_MAX_LANES = 256,
  24         INT_LBASIZE_ALIGNMENT = 64,
  25         NVDIMM_IO_ATOMIC = 1,
  26 };
  27
  28 struct nvdimm_drvdata {
  29         struct device *dev;
  30         int nslabel_size;
  31         struct nd_cmd_get_config_size nsarea;
  32         void *data;
  33         bool cxl;
  34         int ns_current, ns_next;
  35         struct resource dpa;
  36         struct kref kref;
  37 };
  38
  39 static inline const u8 *nsl_ref_name(struct nvdimm_drvdata *ndd,
  40                                      struct nd_namespace_label *nd_label)
  41 {
  42         if (ndd->cxl)
  43                 return nd_label->cxl.name;
  44         return nd_label->efi.name;
  45 }
  46
  47 static inline u8 *nsl_get_name(struct nvdimm_drvdata *ndd,
  48                                struct nd_namespace_label *nd_label, u8 *name)
  49 {
  50         if (ndd->cxl)
  51                 return memcpy(name, nd_label->cxl.name, NSLABEL_NAME_LEN);
  52         return memcpy(name, nd_label->efi.name, NSLABEL_NAME_LEN);
  53 }
  54
  55 static inline u8 *nsl_set_name(struct nvdimm_drvdata *ndd,
  56                                struct nd_namespace_label *nd_label, u8 *name)
  57 {
  58         if (!name)
  59                 return NULL;
  60         if (ndd->cxl)
  61                 return memcpy(nd_label->cxl.name, name, NSLABEL_NAME_LEN);
  62         return memcpy(nd_label->efi.name, name, NSLABEL_NAME_LEN);
  63 }
  64
  65 static inline u32 nsl_get_slot(struct nvdimm_drvdata *ndd,
  66                                struct nd_namespace_label *nd_label)
  67 {
  68         if (ndd->cxl)
  69                 return __le32_to_cpu(nd_label->cxl.slot);
  70         return __le32_to_cpu(nd_label->efi.slot);
  71 }
  72
  73 static inline void nsl_set_slot(struct nvdimm_drvdata *ndd,
  74                                 struct nd_namespace_label *nd_label, u32 slot)
  75 {
  76         if (ndd->cxl)
  77                 nd_label->cxl.slot = __cpu_to_le32(slot);
  78         else
  79                 nd_label->efi.slot = __cpu_to_le32(slot);
  80 }
  81
  82 static inline u64 nsl_get_checksum(struct nvdimm_drvdata *ndd,
  83                                    struct nd_namespace_label *nd_label)
  84 {
  85         if (ndd->cxl)
  86                 return __le64_to_cpu(nd_label->cxl.checksum);
  87         return __le64_to_cpu(nd_label->efi.checksum);
  88 }
  89
  90 static inline void nsl_set_checksum(struct nvdimm_drvdata *ndd,
  91                                     struct nd_namespace_label *nd_label,
  92                                     u64 checksum)
  93 {
  94         if (ndd->cxl)
  95                 nd_label->cxl.checksum = __cpu_to_le64(checksum);
  96         else
  97                 nd_label->efi.checksum = __cpu_to_le64(checksum);
  98 }
  99
 100 static inline u32 nsl_get_flags(struct nvdimm_drvdata *ndd,
 101                                 struct nd_namespace_label *nd_label)
 102 {
 103         if (ndd->cxl)
 104                 return __le32_to_cpu(nd_label->cxl.flags);
 105         return __le32_to_cpu(nd_label->efi.flags);
 106 }
 107
 108 static inline void nsl_set_flags(struct nvdimm_drvdata *ndd,
 109                                  struct nd_namespace_label *nd_label, u32 flags)
 110 {
 111         if (ndd->cxl)
 112                 nd_label->cxl.flags = __cpu_to_le32(flags);
 113         else
 114                 nd_label->efi.flags = __cpu_to_le32(flags);
 115 }
 116
 117 static inline u64 nsl_get_dpa(struct nvdimm_drvdata *ndd,
 118                               struct nd_namespace_label *nd_label)
 119 {
 120         if (ndd->cxl)
 121                 return __le64_to_cpu(nd_label->cxl.dpa);
 122         return __le64_to_cpu(nd_label->efi.dpa);
 123 }
 124
 125 static inline void nsl_set_dpa(struct nvdimm_drvdata *ndd,
 126                                struct nd_namespace_label *nd_label, u64 dpa)
 127 {
 128         if (ndd->cxl)
 129                 nd_label->cxl.dpa = __cpu_to_le64(dpa);
 130         else
 131                 nd_label->efi.dpa = __cpu_to_le64(dpa);
 132 }
 133
 134 static inline u64 nsl_get_rawsize(struct nvdimm_drvdata *ndd,
 135                                   struct nd_namespace_label *nd_label)
 136 {
 137         if (ndd->cxl)
 138                 return __le64_to_cpu(nd_label->cxl.rawsize);
 139         return __le64_to_cpu(nd_label->efi.rawsize);
 140 }
 141
 142 static inline void nsl_set_rawsize(struct nvdimm_drvdata *ndd,
 143                                    struct nd_namespace_label *nd_label,
 144                                    u64 rawsize)
 145 {
 146         if (ndd->cxl)
 147                 nd_label->cxl.rawsize = __cpu_to_le64(rawsize);
 148         else
 149                 nd_label->efi.rawsize = __cpu_to_le64(rawsize);
 150 }
 151
 152 static inline u64 nsl_get_isetcookie(struct nvdimm_drvdata *ndd,
 153                                      struct nd_namespace_label *nd_label)
 154 {
 155         /* WARN future refactor attempts that break this assumption */
 156         if (dev_WARN_ONCE(ndd->dev, ndd->cxl,
 157                           "CXL labels do not use the isetcookie concept\n"))
 158                 return 0;
 159         return __le64_to_cpu(nd_label->efi.isetcookie);
 160 }
 161
 162 static inline void nsl_set_isetcookie(struct nvdimm_drvdata *ndd,
 163                                       struct nd_namespace_label *nd_label,
 164                                       u64 isetcookie)
 165 {
 166         if (!ndd->cxl)
 167                 nd_label->efi.isetcookie = __cpu_to_le64(isetcookie);
 168 }
 169
 170 static inline bool nsl_validate_isetcookie(struct nvdimm_drvdata *ndd,
 171                                            struct nd_namespace_label *nd_label,
 172                                            u64 cookie)
 173 {
 174         /*
 175          * Let the EFI and CXL validation comingle, where fields that
 176          * don't matter to CXL always validate.
 177          */
 178         if (ndd->cxl)
 179                 return true;
 180         return cookie == __le64_to_cpu(nd_label->efi.isetcookie);
 181 }
 182
 183 static inline u16 nsl_get_position(struct nvdimm_drvdata *ndd,
 184                                    struct nd_namespace_label *nd_label)
 185 {
 186         if (ndd->cxl)
 187                 return __le16_to_cpu(nd_label->cxl.position);
 188         return __le16_to_cpu(nd_label->efi.position);
 189 }
 190
 191 static inline void nsl_set_position(struct nvdimm_drvdata *ndd,
 192                                     struct nd_namespace_label *nd_label,
 193                                     u16 position)
 194 {
 195         if (ndd->cxl)
 196                 nd_label->cxl.position = __cpu_to_le16(position);
 197         else
 198                 nd_label->efi.position = __cpu_to_le16(position);
 199 }
 200
 201 static inline u16 nsl_get_nlabel(struct nvdimm_drvdata *ndd,
 202                                  struct nd_namespace_label *nd_label)
 203 {
 204         if (ndd->cxl)
 205                 return 0;
 206         return __le16_to_cpu(nd_label->efi.nlabel);
 207 }
 208
 209 static inline void nsl_set_nlabel(struct nvdimm_drvdata *ndd,
 210                                   struct nd_namespace_label *nd_label,
 211                                   u16 nlabel)
 212 {
 213         if (!ndd->cxl)
 214                 nd_label->efi.nlabel = __cpu_to_le16(nlabel);
 215 }
 216
 217 static inline u16 nsl_get_nrange(struct nvdimm_drvdata *ndd,
 218                                  struct nd_namespace_label *nd_label)
 219 {
 220         if (ndd->cxl)
 221                 return __le16_to_cpu(nd_label->cxl.nrange);
 222         return 1;
 223 }
 224
 225 static inline void nsl_set_nrange(struct nvdimm_drvdata *ndd,
 226                                   struct nd_namespace_label *nd_label,
 227                                   u16 nrange)
 228 {
 229         if (ndd->cxl)
 230                 nd_label->cxl.nrange = __cpu_to_le16(nrange);
 231 }
 232
 233 static inline u64 nsl_get_lbasize(struct nvdimm_drvdata *ndd,
 234                                   struct nd_namespace_label *nd_label)
 235 {
 236         /*
 237          * Yes, for some reason the EFI labels convey a massive 64-bit
 238          * lbasize, that got fixed for CXL.
 239          */
 240         if (ndd->cxl)
 241                 return __le16_to_cpu(nd_label->cxl.lbasize);
 242         return __le64_to_cpu(nd_label->efi.lbasize);
 243 }
 244
 245 static inline void nsl_set_lbasize(struct nvdimm_drvdata *ndd,
 246                                    struct nd_namespace_label *nd_label,
 247                                    u64 lbasize)
 248 {
 249         if (ndd->cxl)
 250                 nd_label->cxl.lbasize = __cpu_to_le16(lbasize);
 251         else
 252                 nd_label->efi.lbasize = __cpu_to_le64(lbasize);
 253 }
 254
 255 static inline const uuid_t *nsl_get_uuid(struct nvdimm_drvdata *ndd,
 256                                          struct nd_namespace_label *nd_label,
 257                                          uuid_t *uuid)
 258 {
 259         if (ndd->cxl)
 260                 import_uuid(uuid, nd_label->cxl.uuid);
 261         else
 262                 import_uuid(uuid, nd_label->efi.uuid);
 263         return uuid;
 264 }
 265
 266 static inline const uuid_t *nsl_set_uuid(struct nvdimm_drvdata *ndd,
 267                                          struct nd_namespace_label *nd_label,
 268                                          const uuid_t *uuid)
 269 {
 270         if (ndd->cxl)
 271                 export_uuid(nd_label->cxl.uuid, uuid);
 272         else
 273                 export_uuid(nd_label->efi.uuid, uuid);
 274         return uuid;
 275 }
 276
 277 static inline bool nsl_uuid_equal(struct nvdimm_drvdata *ndd,
 278                                   struct nd_namespace_label *nd_label,
 279                                   const uuid_t *uuid)
 280 {
 281         uuid_t tmp;
 282
 283         if (ndd->cxl)
 284                 import_uuid(&tmp, nd_label->cxl.uuid);
 285         else
 286                 import_uuid(&tmp, nd_label->efi.uuid);
 287         return uuid_equal(&tmp, uuid);
 288 }
 289
 290 static inline const u8 *nsl_uuid_raw(struct nvdimm_drvdata *ndd,
 291                                      struct nd_namespace_label *nd_label)
 292 {
 293         if (ndd->cxl)
 294                 return nd_label->cxl.uuid;
 295         return nd_label->efi.uuid;
 296 }
 297
 298 bool nsl_validate_type_guid(struct nvdimm_drvdata *ndd,
 299                             struct nd_namespace_label *nd_label, guid_t *guid);
 300 enum nvdimm_claim_class nsl_get_claim_class(struct nvdimm_drvdata *ndd,
 301                                             struct nd_namespace_label *nd_label);
 302
 303 struct nd_region_data {
 304         int ns_count;
 305         int ns_active;
 306         unsigned int hints_shift;
 307         void __iomem *flush_wpq[];
 308 };
 309
 310 static inline void __iomem *ndrd_get_flush_wpq(struct nd_region_data *ndrd,
 311                 int dimm, int hint)
 312 {
 313         unsigned int num = 1 << ndrd->hints_shift;
 314         unsigned int mask = num - 1;
 315
 316         return ndrd->flush_wpq[dimm * num + (hint & mask)];
 317 }
 318
 319 static inline void ndrd_set_flush_wpq(struct nd_region_data *ndrd, int dimm,
 320                 int hint, void __iomem *flush)
 321 {
 322         unsigned int num = 1 << ndrd->hints_shift;
 323         unsigned int mask = num - 1;
 324
 325         ndrd->flush_wpq[dimm * num + (hint & mask)] = flush;
 326 }
 327
 328 static inline struct nd_namespace_index *to_namespace_index(
 329                 struct nvdimm_drvdata *ndd, int i)
 330 {
 331         if (i < 0)
 332                 return NULL;
 333
 334         return ndd->data + sizeof_namespace_index(ndd) * i;
 335 }
 336
 337 static inline struct nd_namespace_index *to_current_namespace_index(
 338                 struct nvdimm_drvdata *ndd)
 339 {
 340         return to_namespace_index(ndd, ndd->ns_current);
 341 }
 342
 343 static inline struct nd_namespace_index *to_next_namespace_index(
 344                 struct nvdimm_drvdata *ndd)
 345 {
 346         return to_namespace_index(ndd, ndd->ns_next);
 347 }
 348
 349 unsigned sizeof_namespace_label(struct nvdimm_drvdata *ndd);
 350
 351 #define efi_namespace_label_has(ndd, field) \
 352         (!ndd->cxl && offsetof(struct nvdimm_efi_label, field) \
 353                 < sizeof_namespace_label(ndd))
 354
 355 #define nd_dbg_dpa(r, d, res, fmt, arg...) \
 356         dev_dbg((r) ? &(r)->dev : (d)->dev, "%s: %.13s: %#llx @ %#llx " fmt, \
 357                 (r) ? dev_name((d)->dev) : "", res ? res->name : "null", \
 358                 (unsigned long long) (res ? resource_size(res) : 0), \
 359                 (unsigned long long) (res ? res->start : 0), ##arg)
 360
 361 #define for_each_dpa_resource(ndd, res) \
 362         for (res = (ndd)->dpa.child; res; res = res->sibling)
 363
 364 #define for_each_dpa_resource_safe(ndd, res, next) \
 365         for (res = (ndd)->dpa.child, next = res ? res->sibling : NULL; \
 366                         res; res = next, next = next ? next->sibling : NULL)
 367
 368 struct nd_percpu_lane {
 369         int count;
 370         spinlock_t lock;
 371 };
 372
 373 enum nd_label_flags {
 374         ND_LABEL_REAP,
 375 };
 376 struct nd_label_ent {
 377         struct list_head list;
 378         unsigned long flags;
 379         struct nd_namespace_label *label;
 380 };
 381
 382 enum nd_mapping_lock_class {
 383         ND_MAPPING_CLASS0,
 384         ND_MAPPING_UUID_SCAN,
 385 };
 386
 387 struct nd_mapping {
 388         struct nvdimm *nvdimm;
 389         u64 start;
 390         u64 size;
 391         int position;
 392         struct list_head labels;
 393         struct mutex lock;
 394         /*
 395          * @ndd is for private use at region enable / disable time for
 396          * get_ndd() + put_ndd(), all other nd_mapping to ndd
 397          * conversions use to_ndd() which respects enabled state of the
 398          * nvdimm.
 399          */
 400         struct nvdimm_drvdata *ndd;
 401 };
 402
 403 struct nd_region {
 404         struct device dev;
 405         struct ida ns_ida;
 406         struct ida btt_ida;
 407         struct ida pfn_ida;
 408         struct ida dax_ida;
 409         unsigned long flags;
 410         struct device *ns_seed;
 411         struct device *btt_seed;
 412         struct device *pfn_seed;
 413         struct device *dax_seed;
 414         unsigned long align;
 415         u16 ndr_mappings;
 416         u64 ndr_size;
 417         u64 ndr_start;
 418         int id, num_lanes, ro, numa_node, target_node;
 419         void *provider_data;
 420         struct kernfs_node *bb_state;
 421         struct badblocks bb;
 422         struct nd_interleave_set *nd_set;
 423         struct nd_percpu_lane __percpu *lane;
 424         int (*flush)(struct nd_region *nd_region, struct bio *bio);
 425         struct nd_mapping mapping[] __counted_by(ndr_mappings);
 426 };
 427
 428 static inline bool nsl_validate_nlabel(struct nd_region *nd_region,
 429                                        struct nvdimm_drvdata *ndd,
 430                                        struct nd_namespace_label *nd_label)
 431 {
 432         if (ndd->cxl)
 433                 return true;
 434         return nsl_get_nlabel(ndd, nd_label) == nd_region->ndr_mappings;
 435 }
 436
 437 /*
 438  * Lookup next in the repeating sequence of 01, 10, and 11.
 439  */
 440 static inline unsigned nd_inc_seq(unsigned seq)
 441 {
 442         static const unsigned next[] = { 0, 2, 3, 1 };
 443
 444         return next[seq & 3];
 445 }
 446
 447 struct btt;
 448 struct nd_btt {
 449         struct device dev;
 450         struct nd_namespace_common *ndns;
 451         struct btt *btt;
 452         unsigned long lbasize;
 453         u64 size;
 454         uuid_t *uuid;
 455         int id;
 456         int initial_offset;
 457         u16 version_major;
 458         u16 version_minor;
 459 };
 460
 461 enum nd_pfn_mode {
 462         PFN_MODE_NONE,
 463         PFN_MODE_RAM,
 464         PFN_MODE_PMEM,
 465 };
 466
 467 struct nd_pfn {
 468         int id;
 469         uuid_t *uuid;
 470         struct device dev;
 471         unsigned long align;
 472         unsigned long npfns;
 473         enum nd_pfn_mode mode;
 474         struct nd_pfn_sb *pfn_sb;
 475         struct nd_namespace_common *ndns;
 476 };
 477
 478 struct nd_dax {
 479         struct nd_pfn nd_pfn;
 480 };
 481
 482 static inline u32 nd_info_block_reserve(void)
 483 {
 484         return ALIGN(SZ_8K, PAGE_SIZE);
 485 }
 486
 487 enum nd_async_mode {
 488         ND_SYNC,
 489         ND_ASYNC,
 490 };
 491
 492 void wait_nvdimm_bus_probe_idle(struct device *dev);
 493 void nd_device_register(struct device *dev);
 494 void nd_device_unregister(struct device *dev, enum nd_async_mode mode);
 495 void nd_device_notify(struct device *dev, enum nvdimm_event event);
 496 int nd_uuid_store(struct device *dev, uuid_t **uuid_out, const char *buf,
 497                 size_t len);
 498 ssize_t nd_size_select_show(unsigned long current_size,
 499                 const unsigned long *supported, char *buf);
 500 ssize_t nd_size_select_store(struct device *dev, const char *buf,
 501                 unsigned long *current_size, const unsigned long *supported);
 502 int __init nvdimm_init(void);
 503 int __init nd_region_init(void);
 504 int __init nd_label_init(void);
 505 void nvdimm_exit(void);
 506 void nd_region_exit(void);
 507 struct nvdimm;
 508 extern const struct attribute_group nd_device_attribute_group;
 509 extern const struct attribute_group nd_numa_attribute_group;
 510 extern const struct attribute_group *nvdimm_bus_attribute_groups[];
 511 struct nvdimm_drvdata *to_ndd(struct nd_mapping *nd_mapping);
 512 int nvdimm_check_config_data(struct device *dev);
 513 int nvdimm_init_nsarea(struct nvdimm_drvdata *ndd);
 514 int nvdimm_init_config_data(struct nvdimm_drvdata *ndd);
 515 int nvdimm_get_config_data(struct nvdimm_drvdata *ndd, void *buf,
 516                            size_t offset, size_t len);
 517 int nvdimm_set_config_data(struct nvdimm_drvdata *ndd, size_t offset,
 518                 void *buf, size_t len);
 519 long nvdimm_clear_poison(struct device *dev, phys_addr_t phys,
 520                 unsigned int len);
 521 void nvdimm_set_labeling(struct device *dev);
 522 void nvdimm_set_locked(struct device *dev);
 523 void nvdimm_clear_locked(struct device *dev);
 524 int nvdimm_security_setup_events(struct device *dev);
 525 #if IS_ENABLED(CONFIG_NVDIMM_KEYS)
 526 int nvdimm_security_unlock(struct device *dev);
 527 #else
 528 static inline int nvdimm_security_unlock(struct device *dev)
 529 {
 530         return 0;
 531 }
 532 #endif
 533 struct nd_btt *to_nd_btt(struct device *dev);
 534
 535 struct nd_gen_sb {
 536         char reserved[SZ_4K - 8];
 537         __le64 checksum;
 538 };
 539
 540 u64 nd_sb_checksum(struct nd_gen_sb *sb);
 541 #if IS_ENABLED(CONFIG_BTT)
 542 int nd_btt_probe(struct device *dev, struct nd_namespace_common *ndns);
 543 bool is_nd_btt(struct device *dev);
 544 struct device *nd_btt_create(struct nd_region *nd_region);
 545 #else
 546 static inline int nd_btt_probe(struct device *dev,
 547                 struct nd_namespace_common *ndns)
 548 {
 549         return -ENODEV;
 550 }
 551
 552 static inline bool is_nd_btt(struct device *dev)
 553 {
 554         return false;
 555 }
 556
 557 static inline struct device *nd_btt_create(struct nd_region *nd_region)
 558 {
 559         return NULL;
 560 }
 561 #endif
 562
 563 struct nd_pfn *to_nd_pfn(struct device *dev);
 564 #if IS_ENABLED(CONFIG_NVDIMM_PFN)
 565
 566 #define MAX_NVDIMM_ALIGN        4
 567
 568 int nd_pfn_probe(struct device *dev, struct nd_namespace_common *ndns);
 569 bool is_nd_pfn(struct device *dev);
 570 struct device *nd_pfn_create(struct nd_region *nd_region);
 571 struct device *nd_pfn_devinit(struct nd_pfn *nd_pfn,
 572                 struct nd_namespace_common *ndns);
 573 int nd_pfn_validate(struct nd_pfn *nd_pfn, const char *sig);
 574 extern const struct attribute_group *nd_pfn_attribute_groups[];
 575 #else
 576 static inline int nd_pfn_probe(struct device *dev,
 577                 struct nd_namespace_common *ndns)
 578 {
 579         return -ENODEV;
 580 }
 581
 582 static inline bool is_nd_pfn(struct device *dev)
 583 {
 584         return false;
 585 }
 586
 587 static inline struct device *nd_pfn_create(struct nd_region *nd_region)
 588 {
 589         return NULL;
 590 }
 591
 592 static inline int nd_pfn_validate(struct nd_pfn *nd_pfn, const char *sig)
 593 {
 594         return -ENODEV;
 595 }
 596 #endif
 597
 598 struct nd_dax *to_nd_dax(struct device *dev);
 599 #if IS_ENABLED(CONFIG_NVDIMM_DAX)
 600 int nd_dax_probe(struct device *dev, struct nd_namespace_common *ndns);
 601 bool is_nd_dax(const struct device *dev);
 602 struct device *nd_dax_create(struct nd_region *nd_region);
 603 #else
 604 static inline int nd_dax_probe(struct device *dev,
 605                 struct nd_namespace_common *ndns)
 606 {
 607         return -ENODEV;
 608 }
 609
 610 static inline bool is_nd_dax(const struct device *dev)
 611 {
 612         return false;
 613 }
 614
 615 static inline struct device *nd_dax_create(struct nd_region *nd_region)
 616 {
 617         return NULL;
 618 }
 619 #endif
 620
 621 int nd_region_to_nstype(struct nd_region *nd_region);
 622 int nd_region_register_namespaces(struct nd_region *nd_region, int *err);
 623 u64 nd_region_interleave_set_cookie(struct nd_region *nd_region,
 624                 struct nd_namespace_index *nsindex);
 625 u64 nd_region_interleave_set_altcookie(struct nd_region *nd_region);
 626 void nvdimm_bus_lock(struct device *dev);
 627 void nvdimm_bus_unlock(struct device *dev);
 628 bool is_nvdimm_bus_locked(struct device *dev);
 629 void nvdimm_check_and_set_ro(struct gendisk *disk);
 630 void nvdimm_drvdata_release(struct kref *kref);
 631 void put_ndd(struct nvdimm_drvdata *ndd);
 632 int nd_label_reserve_dpa(struct nvdimm_drvdata *ndd);
 633 void nvdimm_free_dpa(struct nvdimm_drvdata *ndd, struct resource *res);
 634 struct resource *nvdimm_allocate_dpa(struct nvdimm_drvdata *ndd,
 635                 struct nd_label_id *label_id, resource_size_t start,
 636                 resource_size_t n);
 637 resource_size_t nvdimm_namespace_capacity(struct nd_namespace_common *ndns);
 638 bool nvdimm_namespace_locked(struct nd_namespace_common *ndns);
 639 struct nd_namespace_common *nvdimm_namespace_common_probe(struct device *dev);
 640 int nvdimm_namespace_attach_btt(struct nd_namespace_common *ndns);
 641 int nvdimm_namespace_detach_btt(struct nd_btt *nd_btt);
 642 const char *nvdimm_namespace_disk_name(struct nd_namespace_common *ndns,
 643                 char *name);
 644 unsigned int pmem_sector_size(struct nd_namespace_common *ndns);
 645 struct range;
 646 void nvdimm_badblocks_populate(struct nd_region *nd_region,
 647                 struct badblocks *bb, const struct range *range);
 648 int devm_namespace_enable(struct device *dev, struct nd_namespace_common *ndns,
 649                 resource_size_t size);
 650 void devm_namespace_disable(struct device *dev,
 651                 struct nd_namespace_common *ndns);
 652 #if IS_ENABLED(CONFIG_ND_CLAIM)
 653 /* max struct page size independent of kernel config */
 654 #define MAX_STRUCT_PAGE_SIZE 64
 655 int nvdimm_setup_pfn(struct nd_pfn *nd_pfn, struct dev_pagemap *pgmap);
 656 #else
 657 static inline int nvdimm_setup_pfn(struct nd_pfn *nd_pfn,
 658                                    struct dev_pagemap *pgmap)
 659 {
 660         return -ENXIO;
 661 }
 662 #endif
 663 int nd_region_activate(struct nd_region *nd_region);
 664 static inline bool is_bad_pmem(struct badblocks *bb, sector_t sector,
 665                 unsigned int len)
 666 {
 667         if (bb->count) {
 668                 sector_t first_bad;
 669                 int num_bad;
 670
 671                 return !!badblocks_check(bb, sector, len / 512, &first_bad,
 672                                 &num_bad);
 673         }
 674
 675         return false;
 676 }
 677 const uuid_t *nd_dev_to_uuid(struct device *dev);
 678 bool pmem_should_map_pages(struct device *dev);
 679 #endif /* __ND_H__ */