Linux 2.6.34-rc3
[pohmelfs.git] / drivers / char / bsr.c
blobc02db01f736ea46bc536190910a2f4a9e336bfbb
1 /* IBM POWER Barrier Synchronization Register Driver
3 * Copyright IBM Corporation 2008
5 * Author: Sonny Rao <sonnyrao@us.ibm.com>
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.
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.
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
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/pgtable.h>
31 #include <asm/io.h>
34 This driver exposes a special register which can be used for fast
35 synchronization across a large SMP machine. The hardware is exposed
36 as an array of bytes where each process will write to one of the bytes to
37 indicate it has finished the current stage and this update is broadcast to
38 all processors without having to bounce a cacheline between them. In
39 POWER5 and POWER6 there is one of these registers per SMP, but it is
40 presented in two forms; first, it is given as a whole and then as a number
41 of smaller registers which alias to parts of the single whole register.
42 This can potentially allow multiple groups of processes to each have their
43 own private synchronization device.
45 Note that this hardware *must* be written to using *only* single byte writes.
46 It may be read using 1, 2, 4, or 8 byte loads which must be aligned since
47 this region is treated as cache-inhibited processes should also use a
48 full sync before and after writing to the BSR to ensure all stores and
49 the BSR update have made it to all chips in the system
52 /* This is arbitrary number, up to Power6 it's been 17 or fewer */
53 #define BSR_MAX_DEVS (32)
55 struct bsr_dev {
56 u64 bsr_addr; /* Real address */
57 u64 bsr_len; /* length of mem region we can map */
58 unsigned bsr_bytes; /* size of the BSR reg itself */
59 unsigned bsr_stride; /* interval at which BSR repeats in the page */
60 unsigned bsr_type; /* maps to enum below */
61 unsigned bsr_num; /* bsr id number for its type */
62 int bsr_minor;
64 struct list_head bsr_list;
66 dev_t bsr_dev;
67 struct cdev bsr_cdev;
68 struct device *bsr_device;
69 char bsr_name[32];
73 static unsigned total_bsr_devs;
74 static struct list_head bsr_devs = LIST_HEAD_INIT(bsr_devs);
75 static struct class *bsr_class;
76 static int bsr_major;
78 enum {
79 BSR_8 = 0,
80 BSR_16 = 1,
81 BSR_64 = 2,
82 BSR_128 = 3,
83 BSR_4096 = 4,
84 BSR_UNKNOWN = 5,
85 BSR_MAX = 6,
88 static unsigned bsr_types[BSR_MAX];
90 static ssize_t
91 bsr_size_show(struct device *dev, struct device_attribute *attr, char *buf)
93 struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
94 return sprintf(buf, "%u\n", bsr_dev->bsr_bytes);
97 static ssize_t
98 bsr_stride_show(struct device *dev, struct device_attribute *attr, char *buf)
100 struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
101 return sprintf(buf, "%u\n", bsr_dev->bsr_stride);
104 static ssize_t
105 bsr_len_show(struct device *dev, struct device_attribute *attr, char *buf)
107 struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
108 return sprintf(buf, "%llu\n", bsr_dev->bsr_len);
111 static struct device_attribute bsr_dev_attrs[] = {
112 __ATTR(bsr_size, S_IRUGO, bsr_size_show, NULL),
113 __ATTR(bsr_stride, S_IRUGO, bsr_stride_show, NULL),
114 __ATTR(bsr_length, S_IRUGO, bsr_len_show, NULL),
115 __ATTR_NULL
118 static int bsr_mmap(struct file *filp, struct vm_area_struct *vma)
120 unsigned long size = vma->vm_end - vma->vm_start;
121 struct bsr_dev *dev = filp->private_data;
122 int ret;
124 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
126 /* check for the case of a small BSR device and map one 4k page for it*/
127 if (dev->bsr_len < PAGE_SIZE && size == PAGE_SIZE)
128 ret = remap_4k_pfn(vma, vma->vm_start, dev->bsr_addr >> 12,
129 vma->vm_page_prot);
130 else if (size <= dev->bsr_len)
131 ret = io_remap_pfn_range(vma, vma->vm_start,
132 dev->bsr_addr >> PAGE_SHIFT,
133 size, vma->vm_page_prot);
134 else
135 return -EINVAL;
137 if (ret)
138 return -EAGAIN;
140 return 0;
143 static int bsr_open(struct inode * inode, struct file * filp)
145 struct cdev *cdev = inode->i_cdev;
146 struct bsr_dev *dev = container_of(cdev, struct bsr_dev, bsr_cdev);
148 filp->private_data = dev;
149 return 0;
152 static const struct file_operations bsr_fops = {
153 .owner = THIS_MODULE,
154 .mmap = bsr_mmap,
155 .open = bsr_open,
158 static void bsr_cleanup_devs(void)
160 struct bsr_dev *cur, *n;
162 list_for_each_entry_safe(cur, n, &bsr_devs, bsr_list) {
163 if (cur->bsr_device) {
164 cdev_del(&cur->bsr_cdev);
165 device_del(cur->bsr_device);
167 list_del(&cur->bsr_list);
168 kfree(cur);
172 static int bsr_add_node(struct device_node *bn)
174 int bsr_stride_len, bsr_bytes_len, num_bsr_devs;
175 const u32 *bsr_stride;
176 const u32 *bsr_bytes;
177 unsigned i;
178 int ret = -ENODEV;
180 bsr_stride = of_get_property(bn, "ibm,lock-stride", &bsr_stride_len);
181 bsr_bytes = of_get_property(bn, "ibm,#lock-bytes", &bsr_bytes_len);
183 if (!bsr_stride || !bsr_bytes ||
184 (bsr_stride_len != bsr_bytes_len)) {
185 printk(KERN_ERR "bsr of-node has missing/incorrect property\n");
186 return ret;
189 num_bsr_devs = bsr_bytes_len / sizeof(u32);
191 for (i = 0 ; i < num_bsr_devs; i++) {
192 struct bsr_dev *cur = kzalloc(sizeof(struct bsr_dev),
193 GFP_KERNEL);
194 struct resource res;
195 int result;
197 if (!cur) {
198 printk(KERN_ERR "Unable to alloc bsr dev\n");
199 ret = -ENOMEM;
200 goto out_err;
203 result = of_address_to_resource(bn, i, &res);
204 if (result < 0) {
205 printk(KERN_ERR "bsr of-node has invalid reg property, skipping\n");
206 kfree(cur);
207 continue;
210 cur->bsr_minor = i + total_bsr_devs;
211 cur->bsr_addr = res.start;
212 cur->bsr_len = res.end - res.start + 1;
213 cur->bsr_bytes = bsr_bytes[i];
214 cur->bsr_stride = bsr_stride[i];
215 cur->bsr_dev = MKDEV(bsr_major, i + total_bsr_devs);
217 /* if we have a bsr_len of > 4k and less then PAGE_SIZE (64k pages) */
218 /* we can only map 4k of it, so only advertise the 4k in sysfs */
219 if (cur->bsr_len > 4096 && cur->bsr_len < PAGE_SIZE)
220 cur->bsr_len = 4096;
222 switch(cur->bsr_bytes) {
223 case 8:
224 cur->bsr_type = BSR_8;
225 break;
226 case 16:
227 cur->bsr_type = BSR_16;
228 break;
229 case 64:
230 cur->bsr_type = BSR_64;
231 break;
232 case 128:
233 cur->bsr_type = BSR_128;
234 break;
235 case 4096:
236 cur->bsr_type = BSR_4096;
237 break;
238 default:
239 cur->bsr_type = BSR_UNKNOWN;
242 cur->bsr_num = bsr_types[cur->bsr_type];
243 snprintf(cur->bsr_name, 32, "bsr%d_%d",
244 cur->bsr_bytes, cur->bsr_num);
246 cdev_init(&cur->bsr_cdev, &bsr_fops);
247 result = cdev_add(&cur->bsr_cdev, cur->bsr_dev, 1);
248 if (result) {
249 kfree(cur);
250 goto out_err;
253 cur->bsr_device = device_create(bsr_class, NULL, cur->bsr_dev,
254 cur, cur->bsr_name);
255 if (!cur->bsr_device) {
256 printk(KERN_ERR "device_create failed for %s\n",
257 cur->bsr_name);
258 cdev_del(&cur->bsr_cdev);
259 kfree(cur);
260 goto out_err;
263 bsr_types[cur->bsr_type] = cur->bsr_num + 1;
264 list_add_tail(&cur->bsr_list, &bsr_devs);
267 total_bsr_devs += num_bsr_devs;
269 return 0;
271 out_err:
273 bsr_cleanup_devs();
274 return ret;
277 static int bsr_create_devs(struct device_node *bn)
279 int ret;
281 while (bn) {
282 ret = bsr_add_node(bn);
283 if (ret) {
284 of_node_put(bn);
285 return ret;
287 bn = of_find_compatible_node(bn, NULL, "ibm,bsr");
289 return 0;
292 static int __init bsr_init(void)
294 struct device_node *np;
295 dev_t bsr_dev = MKDEV(bsr_major, 0);
296 int ret = -ENODEV;
297 int result;
299 np = of_find_compatible_node(NULL, NULL, "ibm,bsr");
300 if (!np)
301 goto out_err;
303 bsr_class = class_create(THIS_MODULE, "bsr");
304 if (IS_ERR(bsr_class)) {
305 printk(KERN_ERR "class_create() failed for bsr_class\n");
306 goto out_err_1;
308 bsr_class->dev_attrs = bsr_dev_attrs;
310 result = alloc_chrdev_region(&bsr_dev, 0, BSR_MAX_DEVS, "bsr");
311 bsr_major = MAJOR(bsr_dev);
312 if (result < 0) {
313 printk(KERN_ERR "alloc_chrdev_region() failed for bsr\n");
314 goto out_err_2;
317 if ((ret = bsr_create_devs(np)) < 0) {
318 np = NULL;
319 goto out_err_3;
322 return 0;
324 out_err_3:
325 unregister_chrdev_region(bsr_dev, BSR_MAX_DEVS);
327 out_err_2:
328 class_destroy(bsr_class);
330 out_err_1:
331 of_node_put(np);
333 out_err:
335 return ret;
338 static void __exit bsr_exit(void)
341 bsr_cleanup_devs();
343 if (bsr_class)
344 class_destroy(bsr_class);
346 if (bsr_major)
347 unregister_chrdev_region(MKDEV(bsr_major, 0), BSR_MAX_DEVS);
350 module_init(bsr_init);
351 module_exit(bsr_exit);
352 MODULE_LICENSE("GPL");
353 MODULE_AUTHOR("Sonny Rao <sonnyrao@us.ibm.com>");