Merge tag 'libnvdimm-for-4.2' of git://git.kernel.org/pub/scm/linux/kernel/git/djbw/nvdimm

Pull libnvdimm subsystem from Dan Williams:
 "The libnvdimm sub-system introduces, in addition to the
  libnvdimm-core, 4 drivers / enabling modules:

  NFIT:
    Instantiates an "nvdimm bus" with the core and registers memory
    devices (NVDIMMs) enumerated by the ACPI 6.0 NFIT (NVDIMM Firmware
    Interface table).

    After registering NVDIMMs the NFIT driver then registers "region"
    devices.  A libnvdimm-region defines an access mode and the
    boundaries of persistent memory media.  A region may span multiple
    NVDIMMs that are interleaved by the hardware memory controller.  In
    turn, a libnvdimm-region can be carved into a "namespace" device and
    bound to the PMEM or BLK driver which will attach a Linux block
    device (disk) interface to the memory.

  PMEM:
    Initially merged in v4.1 this driver for contiguous spans of
    persistent memory address ranges is re-worked to drive
    PMEM-namespaces emitted by the libnvdimm-core.

    In this update the PMEM driver, on x86, gains the ability to assert
    that writes to persistent memory have been flushed all the way
    through the caches and buffers in the platform to persistent media.
    See memcpy_to_pmem() and wmb_pmem().

  BLK:
    This new driver enables access to persistent memory media through
    "Block Data Windows" as defined by the NFIT.  The primary difference
    of this driver to PMEM is that only a small window of persistent
    memory is mapped into system address space at any given point in
    time.

    Per-NVDIMM windows are reprogrammed at run time, per-I/O, to access
    different portions of the media.  BLK-mode, by definition, does not
    support DAX.

  BTT:
    This is a library, optionally consumed by either PMEM or BLK, that
    converts a byte-accessible namespace into a disk with atomic sector
    update semantics (prevents sector tearing on crash or power loss).

    The sinister aspect of sector tearing is that most applications do
    not know they have a atomic sector dependency.  At least today's
    disk's rarely ever tear sectors and if they do one almost certainly
    gets a CRC error on access.  NVDIMMs will always tear and always
    silently.  Until an application is audited to be robust in the
    presence of sector-tearing the usage of BTT is recommended.

  Thanks to: Ross Zwisler, Jeff Moyer, Vishal Verma, Christoph Hellwig,
  Ingo Molnar, Neil Brown, Boaz Harrosh, Robert Elliott, Matthew Wilcox,
  Andy Rudoff, Linda Knippers, Toshi Kani, Nicholas Moulin, Rafael
  Wysocki, and Bob Moore"

* tag 'libnvdimm-for-4.2' of git://git.kernel.org/pub/scm/linux/kernel/git/djbw/nvdimm: (33 commits)
  arch, x86: pmem api for ensuring durability of persistent memory updates
  libnvdimm: Add sysfs numa_node to NVDIMM devices
  libnvdimm: Set numa_node to NVDIMM devices
  acpi: Add acpi_map_pxm_to_online_node()
  libnvdimm, nfit: handle unarmed dimms, mark namespaces read-only
  pmem: flag pmem block devices as non-rotational
  libnvdimm: enable iostat
  pmem: make_request cleanups
  libnvdimm, pmem: fix up max_hw_sectors
  libnvdimm, blk: add support for blk integrity
  libnvdimm, btt: add support for blk integrity
  fs/block_dev.c: skip rw_page if bdev has integrity
  libnvdimm: Non-Volatile Devices
  tools/testing/nvdimm: libnvdimm unit test infrastructure
  libnvdimm, nfit, nd_blk: driver for BLK-mode access persistent memory
  nd_btt: atomic sector updates
  libnvdimm: infrastructure for btt devices
  libnvdimm: write blk label set
  libnvdimm: write pmem label set
  libnvdimm: blk labels and namespace instantiation
  ...

8 files changed, 661 insertions, 1 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index c187817471fb..1618cdfb38c7 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -261,8 +261,13 @@ extern void acpi_osi_setup(char *str);
 extern bool acpi_osi_is_win8(void);
 
 #ifdef CONFIG_ACPI_NUMA
+int acpi_map_pxm_to_online_node(int pxm);
 int acpi_get_node(acpi_handle handle);
 #else
+static inline int acpi_map_pxm_to_online_node(int pxm)
+{
+        return 0;
+}
 static inline int acpi_get_node(acpi_handle handle)
 {
         return 0;
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 05be2352fef8..26fc8bc77f85 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -21,6 +21,7 @@
 # define __rcu          __attribute__((noderef, address_space(4)))
 #else
 # define __rcu
+# define __pmem         __attribute__((noderef, address_space(5)))
 #endif
 extern void __chk_user_ptr(const volatile void __user *);
 extern void __chk_io_ptr(const volatile void __iomem *);
@@ -42,6 +43,7 @@ extern void __chk_io_ptr(const volatile void __iomem *);
 # define __cond_lock(x,c) (c)
 # define __percpu
 # define __rcu
+# define __pmem
 #endif
 
 /* Indirect macros required for expanded argument pasting, eg. __LINE__. */
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 5f19efe4eb3f..85ef051ac6fb 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -85,7 +85,8 @@ typedef	struct {
 #define EFI_MEMORY_MAPPED_IO            11
 #define EFI_MEMORY_MAPPED_IO_PORT_SPACE 12
 #define EFI_PAL_CODE                    13
-#define EFI_MAX_MEMORY_TYPE             14
+#define EFI_PERSISTENT_MEMORY           14
+#define EFI_MAX_MEMORY_TYPE             15
 
 /* Attribute values: */
 #define EFI_MEMORY_UC           ((u64)0x0000000000000001ULL)    /* uncached */
diff --git a/include/linux/libnvdimm.h b/include/linux/libnvdimm.h
new file mode 100644
index 000000000000..75e3af01ee32
--- /dev/null
+++ b/include/linux/libnvdimm.h
@@ -0,0 +1,151 @@
+/*
+ * libnvdimm - Non-volatile-memory Devices Subsystem
+ *
+ * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+#ifndef __LIBNVDIMM_H__
+#define __LIBNVDIMM_H__
+#include <linux/kernel.h>
+#include <linux/sizes.h>
+#include <linux/types.h>
+
+enum {
+        /* when a dimm supports both PMEM and BLK access a label is required */
+        NDD_ALIASING = 1 << 0,
+        /* unarmed memory devices may not persist writes */
+        NDD_UNARMED = 1 << 1,
+
+        /* need to set a limit somewhere, but yes, this is likely overkill */
+        ND_IOCTL_MAX_BUFLEN = SZ_4M,
+        ND_CMD_MAX_ELEM = 4,
+        ND_CMD_MAX_ENVELOPE = 16,
+        ND_CMD_ARS_STATUS_MAX = SZ_4K,
+        ND_MAX_MAPPINGS = 32,
+
+        /* mark newly adjusted resources as requiring a label update */
+        DPA_RESOURCE_ADJUSTED = 1 << 0,
+};
+
+extern struct attribute_group nvdimm_bus_attribute_group;
+extern struct attribute_group nvdimm_attribute_group;
+extern struct attribute_group nd_device_attribute_group;
+extern struct attribute_group nd_numa_attribute_group;
+extern struct attribute_group nd_region_attribute_group;
+extern struct attribute_group nd_mapping_attribute_group;
+
+struct nvdimm;
+struct nvdimm_bus_descriptor;
+typedef int (*ndctl_fn)(struct nvdimm_bus_descriptor *nd_desc,
+                struct nvdimm *nvdimm, unsigned int cmd, void *buf,
+                unsigned int buf_len);
+
+struct nd_namespace_label;
+struct nvdimm_drvdata;
+struct nd_mapping {
+        struct nvdimm *nvdimm;
+        struct nd_namespace_label **labels;
+        u64 start;
+        u64 size;
+        /*
+         * @ndd is for private use at region enable / disable time for
+         * get_ndd() + put_ndd(), all other nd_mapping to ndd
+         * conversions use to_ndd() which respects enabled state of the
+         * nvdimm.
+         */
+        struct nvdimm_drvdata *ndd;
+};
+
+struct nvdimm_bus_descriptor {
+        const struct attribute_group **attr_groups;
+        unsigned long dsm_mask;
+        char *provider_name;
+        ndctl_fn ndctl;
+};
+
+struct nd_cmd_desc {
+        int in_num;
+        int out_num;
+        u32 in_sizes[ND_CMD_MAX_ELEM];
+        int out_sizes[ND_CMD_MAX_ELEM];
+};
+
+struct nd_interleave_set {
+        u64 cookie;
+};
+
+struct nd_region_desc {
+        struct resource *res;
+        struct nd_mapping *nd_mapping;
+        u16 num_mappings;
+        const struct attribute_group **attr_groups;
+        struct nd_interleave_set *nd_set;
+        void *provider_data;
+        int num_lanes;
+        int numa_node;
+};
+
+struct nvdimm_bus;
+struct module;
+struct device;
+struct nd_blk_region;
+struct nd_blk_region_desc {
+        int (*enable)(struct nvdimm_bus *nvdimm_bus, struct device *dev);
+        void (*disable)(struct nvdimm_bus *nvdimm_bus, struct device *dev);
+        int (*do_io)(struct nd_blk_region *ndbr, resource_size_t dpa,
+                        void *iobuf, u64 len, int rw);
+        struct nd_region_desc ndr_desc;
+};
+
+static inline struct nd_blk_region_desc *to_blk_region_desc(
+                struct nd_region_desc *ndr_desc)
+{
+        return container_of(ndr_desc, struct nd_blk_region_desc, ndr_desc);
+
+}
+
+struct nvdimm_bus *__nvdimm_bus_register(struct device *parent,
+                struct nvdimm_bus_descriptor *nfit_desc, struct module *module);
+#define nvdimm_bus_register(parent, desc) \
+        __nvdimm_bus_register(parent, desc, THIS_MODULE)
+void nvdimm_bus_unregister(struct nvdimm_bus *nvdimm_bus);
+struct nvdimm_bus *to_nvdimm_bus(struct device *dev);
+struct nvdimm *to_nvdimm(struct device *dev);
+struct nd_region *to_nd_region(struct device *dev);
+struct nd_blk_region *to_nd_blk_region(struct device *dev);
+struct nvdimm_bus_descriptor *to_nd_desc(struct nvdimm_bus *nvdimm_bus);
+const char *nvdimm_name(struct nvdimm *nvdimm);
+void *nvdimm_provider_data(struct nvdimm *nvdimm);
+struct nvdimm *nvdimm_create(struct nvdimm_bus *nvdimm_bus, void *provider_data,
+                const struct attribute_group **groups, unsigned long flags,
+                unsigned long *dsm_mask);
+const struct nd_cmd_desc *nd_cmd_dimm_desc(int cmd);
+const struct nd_cmd_desc *nd_cmd_bus_desc(int cmd);
+u32 nd_cmd_in_size(struct nvdimm *nvdimm, int cmd,
+                const struct nd_cmd_desc *desc, int idx, void *buf);
+u32 nd_cmd_out_size(struct nvdimm *nvdimm, int cmd,
+                const struct nd_cmd_desc *desc, int idx, const u32 *in_field,
+                const u32 *out_field);
+int nvdimm_bus_check_dimm_count(struct nvdimm_bus *nvdimm_bus, int dimm_count);
+struct nd_region *nvdimm_pmem_region_create(struct nvdimm_bus *nvdimm_bus,
+                struct nd_region_desc *ndr_desc);
+struct nd_region *nvdimm_blk_region_create(struct nvdimm_bus *nvdimm_bus,
+                struct nd_region_desc *ndr_desc);
+struct nd_region *nvdimm_volatile_region_create(struct nvdimm_bus *nvdimm_bus,
+                struct nd_region_desc *ndr_desc);
+void *nd_region_provider_data(struct nd_region *nd_region);
+void *nd_blk_region_provider_data(struct nd_blk_region *ndbr);
+void nd_blk_region_set_provider_data(struct nd_blk_region *ndbr, void *data);
+struct nvdimm *nd_blk_region_to_dimm(struct nd_blk_region *ndbr);
+unsigned int nd_region_acquire_lane(struct nd_region *nd_region);
+void nd_region_release_lane(struct nd_region *nd_region, unsigned int lane);
+u64 nd_fletcher64(void *addr, size_t len, bool le);
+#endif /* __LIBNVDIMM_H__ */
diff --git a/include/linux/nd.h b/include/linux/nd.h
new file mode 100644
index 000000000000..507e47c86737
--- /dev/null
+++ b/include/linux/nd.h
@@ -0,0 +1,151 @@
+/*
+ * Copyright(c) 2013-2015 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+#ifndef __LINUX_ND_H__
+#define __LINUX_ND_H__
+#include <linux/fs.h>
+#include <linux/ndctl.h>
+#include <linux/device.h>
+
+struct nd_device_driver {
+        struct device_driver drv;
+        unsigned long type;
+        int (*probe)(struct device *dev);
+        int (*remove)(struct device *dev);
+};
+
+static inline struct nd_device_driver *to_nd_device_driver(
+                struct device_driver *drv)
+{
+        return container_of(drv, struct nd_device_driver, drv);
+};
+
+/**
+ * struct nd_namespace_common - core infrastructure of a namespace
+ * @force_raw: ignore other personalities for the namespace (e.g. btt)
+ * @dev: device model node
+ * @claim: when set a another personality has taken ownership of the namespace
+ * @rw_bytes: access the raw namespace capacity with byte-aligned transfers
+ */
+struct nd_namespace_common {
+        int force_raw;
+        struct device dev;
+        struct device *claim;
+        int (*rw_bytes)(struct nd_namespace_common *, resource_size_t offset,
+                        void *buf, size_t size, int rw);
+};
+
+static inline struct nd_namespace_common *to_ndns(struct device *dev)
+{
+        return container_of(dev, struct nd_namespace_common, dev);
+}
+
+/**
+ * struct nd_namespace_io - infrastructure for loading an nd_pmem instance
+ * @dev: namespace device created by the nd region driver
+ * @res: struct resource conversion of a NFIT SPA table
+ */
+struct nd_namespace_io {
+        struct nd_namespace_common common;
+        struct resource res;
+};
+
+/**
+ * struct nd_namespace_pmem - namespace device for dimm-backed interleaved memory
+ * @nsio: device and system physical address range to drive
+ * @alt_name: namespace name supplied in the dimm label
+ * @uuid: namespace name supplied in the dimm label
+ */
+struct nd_namespace_pmem {
+        struct nd_namespace_io nsio;
+        char *alt_name;
+        u8 *uuid;
+};
+
+/**
+ * struct nd_namespace_blk - namespace for dimm-bounded persistent memory
+ * @alt_name: namespace name supplied in the dimm label
+ * @uuid: namespace name supplied in the dimm label
+ * @id: ida allocated id
+ * @lbasize: blk namespaces have a native sector size when btt not present
+ * @num_resources: number of dpa extents to claim
+ * @res: discontiguous dpa extents for given dimm
+ */
+struct nd_namespace_blk {
+        struct nd_namespace_common common;
+        char *alt_name;
+        u8 *uuid;
+        int id;
+        unsigned long lbasize;
+        int num_resources;
+        struct resource **res;
+};
+
+static inline struct nd_namespace_io *to_nd_namespace_io(struct device *dev)
+{
+        return container_of(dev, struct nd_namespace_io, common.dev);
+}
+
+static inline struct nd_namespace_pmem *to_nd_namespace_pmem(struct device *dev)
+{
+        struct nd_namespace_io *nsio = to_nd_namespace_io(dev);
+
+        return container_of(nsio, struct nd_namespace_pmem, nsio);
+}
+
+static inline struct nd_namespace_blk *to_nd_namespace_blk(struct device *dev)
+{
+        return container_of(dev, struct nd_namespace_blk, common.dev);
+}
+
+/**
+ * nvdimm_read_bytes() - synchronously read bytes from an nvdimm namespace
+ * @ndns: device to read
+ * @offset: namespace-relative starting offset
+ * @buf: buffer to fill
+ * @size: transfer length
+ *
+ * @buf is up-to-date upon return from this routine.
+ */
+static inline int nvdimm_read_bytes(struct nd_namespace_common *ndns,
+                resource_size_t offset, void *buf, size_t size)
+{
+        return ndns->rw_bytes(ndns, offset, buf, size, READ);
+}
+
+/**
+ * nvdimm_write_bytes() - synchronously write bytes to an nvdimm namespace
+ * @ndns: device to read
+ * @offset: namespace-relative starting offset
+ * @buf: buffer to drain
+ * @size: transfer length
+ *
+ * NVDIMM Namepaces disks do not implement sectors internally.  Depending on
+ * the @ndns, the contents of @buf may be in cpu cache, platform buffers,
+ * or on backing memory media upon return from this routine.  Flushing
+ * to media is handled internal to the @ndns driver, if at all.
+ */
+static inline int nvdimm_write_bytes(struct nd_namespace_common *ndns,
+                resource_size_t offset, void *buf, size_t size)
+{
+        return ndns->rw_bytes(ndns, offset, buf, size, WRITE);
+}
+
+#define MODULE_ALIAS_ND_DEVICE(type) \
+        MODULE_ALIAS("nd:t" __stringify(type) "*")
+#define ND_DEVICE_MODALIAS_FMT "nd:t%d"
+
+int __must_check __nd_driver_register(struct nd_device_driver *nd_drv,
+                struct module *module, const char *mod_name);
+#define nd_driver_register(driver) \
+        __nd_driver_register(driver, THIS_MODULE, KBUILD_MODNAME)
+#endif /* __LINUX_ND_H__ */
diff --git a/include/linux/pmem.h b/include/linux/pmem.h
new file mode 100644
index 000000000000..d2114045a6c4
--- /dev/null
+++ b/include/linux/pmem.h
@@ -0,0 +1,152 @@
+/*
+ * Copyright(c) 2015 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of version 2 of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+#ifndef __PMEM_H__
+#define __PMEM_H__
+
+#include <linux/io.h>
+
+#ifdef CONFIG_ARCH_HAS_PMEM_API
+#include <asm/cacheflush.h>
+#else
+static inline void arch_wmb_pmem(void)
+{
+        BUG();
+}
+
+static inline bool __arch_has_wmb_pmem(void)
+{
+        return false;
+}
+
+static inline void __pmem *arch_memremap_pmem(resource_size_t offset,
+                unsigned long size)
+{
+        return NULL;
+}
+
+static inline void arch_memcpy_to_pmem(void __pmem *dst, const void *src,
+                size_t n)
+{
+        BUG();
+}
+#endif
+
+/*
+ * Architectures that define ARCH_HAS_PMEM_API must provide
+ * implementations for arch_memremap_pmem(), arch_memcpy_to_pmem(),
+ * arch_wmb_pmem(), and __arch_has_wmb_pmem().
+ */
+
+static inline void memcpy_from_pmem(void *dst, void __pmem const *src, size_t size)
+{
+        memcpy(dst, (void __force const *) src, size);
+}
+
+static inline void memunmap_pmem(void __pmem *addr)
+{
+        iounmap((void __force __iomem *) addr);
+}
+
+/**
+ * arch_has_wmb_pmem - true if wmb_pmem() ensures durability
+ *
+ * For a given cpu implementation within an architecture it is possible
+ * that wmb_pmem() resolves to a nop.  In the case this returns
+ * false, pmem api users are unable to ensure durability and may want to
+ * fall back to a different data consistency model, or otherwise notify
+ * the user.
+ */
+static inline bool arch_has_wmb_pmem(void)
+{
+        if (IS_ENABLED(CONFIG_ARCH_HAS_PMEM_API))
+                return __arch_has_wmb_pmem();
+        return false;
+}
+
+static inline bool arch_has_pmem_api(void)
+{
+        return IS_ENABLED(CONFIG_ARCH_HAS_PMEM_API) && arch_has_wmb_pmem();
+}
+
+/*
+ * These defaults seek to offer decent performance and minimize the
+ * window between i/o completion and writes being durable on media.
+ * However, it is undefined / architecture specific whether
+ * default_memremap_pmem + default_memcpy_to_pmem is sufficient for
+ * making data durable relative to i/o completion.
+ */
+static void default_memcpy_to_pmem(void __pmem *dst, const void *src,
+                size_t size)
+{
+        memcpy((void __force *) dst, src, size);
+}
+
+static void __pmem *default_memremap_pmem(resource_size_t offset,
+                unsigned long size)
+{
+        return (void __pmem __force *)ioremap_wt(offset, size);
+}
+
+/**
+ * memremap_pmem - map physical persistent memory for pmem api
+ * @offset: physical address of persistent memory
+ * @size: size of the mapping
+ *
+ * Establish a mapping of the architecture specific memory type expected
+ * by memcpy_to_pmem() and wmb_pmem().  For example, it may be
+ * the case that an uncacheable or writethrough mapping is sufficient,
+ * or a writeback mapping provided memcpy_to_pmem() and
+ * wmb_pmem() arrange for the data to be written through the
+ * cache to persistent media.
+ */
+static inline void __pmem *memremap_pmem(resource_size_t offset,
+                unsigned long size)
+{
+        if (arch_has_pmem_api())
+                return arch_memremap_pmem(offset, size);
+        return default_memremap_pmem(offset, size);
+}
+
+/**
+ * memcpy_to_pmem - copy data to persistent memory
+ * @dst: destination buffer for the copy
+ * @src: source buffer for the copy
+ * @n: length of the copy in bytes
+ *
+ * Perform a memory copy that results in the destination of the copy
+ * being effectively evicted from, or never written to, the processor
+ * cache hierarchy after the copy completes.  After memcpy_to_pmem()
+ * data may still reside in cpu or platform buffers, so this operation
+ * must be followed by a wmb_pmem().
+ */
+static inline void memcpy_to_pmem(void __pmem *dst, const void *src, size_t n)
+{
+        if (arch_has_pmem_api())
+                arch_memcpy_to_pmem(dst, src, n);
+        else
+                default_memcpy_to_pmem(dst, src, n);
+}
+
+/**
+ * wmb_pmem - synchronize writes to persistent memory
+ *
+ * After a series of memcpy_to_pmem() operations this drains data from
+ * cpu write buffers and any platform (memory controller) buffers to
+ * ensure that written data is durable on persistent memory media.
+ */
+static inline void wmb_pmem(void)
+{
+        if (arch_has_pmem_api())
+                arch_wmb_pmem();
+}
+#endif /* __PMEM_H__ */
diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild
index c1c23f19d4a2..1ff9942718fe 100644
--- a/include/uapi/linux/Kbuild
+++ b/include/uapi/linux/Kbuild
@@ -272,6 +272,7 @@ header-y += ncp_fs.h
 header-y += ncp.h
 header-y += ncp_mount.h
 header-y += ncp_no.h
+header-y += ndctl.h
 header-y += neighbour.h
 header-y += netconf.h
 header-y += netdevice.h
diff --git a/include/uapi/linux/ndctl.h b/include/uapi/linux/ndctl.h
new file mode 100644
index 000000000000..2b94ea2287bb
--- /dev/null
+++ b/include/uapi/linux/ndctl.h
@@ -0,0 +1,197 @@
+/*
+ * Copyright (c) 2014-2015, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU Lesser General Public License,
+ * version 2.1, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+ * more details.
+ */
+#ifndef __NDCTL_H__
+#define __NDCTL_H__
+
+#include <linux/types.h>
+
+struct nd_cmd_smart {
+        __u32 status;
+        __u8 data[128];
+} __packed;
+
+struct nd_cmd_smart_threshold {
+        __u32 status;
+        __u8 data[8];
+} __packed;
+
+struct nd_cmd_dimm_flags {
+        __u32 status;
+        __u32 flags;
+} __packed;
+
+struct nd_cmd_get_config_size {
+        __u32 status;
+        __u32 config_size;
+        __u32 max_xfer;
+} __packed;
+
+struct nd_cmd_get_config_data_hdr {
+        __u32 in_offset;
+        __u32 in_length;
+        __u32 status;
+        __u8 out_buf[0];
+} __packed;
+
+struct nd_cmd_set_config_hdr {
+        __u32 in_offset;
+        __u32 in_length;
+        __u8 in_buf[0];
+} __packed;
+
+struct nd_cmd_vendor_hdr {
+        __u32 opcode;
+        __u32 in_length;
+        __u8 in_buf[0];
+} __packed;
+
+struct nd_cmd_vendor_tail {
+        __u32 status;
+        __u32 out_length;
+        __u8 out_buf[0];
+} __packed;
+
+struct nd_cmd_ars_cap {
+        __u64 address;
+        __u64 length;
+        __u32 status;
+        __u32 max_ars_out;
+} __packed;
+
+struct nd_cmd_ars_start {
+        __u64 address;
+        __u64 length;
+        __u16 type;
+        __u8 reserved[6];
+        __u32 status;
+} __packed;
+
+struct nd_cmd_ars_status {
+        __u32 status;
+        __u32 out_length;
+        __u64 address;
+        __u64 length;
+        __u16 type;
+        __u32 num_records;
+        struct nd_ars_record {
+                __u32 handle;
+                __u32 flags;
+                __u64 err_address;
+                __u64 mask;
+        } __packed records[0];
+} __packed;
+
+enum {
+        ND_CMD_IMPLEMENTED = 0,
+
+        /* bus commands */
+        ND_CMD_ARS_CAP = 1,
+        ND_CMD_ARS_START = 2,
+        ND_CMD_ARS_STATUS = 3,
+
+        /* per-dimm commands */
+        ND_CMD_SMART = 1,
+        ND_CMD_SMART_THRESHOLD = 2,
+        ND_CMD_DIMM_FLAGS = 3,
+        ND_CMD_GET_CONFIG_SIZE = 4,
+        ND_CMD_GET_CONFIG_DATA = 5,
+        ND_CMD_SET_CONFIG_DATA = 6,
+        ND_CMD_VENDOR_EFFECT_LOG_SIZE = 7,
+        ND_CMD_VENDOR_EFFECT_LOG = 8,
+        ND_CMD_VENDOR = 9,
+};
+
+static inline const char *nvdimm_bus_cmd_name(unsigned cmd)
+{
+        static const char * const names[] = {
+                [ND_CMD_ARS_CAP] = "ars_cap",
+                [ND_CMD_ARS_START] = "ars_start",
+                [ND_CMD_ARS_STATUS] = "ars_status",
+        };
+
+        if (cmd < ARRAY_SIZE(names) && names[cmd])
+                return names[cmd];
+        return "unknown";
+}
+
+static inline const char *nvdimm_cmd_name(unsigned cmd)
+{
+        static const char * const names[] = {
+                [ND_CMD_SMART] = "smart",
+                [ND_CMD_SMART_THRESHOLD] = "smart_thresh",
+                [ND_CMD_DIMM_FLAGS] = "flags",
+                [ND_CMD_GET_CONFIG_SIZE] = "get_size",
+                [ND_CMD_GET_CONFIG_DATA] = "get_data",
+                [ND_CMD_SET_CONFIG_DATA] = "set_data",
+                [ND_CMD_VENDOR_EFFECT_LOG_SIZE] = "effect_size",
+                [ND_CMD_VENDOR_EFFECT_LOG] = "effect_log",
+                [ND_CMD_VENDOR] = "vendor",
+        };
+
+        if (cmd < ARRAY_SIZE(names) && names[cmd])
+                return names[cmd];
+        return "unknown";
+}
+
+#define ND_IOCTL 'N'
+
+#define ND_IOCTL_SMART                  _IOWR(ND_IOCTL, ND_CMD_SMART,\
+                                        struct nd_cmd_smart)
+
+#define ND_IOCTL_SMART_THRESHOLD        _IOWR(ND_IOCTL, ND_CMD_SMART_THRESHOLD,\
+                                        struct nd_cmd_smart_threshold)
+
+#define ND_IOCTL_DIMM_FLAGS             _IOWR(ND_IOCTL, ND_CMD_DIMM_FLAGS,\
+                                        struct nd_cmd_dimm_flags)
+
+#define ND_IOCTL_GET_CONFIG_SIZE        _IOWR(ND_IOCTL, ND_CMD_GET_CONFIG_SIZE,\
+                                        struct nd_cmd_get_config_size)
+
+#define ND_IOCTL_GET_CONFIG_DATA        _IOWR(ND_IOCTL, ND_CMD_GET_CONFIG_DATA,\
+                                        struct nd_cmd_get_config_data_hdr)
+
+#define ND_IOCTL_SET_CONFIG_DATA        _IOWR(ND_IOCTL, ND_CMD_SET_CONFIG_DATA,\
+                                        struct nd_cmd_set_config_hdr)
+
+#define ND_IOCTL_VENDOR                 _IOWR(ND_IOCTL, ND_CMD_VENDOR,\
+                                        struct nd_cmd_vendor_hdr)
+
+#define ND_IOCTL_ARS_CAP                _IOWR(ND_IOCTL, ND_CMD_ARS_CAP,\
+                                        struct nd_cmd_ars_cap)
+
+#define ND_IOCTL_ARS_START              _IOWR(ND_IOCTL, ND_CMD_ARS_START,\
+                                        struct nd_cmd_ars_start)
+
+#define ND_IOCTL_ARS_STATUS             _IOWR(ND_IOCTL, ND_CMD_ARS_STATUS,\
+                                        struct nd_cmd_ars_status)
+
+#define ND_DEVICE_DIMM 1            /* nd_dimm: container for "config data" */
+#define ND_DEVICE_REGION_PMEM 2     /* nd_region: (parent of PMEM namespaces) */
+#define ND_DEVICE_REGION_BLK 3      /* nd_region: (parent of BLK namespaces) */
+#define ND_DEVICE_NAMESPACE_IO 4    /* legacy persistent memory */
+#define ND_DEVICE_NAMESPACE_PMEM 5  /* PMEM namespace (may alias with BLK) */
+#define ND_DEVICE_NAMESPACE_BLK 6   /* BLK namespace (may alias with PMEM) */
+
+enum nd_driver_flags {
+        ND_DRIVER_DIMM            = 1 << ND_DEVICE_DIMM,
+        ND_DRIVER_REGION_PMEM     = 1 << ND_DEVICE_REGION_PMEM,
+        ND_DRIVER_REGION_BLK      = 1 << ND_DEVICE_REGION_BLK,
+        ND_DRIVER_NAMESPACE_IO    = 1 << ND_DEVICE_NAMESPACE_IO,
+        ND_DRIVER_NAMESPACE_PMEM  = 1 << ND_DEVICE_NAMESPACE_PMEM,
+        ND_DRIVER_NAMESPACE_BLK   = 1 << ND_DEVICE_NAMESPACE_BLK,
+};
+
+enum {
+        ND_MIN_NAMESPACE_SIZE = 0x00400000,
+};
+#endif /* __NDCTL_H__ */