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

	down(&c->lct_lock);

	if (c->lct)

	kfree(c->lct);

	lct = c->dlct.virt;

 *	ResultCount, ErrorInfoSize, BlockStatus and BlockSize.

 */

int i2o_parm_issue(struct i2o_device *i2o_dev, int cmd, void *oplist,

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;

		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 */

#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;

	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;

	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;

		}

	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;

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

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

	}

};

 *	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;

	}

	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;

	}

		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;

	}

	if (unlikely(!drv->reply)) {

		pr_debug("%s: Reply to driver %s, but no reply function"

		osm_debug("%s: Reply to driver %s, but no reply function"

			  " defined!\n", c->name, drv->name);

		return -EIO;

	}

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

 *	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)

	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();

	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 {

 *	@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

 *	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

	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;

 *	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);

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

};

/**

 *	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;

	if (end_that_request_chunk(req, uptodate, nr_bytes)) {

		int leftover = (req->hard_nr_sectors << 9);

		/*

		 * 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 (blk_pc_request(req))

			leftover = req->data_len;

		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 (end_io_error(uptodate))

			end_that_request_chunk(req, 0, leftover);

	}

		ireq = req->special;

		dev = ireq->i2o_blk_dev;

		q = dev->gd->queue;

		req->errors++;

	add_disk_randomness(req->rq_disk);

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

	dev->open_queue_depth--;

	list_del(&ireq->queue);

	blk_start_queue(q);

	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)) {

		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)

		 *      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);

		dev->open_queue_depth--;

		list_del(&ireq->queue);

		blk_start_queue(q);

		req->errors++;

		spin_unlock_irqrestore(q->queue_lock, flags);

		uptodate = 0;

	}

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

};

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

	int rc;

	u64 size;

	u32 blocksize;

	u16 power;

	u32 flags, status;

	int segments;

		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;

	 *      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);

	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;

		}

	osm_debug("blocksize = %d\n", blocksize);

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

	unit++;

	osm_info("device added (TID: %03x): %s\n", i2o_dev->lct_data.tid,

		 i2o_blk_dev->gd->disk_name);

	return 0;

      claim_release:

	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 */

};