[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
	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/* IBM POWER Barrier Synchronization Register Driver
	3	*
	4	* Copyright IBM Corporation 2008
	5	*
	6	* Author: Sonny Rao <sonnyrao@us.ibm.com>
	7	*/
	8
	9	#include <linux/kernel.h>
	10	#include <linux/of.h>
	11	#include <linux/of_address.h>
	12	#include <linux/of_device.h>
	13	#include <linux/of_platform.h>
	14	#include <linux/fs.h>
	15	#include <linux/module.h>
	16	#include <linux/cdev.h>
	17	#include <linux/list.h>
	18	#include <linux/mm.h>
	19	#include <linux/slab.h>
	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
	53	struct list_head bsr_list;
	54
	55	dev_t bsr_dev;
	56	struct cdev bsr_cdev;
	57	struct device *bsr_device;
	58	char bsr_name[32];
	59
	60	};
	61
	62	static unsigned total_bsr_devs;
	63	static LIST_HEAD(bsr_devs);
	64	static struct class *bsr_class;
	65	static int bsr_major;
	66
	67	enum {
	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,
	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	}
	85	static DEVICE_ATTR_RO(bsr_size);
	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	}
	93	static DEVICE_ATTR_RO(bsr_stride);
	94
	95	static ssize_t
	96	bsr_length_show(struct device dev, struct device_attribute attr, char *buf)
	97	{
	98	struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
	99	return sprintf(buf, "%llu\n", bsr_dev->bsr_len);
	100	}
	101	static DEVICE_ATTR_RO(bsr_length);
	102
	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,
	108	};
	109	ATTRIBUTE_GROUPS(bsr_dev);
	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;
	115	int ret;
	116
	117	vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
	118
	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)
	131	return -EAGAIN;
	132
	133	return 0;
	134	}
	135
	136	static int bsr_open(struct inode inode, struct file filp)
	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
	145	static const struct file_operations bsr_fops = {
	146	.owner = THIS_MODULE,
	147	.mmap = bsr_mmap,
	148	.open = bsr_open,
	149	.llseek = noop_llseek,
	150	};
	151
	152	static void bsr_cleanup_devs(void)
	153	{
	154	struct bsr_dev cur, n;
	155
	156	list_for_each_entry_safe(cur, n, &bsr_devs, bsr_list) {
	157	if (cur->bsr_device) {
	158	cdev_del(&cur->bsr_cdev);
	159	device_del(cur->bsr_device);
	160	}
	161	list_del(&cur->bsr_list);
	162	kfree(cur);
	163	}
	164	}
	165
	166	static int bsr_add_node(struct device_node *bn)
	167	{
	168	int bsr_stride_len, bsr_bytes_len, num_bsr_devs;
	169	const u32 *bsr_stride;
	170	const u32 *bsr_bytes;
	171	unsigned i;
	172	int ret = -ENODEV;
	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");
	180	return ret;
	181	}
	182
	183	num_bsr_devs = bsr_bytes_len / sizeof(u32);
	184
	185	for (i = 0 ; i < num_bsr_devs; i++) {
	186	struct bsr_dev *cur = kzalloc(sizeof(struct bsr_dev),
	187	GFP_KERNEL);
	188	struct resource res;
	189	int result;
	190
	191	if (!cur) {
	192	printk(KERN_ERR "Unable to alloc bsr dev\n");
	193	ret = -ENOMEM;
	194	goto out_err;
	195	}
	196
	197	result = of_address_to_resource(bn, i, &res);
	198	if (result < 0) {
	199	printk(KERN_ERR "bsr of-node has invalid reg property, skipping\n");
	200	kfree(cur);
	201	continue;
	202	}
	203
	204	cur->bsr_minor = i + total_bsr_devs;
	205	cur->bsr_addr = res.start;
	206	cur->bsr_len = resource_size(&res);
	207	cur->bsr_bytes = bsr_bytes[i];
	208	cur->bsr_stride = bsr_stride[i];
	209	cur->bsr_dev = MKDEV(bsr_major, i + total_bsr_devs);
	210
	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
	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;
	229	case 4096:
	230	cur->bsr_type = BSR_4096;
	231	break;
	232	default:
	233	cur->bsr_type = BSR_UNKNOWN;
	234	}
	235
	236	cur->bsr_num = bsr_types[cur->bsr_type];
	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);
	242	if (result) {
	243	kfree(cur);
	244	goto out_err;
	245	}
	246
	247	cur->bsr_device = device_create(bsr_class, NULL, cur->bsr_dev,
	248	cur, "%s", cur->bsr_name);
	249	if (IS_ERR(cur->bsr_device)) {
	250	printk(KERN_ERR "device_create failed for %s\n",
	251	cur->bsr_name);
	252	cdev_del(&cur->bsr_cdev);
	253	kfree(cur);
	254	goto out_err;
	255	}
	256
	257	bsr_types[cur->bsr_type] = cur->bsr_num + 1;
	258	list_add_tail(&cur->bsr_list, &bsr_devs);
	259	}
	260
	261	total_bsr_devs += num_bsr_devs;
	262
	263	return 0;
	264
	265	out_err:
	266
	267	bsr_cleanup_devs();
	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;
	284	}
	285
	286	static int __init bsr_init(void)
	287	{
	288	struct device_node *np;
	289	dev_t bsr_dev;
	290	int ret = -ENODEV;
	291
	292	np = of_find_compatible_node(NULL, NULL, "ibm,bsr");
	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");
	299	ret = PTR_ERR(bsr_class);
	300	goto out_err_1;
	301	}
	302	bsr_class->dev_groups = bsr_dev_groups;
	303
	304	ret = alloc_chrdev_region(&bsr_dev, 0, BSR_MAX_DEVS, "bsr");
	305	bsr_major = MAJOR(bsr_dev);
	306	if (ret < 0) {
	307	printk(KERN_ERR "alloc_chrdev_region() failed for bsr\n");
	308	goto out_err_2;
	309	}
	310
	311	ret = bsr_create_devs(np);
	312	if (ret < 0) {
	313	np = NULL;
	314	goto out_err_3;
	315	}
	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>");