[mirror_ubuntu-artful-kernel.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_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/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 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;
	}

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