powerpc: Cleanup from l64 to ll64 change: drivers/char
[linux-2.6.git] / drivers / char / bsr.c
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         struct list_head bsr_list;
64
65         dev_t    bsr_dev;
66         struct cdev bsr_cdev;
67         struct device *bsr_device;
68         char     bsr_name[32];
69
70 };
71
72 static unsigned total_bsr_devs;
73 static struct list_head bsr_devs = LIST_HEAD_INIT(bsr_devs);
74 static struct class *bsr_class;
75 static int bsr_major;
76
77 enum {
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
86 static unsigned bsr_types[BSR_MAX];
87
88 static ssize_t
89 bsr_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
95 static ssize_t
96 bsr_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
102 static ssize_t
103 bsr_len_show(struct device *dev, struct device_attribute *attr, char *buf)
104 {
105         struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
106         return sprintf(buf, "%llu\n", bsr_dev->bsr_len);
107 }
108
109 static 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
116 static 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
134 static 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
143 const static struct file_operations bsr_fops = {
144         .owner = THIS_MODULE,
145         .mmap  = bsr_mmap,
146         .open  = bsr_open,
147 };
148
149 static void bsr_cleanup_devs(void)
150 {
151         struct bsr_dev *cur, *n;
152
153         list_for_each_entry_safe(cur, n, &bsr_devs, bsr_list) {
154                 if (cur->bsr_device) {
155                         cdev_del(&cur->bsr_cdev);
156                         device_del(cur->bsr_device);
157                 }
158                 list_del(&cur->bsr_list);
159                 kfree(cur);
160         }
161 }
162
163 static int bsr_add_node(struct device_node *bn)
164 {
165         int bsr_stride_len, bsr_bytes_len, num_bsr_devs;
166         const u32 *bsr_stride;
167         const u32 *bsr_bytes;
168         unsigned i;
169         int ret = -ENODEV;
170
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");
177                 return ret;
178         }
179
180         num_bsr_devs = bsr_bytes_len / sizeof(u32);
181
182         for (i = 0 ; i < num_bsr_devs; i++) {
183                 struct bsr_dev *cur = kzalloc(sizeof(struct bsr_dev),
184                                               GFP_KERNEL);
185                 struct resource res;
186                 int result;
187
188                 if (!cur) {
189                         printk(KERN_ERR "Unable to alloc bsr dev\n");
190                         ret = -ENOMEM;
191                         goto out_err;
192                 }
193
194                 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;
202                 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];
206                 cur->bsr_dev    = MKDEV(bsr_major, i + total_bsr_devs);
207
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];
227                 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);
232                 if (result) {
233                         kfree(cur);
234                         goto out_err;
235                 }
236
237                 cur->bsr_device = device_create(bsr_class, NULL, cur->bsr_dev,
238                                                 cur, cur->bsr_name);
239                 if (!cur->bsr_device) {
240                         printk(KERN_ERR "device_create failed for %s\n",
241                                cur->bsr_name);
242                         cdev_del(&cur->bsr_cdev);
243                         kfree(cur);
244                         goto out_err;
245                 }
246
247                 bsr_types[cur->bsr_type] = cur->bsr_num + 1;
248                 list_add_tail(&cur->bsr_list, &bsr_devs);
249         }
250
251         total_bsr_devs += num_bsr_devs;
252
253         return 0;
254
255  out_err:
256
257         bsr_cleanup_devs();
258         return ret;
259 }
260
261 static 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;
274 }
275
276 static 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
283         np = of_find_compatible_node(NULL, NULL, "ibm,bsr");
284         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
301         if ((ret = bsr_create_devs(np)) < 0) {
302                 np = NULL;
303                 goto out_err_3;
304         }
305
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
322 static 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
334 module_init(bsr_init);
335 module_exit(bsr_exit);
336 MODULE_LICENSE("GPL");
337 MODULE_AUTHOR("Sonny Rao <sonnyrao@us.ibm.com>");