Merge branch 'for-4.5/drivers' of git://git.kernel.dk/linux-block

[deliverable/linux.git] / drivers / nvdimm / pmem.c

diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index b493ff3fccb2dcc85643711a5b02bc3bfc954836..7edf31671dabed8f8d193806f54f3d1b30401e7c 100644 (file)
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -21,10 +21,11 @@
 #include <linux/init.h>
 #include <linux/platform_device.h>
 #include <linux/module.h>
-#include <linux/memory_hotplug.h>
 #include <linux/moduleparam.h>
 #include <linux/badblocks.h>
+#include <linux/memremap.h>
 #include <linux/vmalloc.h>
+#include <linux/pfn_t.h>
 #include <linux/slab.h>
 #include <linux/pmem.h>
 #include <linux/nd.h>
@@ -40,6 +41,7 @@ struct pmem_device {
        phys_addr_t             phys_addr;
        /* when non-zero this device is hosting a 'pfn' instance */
        phys_addr_t             data_offset;
+       unsigned long           pfn_flags;
        void __pmem             *virt_addr;
        size_t                  size;
        struct badblocks        bb;
@@ -135,13 +137,13 @@ static int pmem_rw_page(struct block_device *bdev, sector_t sector,
 }
 
 static long pmem_direct_access(struct block_device *bdev, sector_t sector,
-                     void __pmem **kaddr, unsigned long *pfn)
+                     void __pmem **kaddr, pfn_t *pfn)
 {
        struct pmem_device *pmem = bdev->bd_disk->private_data;
        resource_size_t offset = sector * 512 + pmem->data_offset;
 
        *kaddr = pmem->virt_addr + offset;
-       *pfn = (pmem->phys_addr + offset) >> PAGE_SHIFT;
+       *pfn = phys_to_pfn_t(pmem->phys_addr + offset, pmem->pfn_flags);
 
        return pmem->size - offset;
 }
@@ -157,6 +159,7 @@ static struct pmem_device *pmem_alloc(struct device *dev,
                struct resource *res, int id)
 {
        struct pmem_device *pmem;
+       struct request_queue *q;
 
        pmem = devm_kzalloc(dev, sizeof(*pmem), GFP_KERNEL);
        if (!pmem)
@@ -174,16 +177,26 @@ static struct pmem_device *pmem_alloc(struct device *dev,
                return ERR_PTR(-EBUSY);
        }
 
-       if (pmem_should_map_pages(dev))
-               pmem->virt_addr = (void __pmem *) devm_memremap_pages(dev, res);
-       else
+       q = blk_alloc_queue_node(GFP_KERNEL, dev_to_node(dev));
+       if (!q)
+               return ERR_PTR(-ENOMEM);
+
+       pmem->pfn_flags = PFN_DEV;
+       if (pmem_should_map_pages(dev)) {
+               pmem->virt_addr = (void __pmem *) devm_memremap_pages(dev, res,
+                               &q->q_usage_counter, NULL);
+               pmem->pfn_flags |= PFN_MAP;
+       } else
                pmem->virt_addr = (void __pmem *) devm_memremap(dev,
                                pmem->phys_addr, pmem->size,
                                ARCH_MEMREMAP_PMEM);
 
-       if (IS_ERR(pmem->virt_addr))
+       if (IS_ERR(pmem->virt_addr)) {
+               blk_cleanup_queue(q);
                return (void __force *) pmem->virt_addr;
+       }
 
+       pmem->pmem_queue = q;
        return pmem;
 }
 
@@ -203,10 +216,6 @@ static int pmem_attach_disk(struct device *dev,
        int nid = dev_to_node(dev);
        struct gendisk *disk;
 
-       pmem->pmem_queue = blk_alloc_queue_node(GFP_KERNEL, nid);
-       if (!pmem->pmem_queue)
-               return -ENOMEM;
-
        blk_queue_make_request(pmem->pmem_queue, pmem_make_request);
        blk_queue_physical_block_size(pmem->pmem_queue, PAGE_SIZE);
        blk_queue_max_hw_sectors(pmem->pmem_queue, UINT_MAX);
@@ -352,12 +361,17 @@ static int nvdimm_namespace_attach_pfn(struct nd_namespace_common *ndns)
        struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev);
        struct nd_pfn *nd_pfn = to_nd_pfn(ndns->claim);
        struct device *dev = &nd_pfn->dev;
-       struct vmem_altmap *altmap;
        struct nd_region *nd_region;
+       struct vmem_altmap *altmap;
        struct nd_pfn_sb *pfn_sb;
        struct pmem_device *pmem;
+       struct request_queue *q;
        phys_addr_t offset;
        int rc;
+       struct vmem_altmap __altmap = {
+               .base_pfn = __phys_to_pfn(nsio->res.start),
+               .reserve = __phys_to_pfn(SZ_8K),
+       };
 
        if (!nd_pfn->uuid || !nd_pfn->ndns)
                return -ENODEV;
@@ -375,6 +389,17 @@ static int nvdimm_namespace_attach_pfn(struct nd_namespace_common *ndns)
                        return -EINVAL;
                nd_pfn->npfns = le64_to_cpu(pfn_sb->npfns);
                altmap = NULL;
+       } else if (nd_pfn->mode == PFN_MODE_PMEM) {
+               nd_pfn->npfns = (resource_size(&nsio->res) - offset)
+                       / PAGE_SIZE;
+               if (le64_to_cpu(nd_pfn->pfn_sb->npfns) > nd_pfn->npfns)
+                       dev_info(&nd_pfn->dev,
+                                       "number of pfns truncated from %lld to %ld\n",
+                                       le64_to_cpu(nd_pfn->pfn_sb->npfns),
+                                       nd_pfn->npfns);
+               altmap = & __altmap;
+               altmap->free = __phys_to_pfn(offset - SZ_8K);
+               altmap->alloc = 0;
        } else {
                rc = -ENXIO;
                goto err;
@@ -382,8 +407,11 @@ static int nvdimm_namespace_attach_pfn(struct nd_namespace_common *ndns)
 
        /* establish pfn range for lookup, and switch to direct map */
        pmem = dev_get_drvdata(dev);
+       q = pmem->pmem_queue;
        devm_memunmap(dev, (void __force *) pmem->virt_addr);
-       pmem->virt_addr = (void __pmem *) devm_memremap_pages(dev, &nsio->res);
+       pmem->virt_addr = (void __pmem *) devm_memremap_pages(dev, &nsio->res,
+                       &q->q_usage_counter, altmap);
+       pmem->pfn_flags |= PFN_MAP;
        if (IS_ERR(pmem->virt_addr)) {
                rc = PTR_ERR(pmem->virt_addr);
                goto err;
@@ -424,19 +452,22 @@ static int nd_pmem_probe(struct device *dev)
                return -ENOMEM;
        nvdimm_namespace_add_poison(ndns, &pmem->bb, 0);
 
-       if (is_nd_btt(dev))
+       if (is_nd_btt(dev)) {
+               /* btt allocates its own request_queue */
+               blk_cleanup_queue(pmem->pmem_queue);
+               pmem->pmem_queue = NULL;
                return nvdimm_namespace_attach_btt(ndns);
+       }
 
        if (is_nd_pfn(dev))
                return nvdimm_namespace_attach_pfn(ndns);
 
-       if (nd_btt_probe(ndns, pmem) == 0) {
-               /* we'll come back as btt-pmem */
-               return -ENXIO;
-       }
-
-       if (nd_pfn_probe(ndns, pmem) == 0) {
-               /* we'll come back as pfn-pmem */
+       if (nd_btt_probe(ndns, pmem) == 0 || nd_pfn_probe(ndns, pmem) == 0) {
+               /*
+                * We'll come back as either btt-pmem, or pfn-pmem, so
+                * drop the queue allocation for now.
+                */
+               blk_cleanup_queue(pmem->pmem_queue);
                return -ENXIO;
        }