blob: 140ea10ecb886e276c8a6ba53d112cdf06d96499 [file] [log] [blame]
Sonny Raofe9e8d52008-07-08 15:45:11 +10001/* 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
54struct 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
Sonny Raoa0e2f9f2008-11-09 14:15:11 +000063 struct list_head bsr_list;
64
Sonny Raofe9e8d52008-07-08 15:45:11 +100065 dev_t bsr_dev;
66 struct cdev bsr_cdev;
67 struct device *bsr_device;
68 char bsr_name[32];
69
70};
71
Sonny Raoa0e2f9f2008-11-09 14:15:11 +000072static unsigned total_bsr_devs;
73static struct list_head bsr_devs = LIST_HEAD_INIT(bsr_devs);
Sonny Raofe9e8d52008-07-08 15:45:11 +100074static struct class *bsr_class;
75static int bsr_major;
76
77enum {
78 BSR_8 = 0,
79 BSR_16 = 1,
80 BSR_64 = 2,
81 BSR_128 = 3,
82 BSR_UNKNOWN = 4,
83 BSR_MAX = 5,
84};
85
86static unsigned bsr_types[BSR_MAX];
87
88static ssize_t
89bsr_size_show(struct device *dev, struct device_attribute *attr, char *buf)
90{
91 struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
92 return sprintf(buf, "%u\n", bsr_dev->bsr_bytes);
93}
94
95static ssize_t
96bsr_stride_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, "%u\n", bsr_dev->bsr_stride);
100}
101
102static ssize_t
103bsr_len_show(struct device *dev, struct device_attribute *attr, char *buf)
104{
105 struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
Stephen Rothwell19015152009-01-06 14:28:48 +0000106 return sprintf(buf, "%llu\n", bsr_dev->bsr_len);
Sonny Raofe9e8d52008-07-08 15:45:11 +1000107}
108
109static struct device_attribute bsr_dev_attrs[] = {
110 __ATTR(bsr_size, S_IRUGO, bsr_size_show, NULL),
111 __ATTR(bsr_stride, S_IRUGO, bsr_stride_show, NULL),
112 __ATTR(bsr_length, S_IRUGO, bsr_len_show, NULL),
113 __ATTR_NULL
114};
115
116static int bsr_mmap(struct file *filp, struct vm_area_struct *vma)
117{
118 unsigned long size = vma->vm_end - vma->vm_start;
119 struct bsr_dev *dev = filp->private_data;
120
121 if (size > dev->bsr_len || (size & (PAGE_SIZE-1)))
122 return -EINVAL;
123
124 vma->vm_flags |= (VM_IO | VM_DONTEXPAND);
125 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
126
127 if (io_remap_pfn_range(vma, vma->vm_start, dev->bsr_addr >> PAGE_SHIFT,
128 size, vma->vm_page_prot))
129 return -EAGAIN;
130
131 return 0;
132}
133
134static int bsr_open(struct inode * inode, struct file * filp)
135{
136 struct cdev *cdev = inode->i_cdev;
137 struct bsr_dev *dev = container_of(cdev, struct bsr_dev, bsr_cdev);
138
139 filp->private_data = dev;
140 return 0;
141}
142
Tobias Klauser27157a72009-02-09 22:01:08 +0100143static const struct file_operations bsr_fops = {
Sonny Raofe9e8d52008-07-08 15:45:11 +1000144 .owner = THIS_MODULE,
145 .mmap = bsr_mmap,
146 .open = bsr_open,
147};
148
149static void bsr_cleanup_devs(void)
150{
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000151 struct bsr_dev *cur, *n;
152
153 list_for_each_entry_safe(cur, n, &bsr_devs, bsr_list) {
Sonny Raofe9e8d52008-07-08 15:45:11 +1000154 if (cur->bsr_device) {
155 cdev_del(&cur->bsr_cdev);
156 device_del(cur->bsr_device);
157 }
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000158 list_del(&cur->bsr_list);
159 kfree(cur);
Sonny Raofe9e8d52008-07-08 15:45:11 +1000160 }
Sonny Raofe9e8d52008-07-08 15:45:11 +1000161}
162
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000163static int bsr_add_node(struct device_node *bn)
Sonny Raofe9e8d52008-07-08 15:45:11 +1000164{
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000165 int bsr_stride_len, bsr_bytes_len, num_bsr_devs;
Sonny Raofe9e8d52008-07-08 15:45:11 +1000166 const u32 *bsr_stride;
167 const u32 *bsr_bytes;
168 unsigned i;
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000169 int ret = -ENODEV;
Sonny Raofe9e8d52008-07-08 15:45:11 +1000170
171 bsr_stride = of_get_property(bn, "ibm,lock-stride", &bsr_stride_len);
172 bsr_bytes = of_get_property(bn, "ibm,#lock-bytes", &bsr_bytes_len);
173
174 if (!bsr_stride || !bsr_bytes ||
175 (bsr_stride_len != bsr_bytes_len)) {
176 printk(KERN_ERR "bsr of-node has missing/incorrect property\n");
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000177 return ret;
Sonny Raofe9e8d52008-07-08 15:45:11 +1000178 }
179
180 num_bsr_devs = bsr_bytes_len / sizeof(u32);
181
Sonny Raofe9e8d52008-07-08 15:45:11 +1000182 for (i = 0 ; i < num_bsr_devs; i++) {
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000183 struct bsr_dev *cur = kzalloc(sizeof(struct bsr_dev),
184 GFP_KERNEL);
Sonny Raofe9e8d52008-07-08 15:45:11 +1000185 struct resource res;
186 int result;
187
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000188 if (!cur) {
189 printk(KERN_ERR "Unable to alloc bsr dev\n");
190 ret = -ENOMEM;
Sonny Raofe9e8d52008-07-08 15:45:11 +1000191 goto out_err;
192 }
193
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000194 result = of_address_to_resource(bn, i, &res);
195 if (result < 0) {
196 printk(KERN_ERR "bsr of-node has invalid reg property, skipping\n");
197 kfree(cur);
198 continue;
199 }
200
201 cur->bsr_minor = i + total_bsr_devs;
Sonny Raofe9e8d52008-07-08 15:45:11 +1000202 cur->bsr_addr = res.start;
203 cur->bsr_len = res.end - res.start + 1;
204 cur->bsr_bytes = bsr_bytes[i];
205 cur->bsr_stride = bsr_stride[i];
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000206 cur->bsr_dev = MKDEV(bsr_major, i + total_bsr_devs);
Sonny Raofe9e8d52008-07-08 15:45:11 +1000207
208 switch(cur->bsr_bytes) {
209 case 8:
210 cur->bsr_type = BSR_8;
211 break;
212 case 16:
213 cur->bsr_type = BSR_16;
214 break;
215 case 64:
216 cur->bsr_type = BSR_64;
217 break;
218 case 128:
219 cur->bsr_type = BSR_128;
220 break;
221 default:
222 cur->bsr_type = BSR_UNKNOWN;
223 printk(KERN_INFO "unknown BSR size %d\n",cur->bsr_bytes);
224 }
225
226 cur->bsr_num = bsr_types[cur->bsr_type];
Sonny Raofe9e8d52008-07-08 15:45:11 +1000227 snprintf(cur->bsr_name, 32, "bsr%d_%d",
228 cur->bsr_bytes, cur->bsr_num);
229
230 cdev_init(&cur->bsr_cdev, &bsr_fops);
231 result = cdev_add(&cur->bsr_cdev, cur->bsr_dev, 1);
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000232 if (result) {
233 kfree(cur);
Sonny Raofe9e8d52008-07-08 15:45:11 +1000234 goto out_err;
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000235 }
Sonny Raofe9e8d52008-07-08 15:45:11 +1000236
Greg Kroah-Hartman03457cd2008-07-21 20:03:34 -0700237 cur->bsr_device = device_create(bsr_class, NULL, cur->bsr_dev,
238 cur, cur->bsr_name);
Sonny Raofe9e8d52008-07-08 15:45:11 +1000239 if (!cur->bsr_device) {
240 printk(KERN_ERR "device_create failed for %s\n",
241 cur->bsr_name);
242 cdev_del(&cur->bsr_cdev);
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000243 kfree(cur);
Sonny Raofe9e8d52008-07-08 15:45:11 +1000244 goto out_err;
245 }
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000246
247 bsr_types[cur->bsr_type] = cur->bsr_num + 1;
248 list_add_tail(&cur->bsr_list, &bsr_devs);
Sonny Raofe9e8d52008-07-08 15:45:11 +1000249 }
250
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000251 total_bsr_devs += num_bsr_devs;
252
Sonny Raofe9e8d52008-07-08 15:45:11 +1000253 return 0;
254
255 out_err:
256
257 bsr_cleanup_devs();
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000258 return ret;
259}
260
261static int bsr_create_devs(struct device_node *bn)
262{
263 int ret;
264
265 while (bn) {
266 ret = bsr_add_node(bn);
267 if (ret) {
268 of_node_put(bn);
269 return ret;
270 }
271 bn = of_find_compatible_node(bn, NULL, "ibm,bsr");
272 }
273 return 0;
Sonny Raofe9e8d52008-07-08 15:45:11 +1000274}
275
276static int __init bsr_init(void)
277{
278 struct device_node *np;
279 dev_t bsr_dev = MKDEV(bsr_major, 0);
280 int ret = -ENODEV;
281 int result;
282
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000283 np = of_find_compatible_node(NULL, NULL, "ibm,bsr");
Sonny Raofe9e8d52008-07-08 15:45:11 +1000284 if (!np)
285 goto out_err;
286
287 bsr_class = class_create(THIS_MODULE, "bsr");
288 if (IS_ERR(bsr_class)) {
289 printk(KERN_ERR "class_create() failed for bsr_class\n");
290 goto out_err_1;
291 }
292 bsr_class->dev_attrs = bsr_dev_attrs;
293
294 result = alloc_chrdev_region(&bsr_dev, 0, BSR_MAX_DEVS, "bsr");
295 bsr_major = MAJOR(bsr_dev);
296 if (result < 0) {
297 printk(KERN_ERR "alloc_chrdev_region() failed for bsr\n");
298 goto out_err_2;
299 }
300
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000301 if ((ret = bsr_create_devs(np)) < 0) {
302 np = NULL;
Sonny Raofe9e8d52008-07-08 15:45:11 +1000303 goto out_err_3;
Sonny Raoa0e2f9f2008-11-09 14:15:11 +0000304 }
Sonny Raofe9e8d52008-07-08 15:45:11 +1000305
306 return 0;
307
308 out_err_3:
309 unregister_chrdev_region(bsr_dev, BSR_MAX_DEVS);
310
311 out_err_2:
312 class_destroy(bsr_class);
313
314 out_err_1:
315 of_node_put(np);
316
317 out_err:
318
319 return ret;
320}
321
322static void __exit bsr_exit(void)
323{
324
325 bsr_cleanup_devs();
326
327 if (bsr_class)
328 class_destroy(bsr_class);
329
330 if (bsr_major)
331 unregister_chrdev_region(MKDEV(bsr_major, 0), BSR_MAX_DEVS);
332}
333
334module_init(bsr_init);
335module_exit(bsr_exit);
336MODULE_LICENSE("GPL");
337MODULE_AUTHOR("Sonny Rao <sonnyrao@us.ibm.com>");