xref: /openbmc/linux/drivers/nvdimm/nd.h (revision c91d7136)
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 
nsl_ref_name(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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 
nsl_get_name(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u8 * name)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 
nsl_set_name(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u8 * name)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 
nsl_get_slot(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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 
nsl_set_slot(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u32 slot)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 
nsl_get_checksum(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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 
nsl_set_checksum(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u64 checksum)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 
nsl_get_flags(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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 
nsl_set_flags(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u32 flags)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 
nsl_get_dpa(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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 
nsl_set_dpa(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u64 dpa)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 
nsl_get_rawsize(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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 
nsl_set_rawsize(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u64 rawsize)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 
nsl_get_isetcookie(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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 
nsl_set_isetcookie(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u64 isetcookie)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 
nsl_validate_isetcookie(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u64 cookie)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 
nsl_get_position(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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 
nsl_set_position(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u16 position)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 
nsl_get_nlabel(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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 
nsl_set_nlabel(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u16 nlabel)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 
nsl_get_nrange(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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 
nsl_set_nrange(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u16 nrange)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 
nsl_get_lbasize(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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 
nsl_set_lbasize(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,u64 lbasize)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 
nsl_get_uuid(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,uuid_t * uuid)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 
nsl_set_uuid(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,const uuid_t * uuid)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 
nsl_uuid_equal(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label,const uuid_t * uuid)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 
nsl_uuid_raw(struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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 
ndrd_get_flush_wpq(struct nd_region_data * ndrd,int dimm,int hint)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 
ndrd_set_flush_wpq(struct nd_region_data * ndrd,int dimm,int hint,void __iomem * flush)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 
to_namespace_index(struct nvdimm_drvdata * ndd,int i)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 
to_current_namespace_index(struct nvdimm_drvdata * ndd)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 
to_next_namespace_index(struct nvdimm_drvdata * ndd)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[];
426 };
427 
nsl_validate_nlabel(struct nd_region * nd_region,struct nvdimm_drvdata * ndd,struct nd_namespace_label * nd_label)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  */
nd_inc_seq(unsigned seq)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 
nd_info_block_reserve(void)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 int nd_integrity_init(struct gendisk *disk, unsigned long meta_size);
493 void wait_nvdimm_bus_probe_idle(struct device *dev);
494 void nd_device_register(struct device *dev);
495 void nd_device_unregister(struct device *dev, enum nd_async_mode mode);
496 void nd_device_notify(struct device *dev, enum nvdimm_event event);
497 int nd_uuid_store(struct device *dev, uuid_t **uuid_out, const char *buf,
498 		size_t len);
499 ssize_t nd_size_select_show(unsigned long current_size,
500 		const unsigned long *supported, char *buf);
501 ssize_t nd_size_select_store(struct device *dev, const char *buf,
502 		unsigned long *current_size, const unsigned long *supported);
503 int __init nvdimm_init(void);
504 int __init nd_region_init(void);
505 int __init nd_label_init(void);
506 void nvdimm_exit(void);
507 void nd_region_exit(void);
508 struct nvdimm;
509 extern const struct attribute_group nd_device_attribute_group;
510 extern const struct attribute_group nd_numa_attribute_group;
511 extern const struct attribute_group *nvdimm_bus_attribute_groups[];
512 struct nvdimm_drvdata *to_ndd(struct nd_mapping *nd_mapping);
513 int nvdimm_check_config_data(struct device *dev);
514 int nvdimm_init_nsarea(struct nvdimm_drvdata *ndd);
515 int nvdimm_init_config_data(struct nvdimm_drvdata *ndd);
516 int nvdimm_get_config_data(struct nvdimm_drvdata *ndd, void *buf,
517 			   size_t offset, size_t len);
518 int nvdimm_set_config_data(struct nvdimm_drvdata *ndd, size_t offset,
519 		void *buf, size_t len);
520 long nvdimm_clear_poison(struct device *dev, phys_addr_t phys,
521 		unsigned int len);
522 void nvdimm_set_labeling(struct device *dev);
523 void nvdimm_set_locked(struct device *dev);
524 void nvdimm_clear_locked(struct device *dev);
525 int nvdimm_security_setup_events(struct device *dev);
526 #if IS_ENABLED(CONFIG_NVDIMM_KEYS)
527 int nvdimm_security_unlock(struct device *dev);
528 #else
nvdimm_security_unlock(struct device * dev)529 static inline int nvdimm_security_unlock(struct device *dev)
530 {
531 	return 0;
532 }
533 #endif
534 struct nd_btt *to_nd_btt(struct device *dev);
535 
536 struct nd_gen_sb {
537 	char reserved[SZ_4K - 8];
538 	__le64 checksum;
539 };
540 
541 u64 nd_sb_checksum(struct nd_gen_sb *sb);
542 #if IS_ENABLED(CONFIG_BTT)
543 int nd_btt_probe(struct device *dev, struct nd_namespace_common *ndns);
544 bool is_nd_btt(struct device *dev);
545 struct device *nd_btt_create(struct nd_region *nd_region);
546 #else
nd_btt_probe(struct device * dev,struct nd_namespace_common * ndns)547 static inline int nd_btt_probe(struct device *dev,
548 		struct nd_namespace_common *ndns)
549 {
550 	return -ENODEV;
551 }
552 
is_nd_btt(struct device * dev)553 static inline bool is_nd_btt(struct device *dev)
554 {
555 	return false;
556 }
557 
nd_btt_create(struct nd_region * nd_region)558 static inline struct device *nd_btt_create(struct nd_region *nd_region)
559 {
560 	return NULL;
561 }
562 #endif
563 
564 struct nd_pfn *to_nd_pfn(struct device *dev);
565 #if IS_ENABLED(CONFIG_NVDIMM_PFN)
566 
567 #define MAX_NVDIMM_ALIGN	4
568 
569 int nd_pfn_probe(struct device *dev, struct nd_namespace_common *ndns);
570 bool is_nd_pfn(struct device *dev);
571 struct device *nd_pfn_create(struct nd_region *nd_region);
572 struct device *nd_pfn_devinit(struct nd_pfn *nd_pfn,
573 		struct nd_namespace_common *ndns);
574 int nd_pfn_validate(struct nd_pfn *nd_pfn, const char *sig);
575 extern const struct attribute_group *nd_pfn_attribute_groups[];
576 #else
nd_pfn_probe(struct device * dev,struct nd_namespace_common * ndns)577 static inline int nd_pfn_probe(struct device *dev,
578 		struct nd_namespace_common *ndns)
579 {
580 	return -ENODEV;
581 }
582 
is_nd_pfn(struct device * dev)583 static inline bool is_nd_pfn(struct device *dev)
584 {
585 	return false;
586 }
587 
nd_pfn_create(struct nd_region * nd_region)588 static inline struct device *nd_pfn_create(struct nd_region *nd_region)
589 {
590 	return NULL;
591 }
592 
nd_pfn_validate(struct nd_pfn * nd_pfn,const char * sig)593 static inline int nd_pfn_validate(struct nd_pfn *nd_pfn, const char *sig)
594 {
595 	return -ENODEV;
596 }
597 #endif
598 
599 struct nd_dax *to_nd_dax(struct device *dev);
600 #if IS_ENABLED(CONFIG_NVDIMM_DAX)
601 int nd_dax_probe(struct device *dev, struct nd_namespace_common *ndns);
602 bool is_nd_dax(const struct device *dev);
603 struct device *nd_dax_create(struct nd_region *nd_region);
604 #else
nd_dax_probe(struct device * dev,struct nd_namespace_common * ndns)605 static inline int nd_dax_probe(struct device *dev,
606 		struct nd_namespace_common *ndns)
607 {
608 	return -ENODEV;
609 }
610 
is_nd_dax(const struct device * dev)611 static inline bool is_nd_dax(const struct device *dev)
612 {
613 	return false;
614 }
615 
nd_dax_create(struct nd_region * nd_region)616 static inline struct device *nd_dax_create(struct nd_region *nd_region)
617 {
618 	return NULL;
619 }
620 #endif
621 
622 int nd_region_to_nstype(struct nd_region *nd_region);
623 int nd_region_register_namespaces(struct nd_region *nd_region, int *err);
624 u64 nd_region_interleave_set_cookie(struct nd_region *nd_region,
625 		struct nd_namespace_index *nsindex);
626 u64 nd_region_interleave_set_altcookie(struct nd_region *nd_region);
627 void nvdimm_bus_lock(struct device *dev);
628 void nvdimm_bus_unlock(struct device *dev);
629 bool is_nvdimm_bus_locked(struct device *dev);
630 void nvdimm_check_and_set_ro(struct gendisk *disk);
631 void nvdimm_drvdata_release(struct kref *kref);
632 void put_ndd(struct nvdimm_drvdata *ndd);
633 int nd_label_reserve_dpa(struct nvdimm_drvdata *ndd);
634 void nvdimm_free_dpa(struct nvdimm_drvdata *ndd, struct resource *res);
635 struct resource *nvdimm_allocate_dpa(struct nvdimm_drvdata *ndd,
636 		struct nd_label_id *label_id, resource_size_t start,
637 		resource_size_t n);
638 resource_size_t nvdimm_namespace_capacity(struct nd_namespace_common *ndns);
639 bool nvdimm_namespace_locked(struct nd_namespace_common *ndns);
640 struct nd_namespace_common *nvdimm_namespace_common_probe(struct device *dev);
641 int nvdimm_namespace_attach_btt(struct nd_namespace_common *ndns);
642 int nvdimm_namespace_detach_btt(struct nd_btt *nd_btt);
643 const char *nvdimm_namespace_disk_name(struct nd_namespace_common *ndns,
644 		char *name);
645 unsigned int pmem_sector_size(struct nd_namespace_common *ndns);
646 struct range;
647 void nvdimm_badblocks_populate(struct nd_region *nd_region,
648 		struct badblocks *bb, const struct range *range);
649 int devm_namespace_enable(struct device *dev, struct nd_namespace_common *ndns,
650 		resource_size_t size);
651 void devm_namespace_disable(struct device *dev,
652 		struct nd_namespace_common *ndns);
653 #if IS_ENABLED(CONFIG_ND_CLAIM)
654 /* max struct page size independent of kernel config */
655 #define MAX_STRUCT_PAGE_SIZE 64
656 int nvdimm_setup_pfn(struct nd_pfn *nd_pfn, struct dev_pagemap *pgmap);
657 #else
nvdimm_setup_pfn(struct nd_pfn * nd_pfn,struct dev_pagemap * pgmap)658 static inline int nvdimm_setup_pfn(struct nd_pfn *nd_pfn,
659 				   struct dev_pagemap *pgmap)
660 {
661 	return -ENXIO;
662 }
663 #endif
664 int nd_region_activate(struct nd_region *nd_region);
is_bad_pmem(struct badblocks * bb,sector_t sector,unsigned int len)665 static inline bool is_bad_pmem(struct badblocks *bb, sector_t sector,
666 		unsigned int len)
667 {
668 	if (bb->count) {
669 		sector_t first_bad;
670 		int num_bad;
671 
672 		return !!badblocks_check(bb, sector, len / 512, &first_bad,
673 				&num_bad);
674 	}
675 
676 	return false;
677 }
678 const uuid_t *nd_dev_to_uuid(struct device *dev);
679 bool pmem_should_map_pages(struct device *dev);
680 #endif /* __ND_H__ */
681