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/pgtable.h>
31 #include <asm/io.h>
32
33 /*
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.
44
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
50 */
51
52 /* This is arbitrary number, up to Power6 it's been 17 or fewer */
53 #define BSR_MAX_DEVS (32)
54
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;
63
64 struct list_head bsr_list;
65
66 dev_t bsr_dev;
67 struct cdev bsr_cdev;
68 struct device *bsr_device;
69 char bsr_name[32];
70
71 };
72
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;
77
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,
86 };
87
88 static unsigned bsr_types[BSR_MAX];
89
90 static ssize_t
91 bsr_size_show(struct device *dev, struct device_attribute *attr, char *buf)
92 {
93 struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
94 return sprintf(buf, "%u\n", bsr_dev->bsr_bytes);
95 }
96
97 static ssize_t
98 bsr_stride_show(struct device *dev, struct device_attribute *attr, char *buf)
99 {
100 struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
101 return sprintf(buf, "%u\n", bsr_dev->bsr_stride);
102 }
103
104 static ssize_t
105 bsr_len_show(struct device *dev, struct device_attribute *attr, char *buf)
106 {
107 struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
108 return sprintf(buf, "%llu\n", bsr_dev->bsr_len);
109 }
110
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
116 };
117
118 static int bsr_mmap(struct file *filp, struct vm_area_struct *vma)
119 {
120 unsigned long size = vma->vm_end - vma->vm_start;
121 struct bsr_dev *dev = filp->private_data;
122 int ret;
123
124 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
125
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;
136
137 if (ret)
138 return -EAGAIN;
139
140 return 0;
141 }
142
143 static int bsr_open(struct inode * inode, struct file * filp)
144 {
145 struct cdev *cdev = inode->i_cdev;
146 struct bsr_dev *dev = container_of(cdev, struct bsr_dev, bsr_cdev);
147
148 filp->private_data = dev;
149 return 0;
150 }
151
152 static const struct file_operations bsr_fops = {
153 .owner = THIS_MODULE,
154 .mmap = bsr_mmap,
155 .open = bsr_open,
156 };
157
158 static void bsr_cleanup_devs(void)
159 {
160 struct bsr_dev *cur, *n;
161
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);
166 }
167 list_del(&cur->bsr_list);
168 kfree(cur);
169 }
170 }
171
172 static int bsr_add_node(struct device_node *bn)
173 {
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;
179
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);
182
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;
187 }
188
189 num_bsr_devs = bsr_bytes_len / sizeof(u32);
190
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;
196
197 if (!cur) {
198 printk(KERN_ERR "Unable to alloc bsr dev\n");
199 ret = -ENOMEM;
200 goto out_err;
201 }
202
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;
208 }
209
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);
216
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;
221
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;
240 }
241
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);
245
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;
251 }
252
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;
261 }
262
263 bsr_types[cur->bsr_type] = cur->bsr_num + 1;
264 list_add_tail(&cur->bsr_list, &bsr_devs);
265 }
266
267 total_bsr_devs += num_bsr_devs;
268
269 return 0;
270
271 out_err:
272
273 bsr_cleanup_devs();
274 return ret;
275 }
276
277 static int bsr_create_devs(struct device_node *bn)
278 {
279 int ret;
280
281 while (bn) {
282 ret = bsr_add_node(bn);
283 if (ret) {
284 of_node_put(bn);
285 return ret;
286 }
287 bn = of_find_compatible_node(bn, NULL, "ibm,bsr");
288 }
289 return 0;
290 }
291
292 static int __init bsr_init(void)
293 {
294 struct device_node *np;
295 dev_t bsr_dev = MKDEV(bsr_major, 0);
296 int ret = -ENODEV;
297 int result;
298
299 np = of_find_compatible_node(NULL, NULL, "ibm,bsr");
300 if (!np)
301 goto out_err;
302
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;
307 }
308 bsr_class->dev_attrs = bsr_dev_attrs;
309
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;
315 }
316
317 if ((ret = bsr_create_devs(np)) < 0) {
318 np = NULL;
319 goto out_err_3;
320 }
321
322 return 0;
323
324 out_err_3:
325 unregister_chrdev_region(bsr_dev, BSR_MAX_DEVS);
326
327 out_err_2:
328 class_destroy(bsr_class);
329
330 out_err_1:
331 of_node_put(np);
332
333 out_err:
334
335 return ret;
336 }
337
338 static void __exit bsr_exit(void)
339 {
340
341 bsr_cleanup_devs();
342
343 if (bsr_class)
344 class_destroy(bsr_class);
345
346 if (bsr_major)
347 unregister_chrdev_region(MKDEV(bsr_major, 0), BSR_MAX_DEVS);
348 }
349
350 module_init(bsr_init);
351 module_exit(bsr_exit);
352 MODULE_LICENSE("GPL");
353 MODULE_AUTHOR("Sonny Rao <sonnyrao@us.ibm.com>");
354
|
This page was automatically generated by the
LXR engine.
|