ps3: FLASH ROM Storage Driver

[linux-2.6-omap-h63xx.git] / block / bsg.c

diff --git a/block/bsg.c b/block/bsg.c
index 26a9372962cebed8cd4520cbba2c7216e754bc5f..f2992e72b841e232d5d8b0296b6af9ddb90ac31b 100644 (file)
--- a/block/bsg.c
+++ b/block/bsg.c
@@ -33,7 +33,8 @@
 #include <scsi/scsi_driver.h>
 #include <scsi/sg.h>
 
-const static char bsg_version[] = "block layer sg (bsg) 0.4";
+#define BSG_DESCRIPTION        "Block layer SCSI generic (bsg) driver"
+#define BSG_VERSION    "0.4"
 
 struct bsg_device {
        request_queue_t *queue;
@@ -68,20 +69,15 @@ enum {
 #define dprintk(fmt, args...)
 #endif
 
-/*
- * just for testing
- */
-#define BSG_MAJOR      (240)
-
 static DEFINE_MUTEX(bsg_mutex);
 static int bsg_device_nr, bsg_minor_idx;
 
 #define BSG_LIST_ARRAY_SIZE    8
-#define bsg_list_idx(minor)    ((minor) & (BSG_LIST_ARRAY_SIZE - 1))
 static struct hlist_head bsg_device_list[BSG_LIST_ARRAY_SIZE];
 
 static struct class *bsg_class;
 static LIST_HEAD(bsg_class_list);
+static int bsg_major;
 
 static struct kmem_cache *bsg_cmd_cachep;
 
@@ -143,9 +139,9 @@ out:
        return bc;
 }
 
-static inline void
-bsg_add_done_cmd(struct bsg_device *bd, struct bsg_command *bc)
+static inline struct hlist_head *bsg_dev_idx_hash(int index)
 {
+       return &bsg_device_list[index & (BSG_LIST_ARRAY_SIZE - 1)];
 }
 
 static int bsg_io_schedule(struct bsg_device *bd)
@@ -752,8 +748,7 @@ static struct bsg_device *bsg_add_device(struct inode *inode,
        atomic_set(&bd->ref_count, 1);
        bd->minor = iminor(inode);
        mutex_lock(&bsg_mutex);
-       hlist_add_head(&bd->dev_list,
-               &bsg_device_list[bd->minor & (BSG_LIST_ARRAY_SIZE - 1)]);
+       hlist_add_head(&bd->dev_list, bsg_dev_idx_hash(bd->minor));
 
        strncpy(bd->name, rq->bsg_dev.class_dev->class_id, sizeof(bd->name) - 1);
        dprintk("bound to <%s>, max queue %d\n",
@@ -765,14 +760,12 @@ static struct bsg_device *bsg_add_device(struct inode *inode,
 
 static struct bsg_device *__bsg_get_device(int minor)
 {
-       struct hlist_head *list;
        struct bsg_device *bd = NULL;
        struct hlist_node *entry;
 
        mutex_lock(&bsg_mutex);
 
-       list = &bsg_device_list[minor & (BSG_LIST_ARRAY_SIZE - 1)];
-       hlist_for_each(entry, list) {
+       hlist_for_each(entry, bsg_dev_idx_hash(minor)) {
                bd = hlist_entry(entry, struct bsg_device, dev_list);
                if (bd->minor == minor) {
                        atomic_inc(&bd->ref_count);
@@ -943,7 +936,7 @@ void bsg_unregister_queue(struct request_queue *q)
 
        mutex_lock(&bsg_mutex);
        sysfs_remove_link(&q->kobj, "bsg");
-       class_device_destroy(bsg_class, MKDEV(BSG_MAJOR, bcd->minor));
+       class_device_destroy(bsg_class, MKDEV(bsg_major, bcd->minor));
        bcd->class_dev = NULL;
        list_del_init(&bcd->list);
        bsg_device_nr--;
@@ -989,7 +982,7 @@ retry:
                bsg_minor_idx = 0;
 
        bcd->queue = q;
-       dev = MKDEV(BSG_MAJOR, bcd->minor);
+       dev = MKDEV(bsg_major, bcd->minor);
        class_dev = class_device_create(bsg_class, NULL, dev, bcd->dev, "%s", name);
        if (IS_ERR(class_dev)) {
                ret = PTR_ERR(class_dev);
@@ -1010,7 +1003,7 @@ retry:
        return 0;
 err:
        if (class_dev)
-               class_device_destroy(bsg_class, MKDEV(BSG_MAJOR, bcd->minor));
+               class_device_destroy(bsg_class, MKDEV(bsg_major, bcd->minor));
        mutex_unlock(&bsg_mutex);
        return ret;
 }
@@ -1047,9 +1040,10 @@ static struct cdev bsg_cdev = {
 static int __init bsg_init(void)
 {
        int ret, i;
+       dev_t devid;
 
        bsg_cmd_cachep = kmem_cache_create("bsg_cmd",
-                               sizeof(struct bsg_command), 0, 0, NULL, NULL);
+                               sizeof(struct bsg_command), 0, 0, NULL);
        if (!bsg_cmd_cachep) {
                printk(KERN_ERR "bsg: failed creating slab cache\n");
                return -ENOMEM;
@@ -1060,41 +1054,42 @@ static int __init bsg_init(void)
 
        bsg_class = class_create(THIS_MODULE, "bsg");
        if (IS_ERR(bsg_class)) {
-               kmem_cache_destroy(bsg_cmd_cachep);
-               return PTR_ERR(bsg_class);
+               ret = PTR_ERR(bsg_class);
+               goto destroy_kmemcache;
        }
 
-       ret = register_chrdev_region(MKDEV(BSG_MAJOR, 0), BSG_MAX_DEVS, "bsg");
-       if (ret) {
-               kmem_cache_destroy(bsg_cmd_cachep);
-               class_destroy(bsg_class);
-               return ret;
-       }
+       ret = alloc_chrdev_region(&devid, 0, BSG_MAX_DEVS, "bsg");
+       if (ret)
+               goto destroy_bsg_class;
+
+       bsg_major = MAJOR(devid);
 
        cdev_init(&bsg_cdev, &bsg_fops);
-       ret = cdev_add(&bsg_cdev, MKDEV(BSG_MAJOR, 0), BSG_MAX_DEVS);
-       if (ret) {
-               kmem_cache_destroy(bsg_cmd_cachep);
-               class_destroy(bsg_class);
-               unregister_chrdev_region(MKDEV(BSG_MAJOR, 0), BSG_MAX_DEVS);
-               return ret;
-       }
+       ret = cdev_add(&bsg_cdev, MKDEV(bsg_major, 0), BSG_MAX_DEVS);
+       if (ret)
+               goto unregister_chrdev;
 
        ret = scsi_register_interface(&bsg_intf);
-       if (ret) {
-               printk(KERN_ERR "bsg: failed register scsi interface %d\n", ret);
-               kmem_cache_destroy(bsg_cmd_cachep);
-               class_destroy(bsg_class);
-               unregister_chrdev(BSG_MAJOR, "bsg");
-               return ret;
-       }
+       if (ret)
+               goto remove_cdev;
 
-       printk(KERN_INFO "%s loaded\n", bsg_version);
+       printk(KERN_INFO BSG_DESCRIPTION " version " BSG_VERSION
+              " loaded (major %d)\n", bsg_major);
        return 0;
+remove_cdev:
+       printk(KERN_ERR "bsg: failed register scsi interface %d\n", ret);
+       cdev_del(&bsg_cdev);
+unregister_chrdev:
+       unregister_chrdev_region(MKDEV(bsg_major, 0), BSG_MAX_DEVS);
+destroy_bsg_class:
+       class_destroy(bsg_class);
+destroy_kmemcache:
+       kmem_cache_destroy(bsg_cmd_cachep);
+       return ret;
 }
 
 MODULE_AUTHOR("Jens Axboe");
-MODULE_DESCRIPTION("Block layer SGSI generic (sg) driver");
+MODULE_DESCRIPTION(BSG_DESCRIPTION);
 MODULE_LICENSE("GPL");
 
 device_initcall(bsg_init);