[GitHub/mt8127/android_kernel_alcatel_ttab.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/module.h>
#include <linux/cdev.h>
#include <linux/list.h>
#include <linux/mm.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;

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

};

static unsigned num_bsr_devs;
static struct bsr_dev *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_UNKNOWN = 4,
	BSR_MAX = 5,
};

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, "%lu\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;

	if (size > dev->bsr_len || (size & (PAGE_SIZE-1)))
		return -EINVAL;

	vma->vm_flags |= (VM_IO | VM_DONTEXPAND);
	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

	if (io_remap_pfn_range(vma, vma->vm_start, dev->bsr_addr >> PAGE_SHIFT,
			       size, vma->vm_page_prot))
		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;
}

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

static void bsr_cleanup_devs(void)
{
	int i;
	for (i=0 ; i < num_bsr_devs; i++) {
		struct bsr_dev *cur = bsr_devs + i;
		if (cur->bsr_device) {
			cdev_del(&cur->bsr_cdev);
			device_del(cur->bsr_device);
		}
	}

	kfree(bsr_devs);
}

static int bsr_create_devs(struct device_node *bn)
{
	int bsr_stride_len, bsr_bytes_len;
	const u32 *bsr_stride;
	const u32 *bsr_bytes;
	unsigned i;

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

	num_bsr_devs = bsr_bytes_len / sizeof(u32);

	/* only a warning, its informational since we'll fail and exit */
	WARN_ON(num_bsr_devs > BSR_MAX_DEVS);

	bsr_devs = kzalloc(sizeof(struct bsr_dev) * num_bsr_devs, GFP_KERNEL);
	if (!bsr_devs)
		return -ENOMEM;

	for (i = 0 ; i < num_bsr_devs; i++) {
		struct bsr_dev *cur = bsr_devs + i;
		struct resource res;
		int result;

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

		cur->bsr_minor  = i;
		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);

		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;
		default:
			cur->bsr_type = BSR_UNKNOWN;
			printk(KERN_INFO "unknown BSR size %d\n",cur->bsr_bytes);
		}

		cur->bsr_num = bsr_types[cur->bsr_type];
		bsr_types[cur->bsr_type] = cur->bsr_num + 1;
		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)
			goto out_err;

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

	return 0;

 out_err:

	bsr_cleanup_devs();
	return -ENODEV;
}

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, "ibm,bsr", "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)
		goto out_err_3;

	of_node_put(np);

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