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