[linux-2.6-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/device.h>
#include <linux/kernel.h>
#include <linux/of.h>
#include <linux/of_address.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 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 const struct class bsr_class = {
	.name		= "bsr",
	.dev_groups	= bsr_dev_groups,
};

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;

	ret = class_register(&bsr_class);
	if (ret)
		goto out_err_1;

	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_unregister(&bsr_class);

 out_err_1:
	of_node_put(np);

 out_err:

	return ret;
}

static void __exit  bsr_exit(void)
{

	bsr_cleanup_devs();

	class_unregister(&bsr_class);

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

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