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

[PATCH] I2O: changed I2O API to create I2O messages in kernel memory 



Changed the I2O API to create I2O messages first in kernel memory and then
transfer it at once over the PCI bus instead of sending each quad-word over
the PCI bus.

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 347a8dc3

drivers/message/i2o/bus-osm.c

+11 −10
Original line number Diff line number Diff line
@@ -39,18 +39,18 @@ static struct i2o_class_id i2o_bus_class_id[] = { 
 */

static int i2o_bus_scan(struct i2o_device *dev)

{

	struct i2o_message __iomem *msg;

	u32 m;

	struct i2o_message *msg;



	m = i2o_msg_get_wait(dev->iop, &msg, I2O_TIMEOUT_MESSAGE_GET);

	if (m == I2O_QUEUE_EMPTY)

	msg = i2o_msg_get_wait(dev->iop, I2O_TIMEOUT_MESSAGE_GET);

	if (IS_ERR(msg))

		return -ETIMEDOUT;



	writel(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);

	writel(I2O_CMD_BUS_SCAN << 24 | HOST_TID << 12 | dev->lct_data.tid,

	       &msg->u.head[1]);

	msg->u.head[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0);

	msg->u.head[1] =

	    cpu_to_le32(I2O_CMD_BUS_SCAN << 24 | HOST_TID << 12 | dev->lct_data.

			tid);



	return i2o_msg_post_wait(dev->iop, m, 60);

	return i2o_msg_post_wait(dev->iop, msg, 60);

};



/**
@@ -59,8 +59,9 @@ static int i2o_bus_scan(struct i2o_device *dev) 
 *

 *	Returns count.

 */

static ssize_t i2o_bus_store_scan(struct device *d, struct device_attribute *attr, const char *buf,

				  size_t count)

static ssize_t i2o_bus_store_scan(struct device *d,

				  struct device_attribute *attr,

				  const char *buf, size_t count)

{

	struct i2o_device *i2o_dev = to_i2o_device(d);

	int rc;

drivers/message/i2o/device.c

+26 −25
Original line number Diff line number Diff line
@@ -35,18 +35,18 @@ 
static inline int i2o_device_issue_claim(struct i2o_device *dev, u32 cmd,

					 u32 type)

{

	struct i2o_message __iomem *msg;

	u32 m;

	struct i2o_message *msg;



	m = i2o_msg_get_wait(dev->iop, &msg, I2O_TIMEOUT_MESSAGE_GET);

	if (m == I2O_QUEUE_EMPTY)

		return -ETIMEDOUT;

	msg = i2o_msg_get_wait(dev->iop, I2O_TIMEOUT_MESSAGE_GET);

	if (IS_ERR(msg))

		return PTR_ERR(msg);



	writel(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);

	writel(cmd << 24 | HOST_TID << 12 | dev->lct_data.tid, &msg->u.head[1]);

	writel(type, &msg->body[0]);

	msg->u.head[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0);

	msg->u.head[1] =

		cpu_to_le32(cmd << 24 | HOST_TID << 12 | dev->lct_data.tid);

	msg->body[0] = cpu_to_le32(type);



	return i2o_msg_post_wait(dev->iop, m, 60);

	return i2o_msg_post_wait(dev->iop, msg, 60);

}



/**
@@ -421,8 +421,7 @@ int i2o_device_parse_lct(struct i2o_controller *c) 
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;

	struct i2o_message *msg;

	u32 *res32 = (u32 *) reslist;

	u32 *restmp = (u32 *) reslist;

	int len = 0;
@@ -437,26 +436,28 @@ int i2o_parm_issue(struct i2o_device *i2o_dev, int cmd, void *oplist, 
	if (i2o_dma_alloc(dev, &res, reslen, GFP_KERNEL))

		return -ENOMEM;



	m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);

	if (m == I2O_QUEUE_EMPTY) {

	msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);

	if (IS_ERR(msg)) {

		i2o_dma_free(dev, &res);

		return -ETIMEDOUT;

		return PTR_ERR(msg);

	}



	i = 0;

	writel(cmd << 24 | HOST_TID << 12 | i2o_dev->lct_data.tid,

	       &msg->u.head[1]);

	writel(0, &msg->body[i++]);

	writel(0x4C000000 | oplen, &msg->body[i++]);	/* OperationList */

	memcpy_toio(&msg->body[i], oplist, oplen);

	msg->u.head[1] =

	    cpu_to_le32(cmd << 24 | HOST_TID << 12 | i2o_dev->lct_data.tid);

	msg->body[i++] = cpu_to_le32(0x00000000);

	msg->body[i++] = cpu_to_le32(0x4C000000 | oplen);	/* OperationList */

	memcpy(&msg->body[i], oplist, oplen);



	i += (oplen / 4 + (oplen % 4 ? 1 : 0));

	writel(0xD0000000 | res.len, &msg->body[i++]);	/* ResultList */

	writel(res.phys, &msg->body[i++]);

	msg->body[i++] = cpu_to_le32(0xD0000000 | res.len);	/* ResultList */

	msg->body[i++] = cpu_to_le32(res.phys);



	writel(I2O_MESSAGE_SIZE(i + sizeof(struct i2o_message) / 4) |

	       SGL_OFFSET_5, &msg->u.head[0]);

	msg->u.head[0] =

	    cpu_to_le32(I2O_MESSAGE_SIZE(i + sizeof(struct i2o_message) / 4) |

			SGL_OFFSET_5);



	rc = i2o_msg_post_wait_mem(c, m, 10, &res);

	rc = i2o_msg_post_wait_mem(c, msg, 10, &res);



	/* This only looks like a memory leak - don't "fix" it. */

	if (rc == -ETIMEDOUT)

drivers/message/i2o/exec-osm.c

+47 −46
Original line number Diff line number Diff line
@@ -114,13 +114,12 @@ static void i2o_exec_wait_free(struct i2o_exec_wait *wait) 
 *	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)

int i2o_msg_post_wait_mem(struct i2o_controller *c, struct i2o_message *msg,

			  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 = i2o_msg_in_to_virt(c, m);

	int rc = 0;



	wait = i2o_exec_wait_alloc();
@@ -138,15 +137,15 @@ int i2o_msg_post_wait_mem(struct i2o_controller *c, u32 m, unsigned long 
	 * We will only use transaction contexts >= 0x80000000 for POST WAIT,

	 * so we could find a POST WAIT reply easier in the reply handler.

	 */

	writel(i2o_exec_driver.context, &msg->u.s.icntxt);

	msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);

	wait->tcntxt = tcntxt++;

	writel(wait->tcntxt, &msg->u.s.tcntxt);

	msg->u.s.tcntxt = cpu_to_le32(wait->tcntxt);



	/*

	 * Post the message to the controller. At some point later it will

	 * return. If we time out before it returns then complete will be zero.

	 */

	i2o_msg_post(c, m);

	i2o_msg_post(c, msg);



	if (!wait->complete) {

		wait->wq = &wq;
@@ -266,7 +265,8 @@ static int i2o_msg_post_wait_complete(struct i2o_controller *c, u32 m, 
 *

 *	Returns number of bytes printed into buffer.

 */

static ssize_t i2o_exec_show_vendor_id(struct device *d, struct device_attribute *attr, char *buf)

static ssize_t i2o_exec_show_vendor_id(struct device *d,

				       struct device_attribute *attr, char *buf)

{

	struct i2o_device *dev = to_i2o_device(d);

	u16 id;
@@ -286,7 +286,9 @@ static ssize_t i2o_exec_show_vendor_id(struct device *d, struct device_attribute 
 *

 *	Returns number of bytes printed into buffer.

 */

static ssize_t i2o_exec_show_product_id(struct device *d, struct device_attribute *attr, char *buf)

static ssize_t i2o_exec_show_product_id(struct device *d,

					struct device_attribute *attr,

					char *buf)

{

	struct i2o_device *dev = to_i2o_device(d);

	u16 id;
@@ -385,23 +387,22 @@ static int i2o_exec_reply(struct i2o_controller *c, u32 m, 
	u32 context;



	if (le32_to_cpu(msg->u.head[0]) & MSG_FAIL) {

		struct i2o_message __iomem *pmsg;

		u32 pm;



		/*

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



		pmsg = i2o_msg_in_to_virt(c, pm);

		context = readl(&pmsg->u.s.tcntxt);



		i2o_report_status(KERN_INFO, "i2o_core", msg);



		context = readl(&pmsg->u.s.tcntxt);



		/* Release the preserved msg */

		i2o_msg_nop(c, pm);

		i2o_msg_nop_mfa(c, pm);

	} else

		context = le32_to_cpu(msg->u.s.tcntxt);
@@ -462,25 +463,26 @@ static void i2o_exec_event(struct i2o_event *evt) 
 */

int i2o_exec_lct_get(struct i2o_controller *c)

{

	struct i2o_message __iomem *msg;

	u32 m;

	struct i2o_message *msg;

	int i = 0;

	int rc = -EAGAIN;



	for (i = 1; i <= I2O_LCT_GET_TRIES; i++) {

		m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);

		if (m == I2O_QUEUE_EMPTY)

			return -ETIMEDOUT;



		writel(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6, &msg->u.head[0]);

		writel(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 | ADAPTER_TID,

		       &msg->u.head[1]);

		writel(0xffffffff, &msg->body[0]);

		writel(0x00000000, &msg->body[1]);

		writel(0xd0000000 | c->dlct.len, &msg->body[2]);

		writel(c->dlct.phys, &msg->body[3]);



		rc = i2o_msg_post_wait(c, m, I2O_TIMEOUT_LCT_GET);

		msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);

		if (IS_ERR(msg))

			return PTR_ERR(msg);



		msg->u.head[0] =

		    cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);

		msg->u.head[1] =

		    cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 |

				ADAPTER_TID);

		msg->body[0] = cpu_to_le32(0xffffffff);

		msg->body[1] = cpu_to_le32(0x00000000);

		msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len);

		msg->body[3] = cpu_to_le32(c->dlct.phys);



		rc = i2o_msg_post_wait(c, msg, I2O_TIMEOUT_LCT_GET);

		if (rc < 0)

			break;
@@ -506,29 +508,28 @@ static int i2o_exec_lct_notify(struct i2o_controller *c, u32 change_ind) 
{

	i2o_status_block *sb = c->status_block.virt;

	struct device *dev;

	struct i2o_message __iomem *msg;

	u32 m;

	struct i2o_message *msg;



	dev = &c->pdev->dev;



	if (i2o_dma_realloc(dev, &c->dlct, sb->expected_lct_size, GFP_KERNEL))

		return -ENOMEM;



	m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);

	if (m == I2O_QUEUE_EMPTY)

		return -ETIMEDOUT;



	writel(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6, &msg->u.head[0]);

	writel(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 | ADAPTER_TID,

	       &msg->u.head[1]);

	writel(i2o_exec_driver.context, &msg->u.s.icntxt);

	writel(0, &msg->u.s.tcntxt);	/* FIXME */

	writel(0xffffffff, &msg->body[0]);

	writel(change_ind, &msg->body[1]);

	writel(0xd0000000 | c->dlct.len, &msg->body[2]);

	writel(c->dlct.phys, &msg->body[3]);



	i2o_msg_post(c, m);

	msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);

	if (IS_ERR(msg))

		return PTR_ERR(msg);



	msg->u.head[0] = cpu_to_le32(EIGHT_WORD_MSG_SIZE | SGL_OFFSET_6);

	msg->u.head[1] = cpu_to_le32(I2O_CMD_LCT_NOTIFY << 24 | HOST_TID << 12 |

				     ADAPTER_TID);

	msg->u.s.icntxt = cpu_to_le32(i2o_exec_driver.context);

	msg->u.s.tcntxt = cpu_to_le32(0x00000000);

	msg->body[0] = cpu_to_le32(0xffffffff);

	msg->body[1] = cpu_to_le32(change_ind);

	msg->body[2] = cpu_to_le32(0xd0000000 | c->dlct.len);

	msg->body[3] = cpu_to_le32(c->dlct.phys);



	i2o_msg_post(c, msg);



	return 0;

};

drivers/message/i2o/i2o_block.c

+79 −78
Original line number Diff line number Diff line
@@ -130,20 +130,20 @@ static int i2o_block_remove(struct device *dev) 
 */

static int i2o_block_device_flush(struct i2o_device *dev)

{

	struct i2o_message __iomem *msg;

	u32 m;

	struct i2o_message *msg;



	m = i2o_msg_get_wait(dev->iop, &msg, I2O_TIMEOUT_MESSAGE_GET);

	if (m == I2O_QUEUE_EMPTY)

		return -ETIMEDOUT;

	msg = i2o_msg_get_wait(dev->iop, I2O_TIMEOUT_MESSAGE_GET);

	if (IS_ERR(msg))

		return PTR_ERR(msg);



	writel(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);

	writel(I2O_CMD_BLOCK_CFLUSH << 24 | HOST_TID << 12 | dev->lct_data.tid,

	       &msg->u.head[1]);

	writel(60 << 16, &msg->body[0]);

	msg->u.head[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0);

	msg->u.head[1] =

	    cpu_to_le32(I2O_CMD_BLOCK_CFLUSH << 24 | HOST_TID << 12 | dev->

			lct_data.tid);

	msg->body[0] = cpu_to_le32(60 << 16);

	osm_debug("Flushing...\n");



	return i2o_msg_post_wait(dev->iop, m, 60);

	return i2o_msg_post_wait(dev->iop, msg, 60);

};



/**
@@ -181,21 +181,21 @@ static int i2o_block_issue_flush(request_queue_t * queue, struct gendisk *disk, 
 */

static int i2o_block_device_mount(struct i2o_device *dev, u32 media_id)

{

	struct i2o_message __iomem *msg;

	u32 m;



	m = i2o_msg_get_wait(dev->iop, &msg, I2O_TIMEOUT_MESSAGE_GET);

	if (m == I2O_QUEUE_EMPTY)

		return -ETIMEDOUT;



	writel(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);

	writel(I2O_CMD_BLOCK_MMOUNT << 24 | HOST_TID << 12 | dev->lct_data.tid,

	       &msg->u.head[1]);

	writel(-1, &msg->body[0]);

	writel(0, &msg->body[1]);

	struct i2o_message *msg;



	msg = i2o_msg_get_wait(dev->iop, I2O_TIMEOUT_MESSAGE_GET);

	if (IS_ERR(msg))

		return PTR_ERR(msg);



	msg->u.head[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0);

	msg->u.head[1] =

	    cpu_to_le32(I2O_CMD_BLOCK_MMOUNT << 24 | HOST_TID << 12 | dev->

			lct_data.tid);

	msg->body[0] = cpu_to_le32(-1);

	msg->body[1] = cpu_to_le32(0x00000000);

	osm_debug("Mounting...\n");



	return i2o_msg_post_wait(dev->iop, m, 2);

	return i2o_msg_post_wait(dev->iop, msg, 2);

};



/**
@@ -210,20 +210,20 @@ static int i2o_block_device_mount(struct i2o_device *dev, u32 media_id) 
 */

static int i2o_block_device_lock(struct i2o_device *dev, u32 media_id)

{

	struct i2o_message __iomem *msg;

	u32 m;

	struct i2o_message *msg;



	m = i2o_msg_get_wait(dev->iop, &msg, I2O_TIMEOUT_MESSAGE_GET);

	if (m == I2O_QUEUE_EMPTY)

		return -ETIMEDOUT;

	msg = i2o_msg_get_wait(dev->iop, I2O_TIMEOUT_MESSAGE_GET);

	if (IS_ERR(msg) == I2O_QUEUE_EMPTY)

		return PTR_ERR(msg);



	writel(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);

	writel(I2O_CMD_BLOCK_MLOCK << 24 | HOST_TID << 12 | dev->lct_data.tid,

	       &msg->u.head[1]);

	writel(-1, &msg->body[0]);

	msg->u.head[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0);

	msg->u.head[1] =

	    cpu_to_le32(I2O_CMD_BLOCK_MLOCK << 24 | HOST_TID << 12 | dev->

			lct_data.tid);

	msg->body[0] = cpu_to_le32(-1);

	osm_debug("Locking...\n");



	return i2o_msg_post_wait(dev->iop, m, 2);

	return i2o_msg_post_wait(dev->iop, msg, 2);

};



/**
@@ -238,20 +238,20 @@ static int i2o_block_device_lock(struct i2o_device *dev, u32 media_id) 
 */

static int i2o_block_device_unlock(struct i2o_device *dev, u32 media_id)

{

	struct i2o_message __iomem *msg;

	u32 m;

	struct i2o_message *msg;



	m = i2o_msg_get_wait(dev->iop, &msg, I2O_TIMEOUT_MESSAGE_GET);

	if (m == I2O_QUEUE_EMPTY)

		return -ETIMEDOUT;

	msg = i2o_msg_get_wait(dev->iop, I2O_TIMEOUT_MESSAGE_GET);

	if (IS_ERR(msg))

		return PTR_ERR(msg);



	writel(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);

	writel(I2O_CMD_BLOCK_MUNLOCK << 24 | HOST_TID << 12 | dev->lct_data.tid,

	       &msg->u.head[1]);

	writel(media_id, &msg->body[0]);

	msg->u.head[0] = cpu_to_le32(FIVE_WORD_MSG_SIZE | SGL_OFFSET_0);

	msg->u.head[1] =

	    cpu_to_le32(I2O_CMD_BLOCK_MUNLOCK << 24 | HOST_TID << 12 | dev->

			lct_data.tid);

	msg->body[0] = cpu_to_le32(media_id);

	osm_debug("Unlocking...\n");



	return i2o_msg_post_wait(dev->iop, m, 2);

	return i2o_msg_post_wait(dev->iop, msg, 2);

};



/**
@@ -267,21 +267,21 @@ static int i2o_block_device_power(struct i2o_block_device *dev, u8 op) 
{

	struct i2o_device *i2o_dev = dev->i2o_dev;

	struct i2o_controller *c = i2o_dev->iop;

	struct i2o_message __iomem *msg;

	u32 m;

	struct i2o_message *msg;

	int rc;



	m = i2o_msg_get_wait(c, &msg, I2O_TIMEOUT_MESSAGE_GET);

	if (m == I2O_QUEUE_EMPTY)

		return -ETIMEDOUT;

	msg = i2o_msg_get_wait(c, I2O_TIMEOUT_MESSAGE_GET);

	if (IS_ERR(msg))

		return PTR_ERR(msg);



	writel(FOUR_WORD_MSG_SIZE | SGL_OFFSET_0, &msg->u.head[0]);

	writel(I2O_CMD_BLOCK_POWER << 24 | HOST_TID << 12 | i2o_dev->lct_data.

	       tid, &msg->u.head[1]);

	writel(op << 24, &msg->body[0]);

	msg->u.head[0] = cpu_to_le32(FOUR_WORD_MSG_SIZE | SGL_OFFSET_0);

	msg->u.head[1] =

	    cpu_to_le32(I2O_CMD_BLOCK_POWER << 24 | HOST_TID << 12 | i2o_dev->

			lct_data.tid);

	msg->body[0] = cpu_to_le32(op << 24);

	osm_debug("Power...\n");



	rc = i2o_msg_post_wait(c, m, 60);

	rc = i2o_msg_post_wait(c, msg, 60);

	if (!rc)

		dev->power = op;
@@ -331,7 +331,7 @@ static inline void i2o_block_request_free(struct i2o_block_request *ireq) 
 */

static inline int i2o_block_sglist_alloc(struct i2o_controller *c,

					 struct i2o_block_request *ireq,

					 u32 __iomem ** mptr)

					 u32 ** mptr)

{

	int nents;

	enum dma_data_direction direction;
@@ -745,10 +745,9 @@ static int i2o_block_transfer(struct request *req) 
	struct i2o_block_device *dev = req->rq_disk->private_data;

	struct i2o_controller *c;

	int tid = dev->i2o_dev->lct_data.tid;

	struct i2o_message __iomem *msg;

	u32 __iomem *mptr;

	struct i2o_message *msg;

	u32 *mptr;

	struct i2o_block_request *ireq = req->special;

	u32 m;

	u32 tcntxt;

	u32 sgl_offset = SGL_OFFSET_8;

	u32 ctl_flags = 0x00000000;
@@ -763,9 +762,9 @@ static int i2o_block_transfer(struct request *req) 


	c = dev->i2o_dev->iop;



	m = i2o_msg_get(c, &msg);

	if (m == I2O_QUEUE_EMPTY) {

		rc = -EBUSY;

	msg = i2o_msg_get(c);

	if (IS_ERR(msg)) {

		rc = PTR_ERR(msg);

		goto exit;

	}
@@ -775,8 +774,8 @@ static int i2o_block_transfer(struct request *req) 
		goto nop_msg;

	}



	writel(i2o_block_driver.context, &msg->u.s.icntxt);

	writel(tcntxt, &msg->u.s.tcntxt);

	msg->u.s.icntxt = cpu_to_le32(i2o_block_driver.context);

	msg->u.s.tcntxt = cpu_to_le32(tcntxt);



	mptr = &msg->body[0];
@@ -834,11 +833,11 @@ static int i2o_block_transfer(struct request *req) 


		sgl_offset = SGL_OFFSET_12;



		writel(I2O_CMD_PRIVATE << 24 | HOST_TID << 12 | tid,

		       &msg->u.head[1]);

		msg->u.head[1] =

		    cpu_to_le32(I2O_CMD_PRIVATE << 24 | HOST_TID << 12 | tid);



		writel(I2O_VENDOR_DPT << 16 | I2O_CMD_SCSI_EXEC, mptr++);

		writel(tid, mptr++);

		*mptr++ = cpu_to_le32(I2O_VENDOR_DPT << 16 | I2O_CMD_SCSI_EXEC);

		*mptr++ = cpu_to_le32(tid);



		/*

		 * ENABLE_DISCONNECT
@@ -853,22 +852,24 @@ static int i2o_block_transfer(struct request *req) 
			scsi_flags = 0xa0a0000a;

		}



		writel(scsi_flags, mptr++);

		*mptr++ = cpu_to_le32(scsi_flags);



		*((u32 *) & cmd[2]) = cpu_to_be32(req->sector * hwsec);

		*((u16 *) & cmd[7]) = cpu_to_be16(req->nr_sectors * hwsec);



		memcpy_toio(mptr, cmd, 10);

		memcpy(mptr, cmd, 10);

		mptr += 4;

		writel(req->nr_sectors << KERNEL_SECTOR_SHIFT, mptr++);

		*mptr++ = cpu_to_le32(req->nr_sectors << KERNEL_SECTOR_SHIFT);

	} else

#endif

	{

		writel(cmd | HOST_TID << 12 | tid, &msg->u.head[1]);

		writel(ctl_flags, mptr++);

		writel(req->nr_sectors << KERNEL_SECTOR_SHIFT, mptr++);

		writel((u32) (req->sector << KERNEL_SECTOR_SHIFT), mptr++);

		writel(req->sector >> (32 - KERNEL_SECTOR_SHIFT), mptr++);

		msg->u.head[1] = cpu_to_le32(cmd | HOST_TID << 12 | tid);

		*mptr++ = cpu_to_le32(ctl_flags);

		*mptr++ = cpu_to_le32(req->nr_sectors << KERNEL_SECTOR_SHIFT);

		*mptr++ =

		    cpu_to_le32((u32) (req->sector << KERNEL_SECTOR_SHIFT));

		*mptr++ =

		    cpu_to_le32(req->sector >> (32 - KERNEL_SECTOR_SHIFT));

	}



	if (!i2o_block_sglist_alloc(c, ireq, &mptr)) {
@@ -876,13 +877,13 @@ static int i2o_block_transfer(struct request *req) 
		goto context_remove;

	}



	writel(I2O_MESSAGE_SIZE(mptr - &msg->u.head[0]) |

	       sgl_offset, &msg->u.head[0]);

	msg->u.head[0] =

	    cpu_to_le32(I2O_MESSAGE_SIZE(mptr - &msg->u.head[0]) | sgl_offset);



	list_add_tail(&ireq->queue, &dev->open_queue);

	dev->open_queue_depth++;



	i2o_msg_post(c, m);

	i2o_msg_post(c, msg);



	return 0;
@@ -890,7 +891,7 @@ static int i2o_block_transfer(struct request *req) 
	i2o_cntxt_list_remove(c, req);



      nop_msg:

	i2o_msg_nop(c, m);

	i2o_msg_nop(c, msg);



      exit:

	return rc;

drivers/message/i2o/i2o_config.c

+83 −86

File changed.

Preview size limit exceeded, changes collapsed.