[linux-2.6-block.git] / drivers / scsi / snic / snic_io.c

/*
 * Copyright 2014 Cisco Systems, Inc.  All rights reserved.
 *
 * This program is free software; you may redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; version 2 of the License.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <linux/errno.h>
#include <linux/pci.h>
#include <linux/slab.h>

#include <linux/interrupt.h>
#include <linux/workqueue.h>
#include <linux/spinlock.h>
#include <linux/mempool.h>
#include <scsi/scsi_tcq.h>

#include "snic_io.h"
#include "snic.h"
#include "cq_enet_desc.h"
#include "snic_fwint.h"

static void
snic_wq_cmpl_frame_send(struct vnic_wq *wq,
			    struct cq_desc *cq_desc,
			    struct vnic_wq_buf *buf,
			    void *opaque)
{
	struct snic *snic = svnic_dev_priv(wq->vdev);

	SNIC_BUG_ON(buf->os_buf == NULL);

	if (snic_log_level & SNIC_DESC_LOGGING)
		SNIC_HOST_INFO(snic->shost,
			       "Ack received for snic_host_req %p.\n",
			       buf->os_buf);

	SNIC_TRC(snic->shost->host_no, 0, 0,
		 ((ulong)(buf->os_buf) - sizeof(struct snic_req_info)), 0, 0,
		 0);

	buf->os_buf = NULL;
}

static int
snic_wq_cmpl_handler_cont(struct vnic_dev *vdev,
			  struct cq_desc *cq_desc,
			  u8 type,
			  u16 q_num,
			  u16 cmpl_idx,
			  void *opaque)
{
	struct snic *snic = svnic_dev_priv(vdev);
	unsigned long flags;

	SNIC_BUG_ON(q_num != 0);

	spin_lock_irqsave(&snic->wq_lock[q_num], flags);
	svnic_wq_service(&snic->wq[q_num],
			 cq_desc,
			 cmpl_idx,
			 snic_wq_cmpl_frame_send,
			 NULL);
	spin_unlock_irqrestore(&snic->wq_lock[q_num], flags);

	return 0;
} /* end of snic_cmpl_handler_cont */

int
snic_wq_cmpl_handler(struct snic *snic, int work_to_do)
{
	unsigned int work_done = 0;
	unsigned int i;

	snic->s_stats.misc.last_ack_time = jiffies;
	for (i = 0; i < snic->wq_count; i++) {
		work_done += svnic_cq_service(&snic->cq[i],
					      work_to_do,
					      snic_wq_cmpl_handler_cont,
					      NULL);
	}

	return work_done;
} /* end of snic_wq_cmpl_handler */

void
snic_free_wq_buf(struct vnic_wq *wq, struct vnic_wq_buf *buf)
{

	struct snic_host_req *req = buf->os_buf;
	struct snic *snic = svnic_dev_priv(wq->vdev);
	struct snic_req_info *rqi = NULL;
	unsigned long flags;

	pci_unmap_single(snic->pdev, buf->dma_addr, buf->len, PCI_DMA_TODEVICE);

	rqi = req_to_rqi(req);
	spin_lock_irqsave(&snic->spl_cmd_lock, flags);
	if (list_empty(&rqi->list)) {
		spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
		goto end;
	}

	SNIC_BUG_ON(rqi->list.next == NULL); /* if not added to spl_cmd_list */
	list_del_init(&rqi->list);
	spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);

	if (rqi->sge_va) {
		snic_pci_unmap_rsp_buf(snic, rqi);
		kfree((void *)rqi->sge_va);
		rqi->sge_va = 0;
	}
	snic_req_free(snic, rqi);
	SNIC_HOST_INFO(snic->shost, "snic_free_wq_buf .. freed.\n");

end:
	return;
}

/* Criteria to select work queue in multi queue mode */
static int
snic_select_wq(struct snic *snic)
{
	/* No multi queue support for now */
	BUILD_BUG_ON(SNIC_WQ_MAX > 1);

	return 0;
}

static int
snic_wqdesc_avail(struct snic *snic, int q_num, int req_type)
{
	int nr_wqdesc = snic->config.wq_enet_desc_count;

	if (q_num > 0) {
		/*
		 * Multi Queue case, additional care is required.
		 * Per WQ active requests need to be maintained.
		 */
		SNIC_HOST_INFO(snic->shost, "desc_avail: Multi Queue case.\n");
		SNIC_BUG_ON(q_num > 0);

		return -1;
	}

	nr_wqdesc -= atomic64_read(&snic->s_stats.fw.actv_reqs);

	return ((req_type == SNIC_REQ_HBA_RESET) ? nr_wqdesc : nr_wqdesc - 1);
}

int
snic_queue_wq_desc(struct snic *snic, void *os_buf, u16 len)
{
	dma_addr_t pa = 0;
	unsigned long flags;
	struct snic_fw_stats *fwstats = &snic->s_stats.fw;
	struct snic_host_req *req = (struct snic_host_req *) os_buf;
	long act_reqs;
	long desc_avail = 0;
	int q_num = 0;

	snic_print_desc(__func__, os_buf, len);

	/* Map request buffer */
	pa = pci_map_single(snic->pdev, os_buf, len, PCI_DMA_TODEVICE);
	if (pci_dma_mapping_error(snic->pdev, pa)) {
		SNIC_HOST_ERR(snic->shost, "qdesc: PCI DMA Mapping Fail.\n");

		return -ENOMEM;
	}

	req->req_pa = (ulong)pa;

	q_num = snic_select_wq(snic);

	spin_lock_irqsave(&snic->wq_lock[q_num], flags);
	desc_avail = snic_wqdesc_avail(snic, q_num, req->hdr.type);
	if (desc_avail <= 0) {
		pci_unmap_single(snic->pdev, pa, len, PCI_DMA_TODEVICE);
		req->req_pa = 0;
		spin_unlock_irqrestore(&snic->wq_lock[q_num], flags);
		atomic64_inc(&snic->s_stats.misc.wq_alloc_fail);
		SNIC_DBG("host = %d, WQ is Full\n", snic->shost->host_no);

		return -ENOMEM;
	}

	snic_queue_wq_eth_desc(&snic->wq[q_num], os_buf, pa, len, 0, 0, 1);
	/*
	 * Update stats
	 * note: when multi queue enabled, fw actv_reqs should be per queue.
	 */
	act_reqs = atomic64_inc_return(&fwstats->actv_reqs);
	spin_unlock_irqrestore(&snic->wq_lock[q_num], flags);

	if (act_reqs > atomic64_read(&fwstats->max_actv_reqs))
		atomic64_set(&fwstats->max_actv_reqs, act_reqs);

	return 0;
} /* end of snic_queue_wq_desc() */

/*
 * snic_handle_untagged_req: Adds snic specific requests to spl_cmd_list.
 * Purpose : Used during driver unload to clean up the requests.
 */
void
snic_handle_untagged_req(struct snic *snic, struct snic_req_info *rqi)
{
	unsigned long flags;

	INIT_LIST_HEAD(&rqi->list);

	spin_lock_irqsave(&snic->spl_cmd_lock, flags);
	list_add_tail(&rqi->list, &snic->spl_cmd_list);
	spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
}

/*
 * snic_req_init:
 * Allocates snic_req_info + snic_host_req + sgl data, and initializes.
 */
struct snic_req_info *
snic_req_init(struct snic *snic, int sg_cnt)
{
	u8 typ;
	struct snic_req_info *rqi = NULL;

	typ = (sg_cnt <= SNIC_REQ_CACHE_DFLT_SGL) ?
		SNIC_REQ_CACHE_DFLT_SGL : SNIC_REQ_CACHE_MAX_SGL;

	rqi = mempool_alloc(snic->req_pool[typ], GFP_ATOMIC);
	if (!rqi) {
		atomic64_inc(&snic->s_stats.io.alloc_fail);
		SNIC_HOST_ERR(snic->shost,
			      "Failed to allocate memory from snic req pool id = %d\n",
			      typ);
		return rqi;
	}

	memset(rqi, 0, sizeof(*rqi));
	rqi->rq_pool_type = typ;
	rqi->start_time = jiffies;
	rqi->req = (struct snic_host_req *) (rqi + 1);
	rqi->req_len = sizeof(struct snic_host_req);
	rqi->snic = snic;

	rqi->req = (struct snic_host_req *)(rqi + 1);

	if (sg_cnt == 0)
		goto end;

	rqi->req_len += (sg_cnt * sizeof(struct snic_sg_desc));

	if (sg_cnt > atomic64_read(&snic->s_stats.io.max_sgl))
		atomic64_set(&snic->s_stats.io.max_sgl, sg_cnt);

	SNIC_BUG_ON(sg_cnt > SNIC_MAX_SG_DESC_CNT);
	atomic64_inc(&snic->s_stats.io.sgl_cnt[sg_cnt - 1]);

end:
	memset(rqi->req, 0, rqi->req_len);

	/* pre initialization of init_ctx to support req_to_rqi */
	rqi->req->hdr.init_ctx = (ulong) rqi;

	SNIC_SCSI_DBG(snic->shost, "Req_alloc:rqi = %p allocatd.\n", rqi);

	return rqi;
} /* end of snic_req_init */

/*
 * snic_abort_req_init : Inits abort request.
 */
struct snic_host_req *
snic_abort_req_init(struct snic *snic, struct snic_req_info *rqi)
{
	struct snic_host_req *req = NULL;

	SNIC_BUG_ON(!rqi);

	/* If abort to be issued second time, then reuse */
	if (rqi->abort_req)
		return rqi->abort_req;


	req = mempool_alloc(snic->req_pool[SNIC_REQ_TM_CACHE], GFP_ATOMIC);
	if (!req) {
		SNIC_HOST_ERR(snic->shost, "abts:Failed to alloc tm req.\n");
		WARN_ON_ONCE(1);

		return NULL;
	}

	rqi->abort_req = req;
	memset(req, 0, sizeof(struct snic_host_req));
	/* pre initialization of init_ctx to support req_to_rqi */
	req->hdr.init_ctx = (ulong) rqi;

	return req;
} /* end of snic_abort_req_init */

/*
 * snic_dr_req_init : Inits device reset req
 */
struct snic_host_req *
snic_dr_req_init(struct snic *snic, struct snic_req_info *rqi)
{
	struct snic_host_req *req = NULL;

	SNIC_BUG_ON(!rqi);

	req = mempool_alloc(snic->req_pool[SNIC_REQ_TM_CACHE], GFP_ATOMIC);
	if (!req) {
		SNIC_HOST_ERR(snic->shost, "dr:Failed to alloc tm req.\n");
		WARN_ON_ONCE(1);

		return NULL;
	}

	SNIC_BUG_ON(rqi->dr_req != NULL);
	rqi->dr_req = req;
	memset(req, 0, sizeof(struct snic_host_req));
	/* pre initialization of init_ctx to support req_to_rqi */
	req->hdr.init_ctx = (ulong) rqi;

	return req;
} /* end of snic_dr_req_init */

/* frees snic_req_info and snic_host_req */
void
snic_req_free(struct snic *snic, struct snic_req_info *rqi)
{
	SNIC_BUG_ON(rqi->req == rqi->abort_req);
	SNIC_BUG_ON(rqi->req == rqi->dr_req);
	SNIC_BUG_ON(rqi->sge_va != 0);

	SNIC_SCSI_DBG(snic->shost,
		      "Req_free:rqi %p:ioreq %p:abt %p:dr %p\n",
		      rqi, rqi->req, rqi->abort_req, rqi->dr_req);

	if (rqi->abort_req) {
		if (rqi->abort_req->req_pa)
			pci_unmap_single(snic->pdev,
					 rqi->abort_req->req_pa,
					 sizeof(struct snic_host_req),
					 PCI_DMA_TODEVICE);

		mempool_free(rqi->abort_req, snic->req_pool[SNIC_REQ_TM_CACHE]);
	}

	if (rqi->dr_req) {
		if (rqi->dr_req->req_pa)
			pci_unmap_single(snic->pdev,
					 rqi->dr_req->req_pa,
					 sizeof(struct snic_host_req),
					 PCI_DMA_TODEVICE);

		mempool_free(rqi->dr_req, snic->req_pool[SNIC_REQ_TM_CACHE]);
	}

	if (rqi->req->req_pa)
		pci_unmap_single(snic->pdev,
				 rqi->req->req_pa,
				 rqi->req_len,
				 PCI_DMA_TODEVICE);

	mempool_free(rqi, snic->req_pool[rqi->rq_pool_type]);
}

void
snic_pci_unmap_rsp_buf(struct snic *snic, struct snic_req_info *rqi)
{
	struct snic_sg_desc *sgd;

	sgd = req_to_sgl(rqi_to_req(rqi));
	SNIC_BUG_ON(sgd[0].addr == 0);
	pci_unmap_single(snic->pdev,
			 le64_to_cpu(sgd[0].addr),
			 le32_to_cpu(sgd[0].len),
			 PCI_DMA_FROMDEVICE);
}

/*
 * snic_free_all_untagged_reqs: Walks through untagged reqs and frees them.
 */
void
snic_free_all_untagged_reqs(struct snic *snic)
{
	struct snic_req_info *rqi;
	struct list_head *cur, *nxt;
	unsigned long flags;

	spin_lock_irqsave(&snic->spl_cmd_lock, flags);
	list_for_each_safe(cur, nxt, &snic->spl_cmd_list) {
		rqi = list_entry(cur, struct snic_req_info, list);
		list_del_init(&rqi->list);
		if (rqi->sge_va) {
			snic_pci_unmap_rsp_buf(snic, rqi);
			kfree((void *)rqi->sge_va);
			rqi->sge_va = 0;
		}

		snic_req_free(snic, rqi);
	}
	spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
}

/*
 * snic_release_untagged_req : Unlinks the untagged req and frees it.
 */
void
snic_release_untagged_req(struct snic *snic, struct snic_req_info *rqi)
{
	unsigned long flags;

	spin_lock_irqsave(&snic->snic_lock, flags);
	if (snic->in_remove) {
		spin_unlock_irqrestore(&snic->snic_lock, flags);
		goto end;
	}
	spin_unlock_irqrestore(&snic->snic_lock, flags);

	spin_lock_irqsave(&snic->spl_cmd_lock, flags);
	if (list_empty(&rqi->list)) {
		spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
		goto end;
	}
	list_del_init(&rqi->list);
	spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
	snic_req_free(snic, rqi);

end:
	return;
}

/* dump buf in hex fmt */
void
snic_hex_dump(char *pfx, char *data, int len)
{
	SNIC_INFO("%s Dumping Data of Len = %d\n", pfx, len);
	print_hex_dump_bytes(pfx, DUMP_PREFIX_NONE, data, len);
}

#define	LINE_BUFSZ	128	/* for snic_print_desc fn */
static void
snic_dump_desc(const char *fn, char *os_buf, int len)
{
	struct snic_host_req *req = (struct snic_host_req *) os_buf;
	struct snic_fw_req *fwreq = (struct snic_fw_req *) os_buf;
	struct snic_req_info *rqi = NULL;
	char line[LINE_BUFSZ] = { '\0' };
	char *cmd_str = NULL;

	if (req->hdr.type >= SNIC_RSP_REPORT_TGTS_CMPL)
		rqi = (struct snic_req_info *) fwreq->hdr.init_ctx;
	else
		rqi = (struct snic_req_info *) req->hdr.init_ctx;

	SNIC_BUG_ON(rqi == NULL || rqi->req == NULL);
	switch (req->hdr.type) {
	case SNIC_REQ_REPORT_TGTS:
		cmd_str = "report-tgt : ";
		snprintf(line, LINE_BUFSZ, "SNIC_REQ_REPORT_TGTS :");
		break;

	case SNIC_REQ_ICMND:
		cmd_str = "icmnd : ";
		snprintf(line, LINE_BUFSZ, "SNIC_REQ_ICMND : 0x%x :",
			 req->u.icmnd.cdb[0]);
		break;

	case SNIC_REQ_ITMF:
		cmd_str = "itmf : ";
		snprintf(line, LINE_BUFSZ, "SNIC_REQ_ITMF :");
		break;

	case SNIC_REQ_HBA_RESET:
		cmd_str = "hba reset :";
		snprintf(line, LINE_BUFSZ, "SNIC_REQ_HBA_RESET :");
		break;

	case SNIC_REQ_EXCH_VER:
		cmd_str = "exch ver : ";
		snprintf(line, LINE_BUFSZ, "SNIC_REQ_EXCH_VER :");
		break;

	case SNIC_REQ_TGT_INFO:
		cmd_str = "tgt info : ";
		break;

	case SNIC_RSP_REPORT_TGTS_CMPL:
		cmd_str = "report tgt cmpl : ";
		snprintf(line, LINE_BUFSZ, "SNIC_RSP_REPORT_TGTS_CMPL :");
		break;

	case SNIC_RSP_ICMND_CMPL:
		cmd_str = "icmnd_cmpl : ";
		snprintf(line, LINE_BUFSZ, "SNIC_RSP_ICMND_CMPL : 0x%x :",
			 rqi->req->u.icmnd.cdb[0]);
		break;

	case SNIC_RSP_ITMF_CMPL:
		cmd_str = "itmf_cmpl : ";
		snprintf(line, LINE_BUFSZ, "SNIC_RSP_ITMF_CMPL :");
		break;

	case SNIC_RSP_HBA_RESET_CMPL:
		cmd_str = "hba_reset_cmpl : ";
		snprintf(line, LINE_BUFSZ, "SNIC_RSP_HBA_RESET_CMPL :");
		break;

	case SNIC_RSP_EXCH_VER_CMPL:
		cmd_str = "exch_ver_cmpl : ";
		snprintf(line, LINE_BUFSZ, "SNIC_RSP_EXCH_VER_CMPL :");
		break;

	case SNIC_MSG_ACK:
		cmd_str = "msg ack : ";
		snprintf(line, LINE_BUFSZ, "SNIC_MSG_ACK :");
		break;

	case SNIC_MSG_ASYNC_EVNOTIFY:
		cmd_str = "async notify : ";
		snprintf(line, LINE_BUFSZ, "SNIC_MSG_ASYNC_EVNOTIFY :");
		break;

	default:
		cmd_str = "unknown : ";
		SNIC_BUG_ON(1);
		break;
	}

	SNIC_INFO("%s:%s >>cmndid=%x:sg_cnt = %x:status = %x:ctx = %lx.\n",
		  fn, line, req->hdr.cmnd_id, req->hdr.sg_cnt, req->hdr.status,
		  req->hdr.init_ctx);

	/* Enable it, to dump byte stream */
	if (snic_log_level & 0x20)
		snic_hex_dump(cmd_str, os_buf, len);
} /* end of __snic_print_desc */

void
snic_print_desc(const char *fn, char *os_buf, int len)
{
	if (snic_log_level & SNIC_DESC_LOGGING)
		snic_dump_desc(fn, os_buf, len);
}

void
snic_calc_io_process_time(struct snic *snic, struct snic_req_info *rqi)
{
	u64 duration;

	duration = jiffies - rqi->start_time;

	if (duration > atomic64_read(&snic->s_stats.io.max_time))
		atomic64_set(&snic->s_stats.io.max_time, duration);
}
Commit	Line	Data
c8806b6c NM	1	/*
	2	* Copyright 2014 Cisco Systems, Inc. All rights reserved.
	3	*
	4	* This program is free software; you may redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; version 2 of the License.
	7	*
	8	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
	9	* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
	10	* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
	11	* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
	12	* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
	13	* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
	14	* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	15	* SOFTWARE.
	16	*/
	17
	18	#include <linux/errno.h>
	19	#include <linux/pci.h>
	20	#include <linux/slab.h>
	21
	22	#include <linux/interrupt.h>
	23	#include <linux/workqueue.h>
	24	#include <linux/spinlock.h>
	25	#include <linux/mempool.h>
	26	#include <scsi/scsi_tcq.h>
	27
	28	#include "snic_io.h"
	29	#include "snic.h"
	30	#include "cq_enet_desc.h"
	31	#include "snic_fwint.h"
	32
	33	static void
	34	snic_wq_cmpl_frame_send(struct vnic_wq *wq,
	35	struct cq_desc *cq_desc,
	36	struct vnic_wq_buf *buf,
	37	void *opaque)
	38	{
	39	struct snic *snic = svnic_dev_priv(wq->vdev);
	40
	41	SNIC_BUG_ON(buf->os_buf == NULL);
	42
	43	if (snic_log_level & SNIC_DESC_LOGGING)
	44	SNIC_HOST_INFO(snic->shost,
	45	"Ack received for snic_host_req %p.\n",
	46	buf->os_buf);
	47
	48	SNIC_TRC(snic->shost->host_no, 0, 0,
	49	((ulong)(buf->os_buf) - sizeof(struct snic_req_info)), 0, 0,
	50	0);
c9747821	51
c8806b6c NM	52	buf->os_buf = NULL;
	53	}
	54
	55	static int
	56	snic_wq_cmpl_handler_cont(struct vnic_dev *vdev,
	57	struct cq_desc *cq_desc,
	58	u8 type,
	59	u16 q_num,
	60	u16 cmpl_idx,
	61	void *opaque)
	62	{
	63	struct snic *snic = svnic_dev_priv(vdev);
	64	unsigned long flags;
	65
	66	SNIC_BUG_ON(q_num != 0);
	67
	68	spin_lock_irqsave(&snic->wq_lock[q_num], flags);
	69	svnic_wq_service(&snic->wq[q_num],
	70	cq_desc,
	71	cmpl_idx,
	72	snic_wq_cmpl_frame_send,
	73	NULL);
	74	spin_unlock_irqrestore(&snic->wq_lock[q_num], flags);
	75
	76	return 0;
	77	} /* end of snic_cmpl_handler_cont */
	78
	79	int
	80	snic_wq_cmpl_handler(struct snic *snic, int work_to_do)
	81	{
	82	unsigned int work_done = 0;
	83	unsigned int i;
	84
	85	snic->s_stats.misc.last_ack_time = jiffies;
	86	for (i = 0; i < snic->wq_count; i++) {
	87	work_done += svnic_cq_service(&snic->cq[i],
	88	work_to_do,
	89	snic_wq_cmpl_handler_cont,
	90	NULL);
	91	}
	92
	93	return work_done;
	94	} /* end of snic_wq_cmpl_handler */
	95
	96	void
	97	snic_free_wq_buf(struct vnic_wq wq, struct vnic_wq_buf buf)
	98	{
	99
	100	struct snic_host_req *req = buf->os_buf;
	101	struct snic *snic = svnic_dev_priv(wq->vdev);
	102	struct snic_req_info *rqi = NULL;
	103	unsigned long flags;
	104
	105	pci_unmap_single(snic->pdev, buf->dma_addr, buf->len, PCI_DMA_TODEVICE);
	106
	107	rqi = req_to_rqi(req);
	108	spin_lock_irqsave(&snic->spl_cmd_lock, flags);
	109	if (list_empty(&rqi->list)) {
	110	spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
	111	goto end;
	112	}
	113
	114	SNIC_BUG_ON(rqi->list.next == NULL); /* if not added to spl_cmd_list */
	115	list_del_init(&rqi->list);
116	spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
117
118	if (rqi->sge_va) {
119	snic_pci_unmap_rsp_buf(snic, rqi);
120	kfree((void *)rqi->sge_va);
121	rqi->sge_va = 0;
122	}
123	snic_req_free(snic, rqi);
124	SNIC_HOST_INFO(snic->shost, "snic_free_wq_buf .. freed.\n");
125
126	end:
127	return;
128	}
129
130	/* Criteria to select work queue in multi queue mode */
131	static int
132	snic_select_wq(struct snic *snic)
133	{
134	/* No multi queue support for now */
135	BUILD_BUG_ON(SNIC_WQ_MAX > 1);
136
137	return 0;
138	}
139
c9747821 NM	140	static int
	141	snic_wqdesc_avail(struct snic *snic, int q_num, int req_type)
	142	{
	143	int nr_wqdesc = snic->config.wq_enet_desc_count;
	144
	145	if (q_num > 0) {
	146	/*
	147	* Multi Queue case, additional care is required.
	148	* Per WQ active requests need to be maintained.
	149	*/
	150	SNIC_HOST_INFO(snic->shost, "desc_avail: Multi Queue case.\n");
	151	SNIC_BUG_ON(q_num > 0);
	152
	153	return -1;
	154	}
	155
	156	nr_wqdesc -= atomic64_read(&snic->s_stats.fw.actv_reqs);
	157
	158	return ((req_type == SNIC_REQ_HBA_RESET) ? nr_wqdesc : nr_wqdesc - 1);
	159	}
	160
c8806b6c NM	161	int
	162	snic_queue_wq_desc(struct snic snic, void os_buf, u16 len)
	163	{
	164	dma_addr_t pa = 0;
	165	unsigned long flags;
	166	struct snic_fw_stats *fwstats = &snic->s_stats.fw;
c9747821	167	struct snic_host_req req = (struct snic_host_req ) os_buf;
c8806b6c	168	long act_reqs;
c9747821	169	long desc_avail = 0;
c8806b6c NM	170	int q_num = 0;
	171
	172	snic_print_desc(__func__, os_buf, len);
	173
	174	/* Map request buffer */
	175	pa = pci_map_single(snic->pdev, os_buf, len, PCI_DMA_TODEVICE);
	176	if (pci_dma_mapping_error(snic->pdev, pa)) {
	177	SNIC_HOST_ERR(snic->shost, "qdesc: PCI DMA Mapping Fail.\n");
	178
	179	return -ENOMEM;
	180	}
	181
c9747821 NM	182	req->req_pa = (ulong)pa;
c9747821 NM	183
c8806b6c NM	184	q_num = snic_select_wq(snic);
	185
	186	spin_lock_irqsave(&snic->wq_lock[q_num], flags);
c9747821 NM	187	desc_avail = snic_wqdesc_avail(snic, q_num, req->hdr.type);
c9747821 NM	188	if (desc_avail <= 0) {
c8806b6c	189	pci_unmap_single(snic->pdev, pa, len, PCI_DMA_TODEVICE);
c9747821	190	req->req_pa = 0;
c8806b6c NM	191	spin_unlock_irqrestore(&snic->wq_lock[q_num], flags);
	192	atomic64_inc(&snic->s_stats.misc.wq_alloc_fail);
	193	SNIC_DBG("host = %d, WQ is Full\n", snic->shost->host_no);
	194
	195	return -ENOMEM;
	196	}
	197
	198	snic_queue_wq_eth_desc(&snic->wq[q_num], os_buf, pa, len, 0, 0, 1);
c9747821 NM	199	/*
	200	* Update stats
	201	* note: when multi queue enabled, fw actv_reqs should be per queue.
	202	*/
	203	act_reqs = atomic64_inc_return(&fwstats->actv_reqs);
c8806b6c NM	204	spin_unlock_irqrestore(&snic->wq_lock[q_num], flags);
c8806b6c NM	205
c8806b6c NM	206	if (act_reqs > atomic64_read(&fwstats->max_actv_reqs))
	207	atomic64_set(&fwstats->max_actv_reqs, act_reqs);
	208
	209	return 0;
	210	} /* end of snic_queue_wq_desc() */
	211
	212	/*
	213	* snic_handle_untagged_req: Adds snic specific requests to spl_cmd_list.
	214	* Purpose : Used during driver unload to clean up the requests.
	215	*/
	216	void
	217	snic_handle_untagged_req(struct snic snic, struct snic_req_info rqi)
	218	{
	219	unsigned long flags;
	220
	221	INIT_LIST_HEAD(&rqi->list);
	222
	223	spin_lock_irqsave(&snic->spl_cmd_lock, flags);
	224	list_add_tail(&rqi->list, &snic->spl_cmd_list);
	225	spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
	226	}
	227
	228	/*
	229	* snic_req_init:
	230	* Allocates snic_req_info + snic_host_req + sgl data, and initializes.
	231	*/
	232	struct snic_req_info *
	233	snic_req_init(struct snic *snic, int sg_cnt)
	234	{
	235	u8 typ;
	236	struct snic_req_info *rqi = NULL;
	237
	238	typ = (sg_cnt <= SNIC_REQ_CACHE_DFLT_SGL) ?
	239	SNIC_REQ_CACHE_DFLT_SGL : SNIC_REQ_CACHE_MAX_SGL;
	240
	241	rqi = mempool_alloc(snic->req_pool[typ], GFP_ATOMIC);
	242	if (!rqi) {
	243	atomic64_inc(&snic->s_stats.io.alloc_fail);
	244	SNIC_HOST_ERR(snic->shost,
	245	"Failed to allocate memory from snic req pool id = %d\n",
	246	typ);
	247	return rqi;
	248	}
	249
	250	memset(rqi, 0, sizeof(*rqi));
	251	rqi->rq_pool_type = typ;
	252	rqi->start_time = jiffies;
	253	rqi->req = (struct snic_host_req *) (rqi + 1);
	254	rqi->req_len = sizeof(struct snic_host_req);
	255	rqi->snic = snic;
	256
	257	rqi->req = (struct snic_host_req *)(rqi + 1);
	258
	259	if (sg_cnt == 0)
	260	goto end;
	261
	262	rqi->req_len += (sg_cnt * sizeof(struct snic_sg_desc));
	263
	264	if (sg_cnt > atomic64_read(&snic->s_stats.io.max_sgl))
	265	atomic64_set(&snic->s_stats.io.max_sgl, sg_cnt);
	266
	267	SNIC_BUG_ON(sg_cnt > SNIC_MAX_SG_DESC_CNT);
	268	atomic64_inc(&snic->s_stats.io.sgl_cnt[sg_cnt - 1]);
	269
270	end:
271	memset(rqi->req, 0, rqi->req_len);
272
273	/* pre initialization of init_ctx to support req_to_rqi */
274	rqi->req->hdr.init_ctx = (ulong) rqi;
275
276	SNIC_SCSI_DBG(snic->shost, "Req_alloc:rqi = %p allocatd.\n", rqi);
277
278	return rqi;
279	} /* end of snic_req_init */
280
281	/*
282	* snic_abort_req_init : Inits abort request.
283	*/
284	struct snic_host_req *
285	snic_abort_req_init(struct snic snic, struct snic_req_info rqi)
286	{
287	struct snic_host_req *req = NULL;
288
289	SNIC_BUG_ON(!rqi);
290
291	/* If abort to be issued second time, then reuse */
292	if (rqi->abort_req)
293	return rqi->abort_req;
294
295
296	req = mempool_alloc(snic->req_pool[SNIC_REQ_TM_CACHE], GFP_ATOMIC);
297	if (!req) {
298	SNIC_HOST_ERR(snic->shost, "abts:Failed to alloc tm req.\n");
299	WARN_ON_ONCE(1);
300
301	return NULL;
302	}
303
304	rqi->abort_req = req;
305	memset(req, 0, sizeof(struct snic_host_req));
306	/* pre initialization of init_ctx to support req_to_rqi */
307	req->hdr.init_ctx = (ulong) rqi;
308
309	return req;
310	} /* end of snic_abort_req_init */
311
312	/*
313	* snic_dr_req_init : Inits device reset req
314	*/
315	struct snic_host_req *
316	snic_dr_req_init(struct snic snic, struct snic_req_info rqi)
317	{
318	struct snic_host_req *req = NULL;
319
320	SNIC_BUG_ON(!rqi);
321
322	req = mempool_alloc(snic->req_pool[SNIC_REQ_TM_CACHE], GFP_ATOMIC);
323	if (!req) {
324	SNIC_HOST_ERR(snic->shost, "dr:Failed to alloc tm req.\n");
325	WARN_ON_ONCE(1);
326
327	return NULL;
328	}
329
330	SNIC_BUG_ON(rqi->dr_req != NULL);
331	rqi->dr_req = req;
332	memset(req, 0, sizeof(struct snic_host_req));
333	/* pre initialization of init_ctx to support req_to_rqi */
334	req->hdr.init_ctx = (ulong) rqi;
335
336	return req;
337	} /* end of snic_dr_req_init */
338
339	/* frees snic_req_info and snic_host_req */
340	void
341	snic_req_free(struct snic snic, struct snic_req_info rqi)
342	{
343	SNIC_BUG_ON(rqi->req == rqi->abort_req);
344	SNIC_BUG_ON(rqi->req == rqi->dr_req);
345	SNIC_BUG_ON(rqi->sge_va != 0);
346
347	SNIC_SCSI_DBG(snic->shost,
348	"Req_free:rqi %p:ioreq %p:abt %p:dr %p\n",
349	rqi, rqi->req, rqi->abort_req, rqi->dr_req);
350
c9747821 NM	351	if (rqi->abort_req) {
	352	if (rqi->abort_req->req_pa)
	353	pci_unmap_single(snic->pdev,
	354	rqi->abort_req->req_pa,
	355	sizeof(struct snic_host_req),
	356	PCI_DMA_TODEVICE);
	357
c8806b6c	358	mempool_free(rqi->abort_req, snic->req_pool[SNIC_REQ_TM_CACHE]);
c9747821 NM	359	}
	360
	361	if (rqi->dr_req) {
	362	if (rqi->dr_req->req_pa)
	363	pci_unmap_single(snic->pdev,
	364	rqi->dr_req->req_pa,
	365	sizeof(struct snic_host_req),
	366	PCI_DMA_TODEVICE);
c8806b6c	367
c8806b6c	368	mempool_free(rqi->dr_req, snic->req_pool[SNIC_REQ_TM_CACHE]);
c9747821 NM	369	}
	370
	371	if (rqi->req->req_pa)
	372	pci_unmap_single(snic->pdev,
	373	rqi->req->req_pa,
	374	rqi->req_len,
	375	PCI_DMA_TODEVICE);
c8806b6c NM	376
	377	mempool_free(rqi, snic->req_pool[rqi->rq_pool_type]);
	378	}
	379
	380	void
	381	snic_pci_unmap_rsp_buf(struct snic snic, struct snic_req_info rqi)
	382	{
	383	struct snic_sg_desc *sgd;
	384
	385	sgd = req_to_sgl(rqi_to_req(rqi));
	386	SNIC_BUG_ON(sgd[0].addr == 0);
	387	pci_unmap_single(snic->pdev,
	388	le64_to_cpu(sgd[0].addr),
	389	le32_to_cpu(sgd[0].len),
	390	PCI_DMA_FROMDEVICE);
	391	}
	392
	393	/*
	394	* snic_free_all_untagged_reqs: Walks through untagged reqs and frees them.
	395	*/
	396	void
	397	snic_free_all_untagged_reqs(struct snic *snic)
	398	{
	399	struct snic_req_info *rqi;
	400	struct list_head cur, nxt;
	401	unsigned long flags;
	402
	403	spin_lock_irqsave(&snic->spl_cmd_lock, flags);
	404	list_for_each_safe(cur, nxt, &snic->spl_cmd_list) {
	405	rqi = list_entry(cur, struct snic_req_info, list);
	406	list_del_init(&rqi->list);
	407	if (rqi->sge_va) {
	408	snic_pci_unmap_rsp_buf(snic, rqi);
	409	kfree((void *)rqi->sge_va);
	410	rqi->sge_va = 0;
	411	}
	412
	413	snic_req_free(snic, rqi);
	414	}
	415	spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
	416	}
	417
	418	/*
	419	* snic_release_untagged_req : Unlinks the untagged req and frees it.
	420	*/
	421	void
	422	snic_release_untagged_req(struct snic snic, struct snic_req_info rqi)
	423	{
	424	unsigned long flags;
	425
	426	spin_lock_irqsave(&snic->snic_lock, flags);
	427	if (snic->in_remove) {
	428	spin_unlock_irqrestore(&snic->snic_lock, flags);
	429	goto end;
	430	}
	431	spin_unlock_irqrestore(&snic->snic_lock, flags);
	432
	433	spin_lock_irqsave(&snic->spl_cmd_lock, flags);
	434	if (list_empty(&rqi->list)) {
	435	spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
	436	goto end;
	437	}
	438	list_del_init(&rqi->list);
	439	spin_unlock_irqrestore(&snic->spl_cmd_lock, flags);
440	snic_req_free(snic, rqi);
441
442	end:
443	return;
444	}
445
446	/* dump buf in hex fmt */
447	void
448	snic_hex_dump(char pfx, char data, int len)
449	{
450	SNIC_INFO("%s Dumping Data of Len = %d\n", pfx, len);
451	print_hex_dump_bytes(pfx, DUMP_PREFIX_NONE, data, len);
452	}
453
454	#define LINE_BUFSZ 128 /* for snic_print_desc fn */
455	static void
456	snic_dump_desc(const char fn, char os_buf, int len)
457	{
458	struct snic_host_req req = (struct snic_host_req ) os_buf;
459	struct snic_fw_req fwreq = (struct snic_fw_req ) os_buf;
460	struct snic_req_info *rqi = NULL;
461	char line[LINE_BUFSZ] = { '\0' };
462	char *cmd_str = NULL;
463
464	if (req->hdr.type >= SNIC_RSP_REPORT_TGTS_CMPL)
465	rqi = (struct snic_req_info *) fwreq->hdr.init_ctx;
466	else
467	rqi = (struct snic_req_info *) req->hdr.init_ctx;
468
469	SNIC_BUG_ON(rqi == NULL \|\| rqi->req == NULL);
470	switch (req->hdr.type) {
471	case SNIC_REQ_REPORT_TGTS:
472	cmd_str = "report-tgt : ";
473	snprintf(line, LINE_BUFSZ, "SNIC_REQ_REPORT_TGTS :");
474	break;
475
476	case SNIC_REQ_ICMND:
477	cmd_str = "icmnd : ";
478	snprintf(line, LINE_BUFSZ, "SNIC_REQ_ICMND : 0x%x :",
479	req->u.icmnd.cdb[0]);
480	break;
481
482	case SNIC_REQ_ITMF:
483	cmd_str = "itmf : ";
484	snprintf(line, LINE_BUFSZ, "SNIC_REQ_ITMF :");
485	break;
486
487	case SNIC_REQ_HBA_RESET:
488	cmd_str = "hba reset :";
489	snprintf(line, LINE_BUFSZ, "SNIC_REQ_HBA_RESET :");
490	break;
491
492	case SNIC_REQ_EXCH_VER:
493	cmd_str = "exch ver : ";
494	snprintf(line, LINE_BUFSZ, "SNIC_REQ_EXCH_VER :");
495	break;
496
497	case SNIC_REQ_TGT_INFO:
498	cmd_str = "tgt info : ";
499	break;
500
501	case SNIC_RSP_REPORT_TGTS_CMPL:
502	cmd_str = "report tgt cmpl : ";
503	snprintf(line, LINE_BUFSZ, "SNIC_RSP_REPORT_TGTS_CMPL :");
504	break;
505
506	case SNIC_RSP_ICMND_CMPL:
507	cmd_str = "icmnd_cmpl : ";
508	snprintf(line, LINE_BUFSZ, "SNIC_RSP_ICMND_CMPL : 0x%x :",
509	rqi->req->u.icmnd.cdb[0]);
510	break;
511
512	case SNIC_RSP_ITMF_CMPL:
513	cmd_str = "itmf_cmpl : ";
514	snprintf(line, LINE_BUFSZ, "SNIC_RSP_ITMF_CMPL :");
515	break;
516
517	case SNIC_RSP_HBA_RESET_CMPL:
518	cmd_str = "hba_reset_cmpl : ";
519	snprintf(line, LINE_BUFSZ, "SNIC_RSP_HBA_RESET_CMPL :");
520	break;
521
522	case SNIC_RSP_EXCH_VER_CMPL:
523	cmd_str = "exch_ver_cmpl : ";
524	snprintf(line, LINE_BUFSZ, "SNIC_RSP_EXCH_VER_CMPL :");
525	break;
526
527	case SNIC_MSG_ACK:
528	cmd_str = "msg ack : ";
529	snprintf(line, LINE_BUFSZ, "SNIC_MSG_ACK :");
530	break;
531
532	case SNIC_MSG_ASYNC_EVNOTIFY:
533	cmd_str = "async notify : ";
534	snprintf(line, LINE_BUFSZ, "SNIC_MSG_ASYNC_EVNOTIFY :");
535	break;
536
537	default:
538	cmd_str = "unknown : ";
539	SNIC_BUG_ON(1);
540	break;
541	}
542
543	SNIC_INFO("%s:%s >>cmndid=%x:sg_cnt = %x:status = %x:ctx = %lx.\n",
544	fn, line, req->hdr.cmnd_id, req->hdr.sg_cnt, req->hdr.status,
545	req->hdr.init_ctx);
546
547	/* Enable it, to dump byte stream */
548	if (snic_log_level & 0x20)
549	snic_hex_dump(cmd_str, os_buf, len);
550	} /* end of __snic_print_desc */
551
552	void
553	snic_print_desc(const char fn, char os_buf, int len)
554	{
555	if (snic_log_level & SNIC_DESC_LOGGING)
556	snic_dump_desc(fn, os_buf, len);
557	}
558
559	void
560	snic_calc_io_process_time(struct snic snic, struct snic_req_info rqi)
561	{
562	u64 duration;
563
564	duration = jiffies - rqi->start_time;
565
566	if (duration > atomic64_read(&snic->s_stats.io.max_time))
567	atomic64_set(&snic->s_stats.io.max_time, duration);
568	}