Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 1f40c495 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

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

Pull libnvdimm updates from Dan Williams:
 "The bulk of this update was stabilized before the merge window and
  appeared in -next.  The "device dax" implementation was revised this
  week in response to review feedback, and to address failures detected
  by the recently expanded ndctl unit test suite.

  Not included in this pull request are two dax topic branches (dax
  error handling, and dax radix-tree locking).  These topics were
  deferred to get a few more days of -next integration testing, and to
  coordinate a branch baseline with Ted and the ext4 tree.  Vishal and
  Ross will send the error handling and locking topics respectively in
  the next few days.

  This branch has received a positive build result from the kbuild robot
  across 226 configs.

  Summary:

   - Device DAX for persistent memory: Device DAX is the device-centric
     analogue of Filesystem DAX (CONFIG_FS_DAX).  It allows memory
     ranges to be allocated and mapped without need of an intervening
     file system.  Device DAX is strict, precise and predictable.
     Specifically this interface:

      a) Guarantees fault granularity with respect to a given page size
         (pte, pmd, or pud) set at configuration time.

      b) Enforces deterministic behavior by being strict about what
         fault scenarios are supported.

     Persistent memory is the first target, but the mechanism is also
     targeted for exclusive allocations of performance/feature
     differentiated memory ranges.

   - Support for the HPE DSM (device specific method) command formats.
     This enables management of these first generation devices until a
     unified DSM specification materializes.

   - Further ACPI 6.1 compliance with support for the common dimm
     identifier format.

   - Various fixes and cleanups across the subsystem"

* tag 'libnvdimm-for-4.7' of git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm: (40 commits)
  libnvdimm, dax: fix deletion
  libnvdimm, dax: fix alignment validation
  libnvdimm, dax: autodetect support
  libnvdimm: release ida resources
  Revert "block: enable dax for raw block devices"
  /dev/dax, core: file operations and dax-mmap
  /dev/dax, pmem: direct access to persistent memory
  libnvdimm: stop requiring a driver ->remove() method
  libnvdimm, dax: record the specified alignment of a dax-device instance
  libnvdimm, dax: reserve space to store labels for device-dax
  libnvdimm, dax: introduce device-dax infrastructure
  nfit: add sysfs dimm 'family' and 'dsm_mask' attributes
  tools/testing/nvdimm: ND_CMD_CALL support
  nfit: disable vendor specific commands
  nfit: export subsystem ids as attributes
  nfit: fix format interface code byte order per ACPI6.1
  nfit, libnvdimm: limited/whitelisted dimm command marshaling mechanism
  nfit, libnvdimm: clarify "commands" vs "_DSMs"
  libnvdimm: increase max envelope size for ioctl
  acpi/nfit: Add sysfs "id" for NVDIMM ID
  ...
parents 7639dad9 36092ee8

block/ioctl.c

+0 −32
Original line number Diff line number Diff line
@@ -407,35 +407,6 @@ static inline int is_unrecognized_ioctl(int ret) 
		ret == -ENOIOCTLCMD;

}



#ifdef CONFIG_FS_DAX

bool blkdev_dax_capable(struct block_device *bdev)

{

	struct gendisk *disk = bdev->bd_disk;



	if (!disk->fops->direct_access)

		return false;



	/*

	 * If the partition is not aligned on a page boundary, we can't

	 * do dax I/O to it.

	 */

	if ((bdev->bd_part->start_sect % (PAGE_SIZE / 512))

			|| (bdev->bd_part->nr_sects % (PAGE_SIZE / 512)))

		return false;



	/*

	 * If the device has known bad blocks, force all I/O through the

	 * driver / page cache.

	 *

	 * TODO: support finer grained dax error handling

	 */

	if (disk->bb && disk->bb->count)

		return false;



	return true;

}

#endif



static int blkdev_flushbuf(struct block_device *bdev, fmode_t mode,

		unsigned cmd, unsigned long arg)

{
@@ -598,9 +569,6 @@ int blkdev_ioctl(struct block_device *bdev, fmode_t mode, unsigned cmd, 
	case BLKTRACESETUP:

	case BLKTRACETEARDOWN:

		return blk_trace_ioctl(bdev, cmd, argp);

	case BLKDAXGET:

		return put_int(arg, !!(bdev->bd_inode->i_flags & S_DAX));

		break;

	case IOC_PR_REGISTER:

		return blkdev_pr_register(bdev, argp);

	case IOC_PR_RESERVE:

drivers/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -192,6 +192,8 @@ source "drivers/android/Kconfig" 


source "drivers/nvdimm/Kconfig"



source "drivers/dax/Kconfig"



source "drivers/nvmem/Kconfig"



source "drivers/hwtracing/stm/Kconfig"

drivers/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -66,6 +66,7 @@ obj-$(CONFIG_PARPORT) += parport/ 
obj-$(CONFIG_NVM)		+= lightnvm/

obj-y				+= base/ block/ misc/ mfd/ nfc/

obj-$(CONFIG_LIBNVDIMM)		+= nvdimm/

obj-$(CONFIG_DEV_DAX)		+= dax/

obj-$(CONFIG_DMA_SHARED_BUFFER) += dma-buf/

obj-$(CONFIG_NUBUS)		+= nubus/

obj-y				+= macintosh/

drivers/acpi/nfit.c

+254 −28
Original line number Diff line number Diff line
@@ -45,6 +45,11 @@ module_param(scrub_overflow_abort, uint, S_IRUGO|S_IWUSR); 
MODULE_PARM_DESC(scrub_overflow_abort,

		"Number of times we overflow ARS results before abort");



static bool disable_vendor_specific;

module_param(disable_vendor_specific, bool, S_IRUGO);

MODULE_PARM_DESC(disable_vendor_specific,

		"Limit commands to the publicly specified set\n");



static struct workqueue_struct *nfit_wq;



struct nfit_table_prev {
@@ -171,33 +176,46 @@ static int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, 
		unsigned int buf_len, int *cmd_rc)

{

	struct acpi_nfit_desc *acpi_desc = to_acpi_nfit_desc(nd_desc);

	const struct nd_cmd_desc *desc = NULL;

	union acpi_object in_obj, in_buf, *out_obj;

	const struct nd_cmd_desc *desc = NULL;

	struct device *dev = acpi_desc->dev;

	struct nd_cmd_pkg *call_pkg = NULL;

	const char *cmd_name, *dimm_name;

	unsigned long dsm_mask;

	unsigned long cmd_mask, dsm_mask;

	acpi_handle handle;

	unsigned int func;

	const u8 *uuid;

	u32 offset;

	int rc, i;



	func = cmd;

	if (cmd == ND_CMD_CALL) {

		call_pkg = buf;

		func = call_pkg->nd_command;

	}



	if (nvdimm) {

		struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);

		struct acpi_device *adev = nfit_mem->adev;



		if (!adev)

			return -ENOTTY;

		if (call_pkg && nfit_mem->family != call_pkg->nd_family)

			return -ENOTTY;



		dimm_name = nvdimm_name(nvdimm);

		cmd_name = nvdimm_cmd_name(cmd);

		cmd_mask = nvdimm_cmd_mask(nvdimm);

		dsm_mask = nfit_mem->dsm_mask;

		desc = nd_cmd_dimm_desc(cmd);

		uuid = to_nfit_uuid(NFIT_DEV_DIMM);

		uuid = to_nfit_uuid(nfit_mem->family);

		handle = adev->handle;

	} else {

		struct acpi_device *adev = to_acpi_dev(acpi_desc);



		cmd_name = nvdimm_bus_cmd_name(cmd);

		dsm_mask = nd_desc->dsm_mask;

		cmd_mask = nd_desc->cmd_mask;

		dsm_mask = cmd_mask;

		desc = nd_cmd_bus_desc(cmd);

		uuid = to_nfit_uuid(NFIT_DEV_BUS);

		handle = adev->handle;
@@ -207,7 +225,7 @@ static int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, 
	if (!desc || (cmd && (desc->out_num + desc->in_num == 0)))

		return -ENOTTY;



	if (!test_bit(cmd, &dsm_mask))

	if (!test_bit(cmd, &cmd_mask) || !test_bit(func, &dsm_mask))

		return -ENOTTY;



	in_obj.type = ACPI_TYPE_PACKAGE;
@@ -222,21 +240,44 @@ static int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, 
		in_buf.buffer.length += nd_cmd_in_size(nvdimm, cmd, desc,

				i, buf);



	if (call_pkg) {

		/* skip over package wrapper */

		in_buf.buffer.pointer = (void *) &call_pkg->nd_payload;

		in_buf.buffer.length = call_pkg->nd_size_in;

	}



	if (IS_ENABLED(CONFIG_ACPI_NFIT_DEBUG)) {

		dev_dbg(dev, "%s:%s cmd: %s input length: %d\n", __func__,

				dimm_name, cmd_name, in_buf.buffer.length);

		print_hex_dump_debug(cmd_name, DUMP_PREFIX_OFFSET, 4,

				4, in_buf.buffer.pointer, min_t(u32, 128,

					in_buf.buffer.length), true);

		dev_dbg(dev, "%s:%s cmd: %d: func: %d input length: %d\n",

				__func__, dimm_name, cmd, func,

				in_buf.buffer.length);

		print_hex_dump_debug("nvdimm in  ", DUMP_PREFIX_OFFSET, 4, 4,

			in_buf.buffer.pointer,

			min_t(u32, 256, in_buf.buffer.length), true);

	}



	out_obj = acpi_evaluate_dsm(handle, uuid, 1, cmd, &in_obj);

	out_obj = acpi_evaluate_dsm(handle, uuid, 1, func, &in_obj);

	if (!out_obj) {

		dev_dbg(dev, "%s:%s _DSM failed cmd: %s\n", __func__, dimm_name,

				cmd_name);

		return -EINVAL;

	}



	if (call_pkg) {

		call_pkg->nd_fw_size = out_obj->buffer.length;

		memcpy(call_pkg->nd_payload + call_pkg->nd_size_in,

			out_obj->buffer.pointer,

			min(call_pkg->nd_fw_size, call_pkg->nd_size_out));



		ACPI_FREE(out_obj);

		/*

		 * Need to support FW function w/o known size in advance.

		 * Caller can determine required size based upon nd_fw_size.

		 * If we return an error (like elsewhere) then caller wouldn't

		 * be able to rely upon data returned to make calculation.

		 */

		return 0;

	}



	if (out_obj->package.type != ACPI_TYPE_BUFFER) {

		dev_dbg(dev, "%s:%s unexpected output object type cmd: %s type: %d\n",

				__func__, dimm_name, cmd_name, out_obj->type);
@@ -658,6 +699,7 @@ static int nfit_mem_dcr_init(struct acpi_nfit_desc *acpi_desc, 
			if (!nfit_mem)

				return -ENOMEM;

			INIT_LIST_HEAD(&nfit_mem->list);

			nfit_mem->acpi_desc = acpi_desc;

			list_add(&nfit_mem->list, &acpi_desc->dimms);

		}
@@ -819,7 +861,7 @@ static ssize_t vendor_show(struct device *dev, 
{

	struct acpi_nfit_control_region *dcr = to_nfit_dcr(dev);



	return sprintf(buf, "%#x\n", dcr->vendor_id);

	return sprintf(buf, "0x%04x\n", be16_to_cpu(dcr->vendor_id));

}

static DEVICE_ATTR_RO(vendor);
@@ -828,7 +870,7 @@ static ssize_t rev_id_show(struct device *dev, 
{

	struct acpi_nfit_control_region *dcr = to_nfit_dcr(dev);



	return sprintf(buf, "%#x\n", dcr->revision_id);

	return sprintf(buf, "0x%04x\n", be16_to_cpu(dcr->revision_id));

}

static DEVICE_ATTR_RO(rev_id);
@@ -837,28 +879,142 @@ static ssize_t device_show(struct device *dev, 
{

	struct acpi_nfit_control_region *dcr = to_nfit_dcr(dev);



	return sprintf(buf, "%#x\n", dcr->device_id);

	return sprintf(buf, "0x%04x\n", be16_to_cpu(dcr->device_id));

}

static DEVICE_ATTR_RO(device);



static ssize_t subsystem_vendor_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct acpi_nfit_control_region *dcr = to_nfit_dcr(dev);



	return sprintf(buf, "0x%04x\n", be16_to_cpu(dcr->subsystem_vendor_id));

}

static DEVICE_ATTR_RO(subsystem_vendor);



static ssize_t subsystem_rev_id_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct acpi_nfit_control_region *dcr = to_nfit_dcr(dev);



	return sprintf(buf, "0x%04x\n",

			be16_to_cpu(dcr->subsystem_revision_id));

}

static DEVICE_ATTR_RO(subsystem_rev_id);



static ssize_t subsystem_device_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct acpi_nfit_control_region *dcr = to_nfit_dcr(dev);



	return sprintf(buf, "0x%04x\n", be16_to_cpu(dcr->subsystem_device_id));

}

static DEVICE_ATTR_RO(subsystem_device);



static int num_nvdimm_formats(struct nvdimm *nvdimm)

{

	struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);

	int formats = 0;



	if (nfit_mem->memdev_pmem)

		formats++;

	if (nfit_mem->memdev_bdw)

		formats++;

	return formats;

}



static ssize_t format_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct acpi_nfit_control_region *dcr = to_nfit_dcr(dev);



	return sprintf(buf, "%#x\n", dcr->code);

	return sprintf(buf, "0x%04x\n", be16_to_cpu(dcr->code));

}

static DEVICE_ATTR_RO(format);



static ssize_t format1_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	u32 handle;

	ssize_t rc = -ENXIO;

	struct nfit_mem *nfit_mem;

	struct nfit_memdev *nfit_memdev;

	struct acpi_nfit_desc *acpi_desc;

	struct nvdimm *nvdimm = to_nvdimm(dev);

	struct acpi_nfit_control_region *dcr = to_nfit_dcr(dev);



	nfit_mem = nvdimm_provider_data(nvdimm);

	acpi_desc = nfit_mem->acpi_desc;

	handle = to_nfit_memdev(dev)->device_handle;



	/* assumes DIMMs have at most 2 published interface codes */

	mutex_lock(&acpi_desc->init_mutex);

	list_for_each_entry(nfit_memdev, &acpi_desc->memdevs, list) {

		struct acpi_nfit_memory_map *memdev = nfit_memdev->memdev;

		struct nfit_dcr *nfit_dcr;



		if (memdev->device_handle != handle)

			continue;



		list_for_each_entry(nfit_dcr, &acpi_desc->dcrs, list) {

			if (nfit_dcr->dcr->region_index != memdev->region_index)

				continue;

			if (nfit_dcr->dcr->code == dcr->code)

				continue;

			rc = sprintf(buf, "%#x\n",

					be16_to_cpu(nfit_dcr->dcr->code));

			break;

		}

		if (rc != ENXIO)

			break;

	}

	mutex_unlock(&acpi_desc->init_mutex);

	return rc;

}

static DEVICE_ATTR_RO(format1);



static ssize_t formats_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct nvdimm *nvdimm = to_nvdimm(dev);



	return sprintf(buf, "%d\n", num_nvdimm_formats(nvdimm));

}

static DEVICE_ATTR_RO(formats);



static ssize_t serial_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct acpi_nfit_control_region *dcr = to_nfit_dcr(dev);



	return sprintf(buf, "%#x\n", dcr->serial_number);

	return sprintf(buf, "0x%08x\n", be32_to_cpu(dcr->serial_number));

}

static DEVICE_ATTR_RO(serial);



static ssize_t family_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct nvdimm *nvdimm = to_nvdimm(dev);

	struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);



	if (nfit_mem->family < 0)

		return -ENXIO;

	return sprintf(buf, "%d\n", nfit_mem->family);

}

static DEVICE_ATTR_RO(family);



static ssize_t dsm_mask_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct nvdimm *nvdimm = to_nvdimm(dev);

	struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);



	if (nfit_mem->family < 0)

		return -ENXIO;

	return sprintf(buf, "%#lx\n", nfit_mem->dsm_mask);

}

static DEVICE_ATTR_RO(dsm_mask);



static ssize_t flags_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{
@@ -873,15 +1029,41 @@ static ssize_t flags_show(struct device *dev, 
}

static DEVICE_ATTR_RO(flags);



static ssize_t id_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	struct acpi_nfit_control_region *dcr = to_nfit_dcr(dev);



	if (dcr->valid_fields & ACPI_NFIT_CONTROL_MFG_INFO_VALID)

		return sprintf(buf, "%04x-%02x-%04x-%08x\n",

				be16_to_cpu(dcr->vendor_id),

				dcr->manufacturing_location,

				be16_to_cpu(dcr->manufacturing_date),

				be32_to_cpu(dcr->serial_number));

	else

		return sprintf(buf, "%04x-%08x\n",

				be16_to_cpu(dcr->vendor_id),

				be32_to_cpu(dcr->serial_number));

}

static DEVICE_ATTR_RO(id);



static struct attribute *acpi_nfit_dimm_attributes[] = {

	&dev_attr_handle.attr,

	&dev_attr_phys_id.attr,

	&dev_attr_vendor.attr,

	&dev_attr_device.attr,

	&dev_attr_rev_id.attr,

	&dev_attr_subsystem_vendor.attr,

	&dev_attr_subsystem_device.attr,

	&dev_attr_subsystem_rev_id.attr,

	&dev_attr_format.attr,

	&dev_attr_formats.attr,

	&dev_attr_format1.attr,

	&dev_attr_serial.attr,

	&dev_attr_rev_id.attr,

	&dev_attr_flags.attr,

	&dev_attr_id.attr,

	&dev_attr_family.attr,

	&dev_attr_dsm_mask.attr,

	NULL,

};
@@ -889,11 +1071,13 @@ static umode_t acpi_nfit_dimm_attr_visible(struct kobject *kobj, 
		struct attribute *a, int n)

{

	struct device *dev = container_of(kobj, struct device, kobj);

	struct nvdimm *nvdimm = to_nvdimm(dev);



	if (to_nfit_dcr(dev))

		return a->mode;

	else

	if (!to_nfit_dcr(dev))

		return 0;

	if (a == &dev_attr_format1.attr && num_nvdimm_formats(nvdimm) <= 1)

		return 0;

	return a->mode;

}



static struct attribute_group acpi_nfit_dimm_attribute_group = {
@@ -926,10 +1110,13 @@ static int acpi_nfit_add_dimm(struct acpi_nfit_desc *acpi_desc, 
{

	struct acpi_device *adev, *adev_dimm;

	struct device *dev = acpi_desc->dev;

	const u8 *uuid = to_nfit_uuid(NFIT_DEV_DIMM);

	unsigned long dsm_mask;

	const u8 *uuid;

	int i;



	nfit_mem->dsm_mask = acpi_desc->dimm_dsm_force_en;

	/* nfit test assumes 1:1 relationship between commands and dsms */

	nfit_mem->dsm_mask = acpi_desc->dimm_cmd_force_en;

	nfit_mem->family = NVDIMM_FAMILY_INTEL;

	adev = to_acpi_dev(acpi_desc);

	if (!adev)

		return 0;
@@ -942,7 +1129,35 @@ static int acpi_nfit_add_dimm(struct acpi_nfit_desc *acpi_desc, 
		return force_enable_dimms ? 0 : -ENODEV;

	}



	for (i = ND_CMD_SMART; i <= ND_CMD_VENDOR; i++)

	/*

	 * Until standardization materializes we need to consider up to 3

	 * different command sets.  Note, that checking for function0 (bit0)

	 * tells us if any commands are reachable through this uuid.

	 */

	for (i = NVDIMM_FAMILY_INTEL; i <= NVDIMM_FAMILY_HPE2; i++)

		if (acpi_check_dsm(adev_dimm->handle, to_nfit_uuid(i), 1, 1))

			break;



	/* limit the supported commands to those that are publicly documented */

	nfit_mem->family = i;

	if (nfit_mem->family == NVDIMM_FAMILY_INTEL) {

		dsm_mask = 0x3fe;

		if (disable_vendor_specific)

			dsm_mask &= ~(1 << ND_CMD_VENDOR);

	} else if (nfit_mem->family == NVDIMM_FAMILY_HPE1)

		dsm_mask = 0x1c3c76;

	else if (nfit_mem->family == NVDIMM_FAMILY_HPE2) {

		dsm_mask = 0x1fe;

		if (disable_vendor_specific)

			dsm_mask &= ~(1 << 8);

	} else {

		dev_err(dev, "unknown dimm command family\n");

		nfit_mem->family = -1;

		return force_enable_dimms ? 0 : -ENODEV;

	}



	uuid = to_nfit_uuid(nfit_mem->family);

	for_each_set_bit(i, &dsm_mask, BITS_PER_LONG)

		if (acpi_check_dsm(adev_dimm->handle, uuid, 1, 1ULL << i))

			set_bit(i, &nfit_mem->dsm_mask);
@@ -955,8 +1170,8 @@ static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc) 
	int dimm_count = 0;



	list_for_each_entry(nfit_mem, &acpi_desc->dimms, list) {

		unsigned long flags = 0, cmd_mask;

		struct nvdimm *nvdimm;

		unsigned long flags = 0;

		u32 device_handle;

		u16 mem_flags;

		int rc;
@@ -979,9 +1194,18 @@ static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc) 
		if (rc)

			continue;



		/*

		 * TODO: provide translation for non-NVDIMM_FAMILY_INTEL

		 * devices (i.e. from nd_cmd to acpi_dsm) to standardize the

		 * userspace interface.

		 */

		cmd_mask = 1UL << ND_CMD_CALL;

		if (nfit_mem->family == NVDIMM_FAMILY_INTEL)

			cmd_mask |= nfit_mem->dsm_mask;



		nvdimm = nvdimm_create(acpi_desc->nvdimm_bus, nfit_mem,

				acpi_nfit_dimm_attribute_groups,

				flags, &nfit_mem->dsm_mask);

				flags, cmd_mask);

		if (!nvdimm)

			return -ENOMEM;
@@ -1010,14 +1234,14 @@ static void acpi_nfit_init_dsms(struct acpi_nfit_desc *acpi_desc) 
	struct acpi_device *adev;

	int i;



	nd_desc->dsm_mask = acpi_desc->bus_dsm_force_en;

	nd_desc->cmd_mask = acpi_desc->bus_cmd_force_en;

	adev = to_acpi_dev(acpi_desc);

	if (!adev)

		return;



	for (i = ND_CMD_ARS_CAP; i <= ND_CMD_CLEAR_ERROR; i++)

		if (acpi_check_dsm(adev->handle, uuid, 1, 1ULL << i))

			set_bit(i, &nd_desc->dsm_mask);

			set_bit(i, &nd_desc->cmd_mask);

}



static ssize_t range_index_show(struct device *dev,
@@ -2309,7 +2533,7 @@ static int acpi_nfit_add(struct acpi_device *adev) 
	acpi_size sz;

	int rc;



	status = acpi_get_table_with_size("NFIT", 0, &tbl, &sz);

	status = acpi_get_table_with_size(ACPI_SIG_NFIT, 0, &tbl, &sz);

	if (ACPI_FAILURE(status)) {

		/* This is ok, we could have an nvdimm hotplugged later */

		dev_dbg(dev, "failed to find NFIT at startup\n");
@@ -2466,6 +2690,8 @@ static __init int nfit_init(void) 
	acpi_str_to_uuid(UUID_PERSISTENT_VIRTUAL_CD, nfit_uuid[NFIT_SPA_PCD]);

	acpi_str_to_uuid(UUID_NFIT_BUS, nfit_uuid[NFIT_DEV_BUS]);

	acpi_str_to_uuid(UUID_NFIT_DIMM, nfit_uuid[NFIT_DEV_DIMM]);

	acpi_str_to_uuid(UUID_NFIT_DIMM_N_HPE1, nfit_uuid[NFIT_DEV_DIMM_N_HPE1]);

	acpi_str_to_uuid(UUID_NFIT_DIMM_N_HPE2, nfit_uuid[NFIT_DEV_DIMM_N_HPE2]);



	nfit_wq = create_singlethread_workqueue("nfit");

	if (!nfit_wq)

drivers/acpi/nfit.h

+23 −8
Original line number Diff line number Diff line
@@ -21,13 +21,25 @@ 
#include <linux/acpi.h>

#include <acpi/acuuid.h>



/* ACPI 6.1 */

#define UUID_NFIT_BUS "2f10e7a4-9e91-11e4-89d3-123b93f75cba"



/* http://pmem.io/documents/NVDIMM_DSM_Interface_Example.pdf */

#define UUID_NFIT_DIMM "4309ac30-0d11-11e4-9191-0800200c9a66"



/* https://github.com/HewlettPackard/hpe-nvm/blob/master/Documentation/ */

#define UUID_NFIT_DIMM_N_HPE1 "9002c334-acf3-4c0e-9642-a235f0d53bc6"

#define UUID_NFIT_DIMM_N_HPE2 "5008664b-b758-41a0-a03c-27c2f2d04f7e"



#define ACPI_NFIT_MEM_FAILED_MASK (ACPI_NFIT_MEM_SAVE_FAILED \

		| ACPI_NFIT_MEM_RESTORE_FAILED | ACPI_NFIT_MEM_FLUSH_FAILED \

		| ACPI_NFIT_MEM_NOT_ARMED)



enum nfit_uuids {

	/* for simplicity alias the uuid index with the family id */

	NFIT_DEV_DIMM = NVDIMM_FAMILY_INTEL,

	NFIT_DEV_DIMM_N_HPE1 = NVDIMM_FAMILY_HPE1,

	NFIT_DEV_DIMM_N_HPE2 = NVDIMM_FAMILY_HPE2,

	NFIT_SPA_VOLATILE,

	NFIT_SPA_PM,

	NFIT_SPA_DCR,
@@ -37,15 +49,16 @@ enum nfit_uuids { 
	NFIT_SPA_PDISK,

	NFIT_SPA_PCD,

	NFIT_DEV_BUS,

	NFIT_DEV_DIMM,

	NFIT_UUID_MAX,

};



enum nfit_fic {

	NFIT_FIC_BYTE = 0x101, /* byte-addressable energy backed */

	NFIT_FIC_BLK = 0x201, /* block-addressable non-energy backed */

	NFIT_FIC_BYTEN = 0x301, /* byte-addressable non-energy backed */

};

/*

 * Region format interface codes are stored as an array of bytes in the

 * NFIT DIMM Control Region structure

 */

#define NFIT_FIC_BYTE cpu_to_be16(0x101) /* byte-addressable energy backed */

#define NFIT_FIC_BLK cpu_to_be16(0x201) /* block-addressable non-energy backed */

#define NFIT_FIC_BYTEN cpu_to_be16(0x301) /* byte-addressable non-energy backed */



enum {

	NFIT_BLK_READ_FLUSH = 1,
@@ -109,7 +122,9 @@ struct nfit_mem { 
	struct nfit_flush *nfit_flush;

	struct list_head list;

	struct acpi_device *adev;

	struct acpi_nfit_desc *acpi_desc;

	unsigned long dsm_mask;

	int family;

};



struct acpi_nfit_desc {
@@ -132,8 +147,8 @@ struct acpi_nfit_desc { 
	size_t ars_status_size;

	struct work_struct work;

	unsigned int cancel:1;

	unsigned long dimm_dsm_force_en;

	unsigned long bus_dsm_force_en;

	unsigned long dimm_cmd_force_en;

	unsigned long bus_cmd_force_en;

	int (*blk_do_io)(struct nd_blk_region *ndbr, resource_size_t dpa,

			void *iobuf, u64 len, int rw);

};