Merge branch 'libnvdimm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/djbw/nvdimm
Pull libnvdimm fixes from Dan Williams:
"1) Fixes for a handful of smatch reports (Thanks Dan C.!) and minor
bug fixes (patches 1-6)
2) Correctness fixes to the BLK-mode nvdimm driver (patches 7-10).
Granted these are slightly large for a -rc update. They have been
out for review in one form or another since the end of May and were
deferred from the merge window while we settled on the "PMEM API"
for the PMEM-mode nvdimm driver (ie memremap_pmem, memcpy_to_pmem,
and wmb_pmem).
Now that those apis are merged we implement them in the BLK driver
to guarantee that mmio aperture moves stay ordered with respect to
incoming read/write requests, and that writes are flushed through
those mmio-windows and platform-buffers to be persistent on media.
These pass the sub-system unit tests with the updates to
tools/testing/nvdimm, and have received a successful build-report from
the kbuild robot (468 configs).
With acks from Rafael for the touches to drivers/acpi/"
* 'libnvdimm-fixes' of git://git.kernel.org/pub/scm/linux/kernel/git/djbw/nvdimm:
nfit: add support for NVDIMM "latch" flag
nfit: update block I/O path to use PMEM API
tools/testing/nvdimm: add mock acpi_nfit_flush_address entries to nfit_test
tools/testing/nvdimm: fix return code for unimplemented commands
tools/testing/nvdimm: mock ioremap_wt
pmem: add maintainer for include/linux/pmem.h
nfit: fix smatch "use after null check" report
nvdimm: Fix return value of nvdimm_bus_init() if class_create() fails
libnvdimm: smatch cleanups in __nd_ioctl
sparse: fix misplaced __pmem definition
This commit is contained in:
Linus Torvalds
commit
59c3cb553f
|
|
@ -6160,6 +6160,7 @@ L: linux-nvdimm@lists.01.org
|
|||
Q: https://patchwork.kernel.org/project/linux-nvdimm/list/
|
||||
S: Supported
|
||||
F: drivers/nvdimm/pmem.c
|
||||
F: include/linux/pmem.h
|
||||
|
||||
LINUX FOR IBM pSERIES (RS/6000)
|
||||
M: Paul Mackerras <paulus@au.ibm.com>
|
||||
|
|
|
|||
|
|
@ -18,6 +18,7 @@
|
|||
#include <linux/list.h>
|
||||
#include <linux/acpi.h>
|
||||
#include <linux/sort.h>
|
||||
#include <linux/pmem.h>
|
||||
#include <linux/io.h>
|
||||
#include "nfit.h"
|
||||
|
||||
|
|
@ -305,6 +306,23 @@ static bool add_idt(struct acpi_nfit_desc *acpi_desc,
|
|||
return true;
|
||||
}
|
||||
|
||||
static bool add_flush(struct acpi_nfit_desc *acpi_desc,
|
||||
struct acpi_nfit_flush_address *flush)
|
||||
{
|
||||
struct device *dev = acpi_desc->dev;
|
||||
struct nfit_flush *nfit_flush = devm_kzalloc(dev, sizeof(*nfit_flush),
|
||||
GFP_KERNEL);
|
||||
|
||||
if (!nfit_flush)
|
||||
return false;
|
||||
INIT_LIST_HEAD(&nfit_flush->list);
|
||||
nfit_flush->flush = flush;
|
||||
list_add_tail(&nfit_flush->list, &acpi_desc->flushes);
|
||||
dev_dbg(dev, "%s: nfit_flush handle: %d hint_count: %d\n", __func__,
|
||||
flush->device_handle, flush->hint_count);
|
||||
return true;
|
||||
}
|
||||
|
||||
static void *add_table(struct acpi_nfit_desc *acpi_desc, void *table,
|
||||
const void *end)
|
||||
{
|
||||
|
|
@ -338,7 +356,8 @@ static void *add_table(struct acpi_nfit_desc *acpi_desc, void *table,
|
|||
return err;
|
||||
break;
|
||||
case ACPI_NFIT_TYPE_FLUSH_ADDRESS:
|
||||
dev_dbg(dev, "%s: flush\n", __func__);
|
||||
if (!add_flush(acpi_desc, table))
|
||||
return err;
|
||||
break;
|
||||
case ACPI_NFIT_TYPE_SMBIOS:
|
||||
dev_dbg(dev, "%s: smbios\n", __func__);
|
||||
|
|
@ -389,6 +408,7 @@ static int nfit_mem_add(struct acpi_nfit_desc *acpi_desc,
|
|||
{
|
||||
u16 dcr = __to_nfit_memdev(nfit_mem)->region_index;
|
||||
struct nfit_memdev *nfit_memdev;
|
||||
struct nfit_flush *nfit_flush;
|
||||
struct nfit_dcr *nfit_dcr;
|
||||
struct nfit_bdw *nfit_bdw;
|
||||
struct nfit_idt *nfit_idt;
|
||||
|
|
@ -442,6 +462,14 @@ static int nfit_mem_add(struct acpi_nfit_desc *acpi_desc,
|
|||
nfit_mem->idt_bdw = nfit_idt->idt;
|
||||
break;
|
||||
}
|
||||
|
||||
list_for_each_entry(nfit_flush, &acpi_desc->flushes, list) {
|
||||
if (nfit_flush->flush->device_handle !=
|
||||
nfit_memdev->memdev->device_handle)
|
||||
continue;
|
||||
nfit_mem->nfit_flush = nfit_flush;
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -978,6 +1006,24 @@ static u64 to_interleave_offset(u64 offset, struct nfit_blk_mmio *mmio)
|
|||
return mmio->base_offset + line_offset + table_offset + sub_line_offset;
|
||||
}
|
||||
|
||||
static void wmb_blk(struct nfit_blk *nfit_blk)
|
||||
{
|
||||
|
||||
if (nfit_blk->nvdimm_flush) {
|
||||
/*
|
||||
* The first wmb() is needed to 'sfence' all previous writes
|
||||
* such that they are architecturally visible for the platform
|
||||
* buffer flush. Note that we've already arranged for pmem
|
||||
* writes to avoid the cache via arch_memcpy_to_pmem(). The
|
||||
* final wmb() ensures ordering for the NVDIMM flush write.
|
||||
*/
|
||||
wmb();
|
||||
writeq(1, nfit_blk->nvdimm_flush);
|
||||
wmb();
|
||||
} else
|
||||
wmb_pmem();
|
||||
}
|
||||
|
||||
static u64 read_blk_stat(struct nfit_blk *nfit_blk, unsigned int bw)
|
||||
{
|
||||
struct nfit_blk_mmio *mmio = &nfit_blk->mmio[DCR];
|
||||
|
|
@ -1012,7 +1058,10 @@ static void write_blk_ctl(struct nfit_blk *nfit_blk, unsigned int bw,
|
|||
offset = to_interleave_offset(offset, mmio);
|
||||
|
||||
writeq(cmd, mmio->base + offset);
|
||||
/* FIXME: conditionally perform read-back if mandated by firmware */
|
||||
wmb_blk(nfit_blk);
|
||||
|
||||
if (nfit_blk->dimm_flags & ND_BLK_DCR_LATCH)
|
||||
readq(mmio->base + offset);
|
||||
}
|
||||
|
||||
static int acpi_nfit_blk_single_io(struct nfit_blk *nfit_blk,
|
||||
|
|
@ -1026,7 +1075,6 @@ static int acpi_nfit_blk_single_io(struct nfit_blk *nfit_blk,
|
|||
|
||||
base_offset = nfit_blk->bdw_offset + dpa % L1_CACHE_BYTES
|
||||
+ lane * mmio->size;
|
||||
/* TODO: non-temporal access, flush hints, cache management etc... */
|
||||
write_blk_ctl(nfit_blk, lane, dpa, len, rw);
|
||||
while (len) {
|
||||
unsigned int c;
|
||||
|
|
@ -1045,13 +1093,19 @@ static int acpi_nfit_blk_single_io(struct nfit_blk *nfit_blk,
|
|||
}
|
||||
|
||||
if (rw)
|
||||
memcpy(mmio->aperture + offset, iobuf + copied, c);
|
||||
memcpy_to_pmem(mmio->aperture + offset,
|
||||
iobuf + copied, c);
|
||||
else
|
||||
memcpy(iobuf + copied, mmio->aperture + offset, c);
|
||||
memcpy_from_pmem(iobuf + copied,
|
||||
mmio->aperture + offset, c);
|
||||
|
||||
copied += c;
|
||||
len -= c;
|
||||
}
|
||||
|
||||
if (rw)
|
||||
wmb_blk(nfit_blk);
|
||||
|
||||
rc = read_blk_stat(nfit_blk, lane) ? -EIO : 0;
|
||||
return rc;
|
||||
}
|
||||
|
|
@ -1124,7 +1178,7 @@ static void nfit_spa_unmap(struct acpi_nfit_desc *acpi_desc,
|
|||
}
|
||||
|
||||
static void __iomem *__nfit_spa_map(struct acpi_nfit_desc *acpi_desc,
|
||||
struct acpi_nfit_system_address *spa)
|
||||
struct acpi_nfit_system_address *spa, enum spa_map_type type)
|
||||
{
|
||||
resource_size_t start = spa->address;
|
||||
resource_size_t n = spa->length;
|
||||
|
|
@ -1152,8 +1206,15 @@ static void __iomem *__nfit_spa_map(struct acpi_nfit_desc *acpi_desc,
|
|||
if (!res)
|
||||
goto err_mem;
|
||||
|
||||
/* TODO: cacheability based on the spa type */
|
||||
spa_map->iomem = ioremap_nocache(start, n);
|
||||
if (type == SPA_MAP_APERTURE) {
|
||||
/*
|
||||
* TODO: memremap_pmem() support, but that requires cache
|
||||
* flushing when the aperture is moved.
|
||||
*/
|
||||
spa_map->iomem = ioremap_wc(start, n);
|
||||
} else
|
||||
spa_map->iomem = ioremap_nocache(start, n);
|
||||
|
||||
if (!spa_map->iomem)
|
||||
goto err_map;
|
||||
|
||||
|
|
@ -1171,6 +1232,7 @@ static void __iomem *__nfit_spa_map(struct acpi_nfit_desc *acpi_desc,
|
|||
* nfit_spa_map - interleave-aware managed-mappings of acpi_nfit_system_address ranges
|
||||
* @nvdimm_bus: NFIT-bus that provided the spa table entry
|
||||
* @nfit_spa: spa table to map
|
||||
* @type: aperture or control region
|
||||
*
|
||||
* In the case where block-data-window apertures and
|
||||
* dimm-control-regions are interleaved they will end up sharing a
|
||||
|
|
@ -1180,12 +1242,12 @@ static void __iomem *__nfit_spa_map(struct acpi_nfit_desc *acpi_desc,
|
|||
* unbound.
|
||||
*/
|
||||
static void __iomem *nfit_spa_map(struct acpi_nfit_desc *acpi_desc,
|
||||
struct acpi_nfit_system_address *spa)
|
||||
struct acpi_nfit_system_address *spa, enum spa_map_type type)
|
||||
{
|
||||
void __iomem *iomem;
|
||||
|
||||
mutex_lock(&acpi_desc->spa_map_mutex);
|
||||
iomem = __nfit_spa_map(acpi_desc, spa);
|
||||
iomem = __nfit_spa_map(acpi_desc, spa, type);
|
||||
mutex_unlock(&acpi_desc->spa_map_mutex);
|
||||
|
||||
return iomem;
|
||||
|
|
@ -1206,12 +1268,35 @@ static int nfit_blk_init_interleave(struct nfit_blk_mmio *mmio,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int acpi_nfit_blk_get_flags(struct nvdimm_bus_descriptor *nd_desc,
|
||||
struct nvdimm *nvdimm, struct nfit_blk *nfit_blk)
|
||||
{
|
||||
struct nd_cmd_dimm_flags flags;
|
||||
int rc;
|
||||
|
||||
memset(&flags, 0, sizeof(flags));
|
||||
rc = nd_desc->ndctl(nd_desc, nvdimm, ND_CMD_DIMM_FLAGS, &flags,
|
||||
sizeof(flags));
|
||||
|
||||
if (rc >= 0 && flags.status == 0)
|
||||
nfit_blk->dimm_flags = flags.flags;
|
||||
else if (rc == -ENOTTY) {
|
||||
/* fall back to a conservative default */
|
||||
nfit_blk->dimm_flags = ND_BLK_DCR_LATCH;
|
||||
rc = 0;
|
||||
} else
|
||||
rc = -ENXIO;
|
||||
|
||||
return rc;
|
||||
}
|
||||
|
||||
static int acpi_nfit_blk_region_enable(struct nvdimm_bus *nvdimm_bus,
|
||||
struct device *dev)
|
||||
{
|
||||
struct nvdimm_bus_descriptor *nd_desc = to_nd_desc(nvdimm_bus);
|
||||
struct acpi_nfit_desc *acpi_desc = to_acpi_desc(nd_desc);
|
||||
struct nd_blk_region *ndbr = to_nd_blk_region(dev);
|
||||
struct nfit_flush *nfit_flush;
|
||||
struct nfit_blk_mmio *mmio;
|
||||
struct nfit_blk *nfit_blk;
|
||||
struct nfit_mem *nfit_mem;
|
||||
|
|
@ -1223,8 +1308,8 @@ static int acpi_nfit_blk_region_enable(struct nvdimm_bus *nvdimm_bus,
|
|||
if (!nfit_mem || !nfit_mem->dcr || !nfit_mem->bdw) {
|
||||
dev_dbg(dev, "%s: missing%s%s%s\n", __func__,
|
||||
nfit_mem ? "" : " nfit_mem",
|
||||
nfit_mem->dcr ? "" : " dcr",
|
||||
nfit_mem->bdw ? "" : " bdw");
|
||||
(nfit_mem && nfit_mem->dcr) ? "" : " dcr",
|
||||
(nfit_mem && nfit_mem->bdw) ? "" : " bdw");
|
||||
return -ENXIO;
|
||||
}
|
||||
|
||||
|
|
@ -1237,7 +1322,8 @@ static int acpi_nfit_blk_region_enable(struct nvdimm_bus *nvdimm_bus,
|
|||
/* map block aperture memory */
|
||||
nfit_blk->bdw_offset = nfit_mem->bdw->offset;
|
||||
mmio = &nfit_blk->mmio[BDW];
|
||||
mmio->base = nfit_spa_map(acpi_desc, nfit_mem->spa_bdw);
|
||||
mmio->base = nfit_spa_map(acpi_desc, nfit_mem->spa_bdw,
|
||||
SPA_MAP_APERTURE);
|
||||
if (!mmio->base) {
|
||||
dev_dbg(dev, "%s: %s failed to map bdw\n", __func__,
|
||||
nvdimm_name(nvdimm));
|
||||
|
|
@ -1259,7 +1345,8 @@ static int acpi_nfit_blk_region_enable(struct nvdimm_bus *nvdimm_bus,
|
|||
nfit_blk->cmd_offset = nfit_mem->dcr->command_offset;
|
||||
nfit_blk->stat_offset = nfit_mem->dcr->status_offset;
|
||||
mmio = &nfit_blk->mmio[DCR];
|
||||
mmio->base = nfit_spa_map(acpi_desc, nfit_mem->spa_dcr);
|
||||
mmio->base = nfit_spa_map(acpi_desc, nfit_mem->spa_dcr,
|
||||
SPA_MAP_CONTROL);
|
||||
if (!mmio->base) {
|
||||
dev_dbg(dev, "%s: %s failed to map dcr\n", __func__,
|
||||
nvdimm_name(nvdimm));
|
||||
|
|
@ -1277,6 +1364,24 @@ static int acpi_nfit_blk_region_enable(struct nvdimm_bus *nvdimm_bus,
|
|||
return rc;
|
||||
}
|
||||
|
||||
rc = acpi_nfit_blk_get_flags(nd_desc, nvdimm, nfit_blk);
|
||||
if (rc < 0) {
|
||||
dev_dbg(dev, "%s: %s failed get DIMM flags\n",
|
||||
__func__, nvdimm_name(nvdimm));
|
||||
return rc;
|
||||
}
|
||||
|
||||
nfit_flush = nfit_mem->nfit_flush;
|
||||
if (nfit_flush && nfit_flush->flush->hint_count != 0) {
|
||||
nfit_blk->nvdimm_flush = devm_ioremap_nocache(dev,
|
||||
nfit_flush->flush->hint_address[0], 8);
|
||||
if (!nfit_blk->nvdimm_flush)
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
if (!arch_has_pmem_api() && !nfit_blk->nvdimm_flush)
|
||||
dev_warn(dev, "unable to guarantee persistence of writes\n");
|
||||
|
||||
if (mmio->line_size == 0)
|
||||
return 0;
|
||||
|
||||
|
|
@ -1459,6 +1564,7 @@ int acpi_nfit_init(struct acpi_nfit_desc *acpi_desc, acpi_size sz)
|
|||
INIT_LIST_HEAD(&acpi_desc->dcrs);
|
||||
INIT_LIST_HEAD(&acpi_desc->bdws);
|
||||
INIT_LIST_HEAD(&acpi_desc->idts);
|
||||
INIT_LIST_HEAD(&acpi_desc->flushes);
|
||||
INIT_LIST_HEAD(&acpi_desc->memdevs);
|
||||
INIT_LIST_HEAD(&acpi_desc->dimms);
|
||||
mutex_init(&acpi_desc->spa_map_mutex);
|
||||
|
|
|
|||
|
|
@ -40,6 +40,10 @@ enum nfit_uuids {
|
|||
NFIT_UUID_MAX,
|
||||
};
|
||||
|
||||
enum {
|
||||
ND_BLK_DCR_LATCH = 2,
|
||||
};
|
||||
|
||||
struct nfit_spa {
|
||||
struct acpi_nfit_system_address *spa;
|
||||
struct list_head list;
|
||||
|
|
@ -60,6 +64,11 @@ struct nfit_idt {
|
|||
struct list_head list;
|
||||
};
|
||||
|
||||
struct nfit_flush {
|
||||
struct acpi_nfit_flush_address *flush;
|
||||
struct list_head list;
|
||||
};
|
||||
|
||||
struct nfit_memdev {
|
||||
struct acpi_nfit_memory_map *memdev;
|
||||
struct list_head list;
|
||||
|
|
@ -77,6 +86,7 @@ struct nfit_mem {
|
|||
struct acpi_nfit_system_address *spa_bdw;
|
||||
struct acpi_nfit_interleave *idt_dcr;
|
||||
struct acpi_nfit_interleave *idt_bdw;
|
||||
struct nfit_flush *nfit_flush;
|
||||
struct list_head list;
|
||||
struct acpi_device *adev;
|
||||
unsigned long dsm_mask;
|
||||
|
|
@ -88,6 +98,7 @@ struct acpi_nfit_desc {
|
|||
struct mutex spa_map_mutex;
|
||||
struct list_head spa_maps;
|
||||
struct list_head memdevs;
|
||||
struct list_head flushes;
|
||||
struct list_head dimms;
|
||||
struct list_head spas;
|
||||
struct list_head dcrs;
|
||||
|
|
@ -109,7 +120,7 @@ struct nfit_blk {
|
|||
struct nfit_blk_mmio {
|
||||
union {
|
||||
void __iomem *base;
|
||||
void *aperture;
|
||||
void __pmem *aperture;
|
||||
};
|
||||
u64 size;
|
||||
u64 base_offset;
|
||||
|
|
@ -123,6 +134,13 @@ struct nfit_blk {
|
|||
u64 bdw_offset; /* post interleave offset */
|
||||
u64 stat_offset;
|
||||
u64 cmd_offset;
|
||||
void __iomem *nvdimm_flush;
|
||||
u32 dimm_flags;
|
||||
};
|
||||
|
||||
enum spa_map_type {
|
||||
SPA_MAP_CONTROL,
|
||||
SPA_MAP_APERTURE,
|
||||
};
|
||||
|
||||
struct nfit_spa_mapping {
|
||||
|
|
|
|||
|
|
@ -535,8 +535,6 @@ static int __nd_ioctl(struct nvdimm_bus *nvdimm_bus, struct nvdimm *nvdimm,
|
|||
__func__, dimm_name, cmd_name, i);
|
||||
return -ENXIO;
|
||||
}
|
||||
if (!access_ok(VERIFY_READ, p + in_len, in_size))
|
||||
return -EFAULT;
|
||||
if (in_len < sizeof(in_env))
|
||||
copy = min_t(u32, sizeof(in_env) - in_len, in_size);
|
||||
else
|
||||
|
|
@ -557,8 +555,6 @@ static int __nd_ioctl(struct nvdimm_bus *nvdimm_bus, struct nvdimm *nvdimm,
|
|||
__func__, dimm_name, cmd_name, i);
|
||||
return -EFAULT;
|
||||
}
|
||||
if (!access_ok(VERIFY_WRITE, p + in_len + out_len, out_size))
|
||||
return -EFAULT;
|
||||
if (out_len < sizeof(out_env))
|
||||
copy = min_t(u32, sizeof(out_env) - out_len, out_size);
|
||||
else
|
||||
|
|
@ -570,9 +566,6 @@ static int __nd_ioctl(struct nvdimm_bus *nvdimm_bus, struct nvdimm *nvdimm,
|
|||
}
|
||||
|
||||
buf_len = out_len + in_len;
|
||||
if (!access_ok(VERIFY_WRITE, p, sizeof(buf_len)))
|
||||
return -EFAULT;
|
||||
|
||||
if (buf_len > ND_IOCTL_MAX_BUFLEN) {
|
||||
dev_dbg(dev, "%s:%s cmd: %s buf_len: %zu > %d\n", __func__,
|
||||
dimm_name, cmd_name, buf_len,
|
||||
|
|
@ -706,8 +699,10 @@ int __init nvdimm_bus_init(void)
|
|||
nvdimm_major = rc;
|
||||
|
||||
nd_class = class_create(THIS_MODULE, "nd");
|
||||
if (IS_ERR(nd_class))
|
||||
if (IS_ERR(nd_class)) {
|
||||
rc = PTR_ERR(nd_class);
|
||||
goto err_class;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
|
|
|
|||
|
|
@ -17,11 +17,11 @@
|
|||
# define __release(x) __context__(x,-1)
|
||||
# define __cond_lock(x,c) ((c) ? ({ __acquire(x); 1; }) : 0)
|
||||
# define __percpu __attribute__((noderef, address_space(3)))
|
||||
# define __pmem __attribute__((noderef, address_space(5)))
|
||||
#ifdef CONFIG_SPARSE_RCU_POINTER
|
||||
# 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 *);
|
||||
|
|
|
|||
|
|
@ -1,3 +1,6 @@
|
|||
ldflags-y += --wrap=ioremap_wt
|
||||
ldflags-y += --wrap=ioremap_wc
|
||||
ldflags-y += --wrap=devm_ioremap_nocache
|
||||
ldflags-y += --wrap=ioremap_cache
|
||||
ldflags-y += --wrap=ioremap_nocache
|
||||
ldflags-y += --wrap=iounmap
|
||||
|
|
|
|||
|
|
@ -65,6 +65,21 @@ void __iomem *__nfit_test_ioremap(resource_size_t offset, unsigned long size,
|
|||
return fallback_fn(offset, size);
|
||||
}
|
||||
|
||||
void __iomem *__wrap_devm_ioremap_nocache(struct device *dev,
|
||||
resource_size_t offset, unsigned long size)
|
||||
{
|
||||
struct nfit_test_resource *nfit_res;
|
||||
|
||||
rcu_read_lock();
|
||||
nfit_res = get_nfit_res(offset);
|
||||
rcu_read_unlock();
|
||||
if (nfit_res)
|
||||
return (void __iomem *) nfit_res->buf + offset
|
||||
- nfit_res->res->start;
|
||||
return devm_ioremap_nocache(dev, offset, size);
|
||||
}
|
||||
EXPORT_SYMBOL(__wrap_devm_ioremap_nocache);
|
||||
|
||||
void __iomem *__wrap_ioremap_cache(resource_size_t offset, unsigned long size)
|
||||
{
|
||||
return __nfit_test_ioremap(offset, size, ioremap_cache);
|
||||
|
|
@ -77,6 +92,18 @@ void __iomem *__wrap_ioremap_nocache(resource_size_t offset, unsigned long size)
|
|||
}
|
||||
EXPORT_SYMBOL(__wrap_ioremap_nocache);
|
||||
|
||||
void __iomem *__wrap_ioremap_wt(resource_size_t offset, unsigned long size)
|
||||
{
|
||||
return __nfit_test_ioremap(offset, size, ioremap_wt);
|
||||
}
|
||||
EXPORT_SYMBOL(__wrap_ioremap_wt);
|
||||
|
||||
void __iomem *__wrap_ioremap_wc(resource_size_t offset, unsigned long size)
|
||||
{
|
||||
return __nfit_test_ioremap(offset, size, ioremap_wc);
|
||||
}
|
||||
EXPORT_SYMBOL(__wrap_ioremap_wc);
|
||||
|
||||
void __wrap_iounmap(volatile void __iomem *addr)
|
||||
{
|
||||
struct nfit_test_resource *nfit_res;
|
||||
|
|
|
|||
|
|
@ -128,6 +128,8 @@ struct nfit_test {
|
|||
int num_pm;
|
||||
void **dimm;
|
||||
dma_addr_t *dimm_dma;
|
||||
void **flush;
|
||||
dma_addr_t *flush_dma;
|
||||
void **label;
|
||||
dma_addr_t *label_dma;
|
||||
void **spa_set;
|
||||
|
|
@ -155,7 +157,7 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
|
|||
int i, rc;
|
||||
|
||||
if (!nfit_mem || !test_bit(cmd, &nfit_mem->dsm_mask))
|
||||
return -ENXIO;
|
||||
return -ENOTTY;
|
||||
|
||||
/* lookup label space for the given dimm */
|
||||
for (i = 0; i < ARRAY_SIZE(handle); i++)
|
||||
|
|
@ -331,7 +333,8 @@ static int nfit_test0_alloc(struct nfit_test *t)
|
|||
+ sizeof(struct acpi_nfit_system_address) * NUM_SPA
|
||||
+ sizeof(struct acpi_nfit_memory_map) * NUM_MEM
|
||||
+ sizeof(struct acpi_nfit_control_region) * NUM_DCR
|
||||
+ sizeof(struct acpi_nfit_data_region) * NUM_BDW;
|
||||
+ sizeof(struct acpi_nfit_data_region) * NUM_BDW
|
||||
+ sizeof(struct acpi_nfit_flush_address) * NUM_DCR;
|
||||
int i;
|
||||
|
||||
t->nfit_buf = test_alloc(t, nfit_size, &t->nfit_dma);
|
||||
|
|
@ -356,6 +359,10 @@ static int nfit_test0_alloc(struct nfit_test *t)
|
|||
if (!t->label[i])
|
||||
return -ENOMEM;
|
||||
sprintf(t->label[i], "label%d", i);
|
||||
|
||||
t->flush[i] = test_alloc(t, 8, &t->flush_dma[i]);
|
||||
if (!t->flush[i])
|
||||
return -ENOMEM;
|
||||
}
|
||||
|
||||
for (i = 0; i < NUM_DCR; i++) {
|
||||
|
|
@ -408,6 +415,7 @@ static void nfit_test0_setup(struct nfit_test *t)
|
|||
struct acpi_nfit_system_address *spa;
|
||||
struct acpi_nfit_control_region *dcr;
|
||||
struct acpi_nfit_data_region *bdw;
|
||||
struct acpi_nfit_flush_address *flush;
|
||||
unsigned int offset;
|
||||
|
||||
nfit_test_init_header(nfit_buf, size);
|
||||
|
|
@ -831,6 +839,39 @@ static void nfit_test0_setup(struct nfit_test *t)
|
|||
bdw->capacity = DIMM_SIZE;
|
||||
bdw->start_address = 0;
|
||||
|
||||
offset = offset + sizeof(struct acpi_nfit_data_region) * 4;
|
||||
/* flush0 (dimm0) */
|
||||
flush = nfit_buf + offset;
|
||||
flush->header.type = ACPI_NFIT_TYPE_FLUSH_ADDRESS;
|
||||
flush->header.length = sizeof(struct acpi_nfit_flush_address);
|
||||
flush->device_handle = handle[0];
|
||||
flush->hint_count = 1;
|
||||
flush->hint_address[0] = t->flush_dma[0];
|
||||
|
||||
/* flush1 (dimm1) */
|
||||
flush = nfit_buf + offset + sizeof(struct acpi_nfit_flush_address) * 1;
|
||||
flush->header.type = ACPI_NFIT_TYPE_FLUSH_ADDRESS;
|
||||
flush->header.length = sizeof(struct acpi_nfit_flush_address);
|
||||
flush->device_handle = handle[1];
|
||||
flush->hint_count = 1;
|
||||
flush->hint_address[0] = t->flush_dma[1];
|
||||
|
||||
/* flush2 (dimm2) */
|
||||
flush = nfit_buf + offset + sizeof(struct acpi_nfit_flush_address) * 2;
|
||||
flush->header.type = ACPI_NFIT_TYPE_FLUSH_ADDRESS;
|
||||
flush->header.length = sizeof(struct acpi_nfit_flush_address);
|
||||
flush->device_handle = handle[2];
|
||||
flush->hint_count = 1;
|
||||
flush->hint_address[0] = t->flush_dma[2];
|
||||
|
||||
/* flush3 (dimm3) */
|
||||
flush = nfit_buf + offset + sizeof(struct acpi_nfit_flush_address) * 3;
|
||||
flush->header.type = ACPI_NFIT_TYPE_FLUSH_ADDRESS;
|
||||
flush->header.length = sizeof(struct acpi_nfit_flush_address);
|
||||
flush->device_handle = handle[3];
|
||||
flush->hint_count = 1;
|
||||
flush->hint_address[0] = t->flush_dma[3];
|
||||
|
||||
acpi_desc = &t->acpi_desc;
|
||||
set_bit(ND_CMD_GET_CONFIG_SIZE, &acpi_desc->dimm_dsm_force_en);
|
||||
set_bit(ND_CMD_GET_CONFIG_DATA, &acpi_desc->dimm_dsm_force_en);
|
||||
|
|
@ -933,6 +974,10 @@ static int nfit_test_probe(struct platform_device *pdev)
|
|||
GFP_KERNEL);
|
||||
nfit_test->dimm_dma = devm_kcalloc(dev, num, sizeof(dma_addr_t),
|
||||
GFP_KERNEL);
|
||||
nfit_test->flush = devm_kcalloc(dev, num, sizeof(void *),
|
||||
GFP_KERNEL);
|
||||
nfit_test->flush_dma = devm_kcalloc(dev, num, sizeof(dma_addr_t),
|
||||
GFP_KERNEL);
|
||||
nfit_test->label = devm_kcalloc(dev, num, sizeof(void *),
|
||||
GFP_KERNEL);
|
||||
nfit_test->label_dma = devm_kcalloc(dev, num,
|
||||
|
|
@ -943,7 +988,8 @@ static int nfit_test_probe(struct platform_device *pdev)
|
|||
sizeof(dma_addr_t), GFP_KERNEL);
|
||||
if (nfit_test->dimm && nfit_test->dimm_dma && nfit_test->label
|
||||
&& nfit_test->label_dma && nfit_test->dcr
|
||||
&& nfit_test->dcr_dma)
|
||||
&& nfit_test->dcr_dma && nfit_test->flush
|
||||
&& nfit_test->flush_dma)
|
||||
/* pass */;
|
||||
else
|
||||
return -ENOMEM;
|
||||
|
|
|
|||
Loading…
Reference in New Issue