Commit f88e119c authored by Markus Lidel's avatar Markus Lidel Committed by Linus Torvalds
Browse files

[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: default avatarMarkus Lidel <Markus.Lidel@shadowconnect.com>
Signed-off-by: default avatarAndrew Morton <akpm@osdl.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@osdl.org>
parent 61fbfa81
......@@ -282,8 +282,7 @@ int i2o_device_parse_lct(struct i2o_controller *c)
down(&c->lct_lock);
if (c->lct)
kfree(c->lct);
kfree(c->lct);
lct = c->dlct.virt;
......@@ -447,8 +446,8 @@ static struct class_interface i2o_device_class_interface = {
* ResultCount, ErrorInfoSize, BlockStatus and BlockSize.
*/
int i2o_parm_issue(struct i2o_device *i2o_dev, int cmd, void *oplist,
int oplen, void *reslist, int reslen)
static int i2o_parm_issue(struct i2o_device *i2o_dev, int cmd, void *oplist,
int oplen, void *reslist, int reslen)
{
struct i2o_message __iomem *msg;
u32 m;
......@@ -540,7 +539,7 @@ int i2o_parm_field_get(struct i2o_device *i2o_dev, int group, int field,
opblk[4] = -1;
size = i2o_parm_issue(i2o_dev, I2O_CMD_UTIL_PARAMS_GET, opblk,
sizeof(opblk), resblk, sizeof(resblk));
sizeof(opblk), resblk, buflen + 8);
memcpy(buf, resblk + 8, buflen); /* cut off header */
......
......@@ -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);
......
......@@ -108,7 +108,8 @@ static void i2o_exec_wait_free(struct i2o_exec_wait *wait)
* buffer must not be freed. Instead the event completion will free them
* for you. In all other cases the buffer are your problem.
*
* Returns 0 on success or negative error code on failure.
* Returns 0 on success, negative error code on timeout or positive error
* code from reply.
*/
int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
timeout, struct i2o_dma *dma)
......@@ -116,7 +117,7 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
DECLARE_WAIT_QUEUE_HEAD(wq);
struct i2o_exec_wait *wait;
static u32 tcntxt = 0x80000000;
struct i2o_message __iomem *msg = c->in_queue.virt + m;
struct i2o_message __iomem *msg = i2o_msg_in_to_virt(c, m);
int rc = 0;
wait = i2o_exec_wait_alloc();
......@@ -161,8 +162,7 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
barrier();
if (wait->complete) {
if (readl(&wait->msg->body[0]) >> 24)
rc = readl(&wait->msg->body[0]) & 0xff;
rc = readl(&wait->msg->body[0]) >> 24;
i2o_flush_reply(c, wait->m);
i2o_exec_wait_free(wait);
} else {
......@@ -187,6 +187,7 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
* @c: I2O controller which answers
* @m: message id
* @msg: pointer to the I2O reply message
* @context: transaction context of request
*
* This function is called in interrupt context only. If the reply reached
* before the timeout, the i2o_exec_wait struct is filled with the message
......@@ -201,14 +202,12 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long
* message must also be given back to the controller.
*/
static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
struct i2o_message __iomem *msg)
struct i2o_message __iomem *msg,
u32 context)
{
struct i2o_exec_wait *wait, *tmp;
static spinlock_t lock = SPIN_LOCK_UNLOCKED;
int rc = 1;
u32 context;
context = readl(&msg->u.s.tcntxt);
/*
* We need to search through the i2o_exec_wait_list to see if the given
......@@ -251,7 +250,7 @@ static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m,
spin_unlock(&lock);
pr_debug("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name,
osm_warn("%s: Bogus reply in POST WAIT (tr-context: %08x)!\n", c->name,
context);
return -1;
......@@ -321,29 +320,35 @@ static void i2o_exec_lct_modified(struct i2o_controller *c)
* code on failure and if the reply should be flushed.
*/
static int i2o_exec_reply(struct i2o_controller *c, u32 m,
struct i2o_message *msg)
struct i2o_message __iomem *msg)
{
if (le32_to_cpu(msg->u.head[0]) & MSG_FAIL) { // Fail bit is set
struct i2o_message __iomem *pmsg; /* preserved message */
u32 context;
if (readl(&msg->u.head[0]) & MSG_FAIL) {
/*
* If Fail bit is set we must take the transaction context of
* the preserved message to find the right request again.
*/
struct i2o_message __iomem *pmsg;
u32 pm;
pm = le32_to_cpu(msg->body[3]);
pm = readl(&msg->body[3]);
pmsg = i2o_msg_in_to_virt(c, pm);
i2o_report_status(KERN_INFO, "i2o_core", msg);
/* Release the preserved msg by resubmitting it as a NOP */
i2o_msg_nop(c, pm);
context = readl(&pmsg->u.s.tcntxt);
/* If reply to i2o_post_wait failed, return causes a timeout */
return -1;
}
/* Release the preserved msg */
i2o_msg_nop(c, pm);
} else
context = readl(&msg->u.s.tcntxt);
if (le32_to_cpu(msg->u.s.tcntxt) & 0x80000000)
return i2o_msg_post_wait_complete(c, m, msg);
if (context & 0x80000000)
return i2o_msg_post_wait_complete(c, m, msg, context);
if ((le32_to_cpu(msg->u.head[1]) >> 24) == I2O_CMD_LCT_NOTIFY) {
if ((readl(&msg->u.head[1]) >> 24) == I2O_CMD_LCT_NOTIFY) {
struct work_struct *work;
pr_debug("%s: LCT notify received\n", c->name);
......
......@@ -104,7 +104,8 @@ static int i2o_block_remove(struct device *dev)
struct i2o_device *i2o_dev = to_i2o_device(dev);
struct i2o_block_device *i2o_blk_dev = dev_get_drvdata(dev);
osm_info("Device removed %s\n", i2o_blk_dev->gd->disk_name);
osm_info("device removed (TID: %03x): %s\n", i2o_dev->lct_data.tid,
i2o_blk_dev->gd->disk_name);
i2o_event_register(i2o_dev, &i2o_block_driver, 0, 0);
......@@ -400,71 +401,62 @@ static void i2o_block_delayed_request_fn(void *delayed_request)
};
/**
* i2o_block_reply - Block OSM reply handler.
* @c: I2O controller from which the message arrives
* @m: message id of reply
* qmsg: the actuall I2O message reply
* i2o_block_end_request - Post-processing of completed commands
* @req: request which should be completed
* @uptodate: 1 for success, 0 for I/O error, < 0 for specific error
* @nr_bytes: number of bytes to complete
*
* This function gets all the message replies.
* Mark the request as complete. The lock must not be held when entering.
*
*/
static int i2o_block_reply(struct i2o_controller *c, u32 m,
struct i2o_message *msg)
static void i2o_block_end_request(struct request *req, int uptodate,
int nr_bytes)
{
struct i2o_block_request *ireq;
struct request *req;
struct i2o_block_device *dev;
struct request_queue *q;
u8 st;
struct i2o_block_request *ireq = req->special;
struct i2o_block_device *dev = ireq->i2o_blk_dev;
request_queue_t *q = dev->gd->queue;
unsigned long flags;
/* FAILed message */
if (unlikely(le32_to_cpu(msg->u.head[0]) & (1 << 13))) {
struct i2o_message *pmsg;
u32 pm;
/*
* FAILed message from controller
* We increment the error count and abort it
*
* In theory this will never happen. The I2O block class
* specification states that block devices never return
* FAILs but instead use the REQ status field...but
* better be on the safe side since no one really follows
* the spec to the book :)
*/
pm = le32_to_cpu(msg->body[3]);
pmsg = i2o_msg_in_to_virt(c, pm);
if (end_that_request_chunk(req, uptodate, nr_bytes)) {
int leftover = (req->hard_nr_sectors << 9);
req = i2o_cntxt_list_get(c, le32_to_cpu(pmsg->u.s.tcntxt));
if (unlikely(!req)) {
osm_err("NULL reply received!\n");
return -1;
}
if (blk_pc_request(req))
leftover = req->data_len;
ireq = req->special;
dev = ireq->i2o_blk_dev;
q = dev->gd->queue;
if (end_io_error(uptodate))
end_that_request_chunk(req, 0, leftover);
}
req->errors++;
add_disk_randomness(req->rq_disk);
spin_lock_irqsave(q->queue_lock, flags);
spin_lock_irqsave(q->queue_lock, flags);
while (end_that_request_chunk(req, !req->errors,
le32_to_cpu(pmsg->body[1]))) ;
end_that_request_last(req);
end_that_request_last(req);
dev->open_queue_depth--;
list_del(&ireq->queue);
dev->open_queue_depth--;
list_del(&ireq->queue);
blk_start_queue(q);
blk_start_queue(q);
spin_unlock_irqrestore(q->queue_lock, flags);
spin_unlock_irqrestore(q->queue_lock, flags);
/* Now flush the message by making it a NOP */
i2o_msg_nop(c, pm);
i2o_block_sglist_free(ireq);
i2o_block_request_free(ireq);
};
return -1;
}
/**
* i2o_block_reply - Block OSM reply handler.
* @c: I2O controller from which the message arrives
* @m: message id of reply
* qmsg: the actuall I2O message reply
*
* This function gets all the message replies.
*
*/
static int i2o_block_reply(struct i2o_controller *c, u32 m,
struct i2o_message *msg)
{
struct request *req;
int uptodate = 1;
req = i2o_cntxt_list_get(c, le32_to_cpu(msg->u.s.tcntxt));
if (unlikely(!req)) {
......@@ -472,61 +464,13 @@ static int i2o_block_reply(struct i2o_controller *c, u32 m,
return -1;
}
ireq = req->special;
dev = ireq->i2o_blk_dev;
q = dev->gd->queue;
if (unlikely(!dev->i2o_dev)) {
/*
* This is HACK, but Intel Integrated RAID allows user
* to delete a volume that is claimed, locked, and in use
* by the OS. We have to check for a reply from a
* non-existent device and flag it as an error or the system
* goes kaput...
*/
req->errors++;
osm_warn("Data transfer to deleted device!\n");
spin_lock_irqsave(q->queue_lock, flags);
while (end_that_request_chunk
(req, !req->errors, le32_to_cpu(msg->body[1]))) ;
end_that_request_last(req);
dev->open_queue_depth--;
list_del(&ireq->queue);
blk_start_queue(q);
spin_unlock_irqrestore(q->queue_lock, flags);
return -1;
}
/*
* Lets see what is cooking. We stuffed the
* request in the context.
*/
st = le32_to_cpu(msg->body[0]) >> 24;
if (st != 0) {
int err;
char *bsa_errors[] = {
"Success",
"Media Error",
"Failure communicating to device",
"Device Failure",
"Device is not ready",
"Media not present",
"Media is locked by another user",
"Media has failed",
"Failure communicating to device",
"Device bus failure",
"Device is locked by another user",
"Device is write protected",
"Device has reset",
"Volume has changed, waiting for acknowledgement"
};
err = le32_to_cpu(msg->body[0]) & 0xffff;
if ((le32_to_cpu(msg->body[0]) >> 24) != 0) {
u32 status = le32_to_cpu(msg->body[0]);
/*
* Device not ready means two things. One is that the
* the thing went offline (but not a removal media)
......@@ -539,40 +483,23 @@ static int i2o_block_reply(struct i2o_controller *c, u32 m,
* Don't stick a supertrak100 into cache aggressive modes
*/
osm_err("block-osm: /dev/%s error: %s", dev->gd->disk_name,
bsa_errors[le32_to_cpu(msg->body[0]) & 0xffff]);
if (le32_to_cpu(msg->body[0]) & 0x00ff0000)
printk(KERN_ERR " - DDM attempted %d retries",
(le32_to_cpu(msg->body[0]) >> 16) & 0x00ff);
printk(KERN_ERR ".\n");
req->errors++;
} else
req->errors = 0;
if (!end_that_request_chunk
(req, !req->errors, le32_to_cpu(msg->body[1]))) {
add_disk_randomness(req->rq_disk);
spin_lock_irqsave(q->queue_lock, flags);
osm_err("%03x error status: %02x, detailed status: %04x\n",
(le32_to_cpu(msg->u.head[1]) >> 12 & 0xfff),
status >> 24, status & 0xffff);
end_that_request_last(req);
req->errors++;
dev->open_queue_depth--;
list_del(&ireq->queue);
blk_start_queue(q);
uptodate = 0;
}
spin_unlock_irqrestore(q->queue_lock, flags);
i2o_block_sglist_free(ireq);
i2o_block_request_free(ireq);
} else
osm_err("still remaining chunks\n");
i2o_block_end_request(req, uptodate, le32_to_cpu(msg->body[1]));
return 1;
};
static void i2o_block_event(struct i2o_event *evt)
{
osm_info("block-osm: event received\n");
osm_info("event received\n");
kfree(evt);
};
......@@ -875,9 +802,7 @@ static int i2o_block_transfer(struct request *req)
sg++;
}
writel(I2O_MESSAGE_SIZE
(((unsigned long)mptr -
(unsigned long)&msg->u.head[0]) >> 2) | SGL_OFFSET_8,
writel(I2O_MESSAGE_SIZE(mptr - &msg->u.head[0]) | SGL_OFFSET_8,
&msg->u.head[0]);
list_add_tail(&ireq->queue, &dev->open_queue);
......@@ -1048,7 +973,6 @@ static int i2o_block_probe(struct device *dev)
int rc;
u64 size;
u32 blocksize;
u16 power;
u32 flags, status;
int segments;
......@@ -1058,8 +982,6 @@ static int i2o_block_probe(struct device *dev)
return -ENODEV;
}
osm_info("New device detected (TID: %03x)\n", i2o_dev->lct_data.tid);
if (i2o_device_claim(i2o_dev)) {
osm_warn("Unable to claim device. Installation aborted\n");
rc = -EFAULT;
......@@ -1111,15 +1033,21 @@ static int i2o_block_probe(struct device *dev)
* Ask for the current media data. If that isn't supported
* then we ask for the device capacity data
*/
if (i2o_parm_field_get(i2o_dev, 0x0004, 1, &blocksize, 4) != 0
|| i2o_parm_field_get(i2o_dev, 0x0004, 0, &size, 8) != 0) {
i2o_parm_field_get(i2o_dev, 0x0000, 3, &blocksize, 4);
i2o_parm_field_get(i2o_dev, 0x0000, 4, &size, 8);
}
osm_debug("blocksize = %d\n", blocksize);
if (!i2o_parm_field_get(i2o_dev, 0x0004, 0, &size, 8))
if (!i2o_parm_field_get(i2o_dev, 0x0000, 4, &size, 8)) {
osm_warn("could not get size of %s\n", gd->disk_name);
size = 0;
}
if (i2o_parm_field_get(i2o_dev, 0x0000, 2, &power, 2))
power = 0;
if (!i2o_parm_field_get(i2o_dev, 0x0004, 1, &blocksize, 4))
if (!i2o_parm_field_get(i2o_dev, 0x0000, 3, &blocksize, 4)) {
osm_warn("unable to get blocksize of %s\n",
gd->disk_name);
blocksize = 0;
}
if (!i2o_parm_field_get(i2o_dev, 0x0000, 2, &i2o_blk_dev->power, 2))
i2o_blk_dev->power = 0;
i2o_parm_field_get(i2o_dev, 0x0000, 5, &flags, 4);
i2o_parm_field_get(i2o_dev, 0x0000, 6, &status, 4);
......@@ -1131,6 +1059,9 @@ static int i2o_block_probe(struct device *dev)
unit++;
osm_info("device added (TID: %03x): %s\n", i2o_dev->lct_data.tid,
i2o_blk_dev->gd->disk_name);
return 0;
claim_release:
......
......@@ -74,7 +74,7 @@ struct i2o_block_device {
int rcache; /* read cache flags */
int wcache; /* write cache flags */
int flags;
int power; /* power state */
u16 power; /* power state */
int media_change_flag; /* media changed flag */
};
......
......@@ -80,13 +80,123 @@ struct i2o_cfg_info {
static struct i2o_cfg_info *open_files = NULL;
static ulong i2o_cfg_info_id = 0;
/*
* Each of these describes an i2o message handler. They are
* multiplexed by the i2o_core code
/**
* i2o_config_read_hrt - Returns the HRT of the controller
* @kob: kernel object handle
* @buf: buffer into which the HRT should be copied
* @off: file offset
* @count: number of bytes to read
*
* Put @count bytes starting at @off into @buf from the HRT of the I2O
* controller corresponding to @kobj.
*
* Returns number of bytes copied into buffer.
*/
static ssize_t i2o_config_read_hrt(struct kobject *kobj, char *buf,
loff_t offset, size_t count)
{
struct i2o_controller *c = to_i2o_controller(container_of(kobj,
struct device,
kobj));
i2o_hrt *hrt = c->hrt.virt;
u32 size = (hrt->num_entries * hrt->entry_len + 2) * 4;