Commit 4d88a97a authored by Dan Williams's avatar Dan Williams
Browse files

libnvdimm, nvdimm: dimm driver and base libnvdimm device-driver infrastructure 



* Implement the device-model infrastructure for loading modules and
  attaching drivers to nvdimm devices.  This is a simple association of a
  nd-device-type number with a driver that has a bitmask of supported
  device types.  To facilitate userspace bind/unbind operations 'modalias'
  and 'devtype', that also appear in the uevent, are added as generic
  sysfs attributes for all nvdimm devices.  The reason for the device-type
  number is to support sub-types within a given parent devtype, be it a
  vendor-specific sub-type or otherwise.

* The first consumer of this infrastructure is the driver
  for dimm devices.  It simply uses control messages to retrieve and
  store the configuration-data image (label set) from each dimm.

Note: nd_device_register() arranges for asynchronous registration of
      nvdimm bus devices by default.

Cc: Greg KH <gregkh@linuxfoundation.org>
Cc: Neil Brown <neilb@suse.de>
Acked-by: default avatarChristoph Hellwig <hch@lst.de>
Tested-by: default avatarToshi Kani <toshi.kani@hp.com>
Signed-off-by: default avatarDan Williams <dan.j.williams@intel.com>
parent 62232e45

drivers/acpi/nfit.c

+10 −3
Original line number Diff line number Diff line
@@ -18,6 +18,10 @@ 
#include <linux/acpi.h>

#include "nfit.h"



static bool force_enable_dimms;

module_param(force_enable_dimms, bool, S_IRUGO|S_IWUSR);

MODULE_PARM_DESC(force_enable_dimms, "Ignore _STA (ACPI DIMM device) status");



static u8 nfit_uuid[NFIT_UUID_MAX][16];



static const u8 *to_nfit_uuid(enum nfit_uuids id)
@@ -633,6 +637,7 @@ static struct attribute_group acpi_nfit_dimm_attribute_group = { 


static const struct attribute_group *acpi_nfit_dimm_attribute_groups[] = {

	&nvdimm_attribute_group,

	&nd_device_attribute_group,

	&acpi_nfit_dimm_attribute_group,

	NULL,

};
@@ -669,7 +674,7 @@ static int acpi_nfit_add_dimm(struct acpi_nfit_desc *acpi_desc, 
	if (!adev_dimm) {

		dev_err(dev, "no ACPI.NFIT device with _ADR %#x, disabling...\n",

				device_handle);

		return -ENODEV;

		return force_enable_dimms ? 0 : -ENODEV;

	}



	status = acpi_evaluate_integer(adev_dimm->handle, "_STA", NULL, &sta);
@@ -690,12 +695,13 @@ static int acpi_nfit_add_dimm(struct acpi_nfit_desc *acpi_desc, 
		if (acpi_check_dsm(adev_dimm->handle, uuid, 1, 1ULL << i))

			set_bit(i, &nfit_mem->dsm_mask);



	return rc;

	return force_enable_dimms ? 0 : rc;

}



static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc)

{

	struct nfit_mem *nfit_mem;

	int dimm_count = 0;



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

		struct nvdimm *nvdimm;
@@ -729,9 +735,10 @@ static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc) 
			return -ENOMEM;



		nfit_mem->nvdimm = nvdimm;

		dimm_count++;

	}



	return 0;

	return nvdimm_bus_check_dimm_count(acpi_desc->nvdimm_bus, dimm_count);

}



static void acpi_nfit_init_dsms(struct acpi_nfit_desc *acpi_desc)

drivers/nvdimm/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -3,3 +3,4 @@ obj-$(CONFIG_LIBNVDIMM) += libnvdimm.o 
libnvdimm-y := core.o

libnvdimm-y += bus.o

libnvdimm-y += dimm_devs.o

libnvdimm-y += dimm.o

drivers/nvdimm/bus.c

+166 −2
Original line number Diff line number Diff line
@@ -16,19 +16,183 @@ 
#include <linux/fcntl.h>

#include <linux/async.h>

#include <linux/ndctl.h>

#include <linux/sched.h>

#include <linux/slab.h>

#include <linux/fs.h>

#include <linux/io.h>

#include <linux/mm.h>

#include <linux/nd.h>

#include "nd-core.h"

#include "nd.h"



int nvdimm_major;

static int nvdimm_bus_major;

static struct class *nd_class;



struct bus_type nvdimm_bus_type = {

static int to_nd_device_type(struct device *dev)

{

	if (is_nvdimm(dev))

		return ND_DEVICE_DIMM;



	return 0;

}



static int nvdimm_bus_uevent(struct device *dev, struct kobj_uevent_env *env)

{

	return add_uevent_var(env, "MODALIAS=" ND_DEVICE_MODALIAS_FMT,

			to_nd_device_type(dev));

}



static int nvdimm_bus_match(struct device *dev, struct device_driver *drv)

{

	struct nd_device_driver *nd_drv = to_nd_device_driver(drv);



	return test_bit(to_nd_device_type(dev), &nd_drv->type);

}



static int nvdimm_bus_probe(struct device *dev)

{

	struct nd_device_driver *nd_drv = to_nd_device_driver(dev->driver);

	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);

	int rc;



	rc = nd_drv->probe(dev);

	dev_dbg(&nvdimm_bus->dev, "%s.probe(%s) = %d\n", dev->driver->name,

			dev_name(dev), rc);

	return rc;

}



static int nvdimm_bus_remove(struct device *dev)

{

	struct nd_device_driver *nd_drv = to_nd_device_driver(dev->driver);

	struct nvdimm_bus *nvdimm_bus = walk_to_nvdimm_bus(dev);

	int rc;



	rc = nd_drv->remove(dev);

	dev_dbg(&nvdimm_bus->dev, "%s.remove(%s) = %d\n", dev->driver->name,

			dev_name(dev), rc);

	return rc;

}



static struct bus_type nvdimm_bus_type = {

	.name = "nd",

	.uevent = nvdimm_bus_uevent,

	.match = nvdimm_bus_match,

	.probe = nvdimm_bus_probe,

	.remove = nvdimm_bus_remove,

};



static ASYNC_DOMAIN_EXCLUSIVE(nd_async_domain);



void nd_synchronize(void)

{

	async_synchronize_full_domain(&nd_async_domain);

}

EXPORT_SYMBOL_GPL(nd_synchronize);



static void nd_async_device_register(void *d, async_cookie_t cookie)

{

	struct device *dev = d;



	if (device_add(dev) != 0) {

		dev_err(dev, "%s: failed\n", __func__);

		put_device(dev);

	}

	put_device(dev);

}



static void nd_async_device_unregister(void *d, async_cookie_t cookie)

{

	struct device *dev = d;



	device_unregister(dev);

	put_device(dev);

}



void nd_device_register(struct device *dev)

{

	dev->bus = &nvdimm_bus_type;

	device_initialize(dev);

	get_device(dev);

	async_schedule_domain(nd_async_device_register, dev,

			&nd_async_domain);

}

EXPORT_SYMBOL(nd_device_register);



void nd_device_unregister(struct device *dev, enum nd_async_mode mode)

{

	switch (mode) {

	case ND_ASYNC:

		get_device(dev);

		async_schedule_domain(nd_async_device_unregister, dev,

				&nd_async_domain);

		break;

	case ND_SYNC:

		nd_synchronize();

		device_unregister(dev);

		break;

	}

}

EXPORT_SYMBOL(nd_device_unregister);



/**

 * __nd_driver_register() - register a region or a namespace driver

 * @nd_drv: driver to register

 * @owner: automatically set by nd_driver_register() macro

 * @mod_name: automatically set by nd_driver_register() macro

 */

int __nd_driver_register(struct nd_device_driver *nd_drv, struct module *owner,

		const char *mod_name)

{

	struct device_driver *drv = &nd_drv->drv;



	if (!nd_drv->type) {

		pr_debug("driver type bitmask not set (%pf)\n",

				__builtin_return_address(0));

		return -EINVAL;

	}



	if (!nd_drv->probe || !nd_drv->remove) {

		pr_debug("->probe() and ->remove() must be specified\n");

		return -EINVAL;

	}



	drv->bus = &nvdimm_bus_type;

	drv->owner = owner;

	drv->mod_name = mod_name;



	return driver_register(drv);

}

EXPORT_SYMBOL(__nd_driver_register);



static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,

		char *buf)

{

	return sprintf(buf, ND_DEVICE_MODALIAS_FMT "\n",

			to_nd_device_type(dev));

}

static DEVICE_ATTR_RO(modalias);



static ssize_t devtype_show(struct device *dev, struct device_attribute *attr,

		char *buf)

{

	return sprintf(buf, "%s\n", dev->type->name);

}

static DEVICE_ATTR_RO(devtype);



static struct attribute *nd_device_attributes[] = {

	&dev_attr_modalias.attr,

	&dev_attr_devtype.attr,

	NULL,

};



/**

 * nd_device_attribute_group - generic attributes for all devices on an nd bus

 */

struct attribute_group nd_device_attribute_group = {

	.attrs = nd_device_attributes,

};

EXPORT_SYMBOL_GPL(nd_device_attribute_group);



int nvdimm_bus_create_ndctl(struct nvdimm_bus *nvdimm_bus)

{
@@ -404,7 +568,7 @@ int __init nvdimm_bus_init(void) 
	return rc;

}



void __exit nvdimm_bus_exit(void)

void nvdimm_bus_exit(void)

{

	class_destroy(nd_class);

	unregister_chrdev(nvdimm_bus_major, "ndctl");

drivers/nvdimm/core.c

+41 −2
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#include <linux/mutex.h>

#include <linux/slab.h>

#include "nd-core.h"

#include "nd.h"



LIST_HEAD(nvdimm_bus_list);

DEFINE_MUTEX(nvdimm_bus_list_mutex);
@@ -98,8 +99,33 @@ static ssize_t provider_show(struct device *dev, 
}

static DEVICE_ATTR_RO(provider);



static int flush_namespaces(struct device *dev, void *data)

{

	device_lock(dev);

	device_unlock(dev);

	return 0;

}



static int flush_regions_dimms(struct device *dev, void *data)

{

	device_lock(dev);

	device_unlock(dev);

	device_for_each_child(dev, NULL, flush_namespaces);

	return 0;

}



static ssize_t wait_probe_show(struct device *dev,

		struct device_attribute *attr, char *buf)

{

	nd_synchronize();

	device_for_each_child(dev, NULL, flush_regions_dimms);

	return sprintf(buf, "1\n");

}

static DEVICE_ATTR_RO(wait_probe);



static struct attribute *nvdimm_bus_attributes[] = {

	&dev_attr_commands.attr,

	&dev_attr_wait_probe.attr,

	&dev_attr_provider.attr,

	NULL,

};
@@ -161,7 +187,7 @@ static int child_unregister(struct device *dev, void *data) 
	if (dev->class)

		/* pass */;

	else

		device_unregister(dev);

		nd_device_unregister(dev, ND_SYNC);

	return 0;

}
@@ -174,6 +200,7 @@ void nvdimm_bus_unregister(struct nvdimm_bus *nvdimm_bus) 
	list_del_init(&nvdimm_bus->list);

	mutex_unlock(&nvdimm_bus_list_mutex);



	nd_synchronize();

	device_for_each_child(&nvdimm_bus->dev, NULL, child_unregister);

	nvdimm_bus_destroy_ndctl(nvdimm_bus);
@@ -183,12 +210,24 @@ EXPORT_SYMBOL_GPL(nvdimm_bus_unregister); 


static __init int libnvdimm_init(void)

{

	return nvdimm_bus_init();

	int rc;



	rc = nvdimm_bus_init();

	if (rc)

		return rc;

	rc = nvdimm_init();

	if (rc)

		goto err_dimm;

	return 0;

 err_dimm:

	nvdimm_bus_exit();

	return rc;

}



static __exit void libnvdimm_exit(void)

{

	WARN_ON(!list_empty(&nvdimm_bus_list));

	nvdimm_exit();

	nvdimm_bus_exit();

}

drivers/nvdimm/dimm.c

0 → 100644
+92 −0
Original line number Diff line number Diff line 
/*

 * 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.

 */

#include <linux/vmalloc.h>

#include <linux/module.h>

#include <linux/device.h>

#include <linux/sizes.h>

#include <linux/ndctl.h>

#include <linux/slab.h>

#include <linux/mm.h>

#include <linux/nd.h>

#include "nd.h"



static void free_data(struct nvdimm_drvdata *ndd)

{

	if (!ndd)

		return;



	if (ndd->data && is_vmalloc_addr(ndd->data))

		vfree(ndd->data);

	else

		kfree(ndd->data);

	kfree(ndd);

}



static int nvdimm_probe(struct device *dev)

{

	struct nvdimm_drvdata *ndd;

	int rc;



	ndd = kzalloc(sizeof(*ndd), GFP_KERNEL);

	if (!ndd)

		return -ENOMEM;



	dev_set_drvdata(dev, ndd);

	ndd->dev = dev;



	rc = nvdimm_init_nsarea(ndd);

	if (rc)

		goto err;



	rc = nvdimm_init_config_data(ndd);

	if (rc)

		goto err;



	dev_dbg(dev, "config data size: %d\n", ndd->nsarea.config_size);



	return 0;



 err:

	free_data(ndd);

	return rc;

}



static int nvdimm_remove(struct device *dev)

{

	struct nvdimm_drvdata *ndd = dev_get_drvdata(dev);



	free_data(ndd);



	return 0;

}



static struct nd_device_driver nvdimm_driver = {

	.probe = nvdimm_probe,

	.remove = nvdimm_remove,

	.drv = {

		.name = "nvdimm",

	},

	.type = ND_DRIVER_DIMM,

};



int __init nvdimm_init(void)

{

	return nd_driver_register(&nvdimm_driver);

}



void __exit nvdimm_exit(void)

{

	driver_unregister(&nvdimm_driver.drv);

}



MODULE_ALIAS_ND_DEVICE(ND_DEVICE_DIMM);

CRA Git | Maintained and supported by SUSTech CRA and CCSE