[net-next-2.6.git] / drivers / char / bsr.c

/* IBM POWER Barrier Synchronization Register Driver
 *
 * Copyright IBM Corporation 2008
 *
 * Author: Sonny Rao <sonnyrao@us.ibm.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#include <linux/kernel.h>
#include <linux/of.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/pgtable.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 struct list_head bsr_devs = LIST_HEAD_INIT(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 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 ssize_t
bsr_len_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 struct device_attribute bsr_dev_attrs[] = {
	__ATTR(bsr_size, S_IRUGO, bsr_size_show, NULL),
	__ATTR(bsr_stride, S_IRUGO, bsr_stride_show, NULL),
	__ATTR(bsr_length, S_IRUGO, bsr_len_show, NULL),
	__ATTR_NULL
};

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,
};

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    = res.end - res.start + 1;
		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, 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 = MKDEV(bsr_major, 0);
	int ret = -ENODEV;
	int result;

	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");
		goto out_err_1;
	}
	bsr_class->dev_attrs = bsr_dev_attrs;

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

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