[linux-block.git] / drivers / char / bsr.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* IBM POWER Barrier Synchronization Register Driver
 *
 * Copyright IBM Corporation 2008
 *
 * Author: Sonny Rao <sonnyrao@us.ibm.com>
 */

#include <linux/kernel.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_device.h>
#include <linux/of_platform.h>
#include <linux/fs.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/list.h>
#include <linux/mm.h>
#include <linux/slab.h>
#include <asm/io.h>

/*
 This driver exposes a special register which can be used for fast
 synchronization across a large SMP machine.  The hardware is exposed
 as an array of bytes where each process will write to one of the bytes to
 indicate it has finished the current stage and this update is broadcast to
 all processors without having to bounce a cacheline between them. In
 POWER5 and POWER6 there is one of these registers per SMP,  but it is
 presented in two forms; first, it is given as a whole and then as a number
 of smaller registers which alias to parts of the single whole register.
 This can potentially allow multiple groups of processes to each have their
 own private synchronization device.

 Note that this hardware *must* be written to using *only* single byte writes.
 It may be read using 1, 2, 4, or 8 byte loads which must be aligned since
 this region is treated as cache-inhibited  processes should also use a
 full sync before and after writing to the BSR to ensure all stores and
 the BSR update have made it to all chips in the system
*/

/* This is arbitrary number, up to Power6 it's been 17 or fewer  */
#define BSR_MAX_DEVS (32)

struct bsr_dev {
	u64      bsr_addr;     /* Real address */
	u64      bsr_len;      /* length of mem region we can map */
	unsigned bsr_bytes;    /* size of the BSR reg itself */
	unsigned bsr_stride;   /* interval at which BSR repeats in the page */
	unsigned bsr_type;     /* maps to enum below */
	unsigned bsr_num;      /* bsr id number for its type */
	int      bsr_minor;

	struct list_head bsr_list;

	dev_t    bsr_dev;
	struct cdev bsr_cdev;
	struct device *bsr_device;
	char     bsr_name[32];

};

static unsigned total_bsr_devs;
static LIST_HEAD(bsr_devs);
static struct class *bsr_class;
static int bsr_major;

enum {
	BSR_8    = 0,
	BSR_16   = 1,
	BSR_64   = 2,
	BSR_128  = 3,
	BSR_4096 = 4,
	BSR_UNKNOWN = 5,
	BSR_MAX  = 6,
};

static unsigned bsr_types[BSR_MAX];

static ssize_t
bsr_size_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
	return sprintf(buf, "%u\n", bsr_dev->bsr_bytes);
}
static DEVICE_ATTR_RO(bsr_size);

static ssize_t
bsr_stride_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
	return sprintf(buf, "%u\n", bsr_dev->bsr_stride);
}
static DEVICE_ATTR_RO(bsr_stride);

static ssize_t
bsr_length_show(struct device *dev, struct device_attribute *attr, char *buf)
{
	struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
	return sprintf(buf, "%llu\n", bsr_dev->bsr_len);
}
static DEVICE_ATTR_RO(bsr_length);

static struct attribute *bsr_dev_attrs[] = {
	&dev_attr_bsr_size.attr,
	&dev_attr_bsr_stride.attr,
	&dev_attr_bsr_length.attr,
	NULL,
};
ATTRIBUTE_GROUPS(bsr_dev);

static int bsr_mmap(struct file *filp, struct vm_area_struct *vma)
{
	unsigned long size   = vma->vm_end - vma->vm_start;
	struct bsr_dev *dev = filp->private_data;
	int ret;

	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

	/* check for the case of a small BSR device and map one 4k page for it*/
	if (dev->bsr_len < PAGE_SIZE && size == PAGE_SIZE)
		ret = remap_4k_pfn(vma, vma->vm_start, dev->bsr_addr >> 12,
				   vma->vm_page_prot);
	else if (size <= dev->bsr_len)
		ret = io_remap_pfn_range(vma, vma->vm_start,
					 dev->bsr_addr >> PAGE_SHIFT,
					 size, vma->vm_page_prot);
	else
		return -EINVAL;

	if (ret)
		return -EAGAIN;

	return 0;
}

static int bsr_open(struct inode *inode, struct file *filp)
{
	struct cdev *cdev = inode->i_cdev;
	struct bsr_dev *dev = container_of(cdev, struct bsr_dev, bsr_cdev);

	filp->private_data = dev;
	return 0;
}

static const struct file_operations bsr_fops = {
	.owner = THIS_MODULE,
	.mmap  = bsr_mmap,
	.open  = bsr_open,
	.llseek = noop_llseek,
};

static void bsr_cleanup_devs(void)
{
	struct bsr_dev *cur, *n;

	list_for_each_entry_safe(cur, n, &bsr_devs, bsr_list) {
		if (cur->bsr_device) {
			cdev_del(&cur->bsr_cdev);
			device_del(cur->bsr_device);
		}
		list_del(&cur->bsr_list);
		kfree(cur);
	}
}

static int bsr_add_node(struct device_node *bn)
{
	int bsr_stride_len, bsr_bytes_len, num_bsr_devs;
	const u32 *bsr_stride;
	const u32 *bsr_bytes;
	unsigned i;
	int ret = -ENODEV;

	bsr_stride = of_get_property(bn, "ibm,lock-stride", &bsr_stride_len);
	bsr_bytes  = of_get_property(bn, "ibm,#lock-bytes", &bsr_bytes_len);

	if (!bsr_stride || !bsr_bytes ||
	    (bsr_stride_len != bsr_bytes_len)) {
		printk(KERN_ERR "bsr of-node has missing/incorrect property\n");
		return ret;
	}

	num_bsr_devs = bsr_bytes_len / sizeof(u32);

	for (i = 0 ; i < num_bsr_devs; i++) {
		struct bsr_dev *cur = kzalloc(sizeof(struct bsr_dev),
					      GFP_KERNEL);
		struct resource res;
		int result;

		if (!cur) {
			printk(KERN_ERR "Unable to alloc bsr dev\n");
			ret = -ENOMEM;
			goto out_err;
		}

		result = of_address_to_resource(bn, i, &res);
		if (result < 0) {
			printk(KERN_ERR "bsr of-node has invalid reg property, skipping\n");
			kfree(cur);
			continue;
		}

		cur->bsr_minor  = i + total_bsr_devs;
		cur->bsr_addr   = res.start;
		cur->bsr_len    = resource_size(&res);
		cur->bsr_bytes  = bsr_bytes[i];
		cur->bsr_stride = bsr_stride[i];
		cur->bsr_dev    = MKDEV(bsr_major, i + total_bsr_devs);

		/* if we have a bsr_len of > 4k and less then PAGE_SIZE (64k pages) */
		/* we can only map 4k of it, so only advertise the 4k in sysfs */
		if (cur->bsr_len > 4096 && cur->bsr_len < PAGE_SIZE)
			cur->bsr_len = 4096;

		switch(cur->bsr_bytes) {
		case 8:
			cur->bsr_type = BSR_8;
			break;
		case 16:
			cur->bsr_type = BSR_16;
			break;
		case 64:
			cur->bsr_type = BSR_64;
			break;
		case 128:
			cur->bsr_type = BSR_128;
			break;
		case 4096:
			cur->bsr_type = BSR_4096;
			break;
		default:
			cur->bsr_type = BSR_UNKNOWN;
		}

		cur->bsr_num = bsr_types[cur->bsr_type];
		snprintf(cur->bsr_name, 32, "bsr%d_%d",
			 cur->bsr_bytes, cur->bsr_num);

		cdev_init(&cur->bsr_cdev, &bsr_fops);
		result = cdev_add(&cur->bsr_cdev, cur->bsr_dev, 1);
		if (result) {
			kfree(cur);
			goto out_err;
		}

		cur->bsr_device = device_create(bsr_class, NULL, cur->bsr_dev,
						cur, "%s", cur->bsr_name);
		if (IS_ERR(cur->bsr_device)) {
			printk(KERN_ERR "device_create failed for %s\n",
			       cur->bsr_name);
			cdev_del(&cur->bsr_cdev);
			kfree(cur);
			goto out_err;
		}

		bsr_types[cur->bsr_type] = cur->bsr_num + 1;
		list_add_tail(&cur->bsr_list, &bsr_devs);
	}

	total_bsr_devs += num_bsr_devs;

	return 0;

 out_err:

	bsr_cleanup_devs();
	return ret;
}

static int bsr_create_devs(struct device_node *bn)
{
	int ret;

	while (bn) {
		ret = bsr_add_node(bn);
		if (ret) {
			of_node_put(bn);
			return ret;
		}
		bn = of_find_compatible_node(bn, NULL, "ibm,bsr");
	}
	return 0;
}

static int __init bsr_init(void)
{
	struct device_node *np;
	dev_t bsr_dev;
	int ret = -ENODEV;

	np = of_find_compatible_node(NULL, NULL, "ibm,bsr");
	if (!np)
		goto out_err;

	bsr_class = class_create(THIS_MODULE, "bsr");
	if (IS_ERR(bsr_class)) {
		printk(KERN_ERR "class_create() failed for bsr_class\n");
		ret = PTR_ERR(bsr_class);
		goto out_err_1;
	}
	bsr_class->dev_groups = bsr_dev_groups;

	ret = alloc_chrdev_region(&bsr_dev, 0, BSR_MAX_DEVS, "bsr");
	bsr_major = MAJOR(bsr_dev);
	if (ret < 0) {
		printk(KERN_ERR "alloc_chrdev_region() failed for bsr\n");
		goto out_err_2;
	}

	ret = bsr_create_devs(np);
	if (ret < 0) {
		np = NULL;
		goto out_err_3;
	}

	return 0;

 out_err_3:
	unregister_chrdev_region(bsr_dev, BSR_MAX_DEVS);

 out_err_2:
	class_destroy(bsr_class);

 out_err_1:
	of_node_put(np);

 out_err:

	return ret;
}

static void __exit  bsr_exit(void)
{

	bsr_cleanup_devs();

	if (bsr_class)
		class_destroy(bsr_class);

	if (bsr_major)
		unregister_chrdev_region(MKDEV(bsr_major, 0), BSR_MAX_DEVS);
}

module_init(bsr_init);
module_exit(bsr_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Sonny Rao <sonnyrao@us.ibm.com>");
Commit	Line	Data
1a59d1b8	1	// SPDX-License-Identifier: GPL-2.0-or-later
fe9e8d53 SR	2	/* IBM POWER Barrier Synchronization Register Driver
	3	*
	4	* Copyright IBM Corporation 2008
	5	*
	6	* Author: Sonny Rao <sonnyrao@us.ibm.com>
fe9e8d53 SR	7	*/
	8
	9	#include <linux/kernel.h>
	10	#include <linux/of.h>
5af50730	11	#include <linux/of_address.h>
fe9e8d53 SR	12	#include <linux/of_device.h>
fe9e8d53 SR	13	#include <linux/of_platform.h>
22ae782f	14	#include <linux/fs.h>
fe9e8d53 SR	15	#include <linux/module.h>
	16	#include <linux/cdev.h>
	17	#include <linux/list.h>
	18	#include <linux/mm.h>
5a0e3ad6	19	#include <linux/slab.h>
fe9e8d53 SR	20	#include <asm/io.h>
	21
	22	/*
	23	This driver exposes a special register which can be used for fast
	24	synchronization across a large SMP machine. The hardware is exposed
	25	as an array of bytes where each process will write to one of the bytes to
	26	indicate it has finished the current stage and this update is broadcast to
	27	all processors without having to bounce a cacheline between them. In
	28	POWER5 and POWER6 there is one of these registers per SMP, but it is
	29	presented in two forms; first, it is given as a whole and then as a number
	30	of smaller registers which alias to parts of the single whole register.
	31	This can potentially allow multiple groups of processes to each have their
	32	own private synchronization device.
	33
	34	Note that this hardware must be written to using only single byte writes.
	35	It may be read using 1, 2, 4, or 8 byte loads which must be aligned since
	36	this region is treated as cache-inhibited processes should also use a
	37	full sync before and after writing to the BSR to ensure all stores and
	38	the BSR update have made it to all chips in the system
	39	*/
	40
	41	/* This is arbitrary number, up to Power6 it's been 17 or fewer */
	42	#define BSR_MAX_DEVS (32)
	43
	44	struct bsr_dev {
	45	u64 bsr_addr; /* Real address */
	46	u64 bsr_len; /* length of mem region we can map */
	47	unsigned bsr_bytes; /* size of the BSR reg itself */
	48	unsigned bsr_stride; /* interval at which BSR repeats in the page */
	49	unsigned bsr_type; /* maps to enum below */
	50	unsigned bsr_num; /* bsr id number for its type */
	51	int bsr_minor;
	52
a0e2f9f4 SR	53	struct list_head bsr_list;
a0e2f9f4 SR	54
fe9e8d53 SR	55	dev_t bsr_dev;
	56	struct cdev bsr_cdev;
	57	struct device *bsr_device;
	58	char bsr_name[32];
	59
	60	};
	61
a0e2f9f4	62	static unsigned total_bsr_devs;
aef3125d	63	static LIST_HEAD(bsr_devs);
fe9e8d53 SR	64	static struct class *bsr_class;
	65	static int bsr_major;
	66
	67	enum {
e4031d52 SR	68	BSR_8 = 0,
	69	BSR_16 = 1,
	70	BSR_64 = 2,
	71	BSR_128 = 3,
	72	BSR_4096 = 4,
	73	BSR_UNKNOWN = 5,
	74	BSR_MAX = 6,
fe9e8d53 SR	75	};
	76
	77	static unsigned bsr_types[BSR_MAX];
	78
	79	static ssize_t
	80	bsr_size_show(struct device dev, struct device_attribute attr, char *buf)
	81	{
	82	struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
	83	return sprintf(buf, "%u\n", bsr_dev->bsr_bytes);
	84	}
62e13505	85	static DEVICE_ATTR_RO(bsr_size);
fe9e8d53 SR	86
	87	static ssize_t
	88	bsr_stride_show(struct device dev, struct device_attribute attr, char *buf)
	89	{
	90	struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
	91	return sprintf(buf, "%u\n", bsr_dev->bsr_stride);
	92	}
62e13505	93	static DEVICE_ATTR_RO(bsr_stride);
fe9e8d53 SR	94
fe9e8d53 SR	95	static ssize_t
62e13505	96	bsr_length_show(struct device dev, struct device_attribute attr, char *buf)
fe9e8d53 SR	97	{
fe9e8d53 SR	98	struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
1901515c	99	return sprintf(buf, "%llu\n", bsr_dev->bsr_len);
fe9e8d53	100	}
62e13505	101	static DEVICE_ATTR_RO(bsr_length);
fe9e8d53	102
62e13505 GKH	103	static struct attribute *bsr_dev_attrs[] = {
	104	&dev_attr_bsr_size.attr,
	105	&dev_attr_bsr_stride.attr,
	106	&dev_attr_bsr_length.attr,
	107	NULL,
fe9e8d53	108	};
62e13505	109	ATTRIBUTE_GROUPS(bsr_dev);
fe9e8d53 SR	110
	111	static int bsr_mmap(struct file filp, struct vm_area_struct vma)
	112	{
	113	unsigned long size = vma->vm_end - vma->vm_start;
	114	struct bsr_dev *dev = filp->private_data;
04a85d12	115	int ret;
fe9e8d53	116
fe9e8d53 SR	117	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
fe9e8d53 SR	118
04a85d12 SR	119	/* check for the case of a small BSR device and map one 4k page for it*/
	120	if (dev->bsr_len < PAGE_SIZE && size == PAGE_SIZE)
	121	ret = remap_4k_pfn(vma, vma->vm_start, dev->bsr_addr >> 12,
	122	vma->vm_page_prot);
	123	else if (size <= dev->bsr_len)
	124	ret = io_remap_pfn_range(vma, vma->vm_start,
	125	dev->bsr_addr >> PAGE_SHIFT,
	126	size, vma->vm_page_prot);
	127	else
	128	return -EINVAL;
	129
	130	if (ret)
fe9e8d53 SR	131	return -EAGAIN;
	132
	133	return 0;
	134	}
	135
687685a3	136	static int bsr_open(struct inode inode, struct file filp)
fe9e8d53 SR	137	{
	138	struct cdev *cdev = inode->i_cdev;
	139	struct bsr_dev *dev = container_of(cdev, struct bsr_dev, bsr_cdev);
	140
	141	filp->private_data = dev;
	142	return 0;
	143	}
	144
27157a70	145	static const struct file_operations bsr_fops = {
fe9e8d53 SR	146	.owner = THIS_MODULE,
	147	.mmap = bsr_mmap,
	148	.open = bsr_open,
6038f373	149	.llseek = noop_llseek,
fe9e8d53 SR	150	};
	151
	152	static void bsr_cleanup_devs(void)
	153	{
a0e2f9f4 SR	154	struct bsr_dev cur, n;
	155
	156	list_for_each_entry_safe(cur, n, &bsr_devs, bsr_list) {
fe9e8d53 SR	157	if (cur->bsr_device) {
	158	cdev_del(&cur->bsr_cdev);
	159	device_del(cur->bsr_device);
	160	}
a0e2f9f4 SR	161	list_del(&cur->bsr_list);
a0e2f9f4 SR	162	kfree(cur);
fe9e8d53	163	}
fe9e8d53 SR	164	}
fe9e8d53 SR	165
a0e2f9f4	166	static int bsr_add_node(struct device_node *bn)
fe9e8d53	167	{
a0e2f9f4	168	int bsr_stride_len, bsr_bytes_len, num_bsr_devs;
fe9e8d53 SR	169	const u32 *bsr_stride;
	170	const u32 *bsr_bytes;
	171	unsigned i;
a0e2f9f4	172	int ret = -ENODEV;
fe9e8d53 SR	173
	174	bsr_stride = of_get_property(bn, "ibm,lock-stride", &bsr_stride_len);
	175	bsr_bytes = of_get_property(bn, "ibm,#lock-bytes", &bsr_bytes_len);
	176
	177	if (!bsr_stride \|\| !bsr_bytes \|\|
	178	(bsr_stride_len != bsr_bytes_len)) {
	179	printk(KERN_ERR "bsr of-node has missing/incorrect property\n");
a0e2f9f4	180	return ret;
fe9e8d53 SR	181	}
	182
	183	num_bsr_devs = bsr_bytes_len / sizeof(u32);
	184
fe9e8d53	185	for (i = 0 ; i < num_bsr_devs; i++) {
a0e2f9f4 SR	186	struct bsr_dev *cur = kzalloc(sizeof(struct bsr_dev),
a0e2f9f4 SR	187	GFP_KERNEL);
fe9e8d53 SR	188	struct resource res;
	189	int result;
	190
a0e2f9f4 SR	191	if (!cur) {
	192	printk(KERN_ERR "Unable to alloc bsr dev\n");
	193	ret = -ENOMEM;
	194	goto out_err;
	195	}
	196
fe9e8d53 SR	197	result = of_address_to_resource(bn, i, &res);
fe9e8d53 SR	198	if (result < 0) {
a0e2f9f4 SR	199	printk(KERN_ERR "bsr of-node has invalid reg property, skipping\n");
	200	kfree(cur);
	201	continue;
fe9e8d53 SR	202	}
fe9e8d53 SR	203
a0e2f9f4	204	cur->bsr_minor = i + total_bsr_devs;
fe9e8d53	205	cur->bsr_addr = res.start;
28f65c11	206	cur->bsr_len = resource_size(&res);
fe9e8d53 SR	207	cur->bsr_bytes = bsr_bytes[i];
fe9e8d53 SR	208	cur->bsr_stride = bsr_stride[i];
a0e2f9f4	209	cur->bsr_dev = MKDEV(bsr_major, i + total_bsr_devs);
fe9e8d53	210
04a85d12 SR	211	/* if we have a bsr_len of > 4k and less then PAGE_SIZE (64k pages) */
	212	/* we can only map 4k of it, so only advertise the 4k in sysfs */
	213	if (cur->bsr_len > 4096 && cur->bsr_len < PAGE_SIZE)
	214	cur->bsr_len = 4096;
	215
fe9e8d53 SR	216	switch(cur->bsr_bytes) {
	217	case 8:
	218	cur->bsr_type = BSR_8;
	219	break;
	220	case 16:
	221	cur->bsr_type = BSR_16;
	222	break;
	223	case 64:
	224	cur->bsr_type = BSR_64;
	225	break;
	226	case 128:
	227	cur->bsr_type = BSR_128;
	228	break;
e4031d52 SR	229	case 4096:
	230	cur->bsr_type = BSR_4096;
	231	break;
fe9e8d53 SR	232	default:
fe9e8d53 SR	233	cur->bsr_type = BSR_UNKNOWN;
fe9e8d53 SR	234	}
	235
	236	cur->bsr_num = bsr_types[cur->bsr_type];
fe9e8d53 SR	237	snprintf(cur->bsr_name, 32, "bsr%d_%d",
	238	cur->bsr_bytes, cur->bsr_num);
	239
	240	cdev_init(&cur->bsr_cdev, &bsr_fops);
	241	result = cdev_add(&cur->bsr_cdev, cur->bsr_dev, 1);
a0e2f9f4 SR	242	if (result) {
a0e2f9f4 SR	243	kfree(cur);
fe9e8d53	244	goto out_err;
a0e2f9f4	245	}
fe9e8d53	246
03457cd4	247	cur->bsr_device = device_create(bsr_class, NULL, cur->bsr_dev,
4171ee9e	248	cur, "%s", cur->bsr_name);
30c96ce5	249	if (IS_ERR(cur->bsr_device)) {
fe9e8d53 SR	250	printk(KERN_ERR "device_create failed for %s\n",
	251	cur->bsr_name);
	252	cdev_del(&cur->bsr_cdev);
a0e2f9f4	253	kfree(cur);
fe9e8d53 SR	254	goto out_err;
fe9e8d53 SR	255	}
a0e2f9f4 SR	256
	257	bsr_types[cur->bsr_type] = cur->bsr_num + 1;
	258	list_add_tail(&cur->bsr_list, &bsr_devs);
fe9e8d53 SR	259	}
fe9e8d53 SR	260
a0e2f9f4 SR	261	total_bsr_devs += num_bsr_devs;
a0e2f9f4 SR	262
fe9e8d53 SR	263	return 0;
	264
	265	out_err:
	266
	267	bsr_cleanup_devs();
a0e2f9f4 SR	268	return ret;
	269	}
	270
	271	static int bsr_create_devs(struct device_node *bn)
	272	{
	273	int ret;
	274
	275	while (bn) {
	276	ret = bsr_add_node(bn);
	277	if (ret) {
	278	of_node_put(bn);
	279	return ret;
	280	}
	281	bn = of_find_compatible_node(bn, NULL, "ibm,bsr");
	282	}
	283	return 0;
fe9e8d53 SR	284	}
	285
	286	static int __init bsr_init(void)
	287	{
	288	struct device_node *np;
cce36444	289	dev_t bsr_dev;
fe9e8d53	290	int ret = -ENODEV;
fe9e8d53	291
a0e2f9f4	292	np = of_find_compatible_node(NULL, NULL, "ibm,bsr");
fe9e8d53 SR	293	if (!np)
	294	goto out_err;
	295
	296	bsr_class = class_create(THIS_MODULE, "bsr");
	297	if (IS_ERR(bsr_class)) {
	298	printk(KERN_ERR "class_create() failed for bsr_class\n");
8397c76a	299	ret = PTR_ERR(bsr_class);
fe9e8d53 SR	300	goto out_err_1;
fe9e8d53 SR	301	}
62e13505	302	bsr_class->dev_groups = bsr_dev_groups;
fe9e8d53	303
8397c76a	304	ret = alloc_chrdev_region(&bsr_dev, 0, BSR_MAX_DEVS, "bsr");
fe9e8d53	305	bsr_major = MAJOR(bsr_dev);
8397c76a	306	if (ret < 0) {
fe9e8d53 SR	307	printk(KERN_ERR "alloc_chrdev_region() failed for bsr\n");
	308	goto out_err_2;
	309	}
	310
7256d7f4 NKP	311	ret = bsr_create_devs(np);
7256d7f4 NKP	312	if (ret < 0) {
a0e2f9f4	313	np = NULL;
fe9e8d53	314	goto out_err_3;
a0e2f9f4	315	}
fe9e8d53 SR	316
	317	return 0;
	318
	319	out_err_3:
	320	unregister_chrdev_region(bsr_dev, BSR_MAX_DEVS);
	321
	322	out_err_2:
	323	class_destroy(bsr_class);
	324
	325	out_err_1:
	326	of_node_put(np);
	327
	328	out_err:
	329
	330	return ret;
	331	}
	332
	333	static void __exit bsr_exit(void)
	334	{
	335
	336	bsr_cleanup_devs();
	337
	338	if (bsr_class)
	339	class_destroy(bsr_class);
	340
	341	if (bsr_major)
	342	unregister_chrdev_region(MKDEV(bsr_major, 0), BSR_MAX_DEVS);
	343	}
	344
	345	module_init(bsr_init);
	346	module_exit(bsr_exit);
	347	MODULE_LICENSE("GPL");
	348	MODULE_AUTHOR("Sonny Rao <sonnyrao@us.ibm.com>");