Merge tag 'cleanup' of git://git.kernel.org/pub/scm/linux/kernel/git/arm/arm-soc
[linux-2.6.git] / drivers / char / bsr.c
index b650b4e..0c68823 100644 (file)
 #include <linux/of.h>
 #include <linux/of_device.h>
 #include <linux/of_platform.h>
+#include <linux/fs.h>
 #include <linux/module.h>
 #include <linux/cdev.h>
 #include <linux/list.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
+#include <asm/pgtable.h>
 #include <asm/io.h>
 
 /*
@@ -60,6 +63,8 @@ struct bsr_dev {
        unsigned bsr_num;      /* bsr id number for its type */
        int      bsr_minor;
 
+       struct list_head bsr_list;
+
        dev_t    bsr_dev;
        struct cdev bsr_cdev;
        struct device *bsr_device;
@@ -67,18 +72,19 @@ struct bsr_dev {
 
 };
 
-static unsigned num_bsr_devs;
-static struct bsr_dev *bsr_devs;
+static unsigned total_bsr_devs;
+static struct list_head bsr_devs = LIST_HEAD_INIT(bsr_devs);
 static struct class *bsr_class;
 static int bsr_major;
 
 enum {
-       BSR_8   = 0,
-       BSR_16  = 1,
-       BSR_64  = 2,
-       BSR_128 = 3,
-       BSR_UNKNOWN = 4,
-       BSR_MAX = 5,
+       BSR_8    = 0,
+       BSR_16   = 1,
+       BSR_64   = 2,
+       BSR_128  = 3,
+       BSR_4096 = 4,
+       BSR_UNKNOWN = 5,
+       BSR_MAX  = 6,
 };
 
 static unsigned bsr_types[BSR_MAX];
@@ -101,7 +107,7 @@ static ssize_t
 bsr_len_show(struct device *dev, struct device_attribute *attr, char *buf)
 {
        struct bsr_dev *bsr_dev = dev_get_drvdata(dev);
-       return sprintf(buf, "%lu\n", bsr_dev->bsr_len);
+       return sprintf(buf, "%llu\n", bsr_dev->bsr_len);
 }
 
 static struct device_attribute bsr_dev_attrs[] = {
@@ -115,15 +121,22 @@ static int bsr_mmap(struct file *filp, struct vm_area_struct *vma)
 {
        unsigned long size   = vma->vm_end - vma->vm_start;
        struct bsr_dev *dev = filp->private_data;
+       int ret;
 
-       if (size > dev->bsr_len || (size & (PAGE_SIZE-1)))
-               return -EINVAL;
-
-       vma->vm_flags |= (VM_IO | VM_DONTEXPAND);
        vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 
-       if (io_remap_pfn_range(vma, vma->vm_start, dev->bsr_addr >> PAGE_SHIFT,
-                              size, vma->vm_page_prot))
+       /* check for the case of a small BSR device and map one 4k page for it*/
+       if (dev->bsr_len < PAGE_SIZE && size == PAGE_SIZE)
+               ret = remap_4k_pfn(vma, vma->vm_start, dev->bsr_addr >> 12,
+                                  vma->vm_page_prot);
+       else if (size <= dev->bsr_len)
+               ret = io_remap_pfn_range(vma, vma->vm_start,
+                                        dev->bsr_addr >> PAGE_SHIFT,
+                                        size, vma->vm_page_prot);
+       else
+               return -EINVAL;
+
+       if (ret)
                return -EAGAIN;
 
        return 0;
@@ -138,32 +151,34 @@ static int bsr_open(struct inode * inode, struct file * filp)
        return 0;
 }
 
-const static struct file_operations bsr_fops = {
+static const struct file_operations bsr_fops = {
        .owner = THIS_MODULE,
        .mmap  = bsr_mmap,
        .open  = bsr_open,
+       .llseek = noop_llseek,
 };
 
 static void bsr_cleanup_devs(void)
 {
-       int i;
-       for (i=0 ; i < num_bsr_devs; i++) {
-               struct bsr_dev *cur = bsr_devs + i;
+       struct bsr_dev *cur, *n;
+
+       list_for_each_entry_safe(cur, n, &bsr_devs, bsr_list) {
                if (cur->bsr_device) {
                        cdev_del(&cur->bsr_cdev);
                        device_del(cur->bsr_device);
                }
+               list_del(&cur->bsr_list);
+               kfree(cur);
        }
-
-       kfree(bsr_devs);
 }
 
-static int bsr_create_devs(struct device_node *bn)
+static int bsr_add_node(struct device_node *bn)
 {
-       int bsr_stride_len, bsr_bytes_len;
+       int bsr_stride_len, bsr_bytes_len, num_bsr_devs;
        const u32 *bsr_stride;
        const u32 *bsr_bytes;
        unsigned i;
+       int ret = -ENODEV;
 
        bsr_stride = of_get_property(bn, "ibm,lock-stride", &bsr_stride_len);
        bsr_bytes  = of_get_property(bn, "ibm,#lock-bytes", &bsr_bytes_len);
@@ -171,35 +186,41 @@ static int bsr_create_devs(struct device_node *bn)
        if (!bsr_stride || !bsr_bytes ||
            (bsr_stride_len != bsr_bytes_len)) {
                printk(KERN_ERR "bsr of-node has missing/incorrect property\n");
-               return -ENODEV;
+               return ret;
        }
 
        num_bsr_devs = bsr_bytes_len / sizeof(u32);
 
-       /* only a warning, its informational since we'll fail and exit */
-       WARN_ON(num_bsr_devs > BSR_MAX_DEVS);
-
-       bsr_devs = kzalloc(sizeof(struct bsr_dev) * num_bsr_devs, GFP_KERNEL);
-       if (!bsr_devs)
-               return -ENOMEM;
-
        for (i = 0 ; i < num_bsr_devs; i++) {
-               struct bsr_dev *cur = bsr_devs + i;
+               struct bsr_dev *cur = kzalloc(sizeof(struct bsr_dev),
+                                             GFP_KERNEL);
                struct resource res;
                int result;
 
+               if (!cur) {
+                       printk(KERN_ERR "Unable to alloc bsr dev\n");
+                       ret = -ENOMEM;
+                       goto out_err;
+               }
+
                result = of_address_to_resource(bn, i, &res);
                if (result < 0) {
-                       printk(KERN_ERR "bsr of-node has invalid reg property\n");
-                       goto out_err;
+                       printk(KERN_ERR "bsr of-node has invalid reg property, skipping\n");
+                       kfree(cur);
+                       continue;
                }
 
-               cur->bsr_minor  = i;
+               cur->bsr_minor  = i + total_bsr_devs;
                cur->bsr_addr   = res.start;
-               cur->bsr_len    = res.end - res.start + 1;
+               cur->bsr_len    = resource_size(&res);
                cur->bsr_bytes  = bsr_bytes[i];
                cur->bsr_stride = bsr_stride[i];
-               cur->bsr_dev    = MKDEV(bsr_major, i);
+               cur->bsr_dev    = MKDEV(bsr_major, i + total_bsr_devs);
+
+               /* if we have a bsr_len of > 4k and less then PAGE_SIZE (64k pages) */
+               /* we can only map 4k of it, so only advertise the 4k in sysfs */
+               if (cur->bsr_len > 4096 && cur->bsr_len < PAGE_SIZE)
+                       cur->bsr_len = 4096;
 
                switch(cur->bsr_bytes) {
                case 8:
@@ -214,48 +235,71 @@ static int bsr_create_devs(struct device_node *bn)
                case 128:
                        cur->bsr_type = BSR_128;
                        break;
+               case 4096:
+                       cur->bsr_type = BSR_4096;
+                       break;
                default:
                        cur->bsr_type = BSR_UNKNOWN;
-                       printk(KERN_INFO "unknown BSR size %d\n",cur->bsr_bytes);
                }
 
                cur->bsr_num = bsr_types[cur->bsr_type];
-               bsr_types[cur->bsr_type] = cur->bsr_num + 1;
                snprintf(cur->bsr_name, 32, "bsr%d_%d",
                         cur->bsr_bytes, cur->bsr_num);
 
                cdev_init(&cur->bsr_cdev, &bsr_fops);
                result = cdev_add(&cur->bsr_cdev, cur->bsr_dev, 1);
-               if (result)
+               if (result) {
+                       kfree(cur);
                        goto out_err;
+               }
 
-               cur->bsr_device = device_create_drvdata(bsr_class, NULL,
-                                                       cur->bsr_dev,
-                                                       cur, cur->bsr_name);
-               if (!cur->bsr_device) {
+               cur->bsr_device = device_create(bsr_class, NULL, cur->bsr_dev,
+                                               cur, cur->bsr_name);
+               if (IS_ERR(cur->bsr_device)) {
                        printk(KERN_ERR "device_create failed for %s\n",
                               cur->bsr_name);
                        cdev_del(&cur->bsr_cdev);
+                       kfree(cur);
                        goto out_err;
                }
+
+               bsr_types[cur->bsr_type] = cur->bsr_num + 1;
+               list_add_tail(&cur->bsr_list, &bsr_devs);
        }
 
+       total_bsr_devs += num_bsr_devs;
+
        return 0;
 
  out_err:
 
        bsr_cleanup_devs();
-       return -ENODEV;
+       return ret;
+}
+
+static int bsr_create_devs(struct device_node *bn)
+{
+       int ret;
+
+       while (bn) {
+               ret = bsr_add_node(bn);
+               if (ret) {
+                       of_node_put(bn);
+                       return ret;
+               }
+               bn = of_find_compatible_node(bn, NULL, "ibm,bsr");
+       }
+       return 0;
 }
 
 static int __init bsr_init(void)
 {
        struct device_node *np;
-       dev_t bsr_dev = MKDEV(bsr_major, 0);
+       dev_t bsr_dev;
        int ret = -ENODEV;
        int result;
 
-       np = of_find_compatible_node(NULL, "ibm,bsr", "ibm,bsr");
+       np = of_find_compatible_node(NULL, NULL, "ibm,bsr");
        if (!np)
                goto out_err;
 
@@ -273,10 +317,10 @@ static int __init bsr_init(void)
                goto out_err_2;
        }
 
-       if ((ret = bsr_create_devs(np)) < 0)
+       if ((ret = bsr_create_devs(np)) < 0) {
+               np = NULL;
                goto out_err_3;
-
-       of_node_put(np);
+       }
 
        return 0;