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/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>");