[PATCH] I2O: first code cleanup of spare warnings and unused functions

Changes:

 - Removed unnecessary checking of NULL before calling kfree()
 - Make some functions static
 - Changed pr_debug() into osm_debug()
 - Use i2o_msg_in_to_virt() for getting a pointer to the message frame
 - Cleaned up some comments
 - Changed some le32_to_cpu() into readl() where necessary
 - Make error messages of OSM's look the same
 - Cleaned up error handling in i2o_block_end_request()
 - Removed unused error handling of failed messages in Block-OSM, which
   are not allowed by the I2O spec
 - Corrected the blocksize detection in i2o_block
 - Added hrt and lct sysfs-attribute to controller
 - Call done() function in SCSI-OSM after freeing DMA buffers
 - Removed unneeded variable for message size calculation in
   i2o_scsi_queuecommand()
 - Make some changes to remove sparse warnings
 - Reordered some functions
 - Cleaned up controller initialization
 - Replaced some magic numbers by defines
 - Removed unnecessary dma_sync_single_for_cpu() call on coherent DMA
 - Removed some unused fields in i2o_controller and removed some unused
   functions

Signed-off-by: Markus Lidel <Markus.Lidel@shadowconnect.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

1 files changed, 24 insertions, 22 deletions

diff --git a/drivers/message/i2o/driver.c b/drivers/message/i2o/driver.c
index c71e68f70e7d..bebdd509b5d8 100644
--- a/drivers/message/i2o/driver.c
+++ b/drivers/message/i2o/driver.c
@@ -18,7 +18,7 @@
 #include <linux/rwsem.h>
 #include <linux/i2o.h>
 
-#define OSM_NAME        "core"
+#define OSM_NAME        "i2o"
 
 /* max_drivers - Maximum I2O drivers (OSMs) which could be registered */
 unsigned int i2o_max_drivers = I2O_MAX_DRIVERS;
@@ -78,17 +78,16 @@ int i2o_driver_register(struct i2o_driver *drv)
         int rc = 0;
         unsigned long flags;
 
-        pr_debug("i2o: Register driver %s\n", drv->name);
+        osm_debug("Register driver %s\n", drv->name);
 
         if (drv->event) {
                 drv->event_queue = create_workqueue(drv->name);
                 if (!drv->event_queue) {
-                        printk(KERN_ERR "i2o: Could not initialize event queue "
-                               "for driver %s\n", drv->name);
+                        osm_err("Could not initialize event queue for driver "
+                                "%s\n", drv->name);
                         return -EFAULT;
                 }
-                pr_debug("i2o: Event queue initialized for driver %s\n",
-                         drv->name);
+                osm_debug("Event queue initialized for driver %s\n", drv->name);
         } else
                 drv->event_queue = NULL;
 
@@ -99,8 +98,8 @@ int i2o_driver_register(struct i2o_driver *drv)
 
         for (i = 0; i2o_drivers[i]; i++)
                 if (i >= i2o_max_drivers) {
-                        printk(KERN_ERR "i2o: too many drivers registered, "
-                               "increase max_drivers\n");
+                        osm_err("too many drivers registered, increase "
+                                "max_drivers\n");
                         spin_unlock_irqrestore(&i2o_drivers_lock, flags);
                         return -EFAULT;
                 }
@@ -110,8 +109,7 @@ int i2o_driver_register(struct i2o_driver *drv)
 
         spin_unlock_irqrestore(&i2o_drivers_lock, flags);
 
-        pr_debug("i2o: driver %s gets context id %d\n", drv->name,
-                 drv->context);
+        osm_debug("driver %s gets context id %d\n", drv->name, drv->context);
 
         list_for_each_entry(c, &i2o_controllers, list) {
                 struct i2o_device *i2o_dev;
@@ -141,7 +139,7 @@ void i2o_driver_unregister(struct i2o_driver *drv)
         struct i2o_controller *c;
         unsigned long flags;
 
-        pr_debug("i2o: unregister driver %s\n", drv->name);
+        osm_debug("unregister driver %s\n", drv->name);
 
         driver_unregister(&drv->driver);
 
@@ -161,7 +159,7 @@ void i2o_driver_unregister(struct i2o_driver *drv)
         if (drv->event_queue) {
                 destroy_workqueue(drv->event_queue);
                 drv->event_queue = NULL;
-                pr_debug("i2o: event queue removed for %s\n", drv->name);
+                osm_debug("event queue removed for %s\n", drv->name);
         }
 };
 
@@ -178,15 +176,15 @@ void i2o_driver_unregister(struct i2o_driver *drv)
  *      on success and if the message should be flushed afterwords. Returns
  *      negative error code on failure (the message will be flushed too).
  */
-int i2o_driver_dispatch(struct i2o_controller *c, u32 m,
-                        struct i2o_message __iomem *msg)
+int i2o_driver_dispatch(struct i2o_controller *c, u32 m)
 {
         struct i2o_driver *drv;
+        struct i2o_message __iomem *msg = i2o_msg_out_to_virt(c, m);
         u32 context = readl(&msg->u.s.icntxt);
 
         if (unlikely(context >= i2o_max_drivers)) {
-                printk(KERN_WARNING "%s: Spurious reply to unknown driver "
-                       "%d\n", c->name, readl(&msg->u.s.icntxt));
+                osm_warn("%s: Spurious reply to unknown driver %d\n", c->name,
+                         context);
                 return -EIO;
         }
 
@@ -195,7 +193,8 @@ int i2o_driver_dispatch(struct i2o_controller *c, u32 m,
         spin_unlock(&i2o_drivers_lock);
 
         if (unlikely(!drv)) {
-                osm_warn("Spurious reply to unknown driver %d\n", context);
+                osm_warn("%s: Spurious reply to unknown driver %d\n", c->name,
+                         context);
                 return -EIO;
         }
 
@@ -207,6 +206,9 @@ int i2o_driver_dispatch(struct i2o_controller *c, u32 m,
 
                 osm_debug("event received from device %d\n", tid);
 
+                if (!drv->event)
+                        return -EIO;
+
                 /* cut of header from message size (in 32-bit words) */
                 size = (readl(&msg->u.head[0]) >> 16) - 5;
 
@@ -231,8 +233,8 @@ int i2o_driver_dispatch(struct i2o_controller *c, u32 m,
         }
 
         if (unlikely(!drv->reply)) {
-                pr_debug("%s: Reply to driver %s, but no reply function"
-                         " defined!\n", c->name, drv->name);
+                osm_debug("%s: Reply to driver %s, but no reply function"
+                          " defined!\n", c->name, drv->name);
                 return -EIO;
         }
 
@@ -333,11 +335,11 @@ int __init i2o_driver_init(void)
         if ((i2o_max_drivers < 2) || (i2o_max_drivers > 64) ||
             ((i2o_max_drivers ^ (i2o_max_drivers - 1)) !=
              (2 * i2o_max_drivers - 1))) {
-                printk(KERN_WARNING "i2o: max_drivers set to %d, but must be "
-                       ">=2 and <= 64 and a power of 2\n", i2o_max_drivers);
+                osm_warn("max_drivers set to %d, but must be >=2 and <= 64 and "
+                         "a power of 2\n", i2o_max_drivers);
                 i2o_max_drivers = I2O_MAX_DRIVERS;
         }
-        printk(KERN_INFO "i2o: max drivers = %d\n", i2o_max_drivers);
+        osm_info("max drivers = %d\n", i2o_max_drivers);
 
         i2o_drivers =
             kmalloc(i2o_max_drivers * sizeof(*i2o_drivers), GFP_KERNEL);