[deliverable/linux.git] / drivers / scsi / qla4xxx / ql4_iocb.c

/*
 * QLogic iSCSI HBA Driver
 * Copyright (c)  2003-2013 QLogic Corporation
 *
 * See LICENSE.qla4xxx for copyright and licensing details.
 */

#include "ql4_def.h"
#include "ql4_glbl.h"
#include "ql4_dbg.h"
#include "ql4_inline.h"

#include <scsi/scsi_tcq.h>

static int
qla4xxx_space_in_req_ring(struct scsi_qla_host *ha, uint16_t req_cnt)
{
	uint16_t cnt;

	/* Calculate number of free request entries. */
	if ((req_cnt + 2) >= ha->req_q_count) {
		cnt = (uint16_t) ha->isp_ops->rd_shdw_req_q_out(ha);
		if (ha->request_in < cnt)
			ha->req_q_count = cnt - ha->request_in;
		else
			ha->req_q_count = REQUEST_QUEUE_DEPTH -
						(ha->request_in - cnt);
	}

	/* Check if room for request in request ring. */
	if ((req_cnt + 2) < ha->req_q_count)
		return 1;
	else
		return 0;
}

static void qla4xxx_advance_req_ring_ptr(struct scsi_qla_host *ha)
{
	/* Advance request queue pointer */
	if (ha->request_in == (REQUEST_QUEUE_DEPTH - 1)) {
		ha->request_in = 0;
		ha->request_ptr = ha->request_ring;
	} else {
		ha->request_in++;
		ha->request_ptr++;
	}
}

/**
 * qla4xxx_get_req_pkt - returns a valid entry in request queue.
 * @ha: Pointer to host adapter structure.
 * @queue_entry: Pointer to pointer to queue entry structure
 *
 * This routine performs the following tasks:
 *	- returns the current request_in pointer (if queue not full)
 *	- advances the request_in pointer
 *	- checks for queue full
 **/
static int qla4xxx_get_req_pkt(struct scsi_qla_host *ha,
			       struct queue_entry **queue_entry)
{
	uint16_t req_cnt = 1;

	if (qla4xxx_space_in_req_ring(ha, req_cnt)) {
		*queue_entry = ha->request_ptr;
		memset(*queue_entry, 0, sizeof(**queue_entry));

		qla4xxx_advance_req_ring_ptr(ha);
		ha->req_q_count -= req_cnt;
		return QLA_SUCCESS;
	}

	return QLA_ERROR;
}

/**
 * qla4xxx_send_marker_iocb - issues marker iocb to HBA
 * @ha: Pointer to host adapter structure.
 * @ddb_entry: Pointer to device database entry
 * @lun: SCSI LUN
 * @marker_type: marker identifier
 *
 * This routine issues a marker IOCB.
 **/
int qla4xxx_send_marker_iocb(struct scsi_qla_host *ha,
	struct ddb_entry *ddb_entry, uint64_t lun, uint16_t mrkr_mod)
{
	struct qla4_marker_entry *marker_entry;
	unsigned long flags = 0;
	uint8_t status = QLA_SUCCESS;

	/* Acquire hardware specific lock */
	spin_lock_irqsave(&ha->hardware_lock, flags);

	/* Get pointer to the queue entry for the marker */
	if (qla4xxx_get_req_pkt(ha, (struct queue_entry **) &marker_entry) !=
	    QLA_SUCCESS) {
		status = QLA_ERROR;
		goto exit_send_marker;
	}

	/* Put the marker in the request queue */
	marker_entry->hdr.entryType = ET_MARKER;
	marker_entry->hdr.entryCount = 1;
	marker_entry->target = cpu_to_le16(ddb_entry->fw_ddb_index);
	marker_entry->modifier = cpu_to_le16(mrkr_mod);
	int_to_scsilun(lun, &marker_entry->lun);
	wmb();

	/* Tell ISP it's got a new I/O request */
	ha->isp_ops->queue_iocb(ha);

exit_send_marker:
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
	return status;
}

static struct continuation_t1_entry *
qla4xxx_alloc_cont_entry(struct scsi_qla_host *ha)
{
	struct continuation_t1_entry *cont_entry;

	cont_entry = (struct continuation_t1_entry *)ha->request_ptr;

	qla4xxx_advance_req_ring_ptr(ha);

	/* Load packet defaults */
	cont_entry->hdr.entryType = ET_CONTINUE;
	cont_entry->hdr.entryCount = 1;
	cont_entry->hdr.systemDefined = (uint8_t) cpu_to_le16(ha->request_in);

	return cont_entry;
}

static uint16_t qla4xxx_calc_request_entries(uint16_t dsds)
{
	uint16_t iocbs;

	iocbs = 1;
	if (dsds > COMMAND_SEG) {
		iocbs += (dsds - COMMAND_SEG) / CONTINUE_SEG;
		if ((dsds - COMMAND_SEG) % CONTINUE_SEG)
			iocbs++;
	}
	return iocbs;
}

static void qla4xxx_build_scsi_iocbs(struct srb *srb,
				     struct command_t3_entry *cmd_entry,
				     uint16_t tot_dsds)
{
	struct scsi_qla_host *ha;
	uint16_t avail_dsds;
	struct data_seg_a64 *cur_dsd;
	struct scsi_cmnd *cmd;
	struct scatterlist *sg;
	int i;

	cmd = srb->cmd;
	ha = srb->ha;

	if (!scsi_bufflen(cmd) || cmd->sc_data_direction == DMA_NONE) {
		/* No data being transferred */
		cmd_entry->ttlByteCnt = __constant_cpu_to_le32(0);
		return;
	}

	avail_dsds = COMMAND_SEG;
	cur_dsd = (struct data_seg_a64 *) & (cmd_entry->dataseg[0]);

	scsi_for_each_sg(cmd, sg, tot_dsds, i) {
		dma_addr_t sle_dma;

		/* Allocate additional continuation packets? */
		if (avail_dsds == 0) {
			struct continuation_t1_entry *cont_entry;

			cont_entry = qla4xxx_alloc_cont_entry(ha);
			cur_dsd =
				(struct data_seg_a64 *)
				&cont_entry->dataseg[0];
			avail_dsds = CONTINUE_SEG;
		}

		sle_dma = sg_dma_address(sg);
		cur_dsd->base.addrLow = cpu_to_le32(LSDW(sle_dma));
		cur_dsd->base.addrHigh = cpu_to_le32(MSDW(sle_dma));
		cur_dsd->count = cpu_to_le32(sg_dma_len(sg));
		avail_dsds--;

		cur_dsd++;
	}
}

void qla4_83xx_queue_iocb(struct scsi_qla_host *ha)
{
	writel(ha->request_in, &ha->qla4_83xx_reg->req_q_in);
	readl(&ha->qla4_83xx_reg->req_q_in);
}

void qla4_83xx_complete_iocb(struct scsi_qla_host *ha)
{
	writel(ha->response_out, &ha->qla4_83xx_reg->rsp_q_out);
	readl(&ha->qla4_83xx_reg->rsp_q_out);
}

/**
 * qla4_82xx_queue_iocb - Tell ISP it's got new request(s)
 * @ha: pointer to host adapter structure.
 *
 * This routine notifies the ISP that one or more new request
 * queue entries have been placed on the request queue.
 **/
void qla4_82xx_queue_iocb(struct scsi_qla_host *ha)
{
	uint32_t dbval = 0;

	dbval = 0x14 | (ha->func_num << 5);
	dbval = dbval | (0 << 8) | (ha->request_in << 16);

	qla4_82xx_wr_32(ha, ha->nx_db_wr_ptr, ha->request_in);
}

/**
 * qla4_82xx_complete_iocb - Tell ISP we're done with response(s)
 * @ha: pointer to host adapter structure.
 *
 * This routine notifies the ISP that one or more response/completion
 * queue entries have been processed by the driver.
 * This also clears the interrupt.
 **/
void qla4_82xx_complete_iocb(struct scsi_qla_host *ha)
{
	writel(ha->response_out, &ha->qla4_82xx_reg->rsp_q_out);
	readl(&ha->qla4_82xx_reg->rsp_q_out);
}

/**
 * qla4xxx_queue_iocb - Tell ISP it's got new request(s)
 * @ha: pointer to host adapter structure.
 *
 * This routine is notifies the ISP that one or more new request
 * queue entries have been placed on the request queue.
 **/
void qla4xxx_queue_iocb(struct scsi_qla_host *ha)
{
	writel(ha->request_in, &ha->reg->req_q_in);
	readl(&ha->reg->req_q_in);
}

/**
 * qla4xxx_complete_iocb - Tell ISP we're done with response(s)
 * @ha: pointer to host adapter structure.
 *
 * This routine is notifies the ISP that one or more response/completion
 * queue entries have been processed by the driver.
 * This also clears the interrupt.
 **/
void qla4xxx_complete_iocb(struct scsi_qla_host *ha)
{
	writel(ha->response_out, &ha->reg->rsp_q_out);
	readl(&ha->reg->rsp_q_out);
}

/**
 * qla4xxx_send_command_to_isp - issues command to HBA
 * @ha: pointer to host adapter structure.
 * @srb: pointer to SCSI Request Block to be sent to ISP
 *
 * This routine is called by qla4xxx_queuecommand to build an ISP
 * command and pass it to the ISP for execution.
 **/
int qla4xxx_send_command_to_isp(struct scsi_qla_host *ha, struct srb * srb)
{
	struct scsi_cmnd *cmd = srb->cmd;
	struct ddb_entry *ddb_entry;
	struct command_t3_entry *cmd_entry;
	int nseg;
	uint16_t tot_dsds;
	uint16_t req_cnt;
	unsigned long flags;
	uint32_t index;

	/* Get real lun and adapter */
	ddb_entry = srb->ddb;

	tot_dsds = 0;

	/* Acquire hardware specific lock */
	spin_lock_irqsave(&ha->hardware_lock, flags);

	index = (uint32_t)cmd->request->tag;

	/*
	 * Check to see if adapter is online before placing request on
	 * request queue.  If a reset occurs and a request is in the queue,
	 * the firmware will still attempt to process the request, retrieving
	 * garbage for pointers.
	 */
	if (!test_bit(AF_ONLINE, &ha->flags)) {
		DEBUG2(printk("scsi%ld: %s: Adapter OFFLINE! "
			      "Do not issue command.\n",
			      ha->host_no, __func__));
		goto queuing_error;
	}

	/* Calculate the number of request entries needed. */
	nseg = scsi_dma_map(cmd);
	if (nseg < 0)
		goto queuing_error;
	tot_dsds = nseg;

	req_cnt = qla4xxx_calc_request_entries(tot_dsds);
	if (!qla4xxx_space_in_req_ring(ha, req_cnt))
		goto queuing_error;

	/* total iocbs active */
	if ((ha->iocb_cnt + req_cnt) >= ha->iocb_hiwat)
		goto queuing_error;

	/* Build command packet */
	cmd_entry = (struct command_t3_entry *) ha->request_ptr;
	memset(cmd_entry, 0, sizeof(struct command_t3_entry));
	cmd_entry->hdr.entryType = ET_COMMAND;
	cmd_entry->handle = cpu_to_le32(index);
	cmd_entry->target = cpu_to_le16(ddb_entry->fw_ddb_index);

	int_to_scsilun(cmd->device->lun, &cmd_entry->lun);
	cmd_entry->ttlByteCnt = cpu_to_le32(scsi_bufflen(cmd));
	memcpy(cmd_entry->cdb, cmd->cmnd, cmd->cmd_len);
	cmd_entry->dataSegCnt = cpu_to_le16(tot_dsds);
	cmd_entry->hdr.entryCount = req_cnt;

	/* Set data transfer direction control flags
	 * NOTE: Look at data_direction bits iff there is data to be
	 *	 transferred, as the data direction bit is sometimed filled
	 *	 in when there is no data to be transferred */
	cmd_entry->control_flags = CF_NO_DATA;
	if (scsi_bufflen(cmd)) {
		if (cmd->sc_data_direction == DMA_TO_DEVICE)
			cmd_entry->control_flags = CF_WRITE;
		else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
			cmd_entry->control_flags = CF_READ;

		ha->bytes_xfered += scsi_bufflen(cmd);
		if (ha->bytes_xfered & ~0xFFFFF){
			ha->total_mbytes_xferred += ha->bytes_xfered >> 20;
			ha->bytes_xfered &= 0xFFFFF;
		}
	}

	/* Set tagged queueing control flags */
	cmd_entry->control_flags |= CF_SIMPLE_TAG;

	qla4xxx_advance_req_ring_ptr(ha);
	qla4xxx_build_scsi_iocbs(srb, cmd_entry, tot_dsds);
	wmb();

	srb->cmd->host_scribble = (unsigned char *)(unsigned long)index;

	/* update counters */
	srb->state = SRB_ACTIVE_STATE;
	srb->flags |= SRB_DMA_VALID;

	/* Track IOCB used */
	ha->iocb_cnt += req_cnt;
	srb->iocb_cnt = req_cnt;
	ha->req_q_count -= req_cnt;

	ha->isp_ops->queue_iocb(ha);
	spin_unlock_irqrestore(&ha->hardware_lock, flags);

	return QLA_SUCCESS;

queuing_error:
	if (tot_dsds)
		scsi_dma_unmap(cmd);

	spin_unlock_irqrestore(&ha->hardware_lock, flags);

	return QLA_ERROR;
}

int qla4xxx_send_passthru0(struct iscsi_task *task)
{
	struct passthru0 *passthru_iocb;
	struct iscsi_session *sess = task->conn->session;
	struct ddb_entry *ddb_entry = sess->dd_data;
	struct scsi_qla_host *ha = ddb_entry->ha;
	struct ql4_task_data *task_data = task->dd_data;
	uint16_t ctrl_flags = 0;
	unsigned long flags;
	int ret = QLA_ERROR;

	spin_lock_irqsave(&ha->hardware_lock, flags);
	task_data->iocb_req_cnt = 1;
	/* Put the IOCB on the request queue */
	if (!qla4xxx_space_in_req_ring(ha, task_data->iocb_req_cnt))
		goto queuing_error;

	passthru_iocb = (struct passthru0 *) ha->request_ptr;

	memset(passthru_iocb, 0, sizeof(struct passthru0));
	passthru_iocb->hdr.entryType = ET_PASSTHRU0;
	passthru_iocb->hdr.systemDefined = SD_ISCSI_PDU;
	passthru_iocb->hdr.entryCount = task_data->iocb_req_cnt;
	passthru_iocb->handle = task->itt;
	passthru_iocb->target = cpu_to_le16(ddb_entry->fw_ddb_index);
	passthru_iocb->timeout = cpu_to_le16(PT_DEFAULT_TIMEOUT);

	/* Setup the out & in DSDs */
	if (task_data->req_len) {
		memcpy((uint8_t *)task_data->req_buffer +
		       sizeof(struct iscsi_hdr), task->data, task->data_count);
		ctrl_flags |= PT_FLAG_SEND_BUFFER;
		passthru_iocb->out_dsd.base.addrLow =
					cpu_to_le32(LSDW(task_data->req_dma));
		passthru_iocb->out_dsd.base.addrHigh =
					cpu_to_le32(MSDW(task_data->req_dma));
		passthru_iocb->out_dsd.count =
					cpu_to_le32(task->data_count +
						    sizeof(struct iscsi_hdr));
	}
	if (task_data->resp_len) {
		passthru_iocb->in_dsd.base.addrLow =
					cpu_to_le32(LSDW(task_data->resp_dma));
		passthru_iocb->in_dsd.base.addrHigh =
					cpu_to_le32(MSDW(task_data->resp_dma));
		passthru_iocb->in_dsd.count =
			cpu_to_le32(task_data->resp_len);
	}

	ctrl_flags |= (PT_FLAG_ISCSI_PDU | PT_FLAG_WAIT_4_RESPONSE);
	passthru_iocb->control_flags = cpu_to_le16(ctrl_flags);

	/* Update the request pointer */
	qla4xxx_advance_req_ring_ptr(ha);
	wmb();

	/* Track IOCB used */
	ha->iocb_cnt += task_data->iocb_req_cnt;
	ha->req_q_count -= task_data->iocb_req_cnt;
	ha->isp_ops->queue_iocb(ha);
	ret = QLA_SUCCESS;

queuing_error:
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
	return ret;
}

static struct mrb *qla4xxx_get_new_mrb(struct scsi_qla_host *ha)
{
	struct mrb *mrb;

	mrb = kzalloc(sizeof(*mrb), GFP_KERNEL);
	if (!mrb)
		return mrb;

	mrb->ha = ha;
	return mrb;
}

static int qla4xxx_send_mbox_iocb(struct scsi_qla_host *ha, struct mrb *mrb,
				  uint32_t *in_mbox)
{
	int rval = QLA_SUCCESS;
	uint32_t i;
	unsigned long flags;
	uint32_t index = 0;

	/* Acquire hardware specific lock */
	spin_lock_irqsave(&ha->hardware_lock, flags);

	/* Get pointer to the queue entry for the marker */
	rval = qla4xxx_get_req_pkt(ha, (struct queue_entry **) &(mrb->mbox));
	if (rval != QLA_SUCCESS)
		goto exit_mbox_iocb;

	index = ha->mrb_index;
	/* get valid mrb index*/
	for (i = 0; i < MAX_MRB; i++) {
		index++;
		if (index == MAX_MRB)
			index = 1;
		if (ha->active_mrb_array[index] == NULL) {
			ha->mrb_index = index;
			break;
		}
	}

	mrb->iocb_cnt = 1;
	ha->active_mrb_array[index] = mrb;
	mrb->mbox->handle = index;
	mrb->mbox->hdr.entryType = ET_MBOX_CMD;
	mrb->mbox->hdr.entryCount = mrb->iocb_cnt;
	memcpy(mrb->mbox->in_mbox, in_mbox, 32);
	mrb->mbox_cmd = in_mbox[0];
	wmb();

	ha->iocb_cnt += mrb->iocb_cnt;
	ha->isp_ops->queue_iocb(ha);
exit_mbox_iocb:
	spin_unlock_irqrestore(&ha->hardware_lock, flags);
	return rval;
}

int qla4xxx_ping_iocb(struct scsi_qla_host *ha, uint32_t options,
		      uint32_t payload_size, uint32_t pid, uint8_t *ipaddr)
{
	uint32_t in_mbox[8];
	struct mrb *mrb = NULL;
	int rval = QLA_SUCCESS;

	memset(in_mbox, 0, sizeof(in_mbox));

	mrb = qla4xxx_get_new_mrb(ha);
	if (!mrb) {
		DEBUG2(ql4_printk(KERN_WARNING, ha, "%s: fail to get new mrb\n",
				  __func__));
		rval = QLA_ERROR;
		goto exit_ping;
	}

	in_mbox[0] = MBOX_CMD_PING;
	in_mbox[1] = options;
	memcpy(&in_mbox[2], &ipaddr[0], 4);
	memcpy(&in_mbox[3], &ipaddr[4], 4);
	memcpy(&in_mbox[4], &ipaddr[8], 4);
	memcpy(&in_mbox[5], &ipaddr[12], 4);
	in_mbox[6] = payload_size;

	mrb->pid = pid;
	rval = qla4xxx_send_mbox_iocb(ha, mrb, in_mbox);

	if (rval != QLA_SUCCESS)
		goto exit_ping;

	return rval;
exit_ping:
	kfree(mrb);
	return rval;
}
Commit	Line	Data
afaf5a2d DS	1	/*
afaf5a2d DS	2	* QLogic iSCSI HBA Driver
4a4f51e9	3	* Copyright (c) 2003-2013 QLogic Corporation
afaf5a2d DS	4	*
	5	* See LICENSE.qla4xxx for copyright and licensing details.
	6	*/
	7
	8	#include "ql4_def.h"
e08c182c DS	9	#include "ql4_glbl.h"
	10	#include "ql4_dbg.h"
	11	#include "ql4_inline.h"
	12
afaf5a2d DS	13	#include <scsi/scsi_tcq.h>
afaf5a2d DS	14
16ed55f9 KH	15	static int
	16	qla4xxx_space_in_req_ring(struct scsi_qla_host *ha, uint16_t req_cnt)
	17	{
	18	uint16_t cnt;
	19
	20	/* Calculate number of free request entries. */
	21	if ((req_cnt + 2) >= ha->req_q_count) {
b173a132	22	cnt = (uint16_t) ha->isp_ops->rd_shdw_req_q_out(ha);
16ed55f9 KH	23	if (ha->request_in < cnt)
	24	ha->req_q_count = cnt - ha->request_in;
	25	else
	26	ha->req_q_count = REQUEST_QUEUE_DEPTH -
	27	(ha->request_in - cnt);
	28	}
	29
	30	/* Check if room for request in request ring. */
	31	if ((req_cnt + 2) < ha->req_q_count)
	32	return 1;
	33	else
	34	return 0;
	35	}
	36
	37	static void qla4xxx_advance_req_ring_ptr(struct scsi_qla_host *ha)
	38	{
	39	/* Advance request queue pointer */
	40	if (ha->request_in == (REQUEST_QUEUE_DEPTH - 1)) {
	41	ha->request_in = 0;
	42	ha->request_ptr = ha->request_ring;
	43	} else {
	44	ha->request_in++;
	45	ha->request_ptr++;
	46	}
	47	}
	48
afaf5a2d DS	49	/**
	50	* qla4xxx_get_req_pkt - returns a valid entry in request queue.
	51	* @ha: Pointer to host adapter structure.
	52	* @queue_entry: Pointer to pointer to queue entry structure
	53	*
	54	* This routine performs the following tasks:
	55	* - returns the current request_in pointer (if queue not full)
	56	* - advances the request_in pointer
	57	* - checks for queue full
	58	**/
47975477 AB	59	static int qla4xxx_get_req_pkt(struct scsi_qla_host *ha,
47975477 AB	60	struct queue_entry **queue_entry)
afaf5a2d	61	{
16ed55f9	62	uint16_t req_cnt = 1;
afaf5a2d	63
16ed55f9 KH	64	if (qla4xxx_space_in_req_ring(ha, req_cnt)) {
16ed55f9 KH	65	*queue_entry = ha->request_ptr;
afaf5a2d	66	memset(queue_entry, 0, sizeof(*queue_entry));
16ed55f9 KH	67
	68	qla4xxx_advance_req_ring_ptr(ha);
	69	ha->req_q_count -= req_cnt;
	70	return QLA_SUCCESS;
afaf5a2d DS	71	}
afaf5a2d DS	72
16ed55f9	73	return QLA_ERROR;
afaf5a2d DS	74	}
	75
	76	/**
	77	* qla4xxx_send_marker_iocb - issues marker iocb to HBA
	78	* @ha: Pointer to host adapter structure.
	79	* @ddb_entry: Pointer to device database entry
	80	* @lun: SCSI LUN
	81	* @marker_type: marker identifier
	82	*
	83	* This routine issues a marker IOCB.
	84	**/
9d562913	85	int qla4xxx_send_marker_iocb(struct scsi_qla_host *ha,
9cb78c16	86	struct ddb_entry *ddb_entry, uint64_t lun, uint16_t mrkr_mod)
afaf5a2d	87	{
1c3f0b8e	88	struct qla4_marker_entry *marker_entry;
afaf5a2d DS	89	unsigned long flags = 0;
	90	uint8_t status = QLA_SUCCESS;
	91
	92	/* Acquire hardware specific lock */
	93	spin_lock_irqsave(&ha->hardware_lock, flags);
	94
	95	/* Get pointer to the queue entry for the marker */
	96	if (qla4xxx_get_req_pkt(ha, (struct queue_entry **) &marker_entry) !=
	97	QLA_SUCCESS) {
	98	status = QLA_ERROR;
	99	goto exit_send_marker;
	100	}
	101
	102	/* Put the marker in the request queue */
	103	marker_entry->hdr.entryType = ET_MARKER;
	104	marker_entry->hdr.entryCount = 1;
	105	marker_entry->target = cpu_to_le16(ddb_entry->fw_ddb_index);
9d562913	106	marker_entry->modifier = cpu_to_le16(mrkr_mod);
afaf5a2d DS	107	int_to_scsilun(lun, &marker_entry->lun);
	108	wmb();
	109
	110	/* Tell ISP it's got a new I/O request */
f4f5df23	111	ha->isp_ops->queue_iocb(ha);
afaf5a2d DS	112
	113	exit_send_marker:
	114	spin_unlock_irqrestore(&ha->hardware_lock, flags);
	115	return status;
	116	}
	117
16ed55f9 KH	118	static struct continuation_t1_entry *
16ed55f9 KH	119	qla4xxx_alloc_cont_entry(struct scsi_qla_host *ha)
afaf5a2d DS	120	{
	121	struct continuation_t1_entry *cont_entry;
	122
	123	cont_entry = (struct continuation_t1_entry *)ha->request_ptr;
	124
16ed55f9	125	qla4xxx_advance_req_ring_ptr(ha);
afaf5a2d DS	126
	127	/* Load packet defaults */
	128	cont_entry->hdr.entryType = ET_CONTINUE;
	129	cont_entry->hdr.entryCount = 1;
	130	cont_entry->hdr.systemDefined = (uint8_t) cpu_to_le16(ha->request_in);
	131
	132	return cont_entry;
	133	}
	134
47975477	135	static uint16_t qla4xxx_calc_request_entries(uint16_t dsds)
afaf5a2d DS	136	{
	137	uint16_t iocbs;
	138
	139	iocbs = 1;
	140	if (dsds > COMMAND_SEG) {
	141	iocbs += (dsds - COMMAND_SEG) / CONTINUE_SEG;
	142	if ((dsds - COMMAND_SEG) % CONTINUE_SEG)
	143	iocbs++;
	144	}
	145	return iocbs;
	146	}
	147
47975477 AB	148	static void qla4xxx_build_scsi_iocbs(struct srb *srb,
	149	struct command_t3_entry *cmd_entry,
	150	uint16_t tot_dsds)
afaf5a2d DS	151	{
	152	struct scsi_qla_host *ha;
	153	uint16_t avail_dsds;
	154	struct data_seg_a64 *cur_dsd;
	155	struct scsi_cmnd *cmd;
5f7186c8 FT	156	struct scatterlist *sg;
5f7186c8 FT	157	int i;
afaf5a2d DS	158
	159	cmd = srb->cmd;
	160	ha = srb->ha;
	161
5f7186c8	162	if (!scsi_bufflen(cmd) \|\| cmd->sc_data_direction == DMA_NONE) {
afaf5a2d DS	163	/* No data being transferred */
	164	cmd_entry->ttlByteCnt = __constant_cpu_to_le32(0);
	165	return;
	166	}
	167
	168	avail_dsds = COMMAND_SEG;
	169	cur_dsd = (struct data_seg_a64 *) & (cmd_entry->dataseg[0]);
	170
5f7186c8 FT	171	scsi_for_each_sg(cmd, sg, tot_dsds, i) {
	172	dma_addr_t sle_dma;
	173
	174	/* Allocate additional continuation packets? */
	175	if (avail_dsds == 0) {
	176	struct continuation_t1_entry *cont_entry;
	177
	178	cont_entry = qla4xxx_alloc_cont_entry(ha);
	179	cur_dsd =
	180	(struct data_seg_a64 *)
	181	&cont_entry->dataseg[0];
	182	avail_dsds = CONTINUE_SEG;
afaf5a2d	183	}
5f7186c8 FT	184
	185	sle_dma = sg_dma_address(sg);
	186	cur_dsd->base.addrLow = cpu_to_le32(LSDW(sle_dma));
	187	cur_dsd->base.addrHigh = cpu_to_le32(MSDW(sle_dma));
	188	cur_dsd->count = cpu_to_le32(sg_dma_len(sg));
	189	avail_dsds--;
	190
	191	cur_dsd++;
afaf5a2d DS	192	}
	193	}
	194
6e7b4292 VC	195	void qla4_83xx_queue_iocb(struct scsi_qla_host *ha)
	196	{
	197	writel(ha->request_in, &ha->qla4_83xx_reg->req_q_in);
	198	readl(&ha->qla4_83xx_reg->req_q_in);
	199	}
	200
	201	void qla4_83xx_complete_iocb(struct scsi_qla_host *ha)
	202	{
	203	writel(ha->response_out, &ha->qla4_83xx_reg->rsp_q_out);
	204	readl(&ha->qla4_83xx_reg->rsp_q_out);
	205	}
	206
f4f5df23	207	/**
f8086f4f	208	* qla4_82xx_queue_iocb - Tell ISP it's got new request(s)
f4f5df23 VC	209	* @ha: pointer to host adapter structure.
	210	*
	211	* This routine notifies the ISP that one or more new request
	212	* queue entries have been placed on the request queue.
	213	**/
f8086f4f	214	void qla4_82xx_queue_iocb(struct scsi_qla_host *ha)
f4f5df23 VC	215	{
f4f5df23 VC	216	uint32_t dbval = 0;
f4f5df23 VC	217
	218	dbval = 0x14 \| (ha->func_num << 5);
	219	dbval = dbval \| (0 << 8) \| (ha->request_in << 16);
f4f5df23	220
f8086f4f	221	qla4_82xx_wr_32(ha, ha->nx_db_wr_ptr, ha->request_in);
f4f5df23 VC	222	}
	223
	224	/**
f8086f4f	225	* qla4_82xx_complete_iocb - Tell ISP we're done with response(s)
f4f5df23 VC	226	* @ha: pointer to host adapter structure.
	227	*
	228	* This routine notifies the ISP that one or more response/completion
	229	* queue entries have been processed by the driver.
	230	* This also clears the interrupt.
	231	**/
f8086f4f	232	void qla4_82xx_complete_iocb(struct scsi_qla_host *ha)
f4f5df23	233	{
7664a1fd VC	234	writel(ha->response_out, &ha->qla4_82xx_reg->rsp_q_out);
7664a1fd VC	235	readl(&ha->qla4_82xx_reg->rsp_q_out);
f4f5df23 VC	236	}
	237
	238	/**
	239	* qla4xxx_queue_iocb - Tell ISP it's got new request(s)
	240	* @ha: pointer to host adapter structure.
	241	*
	242	* This routine is notifies the ISP that one or more new request
	243	* queue entries have been placed on the request queue.
	244	**/
	245	void qla4xxx_queue_iocb(struct scsi_qla_host *ha)
	246	{
	247	writel(ha->request_in, &ha->reg->req_q_in);
	248	readl(&ha->reg->req_q_in);
	249	}
	250
	251	/**
	252	* qla4xxx_complete_iocb - Tell ISP we're done with response(s)
	253	* @ha: pointer to host adapter structure.
	254	*
	255	* This routine is notifies the ISP that one or more response/completion
	256	* queue entries have been processed by the driver.
	257	* This also clears the interrupt.
	258	**/
	259	void qla4xxx_complete_iocb(struct scsi_qla_host *ha)
	260	{
	261	writel(ha->response_out, &ha->reg->rsp_q_out);
	262	readl(&ha->reg->rsp_q_out);
	263	}
	264
afaf5a2d DS	265	/**
	266	* qla4xxx_send_command_to_isp - issues command to HBA
	267	* @ha: pointer to host adapter structure.
	268	* @srb: pointer to SCSI Request Block to be sent to ISP
	269	*
	270	* This routine is called by qla4xxx_queuecommand to build an ISP
	271	* command and pass it to the ISP for execution.
	272	**/
	273	int qla4xxx_send_command_to_isp(struct scsi_qla_host ha, struct srb srb)
	274	{
	275	struct scsi_cmnd *cmd = srb->cmd;
	276	struct ddb_entry *ddb_entry;
	277	struct command_t3_entry *cmd_entry;
5f7186c8	278	int nseg;
afaf5a2d DS	279	uint16_t tot_dsds;
afaf5a2d DS	280	uint16_t req_cnt;
afaf5a2d	281	unsigned long flags;
afaf5a2d	282	uint32_t index;
afaf5a2d DS	283
	284	/* Get real lun and adapter */
	285	ddb_entry = srb->ddb;
	286
afaf5a2d DS	287	tot_dsds = 0;
	288
	289	/* Acquire hardware specific lock */
	290	spin_lock_irqsave(&ha->hardware_lock, flags);
	291
	292	index = (uint32_t)cmd->request->tag;
	293
16ed55f9 KH	294	/*
	295	* Check to see if adapter is online before placing request on
	296	* request queue. If a reset occurs and a request is in the queue,
	297	* the firmware will still attempt to process the request, retrieving
	298	* garbage for pointers.
	299	*/
	300	if (!test_bit(AF_ONLINE, &ha->flags)) {
	301	DEBUG2(printk("scsi%ld: %s: Adapter OFFLINE! "
	302	"Do not issue command.\n",
	303	ha->host_no, __func__));
	304	goto queuing_error;
	305	}
	306
afaf5a2d	307	/* Calculate the number of request entries needed. */
5f7186c8 FT	308	nseg = scsi_dma_map(cmd);
	309	if (nseg < 0)
	310	goto queuing_error;
	311	tot_dsds = nseg;
	312
afaf5a2d	313	req_cnt = qla4xxx_calc_request_entries(tot_dsds);
16ed55f9	314	if (!qla4xxx_space_in_req_ring(ha, req_cnt))
afaf5a2d DS	315	goto queuing_error;
	316
	317	/* total iocbs active */
5b1c1bff	318	if ((ha->iocb_cnt + req_cnt) >= ha->iocb_hiwat)
afaf5a2d DS	319	goto queuing_error;
	320
	321	/* Build command packet */
	322	cmd_entry = (struct command_t3_entry *) ha->request_ptr;
	323	memset(cmd_entry, 0, sizeof(struct command_t3_entry));
	324	cmd_entry->hdr.entryType = ET_COMMAND;
	325	cmd_entry->handle = cpu_to_le32(index);
	326	cmd_entry->target = cpu_to_le16(ddb_entry->fw_ddb_index);
afaf5a2d DS	327
afaf5a2d DS	328	int_to_scsilun(cmd->device->lun, &cmd_entry->lun);
5f7186c8	329	cmd_entry->ttlByteCnt = cpu_to_le32(scsi_bufflen(cmd));
afaf5a2d DS	330	memcpy(cmd_entry->cdb, cmd->cmnd, cmd->cmd_len);
	331	cmd_entry->dataSegCnt = cpu_to_le16(tot_dsds);
	332	cmd_entry->hdr.entryCount = req_cnt;
	333
	334	/* Set data transfer direction control flags
	335	* NOTE: Look at data_direction bits iff there is data to be
	336	* transferred, as the data direction bit is sometimed filled
	337	* in when there is no data to be transferred */
	338	cmd_entry->control_flags = CF_NO_DATA;
5f7186c8	339	if (scsi_bufflen(cmd)) {
afaf5a2d DS	340	if (cmd->sc_data_direction == DMA_TO_DEVICE)
	341	cmd_entry->control_flags = CF_WRITE;
	342	else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
	343	cmd_entry->control_flags = CF_READ;
d915058f	344
5f7186c8	345	ha->bytes_xfered += scsi_bufflen(cmd);
d915058f DS	346	if (ha->bytes_xfered & ~0xFFFFF){
	347	ha->total_mbytes_xferred += ha->bytes_xfered >> 20;
	348	ha->bytes_xfered &= 0xFFFFF;
	349	}
afaf5a2d DS	350	}
	351
	352	/* Set tagged queueing control flags */
	353	cmd_entry->control_flags \|= CF_SIMPLE_TAG;
afaf5a2d	354
16ed55f9	355	qla4xxx_advance_req_ring_ptr(ha);
afaf5a2d DS	356	qla4xxx_build_scsi_iocbs(srb, cmd_entry, tot_dsds);
	357	wmb();
	358
5369887a	359	srb->cmd->host_scribble = (unsigned char *)(unsigned long)index;
afaf5a2d DS	360
	361	/* update counters */
	362	srb->state = SRB_ACTIVE_STATE;
	363	srb->flags \|= SRB_DMA_VALID;
	364
	365	/* Track IOCB used */
	366	ha->iocb_cnt += req_cnt;
	367	srb->iocb_cnt = req_cnt;
	368	ha->req_q_count -= req_cnt;
	369
f4f5df23	370	ha->isp_ops->queue_iocb(ha);
afaf5a2d DS	371	spin_unlock_irqrestore(&ha->hardware_lock, flags);
	372
	373	return QLA_SUCCESS;
	374
	375	queuing_error:
5f7186c8 FT	376	if (tot_dsds)
5f7186c8 FT	377	scsi_dma_unmap(cmd);
afaf5a2d	378
afaf5a2d DS	379	spin_unlock_irqrestore(&ha->hardware_lock, flags);
	380
	381	return QLA_ERROR;
	382	}
	383
b3a271a9 MR	384	int qla4xxx_send_passthru0(struct iscsi_task *task)
	385	{
	386	struct passthru0 *passthru_iocb;
	387	struct iscsi_session *sess = task->conn->session;
	388	struct ddb_entry *ddb_entry = sess->dd_data;
	389	struct scsi_qla_host *ha = ddb_entry->ha;
	390	struct ql4_task_data *task_data = task->dd_data;
	391	uint16_t ctrl_flags = 0;
	392	unsigned long flags;
	393	int ret = QLA_ERROR;
	394
	395	spin_lock_irqsave(&ha->hardware_lock, flags);
	396	task_data->iocb_req_cnt = 1;
	397	/* Put the IOCB on the request queue */
	398	if (!qla4xxx_space_in_req_ring(ha, task_data->iocb_req_cnt))
	399	goto queuing_error;
	400
	401	passthru_iocb = (struct passthru0 *) ha->request_ptr;
	402
	403	memset(passthru_iocb, 0, sizeof(struct passthru0));
	404	passthru_iocb->hdr.entryType = ET_PASSTHRU0;
	405	passthru_iocb->hdr.systemDefined = SD_ISCSI_PDU;
	406	passthru_iocb->hdr.entryCount = task_data->iocb_req_cnt;
	407	passthru_iocb->handle = task->itt;
	408	passthru_iocb->target = cpu_to_le16(ddb_entry->fw_ddb_index);
	409	passthru_iocb->timeout = cpu_to_le16(PT_DEFAULT_TIMEOUT);
	410
	411	/* Setup the out & in DSDs */
69ca216e	412	if (task_data->req_len) {
b3a271a9 MR	413	memcpy((uint8_t *)task_data->req_buffer +
	414	sizeof(struct iscsi_hdr), task->data, task->data_count);
	415	ctrl_flags \|= PT_FLAG_SEND_BUFFER;
	416	passthru_iocb->out_dsd.base.addrLow =
	417	cpu_to_le32(LSDW(task_data->req_dma));
	418	passthru_iocb->out_dsd.base.addrHigh =
	419	cpu_to_le32(MSDW(task_data->req_dma));
	420	passthru_iocb->out_dsd.count =
	421	cpu_to_le32(task->data_count +
	422	sizeof(struct iscsi_hdr));
	423	}
	424	if (task_data->resp_len) {
	425	passthru_iocb->in_dsd.base.addrLow =
	426	cpu_to_le32(LSDW(task_data->resp_dma));
	427	passthru_iocb->in_dsd.base.addrHigh =
	428	cpu_to_le32(MSDW(task_data->resp_dma));
	429	passthru_iocb->in_dsd.count =
	430	cpu_to_le32(task_data->resp_len);
	431	}
	432
	433	ctrl_flags \|= (PT_FLAG_ISCSI_PDU \| PT_FLAG_WAIT_4_RESPONSE);
	434	passthru_iocb->control_flags = cpu_to_le16(ctrl_flags);
	435
	436	/* Update the request pointer */
	437	qla4xxx_advance_req_ring_ptr(ha);
	438	wmb();
	439
	440	/* Track IOCB used */
	441	ha->iocb_cnt += task_data->iocb_req_cnt;
	442	ha->req_q_count -= task_data->iocb_req_cnt;
	443	ha->isp_ops->queue_iocb(ha);
	444	ret = QLA_SUCCESS;
	445
	446	queuing_error:
	447	spin_unlock_irqrestore(&ha->hardware_lock, flags);
	448	return ret;
	449	}
c0b9d3f7 VC	450
	451	static struct mrb qla4xxx_get_new_mrb(struct scsi_qla_host ha)
	452	{
	453	struct mrb *mrb;
	454
	455	mrb = kzalloc(sizeof(*mrb), GFP_KERNEL);
	456	if (!mrb)
	457	return mrb;
	458
	459	mrb->ha = ha;
	460	return mrb;
	461	}
	462
a7380a65 VC	463	static int qla4xxx_send_mbox_iocb(struct scsi_qla_host ha, struct mrb mrb,
a7380a65 VC	464	uint32_t *in_mbox)
c0b9d3f7 VC	465	{
	466	int rval = QLA_SUCCESS;
	467	uint32_t i;
	468	unsigned long flags;
	469	uint32_t index = 0;
	470
	471	/* Acquire hardware specific lock */
	472	spin_lock_irqsave(&ha->hardware_lock, flags);
	473
	474	/* Get pointer to the queue entry for the marker */
	475	rval = qla4xxx_get_req_pkt(ha, (struct queue_entry **) &(mrb->mbox));
	476	if (rval != QLA_SUCCESS)
	477	goto exit_mbox_iocb;
	478
	479	index = ha->mrb_index;
	480	/* get valid mrb index*/
	481	for (i = 0; i < MAX_MRB; i++) {
	482	index++;
	483	if (index == MAX_MRB)
	484	index = 1;
	485	if (ha->active_mrb_array[index] == NULL) {
	486	ha->mrb_index = index;
	487	break;
	488	}
	489	}
	490
	491	mrb->iocb_cnt = 1;
	492	ha->active_mrb_array[index] = mrb;
	493	mrb->mbox->handle = index;
	494	mrb->mbox->hdr.entryType = ET_MBOX_CMD;
	495	mrb->mbox->hdr.entryCount = mrb->iocb_cnt;
	496	memcpy(mrb->mbox->in_mbox, in_mbox, 32);
	497	mrb->mbox_cmd = in_mbox[0];
	498	wmb();
	499
d522844a	500	ha->iocb_cnt += mrb->iocb_cnt;
c0b9d3f7 VC	501	ha->isp_ops->queue_iocb(ha);
	502	exit_mbox_iocb:
	503	spin_unlock_irqrestore(&ha->hardware_lock, flags);
	504	return rval;
	505	}
	506
	507	int qla4xxx_ping_iocb(struct scsi_qla_host *ha, uint32_t options,
	508	uint32_t payload_size, uint32_t pid, uint8_t *ipaddr)
	509	{
	510	uint32_t in_mbox[8];
	511	struct mrb *mrb = NULL;
	512	int rval = QLA_SUCCESS;
	513
	514	memset(in_mbox, 0, sizeof(in_mbox));
	515
	516	mrb = qla4xxx_get_new_mrb(ha);
	517	if (!mrb) {
	518	DEBUG2(ql4_printk(KERN_WARNING, ha, "%s: fail to get new mrb\n",
	519	__func__));
	520	rval = QLA_ERROR;
	521	goto exit_ping;
	522	}
	523
	524	in_mbox[0] = MBOX_CMD_PING;
	525	in_mbox[1] = options;
	526	memcpy(&in_mbox[2], &ipaddr[0], 4);
	527	memcpy(&in_mbox[3], &ipaddr[4], 4);
	528	memcpy(&in_mbox[4], &ipaddr[8], 4);
	529	memcpy(&in_mbox[5], &ipaddr[12], 4);
	530	in_mbox[6] = payload_size;
	531
	532	mrb->pid = pid;
	533	rval = qla4xxx_send_mbox_iocb(ha, mrb, in_mbox);
	534
	535	if (rval != QLA_SUCCESS)
	536	goto exit_ping;
	537
	538	return rval;
	539	exit_ping:
	540	kfree(mrb);
	541	return rval;
	542	}