1942b7654SJitendra Bhivare /*
294583217SKetan Mukadam * This file is part of the Emulex Linux Device Driver for Enterprise iSCSI
394583217SKetan Mukadam * Host Bus Adapters. Refer to the README file included with this package
494583217SKetan Mukadam * for driver version and adapter compatibility.
56733b39aSJayamohan Kallickal *
694583217SKetan Mukadam * Copyright (c) 2018 Broadcom. All Rights Reserved.
794583217SKetan Mukadam * The term “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
894583217SKetan Mukadam *
994583217SKetan Mukadam * This program is free software; you can redistribute it and/or modify it
1094583217SKetan Mukadam * under the terms of version 2 of the GNU General Public License as published
1194583217SKetan Mukadam * by the Free Software Foundation.
1294583217SKetan Mukadam *
1394583217SKetan Mukadam * This program is distributed in the hope that it will be useful. ALL EXPRESS
1494583217SKetan Mukadam * OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES, INCLUDING ANY
1594583217SKetan Mukadam * IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
1694583217SKetan Mukadam * OR NON-INFRINGEMENT, ARE DISCLAIMED, EXCEPT TO THE EXTENT THAT SUCH
1794583217SKetan Mukadam * DISCLAIMERS ARE HELD TO BE LEGALLY INVALID.
1894583217SKetan Mukadam * See the GNU General Public License for more details, a copy of which
1994583217SKetan Mukadam * can be found in the file COPYING included with this package.
206733b39aSJayamohan Kallickal *
216733b39aSJayamohan Kallickal * Contact Information:
2260f36e04SJitendra Bhivare * linux-drivers@broadcom.com
236733b39aSJayamohan Kallickal *
246733b39aSJayamohan Kallickal */
25255fa9a3SJayamohan Kallickal
266733b39aSJayamohan Kallickal #include <linux/reboot.h>
276733b39aSJayamohan Kallickal #include <linux/delay.h>
285a0e3ad6STejun Heo #include <linux/slab.h>
296733b39aSJayamohan Kallickal #include <linux/interrupt.h>
306733b39aSJayamohan Kallickal #include <linux/blkdev.h>
316733b39aSJayamohan Kallickal #include <linux/pci.h>
326733b39aSJayamohan Kallickal #include <linux/string.h>
336733b39aSJayamohan Kallickal #include <linux/kernel.h>
346733b39aSJayamohan Kallickal #include <linux/semaphore.h>
35c7acc5b8SJayamohan Kallickal #include <linux/iscsi_boot_sysfs.h>
36acf3368fSPaul Gortmaker #include <linux/module.h>
37ffce3e2eSJayamohan Kallickal #include <linux/bsg-lib.h>
381094cf68SJitendra Bhivare #include <linux/irq_poll.h>
396733b39aSJayamohan Kallickal
406733b39aSJayamohan Kallickal #include <scsi/libiscsi.h>
41ffce3e2eSJayamohan Kallickal #include <scsi/scsi_bsg_iscsi.h>
42ffce3e2eSJayamohan Kallickal #include <scsi/scsi_netlink.h>
436733b39aSJayamohan Kallickal #include <scsi/scsi_transport_iscsi.h>
446733b39aSJayamohan Kallickal #include <scsi/scsi_transport.h>
456733b39aSJayamohan Kallickal #include <scsi/scsi_cmnd.h>
466733b39aSJayamohan Kallickal #include <scsi/scsi_device.h>
476733b39aSJayamohan Kallickal #include <scsi/scsi_host.h>
486733b39aSJayamohan Kallickal #include <scsi/scsi.h>
496733b39aSJayamohan Kallickal #include "be_main.h"
506733b39aSJayamohan Kallickal #include "be_iscsi.h"
516733b39aSJayamohan Kallickal #include "be_mgmt.h"
520a513dd8SJohn Soni Jose #include "be_cmds.h"
536733b39aSJayamohan Kallickal
546733b39aSJayamohan Kallickal static unsigned int be_iopoll_budget = 10;
556733b39aSJayamohan Kallickal static unsigned int be_max_phys_size = 64;
56bfead3b2SJayamohan Kallickal static unsigned int enable_msix = 1;
576733b39aSJayamohan Kallickal
586733b39aSJayamohan Kallickal MODULE_DESCRIPTION(DRV_DESC " " BUILD_STR);
5976d15dbdSJayamohan Kallickal MODULE_VERSION(BUILD_STR);
60c4f39bdaSKetan Mukadam MODULE_AUTHOR("Emulex Corporation");
616733b39aSJayamohan Kallickal MODULE_LICENSE("GPL");
626733b39aSJayamohan Kallickal module_param(be_iopoll_budget, int, 0);
636733b39aSJayamohan Kallickal module_param(enable_msix, int, 0);
646733b39aSJayamohan Kallickal module_param(be_max_phys_size, uint, S_IRUGO);
6599bc5d55SJohn Soni Jose MODULE_PARM_DESC(be_max_phys_size,
6699bc5d55SJohn Soni Jose "Maximum Size (In Kilobytes) of physically contiguous "
6799bc5d55SJohn Soni Jose "memory that can be allocated. Range is 16 - 128");
6899bc5d55SJohn Soni Jose
6999bc5d55SJohn Soni Jose #define beiscsi_disp_param(_name)\
700825b8eeSBaoyou Xie static ssize_t \
7199bc5d55SJohn Soni Jose beiscsi_##_name##_disp(struct device *dev,\
7299bc5d55SJohn Soni Jose struct device_attribute *attrib, char *buf) \
7399bc5d55SJohn Soni Jose { \
7499bc5d55SJohn Soni Jose struct Scsi_Host *shost = class_to_shost(dev);\
7599bc5d55SJohn Soni Jose struct beiscsi_hba *phba = iscsi_host_priv(shost); \
7699bc5d55SJohn Soni Jose return snprintf(buf, PAGE_SIZE, "%d\n",\
7799bc5d55SJohn Soni Jose phba->attr_##_name);\
7899bc5d55SJohn Soni Jose }
7999bc5d55SJohn Soni Jose
8099bc5d55SJohn Soni Jose #define beiscsi_change_param(_name, _minval, _maxval, _defaval)\
810825b8eeSBaoyou Xie static int \
8299bc5d55SJohn Soni Jose beiscsi_##_name##_change(struct beiscsi_hba *phba, uint32_t val)\
8399bc5d55SJohn Soni Jose {\
8499bc5d55SJohn Soni Jose if (val >= _minval && val <= _maxval) {\
8599bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,\
8699bc5d55SJohn Soni Jose "BA_%d : beiscsi_"#_name" updated "\
8799bc5d55SJohn Soni Jose "from 0x%x ==> 0x%x\n",\
8899bc5d55SJohn Soni Jose phba->attr_##_name, val); \
8999bc5d55SJohn Soni Jose phba->attr_##_name = val;\
9099bc5d55SJohn Soni Jose return 0;\
9199bc5d55SJohn Soni Jose } \
9299bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT, \
9399bc5d55SJohn Soni Jose "BA_%d beiscsi_"#_name" attribute "\
9499bc5d55SJohn Soni Jose "cannot be updated to 0x%x, "\
9599bc5d55SJohn Soni Jose "range allowed is ["#_minval" - "#_maxval"]\n", val);\
9699bc5d55SJohn Soni Jose return -EINVAL;\
9799bc5d55SJohn Soni Jose }
9899bc5d55SJohn Soni Jose
9999bc5d55SJohn Soni Jose #define beiscsi_store_param(_name) \
1000825b8eeSBaoyou Xie static ssize_t \
10199bc5d55SJohn Soni Jose beiscsi_##_name##_store(struct device *dev,\
10299bc5d55SJohn Soni Jose struct device_attribute *attr, const char *buf,\
10399bc5d55SJohn Soni Jose size_t count) \
10499bc5d55SJohn Soni Jose { \
10599bc5d55SJohn Soni Jose struct Scsi_Host *shost = class_to_shost(dev);\
10699bc5d55SJohn Soni Jose struct beiscsi_hba *phba = iscsi_host_priv(shost);\
10799bc5d55SJohn Soni Jose uint32_t param_val = 0;\
10899bc5d55SJohn Soni Jose if (!isdigit(buf[0]))\
10999bc5d55SJohn Soni Jose return -EINVAL;\
11099bc5d55SJohn Soni Jose if (sscanf(buf, "%i", ¶m_val) != 1)\
11199bc5d55SJohn Soni Jose return -EINVAL;\
11299bc5d55SJohn Soni Jose if (beiscsi_##_name##_change(phba, param_val) == 0) \
11399bc5d55SJohn Soni Jose return strlen(buf);\
11499bc5d55SJohn Soni Jose else \
11599bc5d55SJohn Soni Jose return -EINVAL;\
11699bc5d55SJohn Soni Jose }
11799bc5d55SJohn Soni Jose
11899bc5d55SJohn Soni Jose #define beiscsi_init_param(_name, _minval, _maxval, _defval) \
1190825b8eeSBaoyou Xie static int \
12099bc5d55SJohn Soni Jose beiscsi_##_name##_init(struct beiscsi_hba *phba, uint32_t val) \
12199bc5d55SJohn Soni Jose { \
12299bc5d55SJohn Soni Jose if (val >= _minval && val <= _maxval) {\
12399bc5d55SJohn Soni Jose phba->attr_##_name = val;\
12499bc5d55SJohn Soni Jose return 0;\
12599bc5d55SJohn Soni Jose } \
12699bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,\
12799bc5d55SJohn Soni Jose "BA_%d beiscsi_"#_name" attribute " \
12899bc5d55SJohn Soni Jose "cannot be updated to 0x%x, "\
12999bc5d55SJohn Soni Jose "range allowed is ["#_minval" - "#_maxval"]\n", val);\
13099bc5d55SJohn Soni Jose phba->attr_##_name = _defval;\
13199bc5d55SJohn Soni Jose return -EINVAL;\
13299bc5d55SJohn Soni Jose }
13399bc5d55SJohn Soni Jose
13499bc5d55SJohn Soni Jose #define BEISCSI_RW_ATTR(_name, _minval, _maxval, _defval, _descp) \
13599bc5d55SJohn Soni Jose static uint beiscsi_##_name = _defval;\
13699bc5d55SJohn Soni Jose module_param(beiscsi_##_name, uint, S_IRUGO);\
13799bc5d55SJohn Soni Jose MODULE_PARM_DESC(beiscsi_##_name, _descp);\
13899bc5d55SJohn Soni Jose beiscsi_disp_param(_name)\
13999bc5d55SJohn Soni Jose beiscsi_change_param(_name, _minval, _maxval, _defval)\
14099bc5d55SJohn Soni Jose beiscsi_store_param(_name)\
14199bc5d55SJohn Soni Jose beiscsi_init_param(_name, _minval, _maxval, _defval)\
1421efbacd2STom Rix static DEVICE_ATTR(beiscsi_##_name, S_IRUGO | S_IWUSR,\
14399bc5d55SJohn Soni Jose beiscsi_##_name##_disp, beiscsi_##_name##_store)
14499bc5d55SJohn Soni Jose
14599bc5d55SJohn Soni Jose /*
146c7fa2c85SChristophe JAILLET * When new log level added update MAX allowed value for log_enable
14799bc5d55SJohn Soni Jose */
14899bc5d55SJohn Soni Jose BEISCSI_RW_ATTR(log_enable, 0x00,
14999bc5d55SJohn Soni Jose 0xFF, 0x00, "Enable logging Bit Mask\n"
15099bc5d55SJohn Soni Jose "\t\t\t\tInitialization Events : 0x01\n"
15199bc5d55SJohn Soni Jose "\t\t\t\tMailbox Events : 0x02\n"
15299bc5d55SJohn Soni Jose "\t\t\t\tMiscellaneous Events : 0x04\n"
15399bc5d55SJohn Soni Jose "\t\t\t\tError Handling : 0x08\n"
15499bc5d55SJohn Soni Jose "\t\t\t\tIO Path Events : 0x10\n"
155afb96058SJayamohan Kallickal "\t\t\t\tConfiguration Path : 0x20\n"
156afb96058SJayamohan Kallickal "\t\t\t\tiSCSI Protocol : 0x40\n");
15799bc5d55SJohn Soni Jose
1581efbacd2STom Rix static DEVICE_ATTR(beiscsi_drvr_ver, S_IRUGO, beiscsi_drvr_ver_disp, NULL);
1591efbacd2STom Rix static DEVICE_ATTR(beiscsi_adapter_family, S_IRUGO, beiscsi_adap_family_disp, NULL);
1601efbacd2STom Rix static DEVICE_ATTR(beiscsi_fw_ver, S_IRUGO, beiscsi_fw_ver_disp, NULL);
1611efbacd2STom Rix static DEVICE_ATTR(beiscsi_phys_port, S_IRUGO, beiscsi_phys_port_disp, NULL);
1621efbacd2STom Rix static DEVICE_ATTR(beiscsi_active_session_count, S_IRUGO,
1636103c1f7SJayamohan Kallickal beiscsi_active_session_disp, NULL);
1641efbacd2STom Rix static DEVICE_ATTR(beiscsi_free_session_count, S_IRUGO,
1656103c1f7SJayamohan Kallickal beiscsi_free_session_disp, NULL);
166ebcbac34SBart Van Assche
167ebcbac34SBart Van Assche static struct attribute *beiscsi_attrs[] = {
168ebcbac34SBart Van Assche &dev_attr_beiscsi_log_enable.attr,
169ebcbac34SBart Van Assche &dev_attr_beiscsi_drvr_ver.attr,
170ebcbac34SBart Van Assche &dev_attr_beiscsi_adapter_family.attr,
171ebcbac34SBart Van Assche &dev_attr_beiscsi_fw_ver.attr,
172ebcbac34SBart Van Assche &dev_attr_beiscsi_active_session_count.attr,
173ebcbac34SBart Van Assche &dev_attr_beiscsi_free_session_count.attr,
174ebcbac34SBart Van Assche &dev_attr_beiscsi_phys_port.attr,
17599bc5d55SJohn Soni Jose NULL,
17699bc5d55SJohn Soni Jose };
1776733b39aSJayamohan Kallickal
178ebcbac34SBart Van Assche ATTRIBUTE_GROUPS(beiscsi);
179ebcbac34SBart Van Assche
1806763daaeSJohn Soni Jose static char const *cqe_desc[] = {
1816763daaeSJohn Soni Jose "RESERVED_DESC",
1826763daaeSJohn Soni Jose "SOL_CMD_COMPLETE",
1836763daaeSJohn Soni Jose "SOL_CMD_KILLED_DATA_DIGEST_ERR",
1846763daaeSJohn Soni Jose "CXN_KILLED_PDU_SIZE_EXCEEDS_DSL",
1856763daaeSJohn Soni Jose "CXN_KILLED_BURST_LEN_MISMATCH",
1866763daaeSJohn Soni Jose "CXN_KILLED_AHS_RCVD",
1876763daaeSJohn Soni Jose "CXN_KILLED_HDR_DIGEST_ERR",
1886763daaeSJohn Soni Jose "CXN_KILLED_UNKNOWN_HDR",
1896763daaeSJohn Soni Jose "CXN_KILLED_STALE_ITT_TTT_RCVD",
1906763daaeSJohn Soni Jose "CXN_KILLED_INVALID_ITT_TTT_RCVD",
1916763daaeSJohn Soni Jose "CXN_KILLED_RST_RCVD",
1926763daaeSJohn Soni Jose "CXN_KILLED_TIMED_OUT",
1936763daaeSJohn Soni Jose "CXN_KILLED_RST_SENT",
1946763daaeSJohn Soni Jose "CXN_KILLED_FIN_RCVD",
1956763daaeSJohn Soni Jose "CXN_KILLED_BAD_UNSOL_PDU_RCVD",
1966763daaeSJohn Soni Jose "CXN_KILLED_BAD_WRB_INDEX_ERROR",
1976763daaeSJohn Soni Jose "CXN_KILLED_OVER_RUN_RESIDUAL",
1986763daaeSJohn Soni Jose "CXN_KILLED_UNDER_RUN_RESIDUAL",
1996763daaeSJohn Soni Jose "CMD_KILLED_INVALID_STATSN_RCVD",
2006763daaeSJohn Soni Jose "CMD_KILLED_INVALID_R2T_RCVD",
2016763daaeSJohn Soni Jose "CMD_CXN_KILLED_LUN_INVALID",
2026763daaeSJohn Soni Jose "CMD_CXN_KILLED_ICD_INVALID",
2036763daaeSJohn Soni Jose "CMD_CXN_KILLED_ITT_INVALID",
2046763daaeSJohn Soni Jose "CMD_CXN_KILLED_SEQ_OUTOFORDER",
2056763daaeSJohn Soni Jose "CMD_CXN_KILLED_INVALID_DATASN_RCVD",
2066763daaeSJohn Soni Jose "CXN_INVALIDATE_NOTIFY",
2076763daaeSJohn Soni Jose "CXN_INVALIDATE_INDEX_NOTIFY",
2086763daaeSJohn Soni Jose "CMD_INVALIDATED_NOTIFY",
2096763daaeSJohn Soni Jose "UNSOL_HDR_NOTIFY",
2106763daaeSJohn Soni Jose "UNSOL_DATA_NOTIFY",
2116763daaeSJohn Soni Jose "UNSOL_DATA_DIGEST_ERROR_NOTIFY",
2126763daaeSJohn Soni Jose "DRIVERMSG_NOTIFY",
2136763daaeSJohn Soni Jose "CXN_KILLED_CMND_DATA_NOT_ON_SAME_CONN",
2146763daaeSJohn Soni Jose "SOL_CMD_KILLED_DIF_ERR",
2156763daaeSJohn Soni Jose "CXN_KILLED_SYN_RCVD",
2166763daaeSJohn Soni Jose "CXN_KILLED_IMM_DATA_RCVD"
2176763daaeSJohn Soni Jose };
2186763daaeSJohn Soni Jose
beiscsi_eh_abort(struct scsi_cmnd * sc)2194183122dSJayamohan Kallickal static int beiscsi_eh_abort(struct scsi_cmnd *sc)
2204183122dSJayamohan Kallickal {
221db22de3eSBart Van Assche struct iscsi_task *abrt_task = iscsi_cmd(sc)->task;
2224183122dSJayamohan Kallickal struct iscsi_cls_session *cls_session;
223faa0a22dSJitendra Bhivare struct beiscsi_io_task *abrt_io_task;
2244183122dSJayamohan Kallickal struct beiscsi_conn *beiscsi_conn;
2254183122dSJayamohan Kallickal struct iscsi_session *session;
226f3505013SJitendra Bhivare struct invldt_cmd_tbl inv_tbl;
227faa0a22dSJitendra Bhivare struct beiscsi_hba *phba;
228faa0a22dSJitendra Bhivare struct iscsi_conn *conn;
2291957aa7fSJayamohan Kallickal int rc;
2304183122dSJayamohan Kallickal
2314183122dSJayamohan Kallickal cls_session = starget_to_session(scsi_target(sc->device));
2324183122dSJayamohan Kallickal session = cls_session->dd_data;
2334183122dSJayamohan Kallickal
234e1c6a7ecSMike Christie completion_check:
235faa0a22dSJitendra Bhivare /* check if we raced, task just got cleaned up under us */
236faa0a22dSJitendra Bhivare spin_lock_bh(&session->back_lock);
237faa0a22dSJitendra Bhivare if (!abrt_task || !abrt_task->sc) {
238faa0a22dSJitendra Bhivare spin_unlock_bh(&session->back_lock);
2394183122dSJayamohan Kallickal return SUCCESS;
2404183122dSJayamohan Kallickal }
241faa0a22dSJitendra Bhivare /* get a task ref till FW processes the req for the ICD used */
242e1c6a7ecSMike Christie if (!iscsi_get_task(abrt_task)) {
243e1c6a7ecSMike Christie spin_unlock(&session->back_lock);
244e1c6a7ecSMike Christie /* We are just about to call iscsi_free_task so wait for it. */
245e1c6a7ecSMike Christie udelay(5);
246e1c6a7ecSMike Christie goto completion_check;
247e1c6a7ecSMike Christie }
248e1c6a7ecSMike Christie
249faa0a22dSJitendra Bhivare abrt_io_task = abrt_task->dd_data;
250faa0a22dSJitendra Bhivare conn = abrt_task->conn;
2514183122dSJayamohan Kallickal beiscsi_conn = conn->dd_data;
2524183122dSJayamohan Kallickal phba = beiscsi_conn->phba;
253faa0a22dSJitendra Bhivare /* mark WRB invalid which have been not processed by FW yet */
254392b7d2fSJitendra Bhivare if (is_chip_be2_be3r(phba)) {
255f3505013SJitendra Bhivare AMAP_SET_BITS(struct amap_iscsi_wrb, invld,
256faa0a22dSJitendra Bhivare abrt_io_task->pwrb_handle->pwrb, 1);
257392b7d2fSJitendra Bhivare } else {
258392b7d2fSJitendra Bhivare AMAP_SET_BITS(struct amap_iscsi_wrb_v2, invld,
259392b7d2fSJitendra Bhivare abrt_io_task->pwrb_handle->pwrb, 1);
260392b7d2fSJitendra Bhivare }
261faa0a22dSJitendra Bhivare inv_tbl.cid = beiscsi_conn->beiscsi_conn_cid;
262faa0a22dSJitendra Bhivare inv_tbl.icd = abrt_io_task->psgl_handle->sgl_index;
263faa0a22dSJitendra Bhivare spin_unlock_bh(&session->back_lock);
264faa0a22dSJitendra Bhivare
26598713216SJitendra Bhivare rc = beiscsi_mgmt_invalidate_icds(phba, &inv_tbl, 1);
266faa0a22dSJitendra Bhivare iscsi_put_task(abrt_task);
26798713216SJitendra Bhivare if (rc) {
26899bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_EH,
26998713216SJitendra Bhivare "BM_%d : sc %p invalidation failed %d\n",
27098713216SJitendra Bhivare sc, rc);
2714183122dSJayamohan Kallickal return FAILED;
2724183122dSJayamohan Kallickal }
273e175defeSJohn Soni Jose
2744183122dSJayamohan Kallickal return iscsi_eh_abort(sc);
2754183122dSJayamohan Kallickal }
2764183122dSJayamohan Kallickal
beiscsi_eh_device_reset(struct scsi_cmnd * sc)2774183122dSJayamohan Kallickal static int beiscsi_eh_device_reset(struct scsi_cmnd *sc)
2784183122dSJayamohan Kallickal {
27998713216SJitendra Bhivare struct beiscsi_invldt_cmd_tbl {
28098713216SJitendra Bhivare struct invldt_cmd_tbl tbl[BE_INVLDT_CMD_TBL_SZ];
28198713216SJitendra Bhivare struct iscsi_task *task[BE_INVLDT_CMD_TBL_SZ];
28298713216SJitendra Bhivare } *inv_tbl;
2834183122dSJayamohan Kallickal struct iscsi_cls_session *cls_session;
28498713216SJitendra Bhivare struct beiscsi_conn *beiscsi_conn;
28598713216SJitendra Bhivare struct beiscsi_io_task *io_task;
28698713216SJitendra Bhivare struct iscsi_session *session;
28798713216SJitendra Bhivare struct beiscsi_hba *phba;
28898713216SJitendra Bhivare struct iscsi_conn *conn;
28998713216SJitendra Bhivare struct iscsi_task *task;
29098713216SJitendra Bhivare unsigned int i, nents;
291f3505013SJitendra Bhivare int rc, more = 0;
2924183122dSJayamohan Kallickal
2934183122dSJayamohan Kallickal cls_session = starget_to_session(scsi_target(sc->device));
2944183122dSJayamohan Kallickal session = cls_session->dd_data;
29598713216SJitendra Bhivare
296659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock);
297db7f7709SJayamohan Kallickal if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) {
298659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock);
299db7f7709SJayamohan Kallickal return FAILED;
300db7f7709SJayamohan Kallickal }
30198713216SJitendra Bhivare
3024183122dSJayamohan Kallickal conn = session->leadconn;
3034183122dSJayamohan Kallickal beiscsi_conn = conn->dd_data;
3044183122dSJayamohan Kallickal phba = beiscsi_conn->phba;
305f3505013SJitendra Bhivare
306f2534736SWei Yongjun inv_tbl = kzalloc(sizeof(*inv_tbl), GFP_ATOMIC);
307f3505013SJitendra Bhivare if (!inv_tbl) {
308f3505013SJitendra Bhivare spin_unlock_bh(&session->frwd_lock);
309f3505013SJitendra Bhivare beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_EH,
310f3505013SJitendra Bhivare "BM_%d : invldt_cmd_tbl alloc failed\n");
311f3505013SJitendra Bhivare return FAILED;
312f3505013SJitendra Bhivare }
313f3505013SJitendra Bhivare nents = 0;
31498713216SJitendra Bhivare /* take back_lock to prevent task from getting cleaned up under us */
31598713216SJitendra Bhivare spin_lock(&session->back_lock);
3164183122dSJayamohan Kallickal for (i = 0; i < conn->session->cmds_max; i++) {
31798713216SJitendra Bhivare task = conn->session->cmds[i];
31898713216SJitendra Bhivare if (!task->sc)
3194183122dSJayamohan Kallickal continue;
3204183122dSJayamohan Kallickal
32198713216SJitendra Bhivare if (sc->device->lun != task->sc->device->lun)
3224183122dSJayamohan Kallickal continue;
323f3505013SJitendra Bhivare /**
324f3505013SJitendra Bhivare * Can't fit in more cmds? Normally this won't happen b'coz
325f3505013SJitendra Bhivare * BEISCSI_CMD_PER_LUN is same as BE_INVLDT_CMD_TBL_SZ.
326f3505013SJitendra Bhivare */
327f3505013SJitendra Bhivare if (nents == BE_INVLDT_CMD_TBL_SZ) {
328f3505013SJitendra Bhivare more = 1;
329f3505013SJitendra Bhivare break;
330f3505013SJitendra Bhivare }
3314183122dSJayamohan Kallickal
33298713216SJitendra Bhivare /* get a task ref till FW processes the req for the ICD used */
333e1c6a7ecSMike Christie if (!iscsi_get_task(task)) {
334e1c6a7ecSMike Christie /*
335e1c6a7ecSMike Christie * The task has completed in the driver and is
336e1c6a7ecSMike Christie * completing in libiscsi. Just ignore it here. When we
337e1c6a7ecSMike Christie * call iscsi_eh_device_reset, it will wait for us.
338e1c6a7ecSMike Christie */
339e1c6a7ecSMike Christie continue;
340e1c6a7ecSMike Christie }
341e1c6a7ecSMike Christie
34298713216SJitendra Bhivare io_task = task->dd_data;
34398713216SJitendra Bhivare /* mark WRB invalid which have been not processed by FW yet */
344392b7d2fSJitendra Bhivare if (is_chip_be2_be3r(phba)) {
3457626c06bSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, invld,
346392b7d2fSJitendra Bhivare io_task->pwrb_handle->pwrb, 1);
347392b7d2fSJitendra Bhivare } else {
348392b7d2fSJitendra Bhivare AMAP_SET_BITS(struct amap_iscsi_wrb_v2, invld,
349392b7d2fSJitendra Bhivare io_task->pwrb_handle->pwrb, 1);
350392b7d2fSJitendra Bhivare }
3517626c06bSJayamohan Kallickal
35298713216SJitendra Bhivare inv_tbl->tbl[nents].cid = beiscsi_conn->beiscsi_conn_cid;
35398713216SJitendra Bhivare inv_tbl->tbl[nents].icd = io_task->psgl_handle->sgl_index;
35498713216SJitendra Bhivare inv_tbl->task[nents] = task;
355f3505013SJitendra Bhivare nents++;
3564183122dSJayamohan Kallickal }
357d1e1d63bSJitendra Bhivare spin_unlock(&session->back_lock);
358659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock);
3594183122dSJayamohan Kallickal
36098713216SJitendra Bhivare rc = SUCCESS;
36198713216SJitendra Bhivare if (!nents)
36298713216SJitendra Bhivare goto end_reset;
36398713216SJitendra Bhivare
364f3505013SJitendra Bhivare if (more) {
365f3505013SJitendra Bhivare beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_EH,
366f3505013SJitendra Bhivare "BM_%d : number of cmds exceeds size of invalidation table\n");
36798713216SJitendra Bhivare rc = FAILED;
36898713216SJitendra Bhivare goto end_reset;
369f3505013SJitendra Bhivare }
370f3505013SJitendra Bhivare
37198713216SJitendra Bhivare if (beiscsi_mgmt_invalidate_icds(phba, &inv_tbl->tbl[0], nents)) {
37299bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_EH,
37398713216SJitendra Bhivare "BM_%d : cid %u scmds invalidation failed\n",
37498713216SJitendra Bhivare beiscsi_conn->beiscsi_conn_cid);
37598713216SJitendra Bhivare rc = FAILED;
3764183122dSJayamohan Kallickal }
377e175defeSJohn Soni Jose
37898713216SJitendra Bhivare end_reset:
37998713216SJitendra Bhivare for (i = 0; i < nents; i++)
38098713216SJitendra Bhivare iscsi_put_task(inv_tbl->task[i]);
38198713216SJitendra Bhivare kfree(inv_tbl);
38298713216SJitendra Bhivare
38398713216SJitendra Bhivare if (rc == SUCCESS)
38498713216SJitendra Bhivare rc = iscsi_eh_device_reset(sc);
38598713216SJitendra Bhivare return rc;
3864183122dSJayamohan Kallickal }
3874183122dSJayamohan Kallickal
388bfead3b2SJayamohan Kallickal /*------------------- PCI Driver operations and data ----------------- */
3899baa3c34SBenoit Taine static const struct pci_device_id beiscsi_pci_id_table[] = {
390bfead3b2SJayamohan Kallickal { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID1) },
391f98c96b0SJayamohan Kallickal { PCI_DEVICE(BE_VENDOR_ID, BE_DEVICE_ID2) },
392bfead3b2SJayamohan Kallickal { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID1) },
393bfead3b2SJayamohan Kallickal { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID2) },
394bfead3b2SJayamohan Kallickal { PCI_DEVICE(BE_VENDOR_ID, OC_DEVICE_ID3) },
395139a1b1eSJohn Soni Jose { PCI_DEVICE(ELX_VENDOR_ID, OC_SKH_ID1) },
396bfead3b2SJayamohan Kallickal { 0 }
397bfead3b2SJayamohan Kallickal };
398bfead3b2SJayamohan Kallickal MODULE_DEVICE_TABLE(pci, beiscsi_pci_id_table);
399bfead3b2SJayamohan Kallickal
40099bc5d55SJohn Soni Jose
40180602acaSBart Van Assche static const struct scsi_host_template beiscsi_sht = {
4026733b39aSJayamohan Kallickal .module = THIS_MODULE,
403c4f39bdaSKetan Mukadam .name = "Emulex 10Gbe open-iscsi Initiator Driver",
4046733b39aSJayamohan Kallickal .proc_name = DRV_NAME,
4056733b39aSJayamohan Kallickal .queuecommand = iscsi_queuecommand,
406db5ed4dfSChristoph Hellwig .change_queue_depth = scsi_change_queue_depth,
4076733b39aSJayamohan Kallickal .target_alloc = iscsi_target_alloc,
408b6a05c82SChristoph Hellwig .eh_timed_out = iscsi_eh_cmd_timed_out,
4094183122dSJayamohan Kallickal .eh_abort_handler = beiscsi_eh_abort,
4104183122dSJayamohan Kallickal .eh_device_reset_handler = beiscsi_eh_device_reset,
411309ce156SJayamohan Kallickal .eh_target_reset_handler = iscsi_eh_session_reset,
412ebcbac34SBart Van Assche .shost_groups = beiscsi_groups,
4136733b39aSJayamohan Kallickal .sg_tablesize = BEISCSI_SGLIST_ELEMENTS,
4146733b39aSJayamohan Kallickal .can_queue = BE2_IO_DEPTH,
4156733b39aSJayamohan Kallickal .this_id = -1,
4166733b39aSJayamohan Kallickal .max_sectors = BEISCSI_MAX_SECTORS,
41750c2e910SChristoph Hellwig .max_segment_size = 65536,
4186733b39aSJayamohan Kallickal .cmd_per_lun = BEISCSI_CMD_PER_LUN,
419ffce3e2eSJayamohan Kallickal .vendor_id = SCSI_NL_VID_TYPE_PCI | BE_VENDOR_ID,
420c40ecc12SChristoph Hellwig .track_queue_depth = 1,
421db22de3eSBart Van Assche .cmd_size = sizeof(struct iscsi_cmd),
4226733b39aSJayamohan Kallickal };
4236733b39aSJayamohan Kallickal
424bfead3b2SJayamohan Kallickal static struct scsi_transport_template *beiscsi_scsi_transport;
4256733b39aSJayamohan Kallickal
beiscsi_hba_alloc(struct pci_dev * pcidev)4266733b39aSJayamohan Kallickal static struct beiscsi_hba *beiscsi_hba_alloc(struct pci_dev *pcidev)
4276733b39aSJayamohan Kallickal {
4286733b39aSJayamohan Kallickal struct beiscsi_hba *phba;
4296733b39aSJayamohan Kallickal struct Scsi_Host *shost;
4306733b39aSJayamohan Kallickal
4316733b39aSJayamohan Kallickal shost = iscsi_host_alloc(&beiscsi_sht, sizeof(*phba), 0);
4326733b39aSJayamohan Kallickal if (!shost) {
43399bc5d55SJohn Soni Jose dev_err(&pcidev->dev,
43499bc5d55SJohn Soni Jose "beiscsi_hba_alloc - iscsi_host_alloc failed\n");
4356733b39aSJayamohan Kallickal return NULL;
4366733b39aSJayamohan Kallickal }
437bdd4aad7SMike Christie shost->max_id = BE2_MAX_SESSIONS - 1;
4386733b39aSJayamohan Kallickal shost->max_channel = 0;
4396733b39aSJayamohan Kallickal shost->max_cmd_len = BEISCSI_MAX_CMD_LEN;
4406733b39aSJayamohan Kallickal shost->max_lun = BEISCSI_NUM_MAX_LUN;
4416733b39aSJayamohan Kallickal shost->transportt = beiscsi_scsi_transport;
4426733b39aSJayamohan Kallickal phba = iscsi_host_priv(shost);
4436733b39aSJayamohan Kallickal memset(phba, 0, sizeof(*phba));
4446733b39aSJayamohan Kallickal phba->shost = shost;
4456733b39aSJayamohan Kallickal phba->pcidev = pci_dev_get(pcidev);
4462807afb7SJayamohan Kallickal pci_set_drvdata(pcidev, phba);
4470e43895eSMike Christie phba->interface_handle = 0xFFFFFFFF;
4486733b39aSJayamohan Kallickal
4496733b39aSJayamohan Kallickal return phba;
4506733b39aSJayamohan Kallickal }
4516733b39aSJayamohan Kallickal
beiscsi_unmap_pci_function(struct beiscsi_hba * phba)4526733b39aSJayamohan Kallickal static void beiscsi_unmap_pci_function(struct beiscsi_hba *phba)
4536733b39aSJayamohan Kallickal {
4546733b39aSJayamohan Kallickal if (phba->csr_va) {
4556733b39aSJayamohan Kallickal iounmap(phba->csr_va);
4566733b39aSJayamohan Kallickal phba->csr_va = NULL;
4576733b39aSJayamohan Kallickal }
4586733b39aSJayamohan Kallickal if (phba->db_va) {
4596733b39aSJayamohan Kallickal iounmap(phba->db_va);
4606733b39aSJayamohan Kallickal phba->db_va = NULL;
4616733b39aSJayamohan Kallickal }
4626733b39aSJayamohan Kallickal if (phba->pci_va) {
4636733b39aSJayamohan Kallickal iounmap(phba->pci_va);
4646733b39aSJayamohan Kallickal phba->pci_va = NULL;
4656733b39aSJayamohan Kallickal }
4666733b39aSJayamohan Kallickal }
4676733b39aSJayamohan Kallickal
beiscsi_map_pci_bars(struct beiscsi_hba * phba,struct pci_dev * pcidev)4686733b39aSJayamohan Kallickal static int beiscsi_map_pci_bars(struct beiscsi_hba *phba,
4696733b39aSJayamohan Kallickal struct pci_dev *pcidev)
4706733b39aSJayamohan Kallickal {
4716733b39aSJayamohan Kallickal u8 __iomem *addr;
472f98c96b0SJayamohan Kallickal int pcicfg_reg;
4736733b39aSJayamohan Kallickal
4744bdc0d67SChristoph Hellwig addr = ioremap(pci_resource_start(pcidev, 2),
4756733b39aSJayamohan Kallickal pci_resource_len(pcidev, 2));
4766733b39aSJayamohan Kallickal if (addr == NULL)
4776733b39aSJayamohan Kallickal return -ENOMEM;
4786733b39aSJayamohan Kallickal phba->ctrl.csr = addr;
4796733b39aSJayamohan Kallickal phba->csr_va = addr;
4806733b39aSJayamohan Kallickal
4814bdc0d67SChristoph Hellwig addr = ioremap(pci_resource_start(pcidev, 4), 128 * 1024);
4826733b39aSJayamohan Kallickal if (addr == NULL)
4836733b39aSJayamohan Kallickal goto pci_map_err;
4846733b39aSJayamohan Kallickal phba->ctrl.db = addr;
4856733b39aSJayamohan Kallickal phba->db_va = addr;
4866733b39aSJayamohan Kallickal
487f98c96b0SJayamohan Kallickal if (phba->generation == BE_GEN2)
488f98c96b0SJayamohan Kallickal pcicfg_reg = 1;
489f98c96b0SJayamohan Kallickal else
490f98c96b0SJayamohan Kallickal pcicfg_reg = 0;
491f98c96b0SJayamohan Kallickal
4924bdc0d67SChristoph Hellwig addr = ioremap(pci_resource_start(pcidev, pcicfg_reg),
493f98c96b0SJayamohan Kallickal pci_resource_len(pcidev, pcicfg_reg));
494f98c96b0SJayamohan Kallickal
4956733b39aSJayamohan Kallickal if (addr == NULL)
4966733b39aSJayamohan Kallickal goto pci_map_err;
4976733b39aSJayamohan Kallickal phba->ctrl.pcicfg = addr;
4986733b39aSJayamohan Kallickal phba->pci_va = addr;
4996733b39aSJayamohan Kallickal return 0;
5006733b39aSJayamohan Kallickal
5016733b39aSJayamohan Kallickal pci_map_err:
5026733b39aSJayamohan Kallickal beiscsi_unmap_pci_function(phba);
5036733b39aSJayamohan Kallickal return -ENOMEM;
5046733b39aSJayamohan Kallickal }
5056733b39aSJayamohan Kallickal
beiscsi_enable_pci(struct pci_dev * pcidev)5066733b39aSJayamohan Kallickal static int beiscsi_enable_pci(struct pci_dev *pcidev)
5076733b39aSJayamohan Kallickal {
5086733b39aSJayamohan Kallickal int ret;
5096733b39aSJayamohan Kallickal
5106733b39aSJayamohan Kallickal ret = pci_enable_device(pcidev);
5116733b39aSJayamohan Kallickal if (ret) {
51299bc5d55SJohn Soni Jose dev_err(&pcidev->dev,
51399bc5d55SJohn Soni Jose "beiscsi_enable_pci - enable device failed\n");
5146733b39aSJayamohan Kallickal return ret;
5156733b39aSJayamohan Kallickal }
5166733b39aSJayamohan Kallickal
517e307f3acSJohn Soni Jose ret = pci_request_regions(pcidev, DRV_NAME);
518e307f3acSJohn Soni Jose if (ret) {
519e307f3acSJohn Soni Jose dev_err(&pcidev->dev,
520e307f3acSJohn Soni Jose "beiscsi_enable_pci - request region failed\n");
521e307f3acSJohn Soni Jose goto pci_dev_disable;
522e307f3acSJohn Soni Jose }
523e307f3acSJohn Soni Jose
524bfead3b2SJayamohan Kallickal pci_set_master(pcidev);
52526a4c991SChristoph Hellwig ret = dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(64));
5266c57625bSJayamohan Kallickal if (ret) {
52726a4c991SChristoph Hellwig ret = dma_set_mask_and_coherent(&pcidev->dev, DMA_BIT_MASK(32));
5286733b39aSJayamohan Kallickal if (ret) {
5296733b39aSJayamohan Kallickal dev_err(&pcidev->dev, "Could not set PCI DMA Mask\n");
530e307f3acSJohn Soni Jose goto pci_region_release;
5316733b39aSJayamohan Kallickal }
5326733b39aSJayamohan Kallickal }
5336733b39aSJayamohan Kallickal return 0;
534e307f3acSJohn Soni Jose
535e307f3acSJohn Soni Jose pci_region_release:
536e307f3acSJohn Soni Jose pci_release_regions(pcidev);
537e307f3acSJohn Soni Jose pci_dev_disable:
538e307f3acSJohn Soni Jose pci_disable_device(pcidev);
539e307f3acSJohn Soni Jose
540e307f3acSJohn Soni Jose return ret;
5416733b39aSJayamohan Kallickal }
5426733b39aSJayamohan Kallickal
be_ctrl_init(struct beiscsi_hba * phba,struct pci_dev * pdev)5436733b39aSJayamohan Kallickal static int be_ctrl_init(struct beiscsi_hba *phba, struct pci_dev *pdev)
5446733b39aSJayamohan Kallickal {
5456733b39aSJayamohan Kallickal struct be_ctrl_info *ctrl = &phba->ctrl;
5466733b39aSJayamohan Kallickal struct be_dma_mem *mbox_mem_alloc = &ctrl->mbox_mem_alloced;
5476733b39aSJayamohan Kallickal struct be_dma_mem *mbox_mem_align = &ctrl->mbox_mem;
5486733b39aSJayamohan Kallickal int status = 0;
5496733b39aSJayamohan Kallickal
5506733b39aSJayamohan Kallickal ctrl->pdev = pdev;
5516733b39aSJayamohan Kallickal status = beiscsi_map_pci_bars(phba, pdev);
5526733b39aSJayamohan Kallickal if (status)
5536733b39aSJayamohan Kallickal return status;
5546733b39aSJayamohan Kallickal mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
55526a4c991SChristoph Hellwig mbox_mem_alloc->va = dma_alloc_coherent(&pdev->dev,
55626a4c991SChristoph Hellwig mbox_mem_alloc->size, &mbox_mem_alloc->dma, GFP_KERNEL);
5576733b39aSJayamohan Kallickal if (!mbox_mem_alloc->va) {
5586733b39aSJayamohan Kallickal beiscsi_unmap_pci_function(phba);
559a49e06d5SJayamohan Kallickal return -ENOMEM;
5606733b39aSJayamohan Kallickal }
5616733b39aSJayamohan Kallickal
5626733b39aSJayamohan Kallickal mbox_mem_align->size = sizeof(struct be_mcc_mailbox);
5636733b39aSJayamohan Kallickal mbox_mem_align->va = PTR_ALIGN(mbox_mem_alloc->va, 16);
5646733b39aSJayamohan Kallickal mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
5656733b39aSJayamohan Kallickal memset(mbox_mem_align->va, 0, sizeof(struct be_mcc_mailbox));
566c03a50f7SJitendra Bhivare mutex_init(&ctrl->mbox_lock);
567bfead3b2SJayamohan Kallickal spin_lock_init(&phba->ctrl.mcc_lock);
568bfead3b2SJayamohan Kallickal
5696733b39aSJayamohan Kallickal return status;
5706733b39aSJayamohan Kallickal }
5716733b39aSJayamohan Kallickal
572843ae752SJayamohan Kallickal /**
573843ae752SJayamohan Kallickal * beiscsi_get_params()- Set the config paramters
574843ae752SJayamohan Kallickal * @phba: ptr device priv structure
575843ae752SJayamohan Kallickal **/
beiscsi_get_params(struct beiscsi_hba * phba)5766733b39aSJayamohan Kallickal static void beiscsi_get_params(struct beiscsi_hba *phba)
5776733b39aSJayamohan Kallickal {
578843ae752SJayamohan Kallickal uint32_t total_cid_count = 0;
579843ae752SJayamohan Kallickal uint32_t total_icd_count = 0;
580843ae752SJayamohan Kallickal uint8_t ulp_num = 0;
581843ae752SJayamohan Kallickal
582843ae752SJayamohan Kallickal total_cid_count = BEISCSI_GET_CID_COUNT(phba, BEISCSI_ULP0) +
583843ae752SJayamohan Kallickal BEISCSI_GET_CID_COUNT(phba, BEISCSI_ULP1);
584843ae752SJayamohan Kallickal
585cf987b79SJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
586cf987b79SJayamohan Kallickal uint32_t align_mask = 0;
587cf987b79SJayamohan Kallickal uint32_t icd_post_per_page = 0;
588cf987b79SJayamohan Kallickal uint32_t icd_count_unavailable = 0;
589cf987b79SJayamohan Kallickal uint32_t icd_start = 0, icd_count = 0;
590cf987b79SJayamohan Kallickal uint32_t icd_start_align = 0, icd_count_align = 0;
591cf987b79SJayamohan Kallickal
592843ae752SJayamohan Kallickal if (test_bit(ulp_num, &phba->fw_config.ulp_supported)) {
593cf987b79SJayamohan Kallickal icd_start = phba->fw_config.iscsi_icd_start[ulp_num];
594cf987b79SJayamohan Kallickal icd_count = phba->fw_config.iscsi_icd_count[ulp_num];
595cf987b79SJayamohan Kallickal
596cf987b79SJayamohan Kallickal /* Get ICD count that can be posted on each page */
597cf987b79SJayamohan Kallickal icd_post_per_page = (PAGE_SIZE / (BE2_SGE *
598cf987b79SJayamohan Kallickal sizeof(struct iscsi_sge)));
599cf987b79SJayamohan Kallickal align_mask = (icd_post_per_page - 1);
600cf987b79SJayamohan Kallickal
601cf987b79SJayamohan Kallickal /* Check if icd_start is aligned ICD per page posting */
602cf987b79SJayamohan Kallickal if (icd_start % icd_post_per_page) {
603cf987b79SJayamohan Kallickal icd_start_align = ((icd_start +
604cf987b79SJayamohan Kallickal icd_post_per_page) &
605cf987b79SJayamohan Kallickal ~(align_mask));
606cf987b79SJayamohan Kallickal phba->fw_config.
607cf987b79SJayamohan Kallickal iscsi_icd_start[ulp_num] =
608cf987b79SJayamohan Kallickal icd_start_align;
609843ae752SJayamohan Kallickal }
610843ae752SJayamohan Kallickal
611cf987b79SJayamohan Kallickal icd_count_align = (icd_count & ~align_mask);
612cf987b79SJayamohan Kallickal
613cf987b79SJayamohan Kallickal /* ICD discarded in the process of alignment */
614cf987b79SJayamohan Kallickal if (icd_start_align)
615cf987b79SJayamohan Kallickal icd_count_unavailable = ((icd_start_align -
616cf987b79SJayamohan Kallickal icd_start) +
617cf987b79SJayamohan Kallickal (icd_count -
618cf987b79SJayamohan Kallickal icd_count_align));
619cf987b79SJayamohan Kallickal
620cf987b79SJayamohan Kallickal /* Updated ICD count available */
621cf987b79SJayamohan Kallickal phba->fw_config.iscsi_icd_count[ulp_num] = (icd_count -
622cf987b79SJayamohan Kallickal icd_count_unavailable);
623cf987b79SJayamohan Kallickal
624cf987b79SJayamohan Kallickal beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
625cf987b79SJayamohan Kallickal "BM_%d : Aligned ICD values\n"
626cf987b79SJayamohan Kallickal "\t ICD Start : %d\n"
627cf987b79SJayamohan Kallickal "\t ICD Count : %d\n"
628cf987b79SJayamohan Kallickal "\t ICD Discarded : %d\n",
629cf987b79SJayamohan Kallickal phba->fw_config.
630cf987b79SJayamohan Kallickal iscsi_icd_start[ulp_num],
631cf987b79SJayamohan Kallickal phba->fw_config.
632cf987b79SJayamohan Kallickal iscsi_icd_count[ulp_num],
633cf987b79SJayamohan Kallickal icd_count_unavailable);
634cf987b79SJayamohan Kallickal break;
635cf987b79SJayamohan Kallickal }
636cf987b79SJayamohan Kallickal }
637cf987b79SJayamohan Kallickal
638cf987b79SJayamohan Kallickal total_icd_count = phba->fw_config.iscsi_icd_count[ulp_num];
639843ae752SJayamohan Kallickal phba->params.ios_per_ctrl = (total_icd_count -
640843ae752SJayamohan Kallickal (total_cid_count +
641843ae752SJayamohan Kallickal BE2_TMFS + BE2_NOPOUT_REQ));
642843ae752SJayamohan Kallickal phba->params.cxns_per_ctrl = total_cid_count;
643843ae752SJayamohan Kallickal phba->params.icds_per_ctrl = total_icd_count;
6446733b39aSJayamohan Kallickal phba->params.num_sge_per_io = BE2_SGE;
6456733b39aSJayamohan Kallickal phba->params.defpdu_hdr_sz = BE2_DEFPDU_HDR_SZ;
6466733b39aSJayamohan Kallickal phba->params.defpdu_data_sz = BE2_DEFPDU_DATA_SZ;
647843ae752SJayamohan Kallickal phba->params.num_eq_entries = 1024;
648843ae752SJayamohan Kallickal phba->params.num_cq_entries = 1024;
6496733b39aSJayamohan Kallickal phba->params.wrbs_per_cxn = 256;
6506733b39aSJayamohan Kallickal }
6516733b39aSJayamohan Kallickal
hwi_ring_eq_db(struct beiscsi_hba * phba,unsigned int id,unsigned int clr_interrupt,unsigned int num_processed,unsigned char rearm,unsigned char event)6526733b39aSJayamohan Kallickal static void hwi_ring_eq_db(struct beiscsi_hba *phba,
6536733b39aSJayamohan Kallickal unsigned int id, unsigned int clr_interrupt,
6546733b39aSJayamohan Kallickal unsigned int num_processed,
6556733b39aSJayamohan Kallickal unsigned char rearm, unsigned char event)
6566733b39aSJayamohan Kallickal {
6576733b39aSJayamohan Kallickal u32 val = 0;
658e08b3c8bSJayamohan Kallickal
6596733b39aSJayamohan Kallickal if (rearm)
6606733b39aSJayamohan Kallickal val |= 1 << DB_EQ_REARM_SHIFT;
6616733b39aSJayamohan Kallickal if (clr_interrupt)
6626733b39aSJayamohan Kallickal val |= 1 << DB_EQ_CLR_SHIFT;
6636733b39aSJayamohan Kallickal if (event)
6646733b39aSJayamohan Kallickal val |= 1 << DB_EQ_EVNT_SHIFT;
665e08b3c8bSJayamohan Kallickal
6666733b39aSJayamohan Kallickal val |= num_processed << DB_EQ_NUM_POPPED_SHIFT;
667e08b3c8bSJayamohan Kallickal /* Setting lower order EQ_ID Bits */
668e08b3c8bSJayamohan Kallickal val |= (id & DB_EQ_RING_ID_LOW_MASK);
669e08b3c8bSJayamohan Kallickal
670e08b3c8bSJayamohan Kallickal /* Setting Higher order EQ_ID Bits */
671e08b3c8bSJayamohan Kallickal val |= (((id >> DB_EQ_HIGH_FEILD_SHIFT) &
672e08b3c8bSJayamohan Kallickal DB_EQ_RING_ID_HIGH_MASK)
673e08b3c8bSJayamohan Kallickal << DB_EQ_HIGH_SET_SHIFT);
674e08b3c8bSJayamohan Kallickal
6756733b39aSJayamohan Kallickal iowrite32(val, phba->db_va + DB_EQ_OFFSET);
6766733b39aSJayamohan Kallickal }
6776733b39aSJayamohan Kallickal
6786733b39aSJayamohan Kallickal /**
679bfead3b2SJayamohan Kallickal * be_isr_mcc - The isr routine of the driver.
680bfead3b2SJayamohan Kallickal * @irq: Not used
681bfead3b2SJayamohan Kallickal * @dev_id: Pointer to host adapter structure
682bfead3b2SJayamohan Kallickal */
be_isr_mcc(int irq,void * dev_id)683bfead3b2SJayamohan Kallickal static irqreturn_t be_isr_mcc(int irq, void *dev_id)
684bfead3b2SJayamohan Kallickal {
685bfead3b2SJayamohan Kallickal struct beiscsi_hba *phba;
686a3095016SJitendra Bhivare struct be_eq_entry *eqe;
687bfead3b2SJayamohan Kallickal struct be_queue_info *eq;
688bfead3b2SJayamohan Kallickal struct be_queue_info *mcc;
689a3095016SJitendra Bhivare unsigned int mcc_events;
690bfead3b2SJayamohan Kallickal struct be_eq_obj *pbe_eq;
691bfead3b2SJayamohan Kallickal
692bfead3b2SJayamohan Kallickal pbe_eq = dev_id;
693bfead3b2SJayamohan Kallickal eq = &pbe_eq->q;
694bfead3b2SJayamohan Kallickal phba = pbe_eq->phba;
695bfead3b2SJayamohan Kallickal mcc = &phba->ctrl.mcc_obj.cq;
696bfead3b2SJayamohan Kallickal eqe = queue_tail_node(eq);
697bfead3b2SJayamohan Kallickal
698a3095016SJitendra Bhivare mcc_events = 0;
699bfead3b2SJayamohan Kallickal while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
700bfead3b2SJayamohan Kallickal & EQE_VALID_MASK) {
701bfead3b2SJayamohan Kallickal if (((eqe->dw[offsetof(struct amap_eq_entry,
702bfead3b2SJayamohan Kallickal resource_id) / 32] &
703bfead3b2SJayamohan Kallickal EQE_RESID_MASK) >> 16) == mcc->id) {
704a3095016SJitendra Bhivare mcc_events++;
705bfead3b2SJayamohan Kallickal }
706bfead3b2SJayamohan Kallickal AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
707bfead3b2SJayamohan Kallickal queue_tail_inc(eq);
708bfead3b2SJayamohan Kallickal eqe = queue_tail_node(eq);
709bfead3b2SJayamohan Kallickal }
710bfead3b2SJayamohan Kallickal
711a3095016SJitendra Bhivare if (mcc_events) {
712a3095016SJitendra Bhivare queue_work(phba->wq, &pbe_eq->mcc_work);
713a3095016SJitendra Bhivare hwi_ring_eq_db(phba, eq->id, 1, mcc_events, 1, 1);
714a3095016SJitendra Bhivare }
715bfead3b2SJayamohan Kallickal return IRQ_HANDLED;
716bfead3b2SJayamohan Kallickal }
717bfead3b2SJayamohan Kallickal
718bfead3b2SJayamohan Kallickal /**
719bfead3b2SJayamohan Kallickal * be_isr_msix - The isr routine of the driver.
720bfead3b2SJayamohan Kallickal * @irq: Not used
721bfead3b2SJayamohan Kallickal * @dev_id: Pointer to host adapter structure
722bfead3b2SJayamohan Kallickal */
be_isr_msix(int irq,void * dev_id)723bfead3b2SJayamohan Kallickal static irqreturn_t be_isr_msix(int irq, void *dev_id)
724bfead3b2SJayamohan Kallickal {
725bfead3b2SJayamohan Kallickal struct beiscsi_hba *phba;
726bfead3b2SJayamohan Kallickal struct be_queue_info *eq;
727bfead3b2SJayamohan Kallickal struct be_eq_obj *pbe_eq;
728bfead3b2SJayamohan Kallickal
729bfead3b2SJayamohan Kallickal pbe_eq = dev_id;
730bfead3b2SJayamohan Kallickal eq = &pbe_eq->q;
731bfead3b2SJayamohan Kallickal
732bfead3b2SJayamohan Kallickal phba = pbe_eq->phba;
7331094cf68SJitendra Bhivare /* disable interrupt till iopoll completes */
7341094cf68SJitendra Bhivare hwi_ring_eq_db(phba, eq->id, 1, 0, 0, 1);
735511cbce2SChristoph Hellwig irq_poll_sched(&pbe_eq->iopoll);
736bfead3b2SJayamohan Kallickal
737bfead3b2SJayamohan Kallickal return IRQ_HANDLED;
738bfead3b2SJayamohan Kallickal }
739bfead3b2SJayamohan Kallickal
740bfead3b2SJayamohan Kallickal /**
7416733b39aSJayamohan Kallickal * be_isr - The isr routine of the driver.
7426733b39aSJayamohan Kallickal * @irq: Not used
7436733b39aSJayamohan Kallickal * @dev_id: Pointer to host adapter structure
7446733b39aSJayamohan Kallickal */
be_isr(int irq,void * dev_id)7456733b39aSJayamohan Kallickal static irqreturn_t be_isr(int irq, void *dev_id)
7466733b39aSJayamohan Kallickal {
7476733b39aSJayamohan Kallickal struct beiscsi_hba *phba;
7486733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
7496733b39aSJayamohan Kallickal struct hwi_context_memory *phwi_context;
750a3095016SJitendra Bhivare struct be_eq_entry *eqe;
7516733b39aSJayamohan Kallickal struct be_queue_info *eq;
752bfead3b2SJayamohan Kallickal struct be_queue_info *mcc;
753a3095016SJitendra Bhivare unsigned int mcc_events, io_events;
7546733b39aSJayamohan Kallickal struct be_ctrl_info *ctrl;
755bfead3b2SJayamohan Kallickal struct be_eq_obj *pbe_eq;
756a3095016SJitendra Bhivare int isr, rearm;
7576733b39aSJayamohan Kallickal
7586733b39aSJayamohan Kallickal phba = dev_id;
7596eab04a8SJustin P. Mattock ctrl = &phba->ctrl;
7606733b39aSJayamohan Kallickal isr = ioread32(ctrl->csr + CEV_ISR0_OFFSET +
7616733b39aSJayamohan Kallickal (PCI_FUNC(ctrl->pdev->devfn) * CEV_ISR_SIZE));
7626733b39aSJayamohan Kallickal if (!isr)
7636733b39aSJayamohan Kallickal return IRQ_NONE;
7646733b39aSJayamohan Kallickal
7656733b39aSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
7666733b39aSJayamohan Kallickal phwi_context = phwi_ctrlr->phwi_ctxt;
767bfead3b2SJayamohan Kallickal pbe_eq = &phwi_context->be_eq[0];
768bfead3b2SJayamohan Kallickal
769bfead3b2SJayamohan Kallickal eq = &phwi_context->be_eq[0].q;
770bfead3b2SJayamohan Kallickal mcc = &phba->ctrl.mcc_obj.cq;
7716733b39aSJayamohan Kallickal eqe = queue_tail_node(eq);
7726733b39aSJayamohan Kallickal
773a3095016SJitendra Bhivare io_events = 0;
774a3095016SJitendra Bhivare mcc_events = 0;
7756733b39aSJayamohan Kallickal while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
7766733b39aSJayamohan Kallickal & EQE_VALID_MASK) {
777bfead3b2SJayamohan Kallickal if (((eqe->dw[offsetof(struct amap_eq_entry,
778a3095016SJitendra Bhivare resource_id) / 32] & EQE_RESID_MASK) >> 16) == mcc->id)
779a3095016SJitendra Bhivare mcc_events++;
780a3095016SJitendra Bhivare else
781a3095016SJitendra Bhivare io_events++;
7826733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
7836733b39aSJayamohan Kallickal queue_tail_inc(eq);
7846733b39aSJayamohan Kallickal eqe = queue_tail_node(eq);
7856733b39aSJayamohan Kallickal }
786a3095016SJitendra Bhivare if (!io_events && !mcc_events)
7876733b39aSJayamohan Kallickal return IRQ_NONE;
788a3095016SJitendra Bhivare
789a3095016SJitendra Bhivare /* no need to rearm if interrupt is only for IOs */
790a3095016SJitendra Bhivare rearm = 0;
791a3095016SJitendra Bhivare if (mcc_events) {
792a3095016SJitendra Bhivare queue_work(phba->wq, &pbe_eq->mcc_work);
793a3095016SJitendra Bhivare /* rearm for MCCQ */
794a3095016SJitendra Bhivare rearm = 1;
795a3095016SJitendra Bhivare }
796a3095016SJitendra Bhivare if (io_events)
797a3095016SJitendra Bhivare irq_poll_sched(&pbe_eq->iopoll);
798a3095016SJitendra Bhivare hwi_ring_eq_db(phba, eq->id, 0, (io_events + mcc_events), rearm, 1);
799a3095016SJitendra Bhivare return IRQ_HANDLED;
8006733b39aSJayamohan Kallickal }
8016733b39aSJayamohan Kallickal
beiscsi_free_irqs(struct beiscsi_hba * phba)80245371aa3SJitendra Bhivare static void beiscsi_free_irqs(struct beiscsi_hba *phba)
80345371aa3SJitendra Bhivare {
80445371aa3SJitendra Bhivare struct hwi_context_memory *phwi_context;
80545371aa3SJitendra Bhivare int i;
80645371aa3SJitendra Bhivare
80745371aa3SJitendra Bhivare if (!phba->pcidev->msix_enabled) {
80845371aa3SJitendra Bhivare if (phba->pcidev->irq)
80945371aa3SJitendra Bhivare free_irq(phba->pcidev->irq, phba);
81045371aa3SJitendra Bhivare return;
81145371aa3SJitendra Bhivare }
81245371aa3SJitendra Bhivare
81345371aa3SJitendra Bhivare phwi_context = phba->phwi_ctrlr->phwi_ctxt;
81445371aa3SJitendra Bhivare for (i = 0; i <= phba->num_cpus; i++) {
81545371aa3SJitendra Bhivare free_irq(pci_irq_vector(phba->pcidev, i),
81645371aa3SJitendra Bhivare &phwi_context->be_eq[i]);
81745371aa3SJitendra Bhivare kfree(phba->msi_name[i]);
81845371aa3SJitendra Bhivare }
81945371aa3SJitendra Bhivare }
8201094cf68SJitendra Bhivare
beiscsi_init_irqs(struct beiscsi_hba * phba)8216733b39aSJayamohan Kallickal static int beiscsi_init_irqs(struct beiscsi_hba *phba)
8226733b39aSJayamohan Kallickal {
8236733b39aSJayamohan Kallickal struct pci_dev *pcidev = phba->pcidev;
824bfead3b2SJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
825bfead3b2SJayamohan Kallickal struct hwi_context_memory *phwi_context;
82683148866SChristoph Hellwig int ret, i, j;
8276733b39aSJayamohan Kallickal
828bfead3b2SJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
829bfead3b2SJayamohan Kallickal phwi_context = phwi_ctrlr->phwi_ctxt;
830bfead3b2SJayamohan Kallickal
83183148866SChristoph Hellwig if (pcidev->msix_enabled) {
832bfead3b2SJayamohan Kallickal for (i = 0; i < phba->num_cpus; i++) {
833d38c9a80SHimanshu Jha phba->msi_name[i] = kasprintf(GFP_KERNEL,
834d38c9a80SHimanshu Jha "beiscsi_%02x_%02x",
835d38c9a80SHimanshu Jha phba->shost->host_no, i);
8368fcfb210SJayamohan Kallickal if (!phba->msi_name[i]) {
8378fcfb210SJayamohan Kallickal ret = -ENOMEM;
8388fcfb210SJayamohan Kallickal goto free_msix_irqs;
8398fcfb210SJayamohan Kallickal }
8408fcfb210SJayamohan Kallickal
84183148866SChristoph Hellwig ret = request_irq(pci_irq_vector(pcidev, i),
84283148866SChristoph Hellwig be_isr_msix, 0, phba->msi_name[i],
843bfead3b2SJayamohan Kallickal &phwi_context->be_eq[i]);
8444f5af07eSJayamohan Kallickal if (ret) {
84599bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
846c7fa2c85SChristophe JAILLET "BM_%d : %s-Failed to register msix for i = %d\n",
847c7fa2c85SChristophe JAILLET __func__, i);
8488fcfb210SJayamohan Kallickal kfree(phba->msi_name[i]);
8494f5af07eSJayamohan Kallickal goto free_msix_irqs;
8504f5af07eSJayamohan Kallickal }
851bfead3b2SJayamohan Kallickal }
852d38c9a80SHimanshu Jha phba->msi_name[i] = kasprintf(GFP_KERNEL, "beiscsi_mcc_%02x",
853d38c9a80SHimanshu Jha phba->shost->host_no);
8548fcfb210SJayamohan Kallickal if (!phba->msi_name[i]) {
8558fcfb210SJayamohan Kallickal ret = -ENOMEM;
8568fcfb210SJayamohan Kallickal goto free_msix_irqs;
8578fcfb210SJayamohan Kallickal }
85883148866SChristoph Hellwig ret = request_irq(pci_irq_vector(pcidev, i), be_isr_mcc, 0,
85983148866SChristoph Hellwig phba->msi_name[i], &phwi_context->be_eq[i]);
8604f5af07eSJayamohan Kallickal if (ret) {
86199bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
862c7fa2c85SChristophe JAILLET "BM_%d : %s-Failed to register beiscsi_msix_mcc\n",
863c7fa2c85SChristophe JAILLET __func__);
8648fcfb210SJayamohan Kallickal kfree(phba->msi_name[i]);
8654f5af07eSJayamohan Kallickal goto free_msix_irqs;
8664f5af07eSJayamohan Kallickal }
8674f5af07eSJayamohan Kallickal
868bfead3b2SJayamohan Kallickal } else {
869bfead3b2SJayamohan Kallickal ret = request_irq(pcidev->irq, be_isr, IRQF_SHARED,
870bfead3b2SJayamohan Kallickal "beiscsi", phba);
8716733b39aSJayamohan Kallickal if (ret) {
87299bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
873c7fa2c85SChristophe JAILLET "BM_%d : %s-Failed to register irq\n",
874c7fa2c85SChristophe JAILLET __func__);
8756733b39aSJayamohan Kallickal return ret;
8766733b39aSJayamohan Kallickal }
877bfead3b2SJayamohan Kallickal }
8786733b39aSJayamohan Kallickal return 0;
8794f5af07eSJayamohan Kallickal free_msix_irqs:
8808fcfb210SJayamohan Kallickal for (j = i - 1; j >= 0; j--) {
88183148866SChristoph Hellwig free_irq(pci_irq_vector(pcidev, i), &phwi_context->be_eq[j]);
8828fcfb210SJayamohan Kallickal kfree(phba->msi_name[j]);
8838fcfb210SJayamohan Kallickal }
8844f5af07eSJayamohan Kallickal return ret;
8856733b39aSJayamohan Kallickal }
8866733b39aSJayamohan Kallickal
hwi_ring_cq_db(struct beiscsi_hba * phba,unsigned int id,unsigned int num_processed,unsigned char rearm)887e08b3c8bSJayamohan Kallickal void hwi_ring_cq_db(struct beiscsi_hba *phba,
8886733b39aSJayamohan Kallickal unsigned int id, unsigned int num_processed,
8891094cf68SJitendra Bhivare unsigned char rearm)
8906733b39aSJayamohan Kallickal {
8916733b39aSJayamohan Kallickal u32 val = 0;
892e08b3c8bSJayamohan Kallickal
8936733b39aSJayamohan Kallickal if (rearm)
8946733b39aSJayamohan Kallickal val |= 1 << DB_CQ_REARM_SHIFT;
895e08b3c8bSJayamohan Kallickal
8966733b39aSJayamohan Kallickal val |= num_processed << DB_CQ_NUM_POPPED_SHIFT;
897e08b3c8bSJayamohan Kallickal
898e08b3c8bSJayamohan Kallickal /* Setting lower order CQ_ID Bits */
899e08b3c8bSJayamohan Kallickal val |= (id & DB_CQ_RING_ID_LOW_MASK);
900e08b3c8bSJayamohan Kallickal
901e08b3c8bSJayamohan Kallickal /* Setting Higher order CQ_ID Bits */
902e08b3c8bSJayamohan Kallickal val |= (((id >> DB_CQ_HIGH_FEILD_SHIFT) &
903e08b3c8bSJayamohan Kallickal DB_CQ_RING_ID_HIGH_MASK)
904e08b3c8bSJayamohan Kallickal << DB_CQ_HIGH_SET_SHIFT);
905e08b3c8bSJayamohan Kallickal
9066733b39aSJayamohan Kallickal iowrite32(val, phba->db_va + DB_CQ_OFFSET);
9076733b39aSJayamohan Kallickal }
9086733b39aSJayamohan Kallickal
alloc_io_sgl_handle(struct beiscsi_hba * phba)9096733b39aSJayamohan Kallickal static struct sgl_handle *alloc_io_sgl_handle(struct beiscsi_hba *phba)
9106733b39aSJayamohan Kallickal {
9116733b39aSJayamohan Kallickal struct sgl_handle *psgl_handle;
9127d2c0d64SJitendra Bhivare unsigned long flags;
9136733b39aSJayamohan Kallickal
9147d2c0d64SJitendra Bhivare spin_lock_irqsave(&phba->io_sgl_lock, flags);
9156733b39aSJayamohan Kallickal if (phba->io_sgl_hndl_avbl) {
91699bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_IO,
91799bc5d55SJohn Soni Jose "BM_%d : In alloc_io_sgl_handle,"
91899bc5d55SJohn Soni Jose " io_sgl_alloc_index=%d\n",
9196733b39aSJayamohan Kallickal phba->io_sgl_alloc_index);
92099bc5d55SJohn Soni Jose
9216733b39aSJayamohan Kallickal psgl_handle = phba->io_sgl_hndl_base[phba->
9226733b39aSJayamohan Kallickal io_sgl_alloc_index];
9236733b39aSJayamohan Kallickal phba->io_sgl_hndl_base[phba->io_sgl_alloc_index] = NULL;
9246733b39aSJayamohan Kallickal phba->io_sgl_hndl_avbl--;
925bfead3b2SJayamohan Kallickal if (phba->io_sgl_alloc_index == (phba->params.
926bfead3b2SJayamohan Kallickal ios_per_ctrl - 1))
9276733b39aSJayamohan Kallickal phba->io_sgl_alloc_index = 0;
9286733b39aSJayamohan Kallickal else
9296733b39aSJayamohan Kallickal phba->io_sgl_alloc_index++;
9306733b39aSJayamohan Kallickal } else
9316733b39aSJayamohan Kallickal psgl_handle = NULL;
9327d2c0d64SJitendra Bhivare spin_unlock_irqrestore(&phba->io_sgl_lock, flags);
9336733b39aSJayamohan Kallickal return psgl_handle;
9346733b39aSJayamohan Kallickal }
9356733b39aSJayamohan Kallickal
9366733b39aSJayamohan Kallickal static void
free_io_sgl_handle(struct beiscsi_hba * phba,struct sgl_handle * psgl_handle)9376733b39aSJayamohan Kallickal free_io_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle)
9386733b39aSJayamohan Kallickal {
9397d2c0d64SJitendra Bhivare unsigned long flags;
9407d2c0d64SJitendra Bhivare
9417d2c0d64SJitendra Bhivare spin_lock_irqsave(&phba->io_sgl_lock, flags);
94299bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_IO,
94399bc5d55SJohn Soni Jose "BM_%d : In free_,io_sgl_free_index=%d\n",
9446733b39aSJayamohan Kallickal phba->io_sgl_free_index);
94599bc5d55SJohn Soni Jose
9466733b39aSJayamohan Kallickal if (phba->io_sgl_hndl_base[phba->io_sgl_free_index]) {
9476733b39aSJayamohan Kallickal /*
9486733b39aSJayamohan Kallickal * this can happen if clean_task is called on a task that
9496733b39aSJayamohan Kallickal * failed in xmit_task or alloc_pdu.
9506733b39aSJayamohan Kallickal */
95199bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_IO,
95245efc940SJitendra Bhivare "BM_%d : Double Free in IO SGL io_sgl_free_index=%d, value there=%p\n",
95345efc940SJitendra Bhivare phba->io_sgl_free_index,
95445efc940SJitendra Bhivare phba->io_sgl_hndl_base[phba->io_sgl_free_index]);
9557d2c0d64SJitendra Bhivare spin_unlock_irqrestore(&phba->io_sgl_lock, flags);
9566733b39aSJayamohan Kallickal return;
9576733b39aSJayamohan Kallickal }
9586733b39aSJayamohan Kallickal phba->io_sgl_hndl_base[phba->io_sgl_free_index] = psgl_handle;
9596733b39aSJayamohan Kallickal phba->io_sgl_hndl_avbl++;
9606733b39aSJayamohan Kallickal if (phba->io_sgl_free_index == (phba->params.ios_per_ctrl - 1))
9616733b39aSJayamohan Kallickal phba->io_sgl_free_index = 0;
9626733b39aSJayamohan Kallickal else
9636733b39aSJayamohan Kallickal phba->io_sgl_free_index++;
9647d2c0d64SJitendra Bhivare spin_unlock_irqrestore(&phba->io_sgl_lock, flags);
9656733b39aSJayamohan Kallickal }
9666733b39aSJayamohan Kallickal
967cb564c6bSJitendra Bhivare static inline struct wrb_handle *
beiscsi_get_wrb_handle(struct hwi_wrb_context * pwrb_context,unsigned int wrbs_per_cxn)968cb564c6bSJitendra Bhivare beiscsi_get_wrb_handle(struct hwi_wrb_context *pwrb_context,
969cb564c6bSJitendra Bhivare unsigned int wrbs_per_cxn)
970cb564c6bSJitendra Bhivare {
971cb564c6bSJitendra Bhivare struct wrb_handle *pwrb_handle;
9727d2c0d64SJitendra Bhivare unsigned long flags;
973cb564c6bSJitendra Bhivare
9747d2c0d64SJitendra Bhivare spin_lock_irqsave(&pwrb_context->wrb_lock, flags);
9753f7f62eeSJitendra Bhivare if (!pwrb_context->wrb_handles_available) {
9763f7f62eeSJitendra Bhivare spin_unlock_irqrestore(&pwrb_context->wrb_lock, flags);
9773f7f62eeSJitendra Bhivare return NULL;
9783f7f62eeSJitendra Bhivare }
979cb564c6bSJitendra Bhivare pwrb_handle = pwrb_context->pwrb_handle_base[pwrb_context->alloc_index];
980cb564c6bSJitendra Bhivare pwrb_context->wrb_handles_available--;
981cb564c6bSJitendra Bhivare if (pwrb_context->alloc_index == (wrbs_per_cxn - 1))
982cb564c6bSJitendra Bhivare pwrb_context->alloc_index = 0;
983cb564c6bSJitendra Bhivare else
984cb564c6bSJitendra Bhivare pwrb_context->alloc_index++;
9857d2c0d64SJitendra Bhivare spin_unlock_irqrestore(&pwrb_context->wrb_lock, flags);
986bf9b7554SJitendra Bhivare
987bf9b7554SJitendra Bhivare if (pwrb_handle)
988e1f9d31eSJitendra Bhivare memset(pwrb_handle->pwrb, 0, sizeof(*pwrb_handle->pwrb));
989cb564c6bSJitendra Bhivare
990cb564c6bSJitendra Bhivare return pwrb_handle;
991cb564c6bSJitendra Bhivare }
992cb564c6bSJitendra Bhivare
9936733b39aSJayamohan Kallickal /**
9946733b39aSJayamohan Kallickal * alloc_wrb_handle - To allocate a wrb handle
9956733b39aSJayamohan Kallickal * @phba: The hba pointer
9966733b39aSJayamohan Kallickal * @cid: The cid to use for allocation
997dbc019a4SLee Jones * @pcontext: ptr to ptr to wrb context
9986733b39aSJayamohan Kallickal *
9996733b39aSJayamohan Kallickal * This happens under session_lock until submission to chip
10006733b39aSJayamohan Kallickal */
alloc_wrb_handle(struct beiscsi_hba * phba,unsigned int cid,struct hwi_wrb_context ** pcontext)1001340c99e9SJohn Soni Jose struct wrb_handle *alloc_wrb_handle(struct beiscsi_hba *phba, unsigned int cid,
1002340c99e9SJohn Soni Jose struct hwi_wrb_context **pcontext)
10036733b39aSJayamohan Kallickal {
10046733b39aSJayamohan Kallickal struct hwi_wrb_context *pwrb_context;
10056733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
1006a7909b39SJayamohan Kallickal uint16_t cri_index = BE_GET_CRI_FROM_CID(cid);
10076733b39aSJayamohan Kallickal
10086733b39aSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
1009a7909b39SJayamohan Kallickal pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
1010cb564c6bSJitendra Bhivare /* return the context address */
1011340c99e9SJohn Soni Jose *pcontext = pwrb_context;
1012cb564c6bSJitendra Bhivare return beiscsi_get_wrb_handle(pwrb_context, phba->params.wrbs_per_cxn);
1013cb564c6bSJitendra Bhivare }
1014cb564c6bSJitendra Bhivare
1015cb564c6bSJitendra Bhivare static inline void
beiscsi_put_wrb_handle(struct hwi_wrb_context * pwrb_context,struct wrb_handle * pwrb_handle,unsigned int wrbs_per_cxn)1016cb564c6bSJitendra Bhivare beiscsi_put_wrb_handle(struct hwi_wrb_context *pwrb_context,
1017cb564c6bSJitendra Bhivare struct wrb_handle *pwrb_handle,
1018cb564c6bSJitendra Bhivare unsigned int wrbs_per_cxn)
1019cb564c6bSJitendra Bhivare {
10207d2c0d64SJitendra Bhivare unsigned long flags;
10217d2c0d64SJitendra Bhivare
10227d2c0d64SJitendra Bhivare spin_lock_irqsave(&pwrb_context->wrb_lock, flags);
1023cb564c6bSJitendra Bhivare pwrb_context->pwrb_handle_base[pwrb_context->free_index] = pwrb_handle;
1024cb564c6bSJitendra Bhivare pwrb_context->wrb_handles_available++;
1025cb564c6bSJitendra Bhivare if (pwrb_context->free_index == (wrbs_per_cxn - 1))
1026cb564c6bSJitendra Bhivare pwrb_context->free_index = 0;
1027cb564c6bSJitendra Bhivare else
1028cb564c6bSJitendra Bhivare pwrb_context->free_index++;
10293f7f62eeSJitendra Bhivare pwrb_handle->pio_handle = NULL;
10307d2c0d64SJitendra Bhivare spin_unlock_irqrestore(&pwrb_context->wrb_lock, flags);
10316733b39aSJayamohan Kallickal }
10326733b39aSJayamohan Kallickal
10336733b39aSJayamohan Kallickal /**
10346733b39aSJayamohan Kallickal * free_wrb_handle - To free the wrb handle back to pool
10356733b39aSJayamohan Kallickal * @phba: The hba pointer
10366733b39aSJayamohan Kallickal * @pwrb_context: The context to free from
10376733b39aSJayamohan Kallickal * @pwrb_handle: The wrb_handle to free
10386733b39aSJayamohan Kallickal *
10396733b39aSJayamohan Kallickal * This happens under session_lock until submission to chip
10406733b39aSJayamohan Kallickal */
10416733b39aSJayamohan Kallickal static void
free_wrb_handle(struct beiscsi_hba * phba,struct hwi_wrb_context * pwrb_context,struct wrb_handle * pwrb_handle)10426733b39aSJayamohan Kallickal free_wrb_handle(struct beiscsi_hba *phba, struct hwi_wrb_context *pwrb_context,
10436733b39aSJayamohan Kallickal struct wrb_handle *pwrb_handle)
10446733b39aSJayamohan Kallickal {
1045cb564c6bSJitendra Bhivare beiscsi_put_wrb_handle(pwrb_context,
1046cb564c6bSJitendra Bhivare pwrb_handle,
1047cb564c6bSJitendra Bhivare phba->params.wrbs_per_cxn);
104899bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO,
104999bc5d55SJohn Soni Jose BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
105099bc5d55SJohn Soni Jose "BM_%d : FREE WRB: pwrb_handle=%p free_index=0x%x "
10516733b39aSJayamohan Kallickal "wrb_handles_available=%d\n",
10526733b39aSJayamohan Kallickal pwrb_handle, pwrb_context->free_index,
1053bfead3b2SJayamohan Kallickal pwrb_context->wrb_handles_available);
10546733b39aSJayamohan Kallickal }
10556733b39aSJayamohan Kallickal
alloc_mgmt_sgl_handle(struct beiscsi_hba * phba)10566733b39aSJayamohan Kallickal static struct sgl_handle *alloc_mgmt_sgl_handle(struct beiscsi_hba *phba)
10576733b39aSJayamohan Kallickal {
10586733b39aSJayamohan Kallickal struct sgl_handle *psgl_handle;
10597d2c0d64SJitendra Bhivare unsigned long flags;
10606733b39aSJayamohan Kallickal
10617d2c0d64SJitendra Bhivare spin_lock_irqsave(&phba->mgmt_sgl_lock, flags);
10626733b39aSJayamohan Kallickal if (phba->eh_sgl_hndl_avbl) {
10636733b39aSJayamohan Kallickal psgl_handle = phba->eh_sgl_hndl_base[phba->eh_sgl_alloc_index];
10646733b39aSJayamohan Kallickal phba->eh_sgl_hndl_base[phba->eh_sgl_alloc_index] = NULL;
106599bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
106699bc5d55SJohn Soni Jose "BM_%d : mgmt_sgl_alloc_index=%d=0x%x\n",
106799bc5d55SJohn Soni Jose phba->eh_sgl_alloc_index,
106899bc5d55SJohn Soni Jose phba->eh_sgl_alloc_index);
106999bc5d55SJohn Soni Jose
10706733b39aSJayamohan Kallickal phba->eh_sgl_hndl_avbl--;
10716733b39aSJayamohan Kallickal if (phba->eh_sgl_alloc_index ==
10726733b39aSJayamohan Kallickal (phba->params.icds_per_ctrl - phba->params.ios_per_ctrl -
10736733b39aSJayamohan Kallickal 1))
10746733b39aSJayamohan Kallickal phba->eh_sgl_alloc_index = 0;
10756733b39aSJayamohan Kallickal else
10766733b39aSJayamohan Kallickal phba->eh_sgl_alloc_index++;
10776733b39aSJayamohan Kallickal } else
10786733b39aSJayamohan Kallickal psgl_handle = NULL;
10797d2c0d64SJitendra Bhivare spin_unlock_irqrestore(&phba->mgmt_sgl_lock, flags);
10806733b39aSJayamohan Kallickal return psgl_handle;
10816733b39aSJayamohan Kallickal }
10826733b39aSJayamohan Kallickal
10836733b39aSJayamohan Kallickal void
free_mgmt_sgl_handle(struct beiscsi_hba * phba,struct sgl_handle * psgl_handle)10846733b39aSJayamohan Kallickal free_mgmt_sgl_handle(struct beiscsi_hba *phba, struct sgl_handle *psgl_handle)
10856733b39aSJayamohan Kallickal {
10867d2c0d64SJitendra Bhivare unsigned long flags;
10877d2c0d64SJitendra Bhivare
10887d2c0d64SJitendra Bhivare spin_lock_irqsave(&phba->mgmt_sgl_lock, flags);
108999bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
109099bc5d55SJohn Soni Jose "BM_%d : In free_mgmt_sgl_handle,"
109199bc5d55SJohn Soni Jose "eh_sgl_free_index=%d\n",
1092bfead3b2SJayamohan Kallickal phba->eh_sgl_free_index);
109399bc5d55SJohn Soni Jose
10946733b39aSJayamohan Kallickal if (phba->eh_sgl_hndl_base[phba->eh_sgl_free_index]) {
10956733b39aSJayamohan Kallickal /*
10966733b39aSJayamohan Kallickal * this can happen if clean_task is called on a task that
10976733b39aSJayamohan Kallickal * failed in xmit_task or alloc_pdu.
10986733b39aSJayamohan Kallickal */
109999bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_CONFIG,
110099bc5d55SJohn Soni Jose "BM_%d : Double Free in eh SGL ,"
110199bc5d55SJohn Soni Jose "eh_sgl_free_index=%d\n",
11026733b39aSJayamohan Kallickal phba->eh_sgl_free_index);
11037d2c0d64SJitendra Bhivare spin_unlock_irqrestore(&phba->mgmt_sgl_lock, flags);
11046733b39aSJayamohan Kallickal return;
11056733b39aSJayamohan Kallickal }
11066733b39aSJayamohan Kallickal phba->eh_sgl_hndl_base[phba->eh_sgl_free_index] = psgl_handle;
11076733b39aSJayamohan Kallickal phba->eh_sgl_hndl_avbl++;
11086733b39aSJayamohan Kallickal if (phba->eh_sgl_free_index ==
11096733b39aSJayamohan Kallickal (phba->params.icds_per_ctrl - phba->params.ios_per_ctrl - 1))
11106733b39aSJayamohan Kallickal phba->eh_sgl_free_index = 0;
11116733b39aSJayamohan Kallickal else
11126733b39aSJayamohan Kallickal phba->eh_sgl_free_index++;
11137d2c0d64SJitendra Bhivare spin_unlock_irqrestore(&phba->mgmt_sgl_lock, flags);
11146733b39aSJayamohan Kallickal }
11156733b39aSJayamohan Kallickal
11166733b39aSJayamohan Kallickal static void
be_complete_io(struct beiscsi_conn * beiscsi_conn,struct iscsi_task * task,struct common_sol_cqe * csol_cqe)11176733b39aSJayamohan Kallickal be_complete_io(struct beiscsi_conn *beiscsi_conn,
111873133261SJohn Soni Jose struct iscsi_task *task,
111973133261SJohn Soni Jose struct common_sol_cqe *csol_cqe)
11206733b39aSJayamohan Kallickal {
11216733b39aSJayamohan Kallickal struct beiscsi_io_task *io_task = task->dd_data;
11226733b39aSJayamohan Kallickal struct be_status_bhs *sts_bhs =
11236733b39aSJayamohan Kallickal (struct be_status_bhs *)io_task->cmd_bhs;
11246733b39aSJayamohan Kallickal struct iscsi_conn *conn = beiscsi_conn->conn;
11256733b39aSJayamohan Kallickal unsigned char *sense;
11266733b39aSJayamohan Kallickal u32 resid = 0, exp_cmdsn, max_cmdsn;
11276733b39aSJayamohan Kallickal u8 rsp, status, flags;
11286733b39aSJayamohan Kallickal
112973133261SJohn Soni Jose exp_cmdsn = csol_cqe->exp_cmdsn;
113073133261SJohn Soni Jose max_cmdsn = (csol_cqe->exp_cmdsn +
113173133261SJohn Soni Jose csol_cqe->cmd_wnd - 1);
113273133261SJohn Soni Jose rsp = csol_cqe->i_resp;
113373133261SJohn Soni Jose status = csol_cqe->i_sts;
113473133261SJohn Soni Jose flags = csol_cqe->i_flags;
113573133261SJohn Soni Jose resid = csol_cqe->res_cnt;
113673133261SJohn Soni Jose
1137bd535451SJayamohan Kallickal if (!task->sc) {
1138da334977SJayamohan Kallickal if (io_task->scsi_cmnd) {
1139bd535451SJayamohan Kallickal scsi_dma_unmap(io_task->scsi_cmnd);
1140da334977SJayamohan Kallickal io_task->scsi_cmnd = NULL;
1141da334977SJayamohan Kallickal }
11426733b39aSJayamohan Kallickal
1143bd535451SJayamohan Kallickal return;
1144bd535451SJayamohan Kallickal }
11456733b39aSJayamohan Kallickal task->sc->result = (DID_OK << 16) | status;
11466733b39aSJayamohan Kallickal if (rsp != ISCSI_STATUS_CMD_COMPLETED) {
11476733b39aSJayamohan Kallickal task->sc->result = DID_ERROR << 16;
11486733b39aSJayamohan Kallickal goto unmap;
11496733b39aSJayamohan Kallickal }
11506733b39aSJayamohan Kallickal
11516733b39aSJayamohan Kallickal /* bidi not initially supported */
11526733b39aSJayamohan Kallickal if (flags & (ISCSI_FLAG_CMD_UNDERFLOW | ISCSI_FLAG_CMD_OVERFLOW)) {
11536733b39aSJayamohan Kallickal if (!status && (flags & ISCSI_FLAG_CMD_OVERFLOW))
11546733b39aSJayamohan Kallickal task->sc->result = DID_ERROR << 16;
11556733b39aSJayamohan Kallickal
11566733b39aSJayamohan Kallickal if (flags & ISCSI_FLAG_CMD_UNDERFLOW) {
11576733b39aSJayamohan Kallickal scsi_set_resid(task->sc, resid);
11586733b39aSJayamohan Kallickal if (!status && (scsi_bufflen(task->sc) - resid <
11596733b39aSJayamohan Kallickal task->sc->underflow))
11606733b39aSJayamohan Kallickal task->sc->result = DID_ERROR << 16;
11616733b39aSJayamohan Kallickal }
11626733b39aSJayamohan Kallickal }
11636733b39aSJayamohan Kallickal
11646733b39aSJayamohan Kallickal if (status == SAM_STAT_CHECK_CONDITION) {
11654053a4beSDan Carpenter u16 sense_len;
1166bfead3b2SJayamohan Kallickal unsigned short *slen = (unsigned short *)sts_bhs->sense_info;
11674053a4beSDan Carpenter
11686733b39aSJayamohan Kallickal sense = sts_bhs->sense_info + sizeof(unsigned short);
11694053a4beSDan Carpenter sense_len = be16_to_cpu(*slen);
11706733b39aSJayamohan Kallickal memcpy(task->sc->sense_buffer, sense,
11716733b39aSJayamohan Kallickal min_t(u16, sense_len, SCSI_SENSE_BUFFERSIZE));
11726733b39aSJayamohan Kallickal }
1173756d29c8SJayamohan Kallickal
117473133261SJohn Soni Jose if (io_task->cmd_bhs->iscsi_hdr.flags & ISCSI_FLAG_CMD_READ)
117573133261SJohn Soni Jose conn->rxdata_octets += resid;
11766733b39aSJayamohan Kallickal unmap:
1177eb1c4692SJohn Soni Jose if (io_task->scsi_cmnd) {
11786733b39aSJayamohan Kallickal scsi_dma_unmap(io_task->scsi_cmnd);
1179da334977SJayamohan Kallickal io_task->scsi_cmnd = NULL;
1180eb1c4692SJohn Soni Jose }
11816733b39aSJayamohan Kallickal iscsi_complete_scsi_task(task, exp_cmdsn, max_cmdsn);
11826733b39aSJayamohan Kallickal }
11836733b39aSJayamohan Kallickal
11846733b39aSJayamohan Kallickal static void
be_complete_logout(struct beiscsi_conn * beiscsi_conn,struct iscsi_task * task,struct common_sol_cqe * csol_cqe)11856733b39aSJayamohan Kallickal be_complete_logout(struct beiscsi_conn *beiscsi_conn,
118673133261SJohn Soni Jose struct iscsi_task *task,
118773133261SJohn Soni Jose struct common_sol_cqe *csol_cqe)
11886733b39aSJayamohan Kallickal {
11896733b39aSJayamohan Kallickal struct iscsi_logout_rsp *hdr;
1190bfead3b2SJayamohan Kallickal struct beiscsi_io_task *io_task = task->dd_data;
11916733b39aSJayamohan Kallickal struct iscsi_conn *conn = beiscsi_conn->conn;
11926733b39aSJayamohan Kallickal
11936733b39aSJayamohan Kallickal hdr = (struct iscsi_logout_rsp *)task->hdr;
11947bd6e25cSJayamohan Kallickal hdr->opcode = ISCSI_OP_LOGOUT_RSP;
11956733b39aSJayamohan Kallickal hdr->t2wait = 5;
11966733b39aSJayamohan Kallickal hdr->t2retain = 0;
119773133261SJohn Soni Jose hdr->flags = csol_cqe->i_flags;
119873133261SJohn Soni Jose hdr->response = csol_cqe->i_resp;
1199702dc5e8SJayamohan Kallickal hdr->exp_cmdsn = cpu_to_be32(csol_cqe->exp_cmdsn);
1200702dc5e8SJayamohan Kallickal hdr->max_cmdsn = cpu_to_be32(csol_cqe->exp_cmdsn +
1201702dc5e8SJayamohan Kallickal csol_cqe->cmd_wnd - 1);
120273133261SJohn Soni Jose
12037bd6e25cSJayamohan Kallickal hdr->dlength[0] = 0;
12047bd6e25cSJayamohan Kallickal hdr->dlength[1] = 0;
12057bd6e25cSJayamohan Kallickal hdr->dlength[2] = 0;
12066733b39aSJayamohan Kallickal hdr->hlength = 0;
1207bfead3b2SJayamohan Kallickal hdr->itt = io_task->libiscsi_itt;
12086733b39aSJayamohan Kallickal __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, NULL, 0);
12096733b39aSJayamohan Kallickal }
12106733b39aSJayamohan Kallickal
12116733b39aSJayamohan Kallickal static void
be_complete_tmf(struct beiscsi_conn * beiscsi_conn,struct iscsi_task * task,struct common_sol_cqe * csol_cqe)12126733b39aSJayamohan Kallickal be_complete_tmf(struct beiscsi_conn *beiscsi_conn,
121373133261SJohn Soni Jose struct iscsi_task *task,
121473133261SJohn Soni Jose struct common_sol_cqe *csol_cqe)
12156733b39aSJayamohan Kallickal {
12166733b39aSJayamohan Kallickal struct iscsi_tm_rsp *hdr;
12176733b39aSJayamohan Kallickal struct iscsi_conn *conn = beiscsi_conn->conn;
1218bfead3b2SJayamohan Kallickal struct beiscsi_io_task *io_task = task->dd_data;
12196733b39aSJayamohan Kallickal
12206733b39aSJayamohan Kallickal hdr = (struct iscsi_tm_rsp *)task->hdr;
12217bd6e25cSJayamohan Kallickal hdr->opcode = ISCSI_OP_SCSI_TMFUNC_RSP;
122273133261SJohn Soni Jose hdr->flags = csol_cqe->i_flags;
122373133261SJohn Soni Jose hdr->response = csol_cqe->i_resp;
1224702dc5e8SJayamohan Kallickal hdr->exp_cmdsn = cpu_to_be32(csol_cqe->exp_cmdsn);
1225702dc5e8SJayamohan Kallickal hdr->max_cmdsn = cpu_to_be32(csol_cqe->exp_cmdsn +
122673133261SJohn Soni Jose csol_cqe->cmd_wnd - 1);
122773133261SJohn Soni Jose
1228bfead3b2SJayamohan Kallickal hdr->itt = io_task->libiscsi_itt;
12296733b39aSJayamohan Kallickal __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, NULL, 0);
12306733b39aSJayamohan Kallickal }
12316733b39aSJayamohan Kallickal
12326733b39aSJayamohan Kallickal static void
hwi_complete_drvr_msgs(struct beiscsi_conn * beiscsi_conn,struct beiscsi_hba * phba,struct sol_cqe * psol)12336733b39aSJayamohan Kallickal hwi_complete_drvr_msgs(struct beiscsi_conn *beiscsi_conn,
12346733b39aSJayamohan Kallickal struct beiscsi_hba *phba, struct sol_cqe *psol)
12356733b39aSJayamohan Kallickal {
12366733b39aSJayamohan Kallickal struct hwi_wrb_context *pwrb_context;
1237a7909b39SJayamohan Kallickal uint16_t wrb_index, cid, cri_index;
1238e1f9d31eSJitendra Bhivare struct hwi_controller *phwi_ctrlr;
1239e1f9d31eSJitendra Bhivare struct wrb_handle *pwrb_handle;
12403f7f62eeSJitendra Bhivare struct iscsi_session *session;
1241e1f9d31eSJitendra Bhivare struct iscsi_task *task;
12426733b39aSJayamohan Kallickal
12436733b39aSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
12442c9dfd36SJayamohan Kallickal if (is_chip_be2_be3r(phba)) {
124573133261SJohn Soni Jose wrb_index = AMAP_GET_BITS(struct amap_it_dmsg_cqe,
124673133261SJohn Soni Jose wrb_idx, psol);
124773133261SJohn Soni Jose cid = AMAP_GET_BITS(struct amap_it_dmsg_cqe,
124873133261SJohn Soni Jose cid, psol);
12492c9dfd36SJayamohan Kallickal } else {
12502c9dfd36SJayamohan Kallickal wrb_index = AMAP_GET_BITS(struct amap_it_dmsg_cqe_v2,
12512c9dfd36SJayamohan Kallickal wrb_idx, psol);
12522c9dfd36SJayamohan Kallickal cid = AMAP_GET_BITS(struct amap_it_dmsg_cqe_v2,
12532c9dfd36SJayamohan Kallickal cid, psol);
125473133261SJohn Soni Jose }
125573133261SJohn Soni Jose
1256a7909b39SJayamohan Kallickal cri_index = BE_GET_CRI_FROM_CID(cid);
1257a7909b39SJayamohan Kallickal pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
125873133261SJohn Soni Jose pwrb_handle = pwrb_context->pwrb_handle_basestd[wrb_index];
12593f7f62eeSJitendra Bhivare session = beiscsi_conn->conn->session;
12603f7f62eeSJitendra Bhivare spin_lock_bh(&session->back_lock);
1261bfead3b2SJayamohan Kallickal task = pwrb_handle->pio_handle;
12623f7f62eeSJitendra Bhivare if (task)
12633f7f62eeSJitendra Bhivare __iscsi_put_task(task);
12643f7f62eeSJitendra Bhivare spin_unlock_bh(&session->back_lock);
12656733b39aSJayamohan Kallickal }
12666733b39aSJayamohan Kallickal
12676733b39aSJayamohan Kallickal static void
be_complete_nopin_resp(struct beiscsi_conn * beiscsi_conn,struct iscsi_task * task,struct common_sol_cqe * csol_cqe)12686733b39aSJayamohan Kallickal be_complete_nopin_resp(struct beiscsi_conn *beiscsi_conn,
126973133261SJohn Soni Jose struct iscsi_task *task,
127073133261SJohn Soni Jose struct common_sol_cqe *csol_cqe)
12716733b39aSJayamohan Kallickal {
12726733b39aSJayamohan Kallickal struct iscsi_nopin *hdr;
12736733b39aSJayamohan Kallickal struct iscsi_conn *conn = beiscsi_conn->conn;
1274bfead3b2SJayamohan Kallickal struct beiscsi_io_task *io_task = task->dd_data;
12756733b39aSJayamohan Kallickal
12766733b39aSJayamohan Kallickal hdr = (struct iscsi_nopin *)task->hdr;
127773133261SJohn Soni Jose hdr->flags = csol_cqe->i_flags;
127873133261SJohn Soni Jose hdr->exp_cmdsn = cpu_to_be32(csol_cqe->exp_cmdsn);
1279702dc5e8SJayamohan Kallickal hdr->max_cmdsn = cpu_to_be32(csol_cqe->exp_cmdsn +
128073133261SJohn Soni Jose csol_cqe->cmd_wnd - 1);
128173133261SJohn Soni Jose
12826733b39aSJayamohan Kallickal hdr->opcode = ISCSI_OP_NOOP_IN;
1283bfead3b2SJayamohan Kallickal hdr->itt = io_task->libiscsi_itt;
12846733b39aSJayamohan Kallickal __iscsi_complete_pdu(conn, (struct iscsi_hdr *)hdr, NULL, 0);
12856733b39aSJayamohan Kallickal }
12866733b39aSJayamohan Kallickal
adapter_get_sol_cqe(struct beiscsi_hba * phba,struct sol_cqe * psol,struct common_sol_cqe * csol_cqe)128773133261SJohn Soni Jose static void adapter_get_sol_cqe(struct beiscsi_hba *phba,
128873133261SJohn Soni Jose struct sol_cqe *psol,
128973133261SJohn Soni Jose struct common_sol_cqe *csol_cqe)
129073133261SJohn Soni Jose {
12912c9dfd36SJayamohan Kallickal if (is_chip_be2_be3r(phba)) {
12922c9dfd36SJayamohan Kallickal csol_cqe->exp_cmdsn = AMAP_GET_BITS(struct amap_sol_cqe,
12932c9dfd36SJayamohan Kallickal i_exp_cmd_sn, psol);
12942c9dfd36SJayamohan Kallickal csol_cqe->res_cnt = AMAP_GET_BITS(struct amap_sol_cqe,
12952c9dfd36SJayamohan Kallickal i_res_cnt, psol);
12962c9dfd36SJayamohan Kallickal csol_cqe->cmd_wnd = AMAP_GET_BITS(struct amap_sol_cqe,
12972c9dfd36SJayamohan Kallickal i_cmd_wnd, psol);
12982c9dfd36SJayamohan Kallickal csol_cqe->wrb_index = AMAP_GET_BITS(struct amap_sol_cqe,
12992c9dfd36SJayamohan Kallickal wrb_index, psol);
13002c9dfd36SJayamohan Kallickal csol_cqe->cid = AMAP_GET_BITS(struct amap_sol_cqe,
13012c9dfd36SJayamohan Kallickal cid, psol);
13022c9dfd36SJayamohan Kallickal csol_cqe->hw_sts = AMAP_GET_BITS(struct amap_sol_cqe,
13032c9dfd36SJayamohan Kallickal hw_sts, psol);
13042c9dfd36SJayamohan Kallickal csol_cqe->i_resp = AMAP_GET_BITS(struct amap_sol_cqe,
13052c9dfd36SJayamohan Kallickal i_resp, psol);
13062c9dfd36SJayamohan Kallickal csol_cqe->i_sts = AMAP_GET_BITS(struct amap_sol_cqe,
13072c9dfd36SJayamohan Kallickal i_sts, psol);
13082c9dfd36SJayamohan Kallickal csol_cqe->i_flags = AMAP_GET_BITS(struct amap_sol_cqe,
13092c9dfd36SJayamohan Kallickal i_flags, psol);
13102c9dfd36SJayamohan Kallickal } else {
131173133261SJohn Soni Jose csol_cqe->exp_cmdsn = AMAP_GET_BITS(struct amap_sol_cqe_v2,
131273133261SJohn Soni Jose i_exp_cmd_sn, psol);
131373133261SJohn Soni Jose csol_cqe->res_cnt = AMAP_GET_BITS(struct amap_sol_cqe_v2,
131473133261SJohn Soni Jose i_res_cnt, psol);
131573133261SJohn Soni Jose csol_cqe->wrb_index = AMAP_GET_BITS(struct amap_sol_cqe_v2,
131673133261SJohn Soni Jose wrb_index, psol);
131773133261SJohn Soni Jose csol_cqe->cid = AMAP_GET_BITS(struct amap_sol_cqe_v2,
131873133261SJohn Soni Jose cid, psol);
131973133261SJohn Soni Jose csol_cqe->hw_sts = AMAP_GET_BITS(struct amap_sol_cqe_v2,
132073133261SJohn Soni Jose hw_sts, psol);
1321702dc5e8SJayamohan Kallickal csol_cqe->cmd_wnd = AMAP_GET_BITS(struct amap_sol_cqe_v2,
132273133261SJohn Soni Jose i_cmd_wnd, psol);
132373133261SJohn Soni Jose if (AMAP_GET_BITS(struct amap_sol_cqe_v2,
132473133261SJohn Soni Jose cmd_cmpl, psol))
132573133261SJohn Soni Jose csol_cqe->i_sts = AMAP_GET_BITS(struct amap_sol_cqe_v2,
132673133261SJohn Soni Jose i_sts, psol);
132773133261SJohn Soni Jose else
132873133261SJohn Soni Jose csol_cqe->i_resp = AMAP_GET_BITS(struct amap_sol_cqe_v2,
132973133261SJohn Soni Jose i_sts, psol);
133073133261SJohn Soni Jose if (AMAP_GET_BITS(struct amap_sol_cqe_v2,
133173133261SJohn Soni Jose u, psol))
133273133261SJohn Soni Jose csol_cqe->i_flags = ISCSI_FLAG_CMD_UNDERFLOW;
133373133261SJohn Soni Jose
133473133261SJohn Soni Jose if (AMAP_GET_BITS(struct amap_sol_cqe_v2,
133573133261SJohn Soni Jose o, psol))
133673133261SJohn Soni Jose csol_cqe->i_flags |= ISCSI_FLAG_CMD_OVERFLOW;
133773133261SJohn Soni Jose }
133873133261SJohn Soni Jose }
133973133261SJohn Soni Jose
134073133261SJohn Soni Jose
hwi_complete_cmd(struct beiscsi_conn * beiscsi_conn,struct beiscsi_hba * phba,struct sol_cqe * psol)13416733b39aSJayamohan Kallickal static void hwi_complete_cmd(struct beiscsi_conn *beiscsi_conn,
13426733b39aSJayamohan Kallickal struct beiscsi_hba *phba, struct sol_cqe *psol)
13436733b39aSJayamohan Kallickal {
13446733b39aSJayamohan Kallickal struct iscsi_conn *conn = beiscsi_conn->conn;
13456733b39aSJayamohan Kallickal struct iscsi_session *session = conn->session;
134673133261SJohn Soni Jose struct common_sol_cqe csol_cqe = {0};
13473f7f62eeSJitendra Bhivare struct hwi_wrb_context *pwrb_context;
13483f7f62eeSJitendra Bhivare struct hwi_controller *phwi_ctrlr;
13493f7f62eeSJitendra Bhivare struct wrb_handle *pwrb_handle;
13503f7f62eeSJitendra Bhivare struct iscsi_task *task;
1351a7909b39SJayamohan Kallickal uint16_t cri_index = 0;
13523f7f62eeSJitendra Bhivare uint8_t type;
13536733b39aSJayamohan Kallickal
13546733b39aSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
135573133261SJohn Soni Jose
135673133261SJohn Soni Jose /* Copy the elements to a common structure */
135773133261SJohn Soni Jose adapter_get_sol_cqe(phba, psol, &csol_cqe);
135873133261SJohn Soni Jose
1359a7909b39SJayamohan Kallickal cri_index = BE_GET_CRI_FROM_CID(csol_cqe.cid);
1360a7909b39SJayamohan Kallickal pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
136173133261SJohn Soni Jose
136273133261SJohn Soni Jose pwrb_handle = pwrb_context->pwrb_handle_basestd[
136373133261SJohn Soni Jose csol_cqe.wrb_index];
136473133261SJohn Soni Jose
13653f7f62eeSJitendra Bhivare spin_lock_bh(&session->back_lock);
13666733b39aSJayamohan Kallickal task = pwrb_handle->pio_handle;
13673f7f62eeSJitendra Bhivare if (!task) {
13683f7f62eeSJitendra Bhivare spin_unlock_bh(&session->back_lock);
13693f7f62eeSJitendra Bhivare return;
13703f7f62eeSJitendra Bhivare }
137173133261SJohn Soni Jose type = ((struct beiscsi_io_task *)task->dd_data)->wrb_type;
137232951dd8SJayamohan Kallickal
1373bfead3b2SJayamohan Kallickal switch (type) {
13746733b39aSJayamohan Kallickal case HWH_TYPE_IO:
13756733b39aSJayamohan Kallickal case HWH_TYPE_IO_RD:
13766733b39aSJayamohan Kallickal if ((task->hdr->opcode & ISCSI_OPCODE_MASK) ==
1377dafab8e0SJayamohan Kallickal ISCSI_OP_NOOP_OUT)
137873133261SJohn Soni Jose be_complete_nopin_resp(beiscsi_conn, task, &csol_cqe);
1379dafab8e0SJayamohan Kallickal else
138073133261SJohn Soni Jose be_complete_io(beiscsi_conn, task, &csol_cqe);
13816733b39aSJayamohan Kallickal break;
13826733b39aSJayamohan Kallickal
13836733b39aSJayamohan Kallickal case HWH_TYPE_LOGOUT:
1384dafab8e0SJayamohan Kallickal if ((task->hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT)
138573133261SJohn Soni Jose be_complete_logout(beiscsi_conn, task, &csol_cqe);
1386dafab8e0SJayamohan Kallickal else
138773133261SJohn Soni Jose be_complete_tmf(beiscsi_conn, task, &csol_cqe);
13886733b39aSJayamohan Kallickal break;
13896733b39aSJayamohan Kallickal
13906733b39aSJayamohan Kallickal case HWH_TYPE_LOGIN:
139199bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR,
139299bc5d55SJohn Soni Jose BEISCSI_LOG_CONFIG | BEISCSI_LOG_IO,
139399bc5d55SJohn Soni Jose "BM_%d :\t\t No HWH_TYPE_LOGIN Expected in"
1394c7fa2c85SChristophe JAILLET " %s- Solicited path\n", __func__);
13956733b39aSJayamohan Kallickal break;
13966733b39aSJayamohan Kallickal
13976733b39aSJayamohan Kallickal case HWH_TYPE_NOP:
139873133261SJohn Soni Jose be_complete_nopin_resp(beiscsi_conn, task, &csol_cqe);
13996733b39aSJayamohan Kallickal break;
14006733b39aSJayamohan Kallickal
14016733b39aSJayamohan Kallickal default:
140299bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_WARNING,
140399bc5d55SJohn Soni Jose BEISCSI_LOG_CONFIG | BEISCSI_LOG_IO,
1404c7fa2c85SChristophe JAILLET "BM_%d : In %s, unknown type = %d "
1405c7fa2c85SChristophe JAILLET "wrb_index 0x%x CID 0x%x\n", __func__, type,
140673133261SJohn Soni Jose csol_cqe.wrb_index,
140773133261SJohn Soni Jose csol_cqe.cid);
14086733b39aSJayamohan Kallickal break;
14096733b39aSJayamohan Kallickal }
141035e66019SJayamohan Kallickal
1411659743b0SShlomo Pongratz spin_unlock_bh(&session->back_lock);
14126733b39aSJayamohan Kallickal }
14136733b39aSJayamohan Kallickal
1414dbc019a4SLee Jones /*
1415938f372cSJitendra Bhivare * ASYNC PDUs include
1416938f372cSJitendra Bhivare * a. Unsolicited NOP-In (target initiated NOP-In)
1417938f372cSJitendra Bhivare * b. ASYNC Messages
1418938f372cSJitendra Bhivare * c. Reject PDU
1419938f372cSJitendra Bhivare * d. Login response
1420938f372cSJitendra Bhivare * These headers arrive unprocessed by the EP firmware.
1421938f372cSJitendra Bhivare * iSCSI layer processes them.
1422938f372cSJitendra Bhivare */
14236733b39aSJayamohan Kallickal static unsigned int
beiscsi_complete_pdu(struct beiscsi_conn * beiscsi_conn,struct pdu_base * phdr,void * pdata,unsigned int dlen)1424938f372cSJitendra Bhivare beiscsi_complete_pdu(struct beiscsi_conn *beiscsi_conn,
1425938f372cSJitendra Bhivare struct pdu_base *phdr, void *pdata, unsigned int dlen)
14266733b39aSJayamohan Kallickal {
1427938f372cSJitendra Bhivare struct beiscsi_hba *phba = beiscsi_conn->phba;
1428938f372cSJitendra Bhivare struct iscsi_conn *conn = beiscsi_conn->conn;
1429938f372cSJitendra Bhivare struct beiscsi_io_task *io_task;
1430938f372cSJitendra Bhivare struct iscsi_hdr *login_hdr;
1431938f372cSJitendra Bhivare struct iscsi_task *task;
1432938f372cSJitendra Bhivare u8 code;
14336733b39aSJayamohan Kallickal
1434938f372cSJitendra Bhivare code = AMAP_GET_BITS(struct amap_pdu_base, opcode, phdr);
1435938f372cSJitendra Bhivare switch (code) {
1436938f372cSJitendra Bhivare case ISCSI_OP_NOOP_IN:
1437938f372cSJitendra Bhivare pdata = NULL;
1438938f372cSJitendra Bhivare dlen = 0;
1439938f372cSJitendra Bhivare break;
1440938f372cSJitendra Bhivare case ISCSI_OP_ASYNC_EVENT:
1441938f372cSJitendra Bhivare break;
1442938f372cSJitendra Bhivare case ISCSI_OP_REJECT:
1443938f372cSJitendra Bhivare WARN_ON(!pdata);
1444938f372cSJitendra Bhivare WARN_ON(!(dlen == 48));
144599bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR,
144699bc5d55SJohn Soni Jose BEISCSI_LOG_CONFIG | BEISCSI_LOG_IO,
1447938f372cSJitendra Bhivare "BM_%d : In ISCSI_OP_REJECT\n");
1448938f372cSJitendra Bhivare break;
1449938f372cSJitendra Bhivare case ISCSI_OP_LOGIN_RSP:
1450938f372cSJitendra Bhivare case ISCSI_OP_TEXT_RSP:
1451938f372cSJitendra Bhivare task = conn->login_task;
1452938f372cSJitendra Bhivare io_task = task->dd_data;
1453938f372cSJitendra Bhivare login_hdr = (struct iscsi_hdr *)phdr;
1454938f372cSJitendra Bhivare login_hdr->itt = io_task->libiscsi_itt;
1455938f372cSJitendra Bhivare break;
1456938f372cSJitendra Bhivare default:
1457938f372cSJitendra Bhivare beiscsi_log(phba, KERN_WARNING,
1458938f372cSJitendra Bhivare BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
1459938f372cSJitendra Bhivare "BM_%d : unrecognized async PDU opcode 0x%x\n",
1460938f372cSJitendra Bhivare code);
1461938f372cSJitendra Bhivare return 1;
14626733b39aSJayamohan Kallickal }
1463938f372cSJitendra Bhivare __iscsi_complete_pdu(conn, (struct iscsi_hdr *)phdr, pdata, dlen);
14646733b39aSJayamohan Kallickal return 0;
14656733b39aSJayamohan Kallickal }
14666733b39aSJayamohan Kallickal
1467938f372cSJitendra Bhivare static inline void
beiscsi_hdl_put_handle(struct hd_async_context * pasync_ctx,struct hd_async_handle * pasync_handle)1468938f372cSJitendra Bhivare beiscsi_hdl_put_handle(struct hd_async_context *pasync_ctx,
1469938f372cSJitendra Bhivare struct hd_async_handle *pasync_handle)
14706733b39aSJayamohan Kallickal {
1471ba6983a7SJitendra Bhivare pasync_handle->is_final = 0;
1472ba6983a7SJitendra Bhivare pasync_handle->buffer_len = 0;
1473ba6983a7SJitendra Bhivare pasync_handle->in_use = 0;
1474ba6983a7SJitendra Bhivare list_del_init(&pasync_handle->link);
14756733b39aSJayamohan Kallickal }
1476ba6983a7SJitendra Bhivare
1477ba6983a7SJitendra Bhivare static void
beiscsi_hdl_purge_handles(struct beiscsi_hba * phba,struct hd_async_context * pasync_ctx,u16 cri)1478ba6983a7SJitendra Bhivare beiscsi_hdl_purge_handles(struct beiscsi_hba *phba,
1479ba6983a7SJitendra Bhivare struct hd_async_context *pasync_ctx,
1480ba6983a7SJitendra Bhivare u16 cri)
1481ba6983a7SJitendra Bhivare {
1482ba6983a7SJitendra Bhivare struct hd_async_handle *pasync_handle, *tmp_handle;
1483ba6983a7SJitendra Bhivare struct list_head *plist;
1484ba6983a7SJitendra Bhivare
1485ba6983a7SJitendra Bhivare plist = &pasync_ctx->async_entry[cri].wq.list;
1486ba6983a7SJitendra Bhivare list_for_each_entry_safe(pasync_handle, tmp_handle, plist, link)
1487ba6983a7SJitendra Bhivare beiscsi_hdl_put_handle(pasync_ctx, pasync_handle);
1488ba6983a7SJitendra Bhivare
1489ba6983a7SJitendra Bhivare INIT_LIST_HEAD(&pasync_ctx->async_entry[cri].wq.list);
1490ba6983a7SJitendra Bhivare pasync_ctx->async_entry[cri].wq.hdr_len = 0;
1491ba6983a7SJitendra Bhivare pasync_ctx->async_entry[cri].wq.bytes_received = 0;
1492ba6983a7SJitendra Bhivare pasync_ctx->async_entry[cri].wq.bytes_needed = 0;
14936733b39aSJayamohan Kallickal }
14946733b39aSJayamohan Kallickal
1495938f372cSJitendra Bhivare static struct hd_async_handle *
beiscsi_hdl_get_handle(struct beiscsi_conn * beiscsi_conn,struct hd_async_context * pasync_ctx,struct i_t_dpdu_cqe * pdpdu_cqe,u8 * header)1496938f372cSJitendra Bhivare beiscsi_hdl_get_handle(struct beiscsi_conn *beiscsi_conn,
1497938f372cSJitendra Bhivare struct hd_async_context *pasync_ctx,
14981e2931f1SJitendra Bhivare struct i_t_dpdu_cqe *pdpdu_cqe,
14991e2931f1SJitendra Bhivare u8 *header)
1500938f372cSJitendra Bhivare {
1501938f372cSJitendra Bhivare struct beiscsi_hba *phba = beiscsi_conn->phba;
1502938f372cSJitendra Bhivare struct hd_async_handle *pasync_handle;
1503938f372cSJitendra Bhivare struct be_bus_address phys_addr;
1504ba6983a7SJitendra Bhivare u16 cid, code, ci, cri;
1505938f372cSJitendra Bhivare u8 final, error = 0;
1506938f372cSJitendra Bhivare u32 dpl;
1507938f372cSJitendra Bhivare
1508938f372cSJitendra Bhivare cid = beiscsi_conn->beiscsi_conn_cid;
1509ba6983a7SJitendra Bhivare cri = BE_GET_ASYNC_CRI_FROM_CID(cid);
1510938f372cSJitendra Bhivare /**
1511938f372cSJitendra Bhivare * This function is invoked to get the right async_handle structure
1512938f372cSJitendra Bhivare * from a given DEF PDU CQ entry.
1513938f372cSJitendra Bhivare *
1514938f372cSJitendra Bhivare * - index in CQ entry gives the vertical index
1515938f372cSJitendra Bhivare * - address in CQ entry is the offset where the DMA last ended
1516938f372cSJitendra Bhivare * - final - no more notifications for this PDU
1517938f372cSJitendra Bhivare */
1518938f372cSJitendra Bhivare if (is_chip_be2_be3r(phba)) {
1519938f372cSJitendra Bhivare dpl = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe,
1520938f372cSJitendra Bhivare dpl, pdpdu_cqe);
1521938f372cSJitendra Bhivare ci = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe,
1522938f372cSJitendra Bhivare index, pdpdu_cqe);
1523938f372cSJitendra Bhivare final = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe,
1524938f372cSJitendra Bhivare final, pdpdu_cqe);
1525938f372cSJitendra Bhivare } else {
1526938f372cSJitendra Bhivare dpl = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe_v2,
1527938f372cSJitendra Bhivare dpl, pdpdu_cqe);
1528938f372cSJitendra Bhivare ci = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe_v2,
1529938f372cSJitendra Bhivare index, pdpdu_cqe);
1530938f372cSJitendra Bhivare final = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe_v2,
1531938f372cSJitendra Bhivare final, pdpdu_cqe);
15326733b39aSJayamohan Kallickal }
15336733b39aSJayamohan Kallickal
1534938f372cSJitendra Bhivare /**
1535938f372cSJitendra Bhivare * DB addr Hi/Lo is same for BE and SKH.
1536938f372cSJitendra Bhivare * Subtract the dataplacementlength to get to the base.
1537938f372cSJitendra Bhivare */
1538938f372cSJitendra Bhivare phys_addr.u.a32.address_lo = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe,
1539938f372cSJitendra Bhivare db_addr_lo, pdpdu_cqe);
1540938f372cSJitendra Bhivare phys_addr.u.a32.address_lo -= dpl;
1541938f372cSJitendra Bhivare phys_addr.u.a32.address_hi = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe,
1542938f372cSJitendra Bhivare db_addr_hi, pdpdu_cqe);
15436733b39aSJayamohan Kallickal
1544938f372cSJitendra Bhivare code = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe, code, pdpdu_cqe);
1545938f372cSJitendra Bhivare switch (code) {
1546938f372cSJitendra Bhivare case UNSOL_HDR_NOTIFY:
1547938f372cSJitendra Bhivare pasync_handle = pasync_ctx->async_entry[ci].header;
15481e2931f1SJitendra Bhivare *header = 1;
1549938f372cSJitendra Bhivare break;
1550938f372cSJitendra Bhivare case UNSOL_DATA_DIGEST_ERROR_NOTIFY:
1551938f372cSJitendra Bhivare error = 1;
1552df561f66SGustavo A. R. Silva fallthrough;
1553938f372cSJitendra Bhivare case UNSOL_DATA_NOTIFY:
1554938f372cSJitendra Bhivare pasync_handle = pasync_ctx->async_entry[ci].data;
1555938f372cSJitendra Bhivare break;
1556938f372cSJitendra Bhivare /* called only for above codes */
1557938f372cSJitendra Bhivare default:
1558ba6983a7SJitendra Bhivare return NULL;
1559938f372cSJitendra Bhivare }
1560938f372cSJitendra Bhivare
1561938f372cSJitendra Bhivare if (pasync_handle->pa.u.a64.address != phys_addr.u.a64.address ||
1562938f372cSJitendra Bhivare pasync_handle->index != ci) {
1563938f372cSJitendra Bhivare /* driver bug - if ci does not match async handle index */
1564938f372cSJitendra Bhivare error = 1;
1565938f372cSJitendra Bhivare beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_ISCSI,
1566938f372cSJitendra Bhivare "BM_%d : cid %u async PDU handle mismatch - addr in %cQE %llx at %u:addr in CQE %llx ci %u\n",
1567938f372cSJitendra Bhivare cid, pasync_handle->is_header ? 'H' : 'D',
1568938f372cSJitendra Bhivare pasync_handle->pa.u.a64.address,
1569938f372cSJitendra Bhivare pasync_handle->index,
1570938f372cSJitendra Bhivare phys_addr.u.a64.address, ci);
1571938f372cSJitendra Bhivare /* FW has stale address - attempt continuing by dropping */
1572938f372cSJitendra Bhivare }
1573938f372cSJitendra Bhivare
1574938f372cSJitendra Bhivare /**
1575938f372cSJitendra Bhivare * DEF PDU header and data buffers with errors should be simply
1576938f372cSJitendra Bhivare * dropped as there are no consumers for it.
1577938f372cSJitendra Bhivare */
1578938f372cSJitendra Bhivare if (error) {
1579938f372cSJitendra Bhivare beiscsi_hdl_put_handle(pasync_ctx, pasync_handle);
1580ba6983a7SJitendra Bhivare return NULL;
1581938f372cSJitendra Bhivare }
1582ba6983a7SJitendra Bhivare
1583ba6983a7SJitendra Bhivare if (pasync_handle->in_use || !list_empty(&pasync_handle->link)) {
1584ba6983a7SJitendra Bhivare beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_ISCSI,
1585ba6983a7SJitendra Bhivare "BM_%d : cid %d async PDU handle in use - code %d ci %d addr %llx\n",
1586ba6983a7SJitendra Bhivare cid, code, ci, phys_addr.u.a64.address);
1587ba6983a7SJitendra Bhivare beiscsi_hdl_purge_handles(phba, pasync_ctx, cri);
1588ba6983a7SJitendra Bhivare }
1589ba6983a7SJitendra Bhivare
1590ba6983a7SJitendra Bhivare list_del_init(&pasync_handle->link);
1591ba6983a7SJitendra Bhivare /**
1592ba6983a7SJitendra Bhivare * Each CID is associated with unique CRI.
1593ba6983a7SJitendra Bhivare * ASYNC_CRI_FROM_CID mapping and CRI_FROM_CID are totaly different.
1594ba6983a7SJitendra Bhivare **/
1595ba6983a7SJitendra Bhivare pasync_handle->cri = cri;
1596ba6983a7SJitendra Bhivare pasync_handle->is_final = final;
1597ba6983a7SJitendra Bhivare pasync_handle->buffer_len = dpl;
1598ba6983a7SJitendra Bhivare pasync_handle->in_use = 1;
1599ba6983a7SJitendra Bhivare
1600938f372cSJitendra Bhivare return pasync_handle;
16016733b39aSJayamohan Kallickal }
16026733b39aSJayamohan Kallickal
1603938f372cSJitendra Bhivare static unsigned int
beiscsi_hdl_fwd_pdu(struct beiscsi_conn * beiscsi_conn,struct hd_async_context * pasync_ctx,u16 cri)1604938f372cSJitendra Bhivare beiscsi_hdl_fwd_pdu(struct beiscsi_conn *beiscsi_conn,
1605938f372cSJitendra Bhivare struct hd_async_context *pasync_ctx,
1606938f372cSJitendra Bhivare u16 cri)
1607938f372cSJitendra Bhivare {
1608938f372cSJitendra Bhivare struct iscsi_session *session = beiscsi_conn->conn->session;
1609938f372cSJitendra Bhivare struct hd_async_handle *pasync_handle, *plast_handle;
1610938f372cSJitendra Bhivare struct beiscsi_hba *phba = beiscsi_conn->phba;
1611938f372cSJitendra Bhivare void *phdr = NULL, *pdata = NULL;
1612938f372cSJitendra Bhivare u32 dlen = 0, status = 0;
1613938f372cSJitendra Bhivare struct list_head *plist;
1614938f372cSJitendra Bhivare
1615938f372cSJitendra Bhivare plist = &pasync_ctx->async_entry[cri].wq.list;
1616938f372cSJitendra Bhivare plast_handle = NULL;
1617938f372cSJitendra Bhivare list_for_each_entry(pasync_handle, plist, link) {
1618938f372cSJitendra Bhivare plast_handle = pasync_handle;
1619938f372cSJitendra Bhivare /* get the header, the first entry */
1620938f372cSJitendra Bhivare if (!phdr) {
1621938f372cSJitendra Bhivare phdr = pasync_handle->pbuffer;
1622938f372cSJitendra Bhivare continue;
1623938f372cSJitendra Bhivare }
1624938f372cSJitendra Bhivare /* use first buffer to collect all the data */
1625938f372cSJitendra Bhivare if (!pdata) {
1626938f372cSJitendra Bhivare pdata = pasync_handle->pbuffer;
1627938f372cSJitendra Bhivare dlen = pasync_handle->buffer_len;
1628938f372cSJitendra Bhivare continue;
1629938f372cSJitendra Bhivare }
16300ddee50eSJitendra Bhivare if (!pasync_handle->buffer_len ||
16310ddee50eSJitendra Bhivare (dlen + pasync_handle->buffer_len) >
16320ddee50eSJitendra Bhivare pasync_ctx->async_data.buffer_size)
16330ddee50eSJitendra Bhivare break;
1634938f372cSJitendra Bhivare memcpy(pdata + dlen, pasync_handle->pbuffer,
1635938f372cSJitendra Bhivare pasync_handle->buffer_len);
1636938f372cSJitendra Bhivare dlen += pasync_handle->buffer_len;
1637938f372cSJitendra Bhivare }
1638938f372cSJitendra Bhivare
1639938f372cSJitendra Bhivare if (!plast_handle->is_final) {
1640938f372cSJitendra Bhivare /* last handle should have final PDU notification from FW */
1641938f372cSJitendra Bhivare beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_ISCSI,
16420ddee50eSJitendra Bhivare "BM_%d : cid %u %p fwd async PDU opcode %x with last handle missing - HL%u:DN%u:DR%u\n",
1643938f372cSJitendra Bhivare beiscsi_conn->beiscsi_conn_cid, plast_handle,
16440ddee50eSJitendra Bhivare AMAP_GET_BITS(struct amap_pdu_base, opcode, phdr),
1645938f372cSJitendra Bhivare pasync_ctx->async_entry[cri].wq.hdr_len,
1646938f372cSJitendra Bhivare pasync_ctx->async_entry[cri].wq.bytes_needed,
1647938f372cSJitendra Bhivare pasync_ctx->async_entry[cri].wq.bytes_received);
1648938f372cSJitendra Bhivare }
1649938f372cSJitendra Bhivare spin_lock_bh(&session->back_lock);
1650938f372cSJitendra Bhivare status = beiscsi_complete_pdu(beiscsi_conn, phdr, pdata, dlen);
1651938f372cSJitendra Bhivare spin_unlock_bh(&session->back_lock);
1652938f372cSJitendra Bhivare beiscsi_hdl_purge_handles(phba, pasync_ctx, cri);
1653938f372cSJitendra Bhivare return status;
1654938f372cSJitendra Bhivare }
1655938f372cSJitendra Bhivare
1656938f372cSJitendra Bhivare static unsigned int
beiscsi_hdl_gather_pdu(struct beiscsi_conn * beiscsi_conn,struct hd_async_context * pasync_ctx,struct hd_async_handle * pasync_handle)1657938f372cSJitendra Bhivare beiscsi_hdl_gather_pdu(struct beiscsi_conn *beiscsi_conn,
1658938f372cSJitendra Bhivare struct hd_async_context *pasync_ctx,
1659938f372cSJitendra Bhivare struct hd_async_handle *pasync_handle)
1660938f372cSJitendra Bhivare {
1661938f372cSJitendra Bhivare unsigned int bytes_needed = 0, status = 0;
1662938f372cSJitendra Bhivare u16 cri = pasync_handle->cri;
1663938f372cSJitendra Bhivare struct cri_wait_queue *wq;
1664938f372cSJitendra Bhivare struct beiscsi_hba *phba;
1665938f372cSJitendra Bhivare struct pdu_base *ppdu;
1666938f372cSJitendra Bhivare char *err = "";
1667938f372cSJitendra Bhivare
1668938f372cSJitendra Bhivare phba = beiscsi_conn->phba;
1669938f372cSJitendra Bhivare wq = &pasync_ctx->async_entry[cri].wq;
1670938f372cSJitendra Bhivare if (pasync_handle->is_header) {
1671938f372cSJitendra Bhivare /* check if PDU hdr is rcv'd when old hdr not completed */
1672938f372cSJitendra Bhivare if (wq->hdr_len) {
1673938f372cSJitendra Bhivare err = "incomplete";
1674938f372cSJitendra Bhivare goto drop_pdu;
1675938f372cSJitendra Bhivare }
1676938f372cSJitendra Bhivare ppdu = pasync_handle->pbuffer;
1677938f372cSJitendra Bhivare bytes_needed = AMAP_GET_BITS(struct amap_pdu_base,
1678938f372cSJitendra Bhivare data_len_hi, ppdu);
1679938f372cSJitendra Bhivare bytes_needed <<= 16;
1680938f372cSJitendra Bhivare bytes_needed |= be16_to_cpu(AMAP_GET_BITS(struct amap_pdu_base,
1681938f372cSJitendra Bhivare data_len_lo, ppdu));
1682938f372cSJitendra Bhivare wq->hdr_len = pasync_handle->buffer_len;
1683938f372cSJitendra Bhivare wq->bytes_received = 0;
1684938f372cSJitendra Bhivare wq->bytes_needed = bytes_needed;
1685938f372cSJitendra Bhivare list_add_tail(&pasync_handle->link, &wq->list);
1686938f372cSJitendra Bhivare if (!bytes_needed)
1687938f372cSJitendra Bhivare status = beiscsi_hdl_fwd_pdu(beiscsi_conn,
1688938f372cSJitendra Bhivare pasync_ctx, cri);
1689938f372cSJitendra Bhivare } else {
1690938f372cSJitendra Bhivare /* check if data received has header and is needed */
1691938f372cSJitendra Bhivare if (!wq->hdr_len || !wq->bytes_needed) {
1692938f372cSJitendra Bhivare err = "header less";
1693938f372cSJitendra Bhivare goto drop_pdu;
1694938f372cSJitendra Bhivare }
1695938f372cSJitendra Bhivare wq->bytes_received += pasync_handle->buffer_len;
1696938f372cSJitendra Bhivare /* Something got overwritten? Better catch it here. */
1697938f372cSJitendra Bhivare if (wq->bytes_received > wq->bytes_needed) {
1698938f372cSJitendra Bhivare err = "overflow";
1699938f372cSJitendra Bhivare goto drop_pdu;
1700938f372cSJitendra Bhivare }
1701938f372cSJitendra Bhivare list_add_tail(&pasync_handle->link, &wq->list);
1702938f372cSJitendra Bhivare if (wq->bytes_received == wq->bytes_needed)
1703938f372cSJitendra Bhivare status = beiscsi_hdl_fwd_pdu(beiscsi_conn,
1704938f372cSJitendra Bhivare pasync_ctx, cri);
1705938f372cSJitendra Bhivare }
1706938f372cSJitendra Bhivare return status;
1707938f372cSJitendra Bhivare
1708938f372cSJitendra Bhivare drop_pdu:
1709938f372cSJitendra Bhivare beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_ISCSI,
1710938f372cSJitendra Bhivare "BM_%d : cid %u async PDU %s - def-%c:HL%u:DN%u:DR%u\n",
1711938f372cSJitendra Bhivare beiscsi_conn->beiscsi_conn_cid, err,
1712938f372cSJitendra Bhivare pasync_handle->is_header ? 'H' : 'D',
1713938f372cSJitendra Bhivare wq->hdr_len, wq->bytes_needed,
1714938f372cSJitendra Bhivare pasync_handle->buffer_len);
1715938f372cSJitendra Bhivare /* discard this handle */
1716938f372cSJitendra Bhivare beiscsi_hdl_put_handle(pasync_ctx, pasync_handle);
1717938f372cSJitendra Bhivare /* free all the other handles in cri_wait_queue */
1718938f372cSJitendra Bhivare beiscsi_hdl_purge_handles(phba, pasync_ctx, cri);
1719938f372cSJitendra Bhivare /* try continuing */
1720938f372cSJitendra Bhivare return status;
1721938f372cSJitendra Bhivare }
1722938f372cSJitendra Bhivare
1723938f372cSJitendra Bhivare static void
beiscsi_hdq_post_handles(struct beiscsi_hba * phba,u8 header,u8 ulp_num,u16 nbuf)1724938f372cSJitendra Bhivare beiscsi_hdq_post_handles(struct beiscsi_hba *phba,
17251e2931f1SJitendra Bhivare u8 header, u8 ulp_num, u16 nbuf)
1726938f372cSJitendra Bhivare {
17271e2931f1SJitendra Bhivare struct hd_async_handle *pasync_handle;
1728938f372cSJitendra Bhivare struct hd_async_context *pasync_ctx;
17296733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
17306733b39aSJayamohan Kallickal struct phys_addr *pasync_sge;
1731938f372cSJitendra Bhivare u32 ring_id, doorbell = 0;
1732938f372cSJitendra Bhivare u32 doorbell_offset;
17331e2931f1SJitendra Bhivare u16 prod, pi;
17346733b39aSJayamohan Kallickal
17356733b39aSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
17368a86e833SJayamohan Kallickal pasync_ctx = HWI_GET_ASYNC_PDU_CTX(phwi_ctrlr, ulp_num);
1737938f372cSJitendra Bhivare if (header) {
17381e2931f1SJitendra Bhivare pasync_sge = pasync_ctx->async_header.ring_base;
17391e2931f1SJitendra Bhivare pi = pasync_ctx->async_header.pi;
17408a86e833SJayamohan Kallickal ring_id = phwi_ctrlr->default_pdu_hdr[ulp_num].id;
17418a86e833SJayamohan Kallickal doorbell_offset = phwi_ctrlr->default_pdu_hdr[ulp_num].
17428a86e833SJayamohan Kallickal doorbell_offset;
17436733b39aSJayamohan Kallickal } else {
17441e2931f1SJitendra Bhivare pasync_sge = pasync_ctx->async_data.ring_base;
17451e2931f1SJitendra Bhivare pi = pasync_ctx->async_data.pi;
17468a86e833SJayamohan Kallickal ring_id = phwi_ctrlr->default_pdu_data[ulp_num].id;
17478a86e833SJayamohan Kallickal doorbell_offset = phwi_ctrlr->default_pdu_data[ulp_num].
17488a86e833SJayamohan Kallickal doorbell_offset;
17496733b39aSJayamohan Kallickal }
17506733b39aSJayamohan Kallickal
17511e2931f1SJitendra Bhivare for (prod = 0; prod < nbuf; prod++) {
17521e2931f1SJitendra Bhivare if (header)
17531e2931f1SJitendra Bhivare pasync_handle = pasync_ctx->async_entry[pi].header;
17541e2931f1SJitendra Bhivare else
17551e2931f1SJitendra Bhivare pasync_handle = pasync_ctx->async_entry[pi].data;
1756938f372cSJitendra Bhivare WARN_ON(pasync_handle->is_header != header);
17571e2931f1SJitendra Bhivare WARN_ON(pasync_handle->index != pi);
17581e2931f1SJitendra Bhivare /* setup the ring only once */
17591e2931f1SJitendra Bhivare if (nbuf == pasync_ctx->num_entries) {
17601e2931f1SJitendra Bhivare /* note hi is lo */
17611e2931f1SJitendra Bhivare pasync_sge[pi].hi = pasync_handle->pa.u.a32.address_lo;
17621e2931f1SJitendra Bhivare pasync_sge[pi].lo = pasync_handle->pa.u.a32.address_hi;
1763938f372cSJitendra Bhivare }
17641e2931f1SJitendra Bhivare if (++pi == pasync_ctx->num_entries)
17651e2931f1SJitendra Bhivare pi = 0;
17661e2931f1SJitendra Bhivare }
17676733b39aSJayamohan Kallickal
1768938f372cSJitendra Bhivare if (header)
17691e2931f1SJitendra Bhivare pasync_ctx->async_header.pi = pi;
1770938f372cSJitendra Bhivare else
17711e2931f1SJitendra Bhivare pasync_ctx->async_data.pi = pi;
17726733b39aSJayamohan Kallickal
17736733b39aSJayamohan Kallickal doorbell |= ring_id & DB_DEF_PDU_RING_ID_MASK;
17746733b39aSJayamohan Kallickal doorbell |= 1 << DB_DEF_PDU_REARM_SHIFT;
17756733b39aSJayamohan Kallickal doorbell |= 0 << DB_DEF_PDU_EVENT_SHIFT;
1776938f372cSJitendra Bhivare doorbell |= (prod & DB_DEF_PDU_CQPROC_MASK) << DB_DEF_PDU_CQPROC_SHIFT;
17778a86e833SJayamohan Kallickal iowrite32(doorbell, phba->db_va + doorbell_offset);
17786733b39aSJayamohan Kallickal }
17796733b39aSJayamohan Kallickal
1780938f372cSJitendra Bhivare static void
beiscsi_hdq_process_compl(struct beiscsi_conn * beiscsi_conn,struct i_t_dpdu_cqe * pdpdu_cqe)1781938f372cSJitendra Bhivare beiscsi_hdq_process_compl(struct beiscsi_conn *beiscsi_conn,
17826733b39aSJayamohan Kallickal struct i_t_dpdu_cqe *pdpdu_cqe)
17836733b39aSJayamohan Kallickal {
1784938f372cSJitendra Bhivare struct beiscsi_hba *phba = beiscsi_conn->phba;
1785938f372cSJitendra Bhivare struct hd_async_handle *pasync_handle = NULL;
1786938f372cSJitendra Bhivare struct hd_async_context *pasync_ctx;
17876733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
17881e2931f1SJitendra Bhivare u8 ulp_num, consumed, header = 0;
1789938f372cSJitendra Bhivare u16 cid_cri;
17906733b39aSJayamohan Kallickal
17916733b39aSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
1792938f372cSJitendra Bhivare cid_cri = BE_GET_CRI_FROM_CID(beiscsi_conn->beiscsi_conn_cid);
1793938f372cSJitendra Bhivare ulp_num = BEISCSI_GET_ULP_FROM_CRI(phwi_ctrlr, cid_cri);
1794938f372cSJitendra Bhivare pasync_ctx = HWI_GET_ASYNC_PDU_CTX(phwi_ctrlr, ulp_num);
1795938f372cSJitendra Bhivare pasync_handle = beiscsi_hdl_get_handle(beiscsi_conn, pasync_ctx,
17961e2931f1SJitendra Bhivare pdpdu_cqe, &header);
17971e2931f1SJitendra Bhivare if (is_chip_be2_be3r(phba))
17981e2931f1SJitendra Bhivare consumed = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe,
17991e2931f1SJitendra Bhivare num_cons, pdpdu_cqe);
18001e2931f1SJitendra Bhivare else
18011e2931f1SJitendra Bhivare consumed = AMAP_GET_BITS(struct amap_i_t_dpdu_cqe_v2,
18021e2931f1SJitendra Bhivare num_cons, pdpdu_cqe);
18031e2931f1SJitendra Bhivare if (pasync_handle)
1804938f372cSJitendra Bhivare beiscsi_hdl_gather_pdu(beiscsi_conn, pasync_ctx, pasync_handle);
18051e2931f1SJitendra Bhivare /* num_cons indicates number of 8 RQEs consumed */
18061e2931f1SJitendra Bhivare if (consumed)
18071e2931f1SJitendra Bhivare beiscsi_hdq_post_handles(phba, header, ulp_num, 8 * consumed);
18086733b39aSJayamohan Kallickal }
18096733b39aSJayamohan Kallickal
beiscsi_process_mcc_cq(struct beiscsi_hba * phba)18102e4e8f65SJitendra Bhivare void beiscsi_process_mcc_cq(struct beiscsi_hba *phba)
1811756d29c8SJayamohan Kallickal {
1812756d29c8SJayamohan Kallickal struct be_queue_info *mcc_cq;
1813756d29c8SJayamohan Kallickal struct be_mcc_compl *mcc_compl;
1814756d29c8SJayamohan Kallickal unsigned int num_processed = 0;
1815756d29c8SJayamohan Kallickal
1816756d29c8SJayamohan Kallickal mcc_cq = &phba->ctrl.mcc_obj.cq;
1817756d29c8SJayamohan Kallickal mcc_compl = queue_tail_node(mcc_cq);
1818756d29c8SJayamohan Kallickal mcc_compl->flags = le32_to_cpu(mcc_compl->flags);
1819756d29c8SJayamohan Kallickal while (mcc_compl->flags & CQE_FLAGS_VALID_MASK) {
18209122e991SJitendra Bhivare if (beiscsi_hba_in_error(phba))
18219122e991SJitendra Bhivare return;
18229122e991SJitendra Bhivare
1823756d29c8SJayamohan Kallickal if (num_processed >= 32) {
1824756d29c8SJayamohan Kallickal hwi_ring_cq_db(phba, mcc_cq->id,
18251094cf68SJitendra Bhivare num_processed, 0);
1826756d29c8SJayamohan Kallickal num_processed = 0;
1827756d29c8SJayamohan Kallickal }
1828756d29c8SJayamohan Kallickal if (mcc_compl->flags & CQE_FLAGS_ASYNC_MASK) {
182953aefe25SJitendra Bhivare beiscsi_process_async_event(phba, mcc_compl);
1830756d29c8SJayamohan Kallickal } else if (mcc_compl->flags & CQE_FLAGS_COMPLETED_MASK) {
18312e4e8f65SJitendra Bhivare beiscsi_process_mcc_compl(&phba->ctrl, mcc_compl);
1832756d29c8SJayamohan Kallickal }
1833756d29c8SJayamohan Kallickal
1834756d29c8SJayamohan Kallickal mcc_compl->flags = 0;
1835756d29c8SJayamohan Kallickal queue_tail_inc(mcc_cq);
1836756d29c8SJayamohan Kallickal mcc_compl = queue_tail_node(mcc_cq);
1837756d29c8SJayamohan Kallickal mcc_compl->flags = le32_to_cpu(mcc_compl->flags);
1838756d29c8SJayamohan Kallickal num_processed++;
1839756d29c8SJayamohan Kallickal }
1840756d29c8SJayamohan Kallickal
1841756d29c8SJayamohan Kallickal if (num_processed > 0)
18421094cf68SJitendra Bhivare hwi_ring_cq_db(phba, mcc_cq->id, num_processed, 1);
1843756d29c8SJayamohan Kallickal }
1844bfead3b2SJayamohan Kallickal
beiscsi_mcc_work(struct work_struct * work)1845a3095016SJitendra Bhivare static void beiscsi_mcc_work(struct work_struct *work)
1846a3095016SJitendra Bhivare {
1847a3095016SJitendra Bhivare struct be_eq_obj *pbe_eq;
1848a3095016SJitendra Bhivare struct beiscsi_hba *phba;
1849a3095016SJitendra Bhivare
1850a3095016SJitendra Bhivare pbe_eq = container_of(work, struct be_eq_obj, mcc_work);
1851a3095016SJitendra Bhivare phba = pbe_eq->phba;
1852a3095016SJitendra Bhivare beiscsi_process_mcc_cq(phba);
1853a3095016SJitendra Bhivare /* rearm EQ for further interrupts */
18549122e991SJitendra Bhivare if (!beiscsi_hba_in_error(phba))
1855a3095016SJitendra Bhivare hwi_ring_eq_db(phba, pbe_eq->q.id, 0, 0, 1, 1);
1856a3095016SJitendra Bhivare }
1857a3095016SJitendra Bhivare
18586763daaeSJohn Soni Jose /**
18596763daaeSJohn Soni Jose * beiscsi_process_cq()- Process the Completion Queue
18606763daaeSJohn Soni Jose * @pbe_eq: Event Q on which the Completion has come
18611094cf68SJitendra Bhivare * @budget: Max number of events to processed
18626763daaeSJohn Soni Jose *
18636763daaeSJohn Soni Jose * return
18646763daaeSJohn Soni Jose * Number of Completion Entries processed.
18656763daaeSJohn Soni Jose **/
beiscsi_process_cq(struct be_eq_obj * pbe_eq,int budget)18661094cf68SJitendra Bhivare unsigned int beiscsi_process_cq(struct be_eq_obj *pbe_eq, int budget)
18676733b39aSJayamohan Kallickal {
18686733b39aSJayamohan Kallickal struct be_queue_info *cq;
18696733b39aSJayamohan Kallickal struct sol_cqe *sol;
18701094cf68SJitendra Bhivare unsigned int total = 0;
18716733b39aSJayamohan Kallickal unsigned int num_processed = 0;
18720a513dd8SJohn Soni Jose unsigned short code = 0, cid = 0;
1873a7909b39SJayamohan Kallickal uint16_t cri_index = 0;
18746733b39aSJayamohan Kallickal struct beiscsi_conn *beiscsi_conn;
1875c2462288SJayamohan Kallickal struct beiscsi_endpoint *beiscsi_ep;
1876c2462288SJayamohan Kallickal struct iscsi_endpoint *ep;
1877bfead3b2SJayamohan Kallickal struct beiscsi_hba *phba;
18786733b39aSJayamohan Kallickal
1879bfead3b2SJayamohan Kallickal cq = pbe_eq->cq;
18806733b39aSJayamohan Kallickal sol = queue_tail_node(cq);
1881bfead3b2SJayamohan Kallickal phba = pbe_eq->phba;
18826733b39aSJayamohan Kallickal
18836733b39aSJayamohan Kallickal while (sol->dw[offsetof(struct amap_sol_cqe, valid) / 32] &
18846733b39aSJayamohan Kallickal CQE_VALID_MASK) {
18859122e991SJitendra Bhivare if (beiscsi_hba_in_error(phba))
18869122e991SJitendra Bhivare return 0;
18879122e991SJitendra Bhivare
18886733b39aSJayamohan Kallickal be_dws_le_to_cpu(sol, sizeof(struct sol_cqe));
18896733b39aSJayamohan Kallickal
189045efc940SJitendra Bhivare code = (sol->dw[offsetof(struct amap_sol_cqe, code) / 32] &
189145efc940SJitendra Bhivare CQE_CODE_MASK);
189232951dd8SJayamohan Kallickal
189373133261SJohn Soni Jose /* Get the CID */
18942c9dfd36SJayamohan Kallickal if (is_chip_be2_be3r(phba)) {
18952c9dfd36SJayamohan Kallickal cid = AMAP_GET_BITS(struct amap_sol_cqe, cid, sol);
18962c9dfd36SJayamohan Kallickal } else {
189773133261SJohn Soni Jose if ((code == DRIVERMSG_NOTIFY) ||
189873133261SJohn Soni Jose (code == UNSOL_HDR_NOTIFY) ||
189973133261SJohn Soni Jose (code == UNSOL_DATA_NOTIFY))
190073133261SJohn Soni Jose cid = AMAP_GET_BITS(
190173133261SJohn Soni Jose struct amap_i_t_dpdu_cqe_v2,
190273133261SJohn Soni Jose cid, sol);
190373133261SJohn Soni Jose else
190473133261SJohn Soni Jose cid = AMAP_GET_BITS(struct amap_sol_cqe_v2,
190573133261SJohn Soni Jose cid, sol);
19062c9dfd36SJayamohan Kallickal }
190773133261SJohn Soni Jose
1908a7909b39SJayamohan Kallickal cri_index = BE_GET_CRI_FROM_CID(cid);
1909a7909b39SJayamohan Kallickal ep = phba->ep_array[cri_index];
1910b7ab35b1SJayamohan Kallickal
1911b7ab35b1SJayamohan Kallickal if (ep == NULL) {
1912b7ab35b1SJayamohan Kallickal /* connection has already been freed
1913b7ab35b1SJayamohan Kallickal * just move on to next one
1914b7ab35b1SJayamohan Kallickal */
1915b7ab35b1SJayamohan Kallickal beiscsi_log(phba, KERN_WARNING,
1916b7ab35b1SJayamohan Kallickal BEISCSI_LOG_INIT,
1917b7ab35b1SJayamohan Kallickal "BM_%d : proc cqe of disconn ep: cid %d\n",
1918b7ab35b1SJayamohan Kallickal cid);
1919b7ab35b1SJayamohan Kallickal goto proc_next_cqe;
1920b7ab35b1SJayamohan Kallickal }
1921b7ab35b1SJayamohan Kallickal
1922c2462288SJayamohan Kallickal beiscsi_ep = ep->dd_data;
1923c2462288SJayamohan Kallickal beiscsi_conn = beiscsi_ep->conn;
1924756d29c8SJayamohan Kallickal
19251094cf68SJitendra Bhivare /* replenish cq */
19261094cf68SJitendra Bhivare if (num_processed == 32) {
19271094cf68SJitendra Bhivare hwi_ring_cq_db(phba, cq->id, 32, 0);
19286733b39aSJayamohan Kallickal num_processed = 0;
19296733b39aSJayamohan Kallickal }
19301094cf68SJitendra Bhivare total++;
19316733b39aSJayamohan Kallickal
19320a513dd8SJohn Soni Jose switch (code) {
19336733b39aSJayamohan Kallickal case SOL_CMD_COMPLETE:
19346733b39aSJayamohan Kallickal hwi_complete_cmd(beiscsi_conn, phba, sol);
19356733b39aSJayamohan Kallickal break;
19366733b39aSJayamohan Kallickal case DRIVERMSG_NOTIFY:
193799bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO,
193899bc5d55SJohn Soni Jose BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
19396763daaeSJohn Soni Jose "BM_%d : Received %s[%d] on CID : %d\n",
19406763daaeSJohn Soni Jose cqe_desc[code], code, cid);
194199bc5d55SJohn Soni Jose
19426733b39aSJayamohan Kallickal hwi_complete_drvr_msgs(beiscsi_conn, phba, sol);
19436733b39aSJayamohan Kallickal break;
19446733b39aSJayamohan Kallickal case UNSOL_HDR_NOTIFY:
194599bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO,
194699bc5d55SJohn Soni Jose BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
19476763daaeSJohn Soni Jose "BM_%d : Received %s[%d] on CID : %d\n",
19486763daaeSJohn Soni Jose cqe_desc[code], code, cid);
194999bc5d55SJohn Soni Jose
19508f09a3b9SJayamohan Kallickal spin_lock_bh(&phba->async_pdu_lock);
1951938f372cSJitendra Bhivare beiscsi_hdq_process_compl(beiscsi_conn,
1952bfead3b2SJayamohan Kallickal (struct i_t_dpdu_cqe *)sol);
19538f09a3b9SJayamohan Kallickal spin_unlock_bh(&phba->async_pdu_lock);
1954bfead3b2SJayamohan Kallickal break;
19556733b39aSJayamohan Kallickal case UNSOL_DATA_NOTIFY:
195699bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO,
195799bc5d55SJohn Soni Jose BEISCSI_LOG_CONFIG | BEISCSI_LOG_IO,
19586763daaeSJohn Soni Jose "BM_%d : Received %s[%d] on CID : %d\n",
19596763daaeSJohn Soni Jose cqe_desc[code], code, cid);
196099bc5d55SJohn Soni Jose
19618f09a3b9SJayamohan Kallickal spin_lock_bh(&phba->async_pdu_lock);
1962938f372cSJitendra Bhivare beiscsi_hdq_process_compl(beiscsi_conn,
19636733b39aSJayamohan Kallickal (struct i_t_dpdu_cqe *)sol);
19648f09a3b9SJayamohan Kallickal spin_unlock_bh(&phba->async_pdu_lock);
19656733b39aSJayamohan Kallickal break;
19666733b39aSJayamohan Kallickal case CXN_INVALIDATE_INDEX_NOTIFY:
19676733b39aSJayamohan Kallickal case CMD_INVALIDATED_NOTIFY:
19686733b39aSJayamohan Kallickal case CXN_INVALIDATE_NOTIFY:
196999bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR,
197099bc5d55SJohn Soni Jose BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
19716763daaeSJohn Soni Jose "BM_%d : Ignoring %s[%d] on CID : %d\n",
19726763daaeSJohn Soni Jose cqe_desc[code], code, cid);
19736733b39aSJayamohan Kallickal break;
19741094cf68SJitendra Bhivare case CXN_KILLED_HDR_DIGEST_ERR:
19756733b39aSJayamohan Kallickal case SOL_CMD_KILLED_DATA_DIGEST_ERR:
19761094cf68SJitendra Bhivare beiscsi_log(phba, KERN_ERR,
19771094cf68SJitendra Bhivare BEISCSI_LOG_CONFIG | BEISCSI_LOG_IO,
19781094cf68SJitendra Bhivare "BM_%d : Cmd Notification %s[%d] on CID : %d\n",
19791094cf68SJitendra Bhivare cqe_desc[code], code, cid);
19801094cf68SJitendra Bhivare break;
19816733b39aSJayamohan Kallickal case CMD_KILLED_INVALID_STATSN_RCVD:
19826733b39aSJayamohan Kallickal case CMD_KILLED_INVALID_R2T_RCVD:
19836733b39aSJayamohan Kallickal case CMD_CXN_KILLED_LUN_INVALID:
19846733b39aSJayamohan Kallickal case CMD_CXN_KILLED_ICD_INVALID:
19856733b39aSJayamohan Kallickal case CMD_CXN_KILLED_ITT_INVALID:
19866733b39aSJayamohan Kallickal case CMD_CXN_KILLED_SEQ_OUTOFORDER:
19876733b39aSJayamohan Kallickal case CMD_CXN_KILLED_INVALID_DATASN_RCVD:
198899bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR,
198999bc5d55SJohn Soni Jose BEISCSI_LOG_CONFIG | BEISCSI_LOG_IO,
19906763daaeSJohn Soni Jose "BM_%d : Cmd Notification %s[%d] on CID : %d\n",
19916763daaeSJohn Soni Jose cqe_desc[code], code, cid);
19926733b39aSJayamohan Kallickal break;
19936733b39aSJayamohan Kallickal case UNSOL_DATA_DIGEST_ERROR_NOTIFY:
199499bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR,
199599bc5d55SJohn Soni Jose BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
19966763daaeSJohn Soni Jose "BM_%d : Dropping %s[%d] on DPDU ring on CID : %d\n",
19976763daaeSJohn Soni Jose cqe_desc[code], code, cid);
19988f09a3b9SJayamohan Kallickal spin_lock_bh(&phba->async_pdu_lock);
1999938f372cSJitendra Bhivare /* driver consumes the entry and drops the contents */
2000938f372cSJitendra Bhivare beiscsi_hdq_process_compl(beiscsi_conn,
20016733b39aSJayamohan Kallickal (struct i_t_dpdu_cqe *)sol);
20028f09a3b9SJayamohan Kallickal spin_unlock_bh(&phba->async_pdu_lock);
20036733b39aSJayamohan Kallickal break;
20046733b39aSJayamohan Kallickal case CXN_KILLED_PDU_SIZE_EXCEEDS_DSL:
20056733b39aSJayamohan Kallickal case CXN_KILLED_BURST_LEN_MISMATCH:
20066733b39aSJayamohan Kallickal case CXN_KILLED_AHS_RCVD:
20076733b39aSJayamohan Kallickal case CXN_KILLED_UNKNOWN_HDR:
20086733b39aSJayamohan Kallickal case CXN_KILLED_STALE_ITT_TTT_RCVD:
20096733b39aSJayamohan Kallickal case CXN_KILLED_INVALID_ITT_TTT_RCVD:
20106733b39aSJayamohan Kallickal case CXN_KILLED_TIMED_OUT:
20116733b39aSJayamohan Kallickal case CXN_KILLED_FIN_RCVD:
20126763daaeSJohn Soni Jose case CXN_KILLED_RST_SENT:
20136763daaeSJohn Soni Jose case CXN_KILLED_RST_RCVD:
20146733b39aSJayamohan Kallickal case CXN_KILLED_BAD_UNSOL_PDU_RCVD:
20156733b39aSJayamohan Kallickal case CXN_KILLED_BAD_WRB_INDEX_ERROR:
20166733b39aSJayamohan Kallickal case CXN_KILLED_OVER_RUN_RESIDUAL:
20176733b39aSJayamohan Kallickal case CXN_KILLED_UNDER_RUN_RESIDUAL:
20186733b39aSJayamohan Kallickal case CXN_KILLED_CMND_DATA_NOT_ON_SAME_CONN:
201999bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR,
202099bc5d55SJohn Soni Jose BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
20216763daaeSJohn Soni Jose "BM_%d : Event %s[%d] received on CID : %d\n",
20226763daaeSJohn Soni Jose cqe_desc[code], code, cid);
20230a513dd8SJohn Soni Jose if (beiscsi_conn)
20246733b39aSJayamohan Kallickal iscsi_conn_failure(beiscsi_conn->conn,
20256733b39aSJayamohan Kallickal ISCSI_ERR_CONN_FAILED);
20266733b39aSJayamohan Kallickal break;
20276733b39aSJayamohan Kallickal default:
202899bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR,
202999bc5d55SJohn Soni Jose BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
2030c7fa2c85SChristophe JAILLET "BM_%d : Invalid CQE Event Received Code : %d CID 0x%x...\n",
20310a513dd8SJohn Soni Jose code, cid);
20326733b39aSJayamohan Kallickal break;
20336733b39aSJayamohan Kallickal }
20346733b39aSJayamohan Kallickal
2035b7ab35b1SJayamohan Kallickal proc_next_cqe:
20366733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_sol_cqe, valid, sol, 0);
20376733b39aSJayamohan Kallickal queue_tail_inc(cq);
20386733b39aSJayamohan Kallickal sol = queue_tail_node(cq);
20396733b39aSJayamohan Kallickal num_processed++;
20401094cf68SJitendra Bhivare if (total == budget)
20411094cf68SJitendra Bhivare break;
20426733b39aSJayamohan Kallickal }
20436733b39aSJayamohan Kallickal
20441094cf68SJitendra Bhivare hwi_ring_cq_db(phba, cq->id, num_processed, 1);
20451094cf68SJitendra Bhivare return total;
20466733b39aSJayamohan Kallickal }
20476733b39aSJayamohan Kallickal
be_iopoll(struct irq_poll * iop,int budget)2048511cbce2SChristoph Hellwig static int be_iopoll(struct irq_poll *iop, int budget)
20496733b39aSJayamohan Kallickal {
2050a3095016SJitendra Bhivare unsigned int ret, io_events;
20516733b39aSJayamohan Kallickal struct beiscsi_hba *phba;
2052bfead3b2SJayamohan Kallickal struct be_eq_obj *pbe_eq;
20531094cf68SJitendra Bhivare struct be_eq_entry *eqe = NULL;
20541094cf68SJitendra Bhivare struct be_queue_info *eq;
20556733b39aSJayamohan Kallickal
2056bfead3b2SJayamohan Kallickal pbe_eq = container_of(iop, struct be_eq_obj, iopoll);
20571094cf68SJitendra Bhivare phba = pbe_eq->phba;
20589122e991SJitendra Bhivare if (beiscsi_hba_in_error(phba)) {
20599122e991SJitendra Bhivare irq_poll_complete(iop);
20609122e991SJitendra Bhivare return 0;
20619122e991SJitendra Bhivare }
20629122e991SJitendra Bhivare
20639122e991SJitendra Bhivare io_events = 0;
20641094cf68SJitendra Bhivare eq = &pbe_eq->q;
20651094cf68SJitendra Bhivare eqe = queue_tail_node(eq);
20661094cf68SJitendra Bhivare while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32] &
20671094cf68SJitendra Bhivare EQE_VALID_MASK) {
20681094cf68SJitendra Bhivare AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
20691094cf68SJitendra Bhivare queue_tail_inc(eq);
20701094cf68SJitendra Bhivare eqe = queue_tail_node(eq);
2071a3095016SJitendra Bhivare io_events++;
20721094cf68SJitendra Bhivare }
2073a3095016SJitendra Bhivare hwi_ring_eq_db(phba, eq->id, 1, io_events, 0, 1);
20741094cf68SJitendra Bhivare
20751094cf68SJitendra Bhivare ret = beiscsi_process_cq(pbe_eq, budget);
207673af08e1SJayamohan Kallickal pbe_eq->cq_count += ret;
20776733b39aSJayamohan Kallickal if (ret < budget) {
2078511cbce2SChristoph Hellwig irq_poll_complete(iop);
207999bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO,
208099bc5d55SJohn Soni Jose BEISCSI_LOG_CONFIG | BEISCSI_LOG_IO,
20811094cf68SJitendra Bhivare "BM_%d : rearm pbe_eq->q.id =%d ret %d\n",
20821094cf68SJitendra Bhivare pbe_eq->q.id, ret);
20839122e991SJitendra Bhivare if (!beiscsi_hba_in_error(phba))
2084bfead3b2SJayamohan Kallickal hwi_ring_eq_db(phba, pbe_eq->q.id, 0, 0, 1, 1);
20856733b39aSJayamohan Kallickal }
20866733b39aSJayamohan Kallickal return ret;
20876733b39aSJayamohan Kallickal }
20886733b39aSJayamohan Kallickal
20896733b39aSJayamohan Kallickal static void
hwi_write_sgl_v2(struct iscsi_wrb * pwrb,struct scatterlist * sg,unsigned int num_sg,struct beiscsi_io_task * io_task)209009a1093aSJohn Soni Jose hwi_write_sgl_v2(struct iscsi_wrb *pwrb, struct scatterlist *sg,
209109a1093aSJohn Soni Jose unsigned int num_sg, struct beiscsi_io_task *io_task)
209209a1093aSJohn Soni Jose {
209309a1093aSJohn Soni Jose struct iscsi_sge *psgl;
209409a1093aSJohn Soni Jose unsigned int sg_len, index;
209509a1093aSJohn Soni Jose unsigned int sge_len = 0;
209609a1093aSJohn Soni Jose unsigned long long addr;
209709a1093aSJohn Soni Jose struct scatterlist *l_sg;
209809a1093aSJohn Soni Jose unsigned int offset;
209909a1093aSJohn Soni Jose
210009a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, iscsi_bhs_addr_lo, pwrb,
210109a1093aSJohn Soni Jose io_task->bhs_pa.u.a32.address_lo);
210209a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, iscsi_bhs_addr_hi, pwrb,
210309a1093aSJohn Soni Jose io_task->bhs_pa.u.a32.address_hi);
210409a1093aSJohn Soni Jose
210509a1093aSJohn Soni Jose l_sg = sg;
210609a1093aSJohn Soni Jose for (index = 0; (index < num_sg) && (index < 2); index++,
210709a1093aSJohn Soni Jose sg = sg_next(sg)) {
210809a1093aSJohn Soni Jose if (index == 0) {
210909a1093aSJohn Soni Jose sg_len = sg_dma_len(sg);
211009a1093aSJohn Soni Jose addr = (u64) sg_dma_address(sg);
211109a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2,
211209a1093aSJohn Soni Jose sge0_addr_lo, pwrb,
211309a1093aSJohn Soni Jose lower_32_bits(addr));
211409a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2,
211509a1093aSJohn Soni Jose sge0_addr_hi, pwrb,
211609a1093aSJohn Soni Jose upper_32_bits(addr));
211709a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2,
211809a1093aSJohn Soni Jose sge0_len, pwrb,
211909a1093aSJohn Soni Jose sg_len);
212009a1093aSJohn Soni Jose sge_len = sg_len;
212109a1093aSJohn Soni Jose } else {
212209a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge1_r2t_offset,
212309a1093aSJohn Soni Jose pwrb, sge_len);
212409a1093aSJohn Soni Jose sg_len = sg_dma_len(sg);
212509a1093aSJohn Soni Jose addr = (u64) sg_dma_address(sg);
212609a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2,
212709a1093aSJohn Soni Jose sge1_addr_lo, pwrb,
212809a1093aSJohn Soni Jose lower_32_bits(addr));
212909a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2,
213009a1093aSJohn Soni Jose sge1_addr_hi, pwrb,
213109a1093aSJohn Soni Jose upper_32_bits(addr));
213209a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2,
213309a1093aSJohn Soni Jose sge1_len, pwrb,
213409a1093aSJohn Soni Jose sg_len);
213509a1093aSJohn Soni Jose }
213609a1093aSJohn Soni Jose }
213709a1093aSJohn Soni Jose psgl = (struct iscsi_sge *)io_task->psgl_handle->pfrag;
213809a1093aSJohn Soni Jose memset(psgl, 0, sizeof(*psgl) * BE2_SGE);
213909a1093aSJohn Soni Jose
214009a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_sge, len, psgl, io_task->bhs_len - 2);
214109a1093aSJohn Soni Jose
214209a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_sge, addr_hi, psgl,
214309a1093aSJohn Soni Jose io_task->bhs_pa.u.a32.address_hi);
214409a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
214509a1093aSJohn Soni Jose io_task->bhs_pa.u.a32.address_lo);
214609a1093aSJohn Soni Jose
214709a1093aSJohn Soni Jose if (num_sg == 1) {
214809a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge0_last, pwrb,
214909a1093aSJohn Soni Jose 1);
215009a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge1_last, pwrb,
215109a1093aSJohn Soni Jose 0);
215209a1093aSJohn Soni Jose } else if (num_sg == 2) {
215309a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge0_last, pwrb,
215409a1093aSJohn Soni Jose 0);
215509a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge1_last, pwrb,
215609a1093aSJohn Soni Jose 1);
215709a1093aSJohn Soni Jose } else {
215809a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge0_last, pwrb,
215909a1093aSJohn Soni Jose 0);
216009a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sge1_last, pwrb,
216109a1093aSJohn Soni Jose 0);
216209a1093aSJohn Soni Jose }
216309a1093aSJohn Soni Jose
216409a1093aSJohn Soni Jose sg = l_sg;
216509a1093aSJohn Soni Jose psgl++;
216609a1093aSJohn Soni Jose psgl++;
216709a1093aSJohn Soni Jose offset = 0;
216809a1093aSJohn Soni Jose for (index = 0; index < num_sg; index++, sg = sg_next(sg), psgl++) {
216909a1093aSJohn Soni Jose sg_len = sg_dma_len(sg);
217009a1093aSJohn Soni Jose addr = (u64) sg_dma_address(sg);
217109a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
217209a1093aSJohn Soni Jose lower_32_bits(addr));
217309a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_sge, addr_hi, psgl,
217409a1093aSJohn Soni Jose upper_32_bits(addr));
217509a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_sge, len, psgl, sg_len);
217609a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_sge, sge_offset, psgl, offset);
217709a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_sge, last_sge, psgl, 0);
217809a1093aSJohn Soni Jose offset += sg_len;
217909a1093aSJohn Soni Jose }
218009a1093aSJohn Soni Jose psgl--;
218109a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_sge, last_sge, psgl, 1);
218209a1093aSJohn Soni Jose }
218309a1093aSJohn Soni Jose
218409a1093aSJohn Soni Jose static void
hwi_write_sgl(struct iscsi_wrb * pwrb,struct scatterlist * sg,unsigned int num_sg,struct beiscsi_io_task * io_task)21856733b39aSJayamohan Kallickal hwi_write_sgl(struct iscsi_wrb *pwrb, struct scatterlist *sg,
21866733b39aSJayamohan Kallickal unsigned int num_sg, struct beiscsi_io_task *io_task)
21876733b39aSJayamohan Kallickal {
21886733b39aSJayamohan Kallickal struct iscsi_sge *psgl;
218958ff4bd0SJayamohan Kallickal unsigned int sg_len, index;
21906733b39aSJayamohan Kallickal unsigned int sge_len = 0;
21916733b39aSJayamohan Kallickal unsigned long long addr;
21926733b39aSJayamohan Kallickal struct scatterlist *l_sg;
21936733b39aSJayamohan Kallickal unsigned int offset;
21946733b39aSJayamohan Kallickal
21956733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, iscsi_bhs_addr_lo, pwrb,
21966733b39aSJayamohan Kallickal io_task->bhs_pa.u.a32.address_lo);
21976733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, iscsi_bhs_addr_hi, pwrb,
21986733b39aSJayamohan Kallickal io_task->bhs_pa.u.a32.address_hi);
21996733b39aSJayamohan Kallickal
22006733b39aSJayamohan Kallickal l_sg = sg;
220148bd86cfSJayamohan Kallickal for (index = 0; (index < num_sg) && (index < 2); index++,
220248bd86cfSJayamohan Kallickal sg = sg_next(sg)) {
22036733b39aSJayamohan Kallickal if (index == 0) {
22046733b39aSJayamohan Kallickal sg_len = sg_dma_len(sg);
22056733b39aSJayamohan Kallickal addr = (u64) sg_dma_address(sg);
22066733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_addr_lo, pwrb,
2207457ff3b7SJayamohan Kallickal ((u32)(addr & 0xFFFFFFFF)));
22086733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_addr_hi, pwrb,
2209457ff3b7SJayamohan Kallickal ((u32)(addr >> 32)));
22106733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_len, pwrb,
22116733b39aSJayamohan Kallickal sg_len);
22126733b39aSJayamohan Kallickal sge_len = sg_len;
22136733b39aSJayamohan Kallickal } else {
22146733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_r2t_offset,
22156733b39aSJayamohan Kallickal pwrb, sge_len);
22166733b39aSJayamohan Kallickal sg_len = sg_dma_len(sg);
22176733b39aSJayamohan Kallickal addr = (u64) sg_dma_address(sg);
22186733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_addr_lo, pwrb,
2219457ff3b7SJayamohan Kallickal ((u32)(addr & 0xFFFFFFFF)));
22206733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_addr_hi, pwrb,
2221457ff3b7SJayamohan Kallickal ((u32)(addr >> 32)));
22226733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_len, pwrb,
22236733b39aSJayamohan Kallickal sg_len);
22246733b39aSJayamohan Kallickal }
22256733b39aSJayamohan Kallickal }
22266733b39aSJayamohan Kallickal psgl = (struct iscsi_sge *)io_task->psgl_handle->pfrag;
22276733b39aSJayamohan Kallickal memset(psgl, 0, sizeof(*psgl) * BE2_SGE);
22286733b39aSJayamohan Kallickal
22296733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, len, psgl, io_task->bhs_len - 2);
22306733b39aSJayamohan Kallickal
22316733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, addr_hi, psgl,
22326733b39aSJayamohan Kallickal io_task->bhs_pa.u.a32.address_hi);
22336733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
22346733b39aSJayamohan Kallickal io_task->bhs_pa.u.a32.address_lo);
22356733b39aSJayamohan Kallickal
2236caf818f1SJayamohan Kallickal if (num_sg == 1) {
2237caf818f1SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
2238caf818f1SJayamohan Kallickal 1);
2239caf818f1SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb,
2240caf818f1SJayamohan Kallickal 0);
2241caf818f1SJayamohan Kallickal } else if (num_sg == 2) {
2242caf818f1SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
2243caf818f1SJayamohan Kallickal 0);
2244caf818f1SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb,
2245caf818f1SJayamohan Kallickal 1);
2246caf818f1SJayamohan Kallickal } else {
2247caf818f1SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb,
2248caf818f1SJayamohan Kallickal 0);
2249caf818f1SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge1_last, pwrb,
2250caf818f1SJayamohan Kallickal 0);
2251caf818f1SJayamohan Kallickal }
22526733b39aSJayamohan Kallickal sg = l_sg;
22536733b39aSJayamohan Kallickal psgl++;
22546733b39aSJayamohan Kallickal psgl++;
22556733b39aSJayamohan Kallickal offset = 0;
225648bd86cfSJayamohan Kallickal for (index = 0; index < num_sg; index++, sg = sg_next(sg), psgl++) {
22576733b39aSJayamohan Kallickal sg_len = sg_dma_len(sg);
22586733b39aSJayamohan Kallickal addr = (u64) sg_dma_address(sg);
22596733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
22606733b39aSJayamohan Kallickal (addr & 0xFFFFFFFF));
22616733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, addr_hi, psgl,
22626733b39aSJayamohan Kallickal (addr >> 32));
22636733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, len, psgl, sg_len);
22646733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, sge_offset, psgl, offset);
22656733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, last_sge, psgl, 0);
22666733b39aSJayamohan Kallickal offset += sg_len;
22676733b39aSJayamohan Kallickal }
22686733b39aSJayamohan Kallickal psgl--;
22696733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, last_sge, psgl, 1);
22706733b39aSJayamohan Kallickal }
22716733b39aSJayamohan Kallickal
2272d629c471SJohn Soni Jose /**
2273d629c471SJohn Soni Jose * hwi_write_buffer()- Populate the WRB with task info
2274d629c471SJohn Soni Jose * @pwrb: ptr to the WRB entry
2275d629c471SJohn Soni Jose * @task: iscsi task which is to be executed
2276d629c471SJohn Soni Jose **/
hwi_write_buffer(struct iscsi_wrb * pwrb,struct iscsi_task * task)2277e0493627SAlexey Khoroshilov static int hwi_write_buffer(struct iscsi_wrb *pwrb, struct iscsi_task *task)
22786733b39aSJayamohan Kallickal {
22796733b39aSJayamohan Kallickal struct iscsi_sge *psgl;
22806733b39aSJayamohan Kallickal struct beiscsi_io_task *io_task = task->dd_data;
22816733b39aSJayamohan Kallickal struct beiscsi_conn *beiscsi_conn = io_task->conn;
22826733b39aSJayamohan Kallickal struct beiscsi_hba *phba = beiscsi_conn->phba;
228309a1093aSJohn Soni Jose uint8_t dsp_value = 0;
22846733b39aSJayamohan Kallickal
22856733b39aSJayamohan Kallickal io_task->bhs_len = sizeof(struct be_nonio_bhs) - 2;
22866733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, iscsi_bhs_addr_lo, pwrb,
22876733b39aSJayamohan Kallickal io_task->bhs_pa.u.a32.address_lo);
22886733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, iscsi_bhs_addr_hi, pwrb,
22896733b39aSJayamohan Kallickal io_task->bhs_pa.u.a32.address_hi);
22906733b39aSJayamohan Kallickal
22916733b39aSJayamohan Kallickal if (task->data) {
229209a1093aSJohn Soni Jose
229309a1093aSJohn Soni Jose /* Check for the data_count */
229409a1093aSJohn Soni Jose dsp_value = (task->data_count) ? 1 : 0;
229509a1093aSJohn Soni Jose
22962c9dfd36SJayamohan Kallickal if (is_chip_be2_be3r(phba))
22972c9dfd36SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, dsp,
229809a1093aSJohn Soni Jose pwrb, dsp_value);
229909a1093aSJohn Soni Jose else
23002c9dfd36SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb_v2, dsp,
230109a1093aSJohn Soni Jose pwrb, dsp_value);
230209a1093aSJohn Soni Jose
230309a1093aSJohn Soni Jose /* Map addr only if there is data_count */
230409a1093aSJohn Soni Jose if (dsp_value) {
230526a4c991SChristoph Hellwig io_task->mtask_addr = dma_map_single(&phba->pcidev->dev,
23066733b39aSJayamohan Kallickal task->data,
2307d629c471SJohn Soni Jose task->data_count,
230826a4c991SChristoph Hellwig DMA_TO_DEVICE);
230926a4c991SChristoph Hellwig if (dma_mapping_error(&phba->pcidev->dev,
2310e0493627SAlexey Khoroshilov io_task->mtask_addr))
2311e0493627SAlexey Khoroshilov return -ENOMEM;
2312d629c471SJohn Soni Jose io_task->mtask_data_count = task->data_count;
231309a1093aSJohn Soni Jose } else
2314d629c471SJohn Soni Jose io_task->mtask_addr = 0;
231509a1093aSJohn Soni Jose
23166733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_addr_lo, pwrb,
2317d629c471SJohn Soni Jose lower_32_bits(io_task->mtask_addr));
23186733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_addr_hi, pwrb,
2319d629c471SJohn Soni Jose upper_32_bits(io_task->mtask_addr));
23206733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_len, pwrb,
23216733b39aSJayamohan Kallickal task->data_count);
23226733b39aSJayamohan Kallickal
23236733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sge0_last, pwrb, 1);
23246733b39aSJayamohan Kallickal } else {
23256733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 0);
2326d629c471SJohn Soni Jose io_task->mtask_addr = 0;
23276733b39aSJayamohan Kallickal }
23286733b39aSJayamohan Kallickal
23296733b39aSJayamohan Kallickal psgl = (struct iscsi_sge *)io_task->psgl_handle->pfrag;
23306733b39aSJayamohan Kallickal
23316733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, len, psgl, io_task->bhs_len);
23326733b39aSJayamohan Kallickal
23336733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, addr_hi, psgl,
23346733b39aSJayamohan Kallickal io_task->bhs_pa.u.a32.address_hi);
23356733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
23366733b39aSJayamohan Kallickal io_task->bhs_pa.u.a32.address_lo);
23376733b39aSJayamohan Kallickal if (task->data) {
23386733b39aSJayamohan Kallickal psgl++;
23396733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, addr_hi, psgl, 0);
23406733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl, 0);
23416733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, len, psgl, 0);
23426733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, sge_offset, psgl, 0);
23436733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, rsvd0, psgl, 0);
23446733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, last_sge, psgl, 0);
23456733b39aSJayamohan Kallickal
23466733b39aSJayamohan Kallickal psgl++;
23476733b39aSJayamohan Kallickal if (task->data) {
23486733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, psgl,
2349d629c471SJohn Soni Jose lower_32_bits(io_task->mtask_addr));
23506733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, addr_hi, psgl,
2351d629c471SJohn Soni Jose upper_32_bits(io_task->mtask_addr));
23526733b39aSJayamohan Kallickal }
23536733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, len, psgl, 0x106);
23546733b39aSJayamohan Kallickal }
23556733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, last_sge, psgl, 1);
2356e0493627SAlexey Khoroshilov return 0;
23576733b39aSJayamohan Kallickal }
23586733b39aSJayamohan Kallickal
2359843ae752SJayamohan Kallickal /**
2360843ae752SJayamohan Kallickal * beiscsi_find_mem_req()- Find mem needed
2361843ae752SJayamohan Kallickal * @phba: ptr to HBA struct
2362843ae752SJayamohan Kallickal **/
beiscsi_find_mem_req(struct beiscsi_hba * phba)23636733b39aSJayamohan Kallickal static void beiscsi_find_mem_req(struct beiscsi_hba *phba)
23646733b39aSJayamohan Kallickal {
23658a86e833SJayamohan Kallickal uint8_t mem_descr_index, ulp_num;
2366fa1261c4SJitendra Bhivare unsigned int num_async_pdu_buf_pages;
23676733b39aSJayamohan Kallickal unsigned int num_async_pdu_data_pages, wrb_sz_per_cxn;
23686733b39aSJayamohan Kallickal unsigned int num_async_pdu_buf_sgl_pages, num_async_pdu_data_sgl_pages;
23696733b39aSJayamohan Kallickal
23706733b39aSJayamohan Kallickal phba->params.hwi_ws_sz = sizeof(struct hwi_controller);
23716733b39aSJayamohan Kallickal
23726733b39aSJayamohan Kallickal phba->mem_req[ISCSI_MEM_GLOBAL_HEADER] = 2 *
23736733b39aSJayamohan Kallickal BE_ISCSI_PDU_HEADER_SIZE;
23746733b39aSJayamohan Kallickal phba->mem_req[HWI_MEM_ADDN_CONTEXT] =
23756733b39aSJayamohan Kallickal sizeof(struct hwi_context_memory);
23766733b39aSJayamohan Kallickal
23776733b39aSJayamohan Kallickal
23786733b39aSJayamohan Kallickal phba->mem_req[HWI_MEM_WRB] = sizeof(struct iscsi_wrb)
23796733b39aSJayamohan Kallickal * (phba->params.wrbs_per_cxn)
23806733b39aSJayamohan Kallickal * phba->params.cxns_per_ctrl;
23816733b39aSJayamohan Kallickal wrb_sz_per_cxn = sizeof(struct wrb_handle) *
23826733b39aSJayamohan Kallickal (phba->params.wrbs_per_cxn);
23836733b39aSJayamohan Kallickal phba->mem_req[HWI_MEM_WRBH] = roundup_pow_of_two((wrb_sz_per_cxn) *
23846733b39aSJayamohan Kallickal phba->params.cxns_per_ctrl);
23856733b39aSJayamohan Kallickal
23866733b39aSJayamohan Kallickal phba->mem_req[HWI_MEM_SGLH] = sizeof(struct sgl_handle) *
23876733b39aSJayamohan Kallickal phba->params.icds_per_ctrl;
23886733b39aSJayamohan Kallickal phba->mem_req[HWI_MEM_SGE] = sizeof(struct iscsi_sge) *
23896733b39aSJayamohan Kallickal phba->params.num_sge_per_io * phba->params.icds_per_ctrl;
23908a86e833SJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
23918a86e833SJayamohan Kallickal if (test_bit(ulp_num, &phba->fw_config.ulp_supported)) {
23926733b39aSJayamohan Kallickal
23938a86e833SJayamohan Kallickal num_async_pdu_buf_sgl_pages =
2394fecc3824SJitendra Bhivare PAGES_REQUIRED(BEISCSI_ASYNC_HDQ_SIZE(
23958a86e833SJayamohan Kallickal phba, ulp_num) *
23968a86e833SJayamohan Kallickal sizeof(struct phys_addr));
23978a86e833SJayamohan Kallickal
23988a86e833SJayamohan Kallickal num_async_pdu_buf_pages =
2399fecc3824SJitendra Bhivare PAGES_REQUIRED(BEISCSI_ASYNC_HDQ_SIZE(
24008a86e833SJayamohan Kallickal phba, ulp_num) *
24018a86e833SJayamohan Kallickal phba->params.defpdu_hdr_sz);
24028a86e833SJayamohan Kallickal
24038a86e833SJayamohan Kallickal num_async_pdu_data_pages =
2404fecc3824SJitendra Bhivare PAGES_REQUIRED(BEISCSI_ASYNC_HDQ_SIZE(
24058a86e833SJayamohan Kallickal phba, ulp_num) *
24068a86e833SJayamohan Kallickal phba->params.defpdu_data_sz);
24078a86e833SJayamohan Kallickal
24088a86e833SJayamohan Kallickal num_async_pdu_data_sgl_pages =
2409fecc3824SJitendra Bhivare PAGES_REQUIRED(BEISCSI_ASYNC_HDQ_SIZE(
24108a86e833SJayamohan Kallickal phba, ulp_num) *
24118a86e833SJayamohan Kallickal sizeof(struct phys_addr));
24128a86e833SJayamohan Kallickal
2413a129d92fSJayamohan Kallickal mem_descr_index = (HWI_MEM_TEMPLATE_HDR_ULP0 +
2414a129d92fSJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET));
2415a129d92fSJayamohan Kallickal phba->mem_req[mem_descr_index] =
2416a129d92fSJayamohan Kallickal BEISCSI_GET_CID_COUNT(phba, ulp_num) *
2417a129d92fSJayamohan Kallickal BEISCSI_TEMPLATE_HDR_PER_CXN_SIZE;
2418a129d92fSJayamohan Kallickal
24198a86e833SJayamohan Kallickal mem_descr_index = (HWI_MEM_ASYNC_HEADER_BUF_ULP0 +
24208a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET));
24218a86e833SJayamohan Kallickal phba->mem_req[mem_descr_index] =
24228a86e833SJayamohan Kallickal num_async_pdu_buf_pages *
24238a86e833SJayamohan Kallickal PAGE_SIZE;
24248a86e833SJayamohan Kallickal
24258a86e833SJayamohan Kallickal mem_descr_index = (HWI_MEM_ASYNC_DATA_BUF_ULP0 +
24268a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET));
24278a86e833SJayamohan Kallickal phba->mem_req[mem_descr_index] =
24288a86e833SJayamohan Kallickal num_async_pdu_data_pages *
24298a86e833SJayamohan Kallickal PAGE_SIZE;
24308a86e833SJayamohan Kallickal
24318a86e833SJayamohan Kallickal mem_descr_index = (HWI_MEM_ASYNC_HEADER_RING_ULP0 +
24328a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET));
24338a86e833SJayamohan Kallickal phba->mem_req[mem_descr_index] =
24348a86e833SJayamohan Kallickal num_async_pdu_buf_sgl_pages *
24358a86e833SJayamohan Kallickal PAGE_SIZE;
24368a86e833SJayamohan Kallickal
24378a86e833SJayamohan Kallickal mem_descr_index = (HWI_MEM_ASYNC_DATA_RING_ULP0 +
24388a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET));
24398a86e833SJayamohan Kallickal phba->mem_req[mem_descr_index] =
24408a86e833SJayamohan Kallickal num_async_pdu_data_sgl_pages *
24418a86e833SJayamohan Kallickal PAGE_SIZE;
24428a86e833SJayamohan Kallickal
24438a86e833SJayamohan Kallickal mem_descr_index = (HWI_MEM_ASYNC_HEADER_HANDLE_ULP0 +
24448a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET));
24458a86e833SJayamohan Kallickal phba->mem_req[mem_descr_index] =
2446fecc3824SJitendra Bhivare BEISCSI_ASYNC_HDQ_SIZE(phba, ulp_num) *
2447938f372cSJitendra Bhivare sizeof(struct hd_async_handle);
24488a86e833SJayamohan Kallickal
24498a86e833SJayamohan Kallickal mem_descr_index = (HWI_MEM_ASYNC_DATA_HANDLE_ULP0 +
24508a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET));
24518a86e833SJayamohan Kallickal phba->mem_req[mem_descr_index] =
2452fecc3824SJitendra Bhivare BEISCSI_ASYNC_HDQ_SIZE(phba, ulp_num) *
2453938f372cSJitendra Bhivare sizeof(struct hd_async_handle);
24548a86e833SJayamohan Kallickal
24558a86e833SJayamohan Kallickal mem_descr_index = (HWI_MEM_ASYNC_PDU_CONTEXT_ULP0 +
24568a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET));
24578a86e833SJayamohan Kallickal phba->mem_req[mem_descr_index] =
2458938f372cSJitendra Bhivare sizeof(struct hd_async_context) +
2459fecc3824SJitendra Bhivare (BEISCSI_ASYNC_HDQ_SIZE(phba, ulp_num) *
2460938f372cSJitendra Bhivare sizeof(struct hd_async_entry));
24618a86e833SJayamohan Kallickal }
24628a86e833SJayamohan Kallickal }
24636733b39aSJayamohan Kallickal }
24646733b39aSJayamohan Kallickal
beiscsi_alloc_mem(struct beiscsi_hba * phba)24656733b39aSJayamohan Kallickal static int beiscsi_alloc_mem(struct beiscsi_hba *phba)
24666733b39aSJayamohan Kallickal {
24676733b39aSJayamohan Kallickal dma_addr_t bus_add;
2468a7909b39SJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
2469a7909b39SJayamohan Kallickal struct be_mem_descriptor *mem_descr;
24706733b39aSJayamohan Kallickal struct mem_array *mem_arr, *mem_arr_orig;
24716733b39aSJayamohan Kallickal unsigned int i, j, alloc_size, curr_alloc_size;
24726733b39aSJayamohan Kallickal
24733ec78271SJayamohan Kallickal phba->phwi_ctrlr = kzalloc(phba->params.hwi_ws_sz, GFP_KERNEL);
24746733b39aSJayamohan Kallickal if (!phba->phwi_ctrlr)
24756733b39aSJayamohan Kallickal return -ENOMEM;
24766733b39aSJayamohan Kallickal
2477a7909b39SJayamohan Kallickal /* Allocate memory for wrb_context */
2478a7909b39SJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
24796396bb22SKees Cook phwi_ctrlr->wrb_context = kcalloc(phba->params.cxns_per_ctrl,
24806396bb22SKees Cook sizeof(struct hwi_wrb_context),
2481a7909b39SJayamohan Kallickal GFP_KERNEL);
24820c88740dSMaurizio Lombardi if (!phwi_ctrlr->wrb_context) {
24830c88740dSMaurizio Lombardi kfree(phba->phwi_ctrlr);
2484a7909b39SJayamohan Kallickal return -ENOMEM;
24850c88740dSMaurizio Lombardi }
2486a7909b39SJayamohan Kallickal
24876733b39aSJayamohan Kallickal phba->init_mem = kcalloc(SE_MEM_MAX, sizeof(*mem_descr),
24886733b39aSJayamohan Kallickal GFP_KERNEL);
24896733b39aSJayamohan Kallickal if (!phba->init_mem) {
2490a7909b39SJayamohan Kallickal kfree(phwi_ctrlr->wrb_context);
24916733b39aSJayamohan Kallickal kfree(phba->phwi_ctrlr);
24926733b39aSJayamohan Kallickal return -ENOMEM;
24936733b39aSJayamohan Kallickal }
24946733b39aSJayamohan Kallickal
24956da2ec56SKees Cook mem_arr_orig = kmalloc_array(BEISCSI_MAX_FRAGS_INIT,
24966da2ec56SKees Cook sizeof(*mem_arr_orig),
24976733b39aSJayamohan Kallickal GFP_KERNEL);
24986733b39aSJayamohan Kallickal if (!mem_arr_orig) {
24996733b39aSJayamohan Kallickal kfree(phba->init_mem);
2500a7909b39SJayamohan Kallickal kfree(phwi_ctrlr->wrb_context);
25016733b39aSJayamohan Kallickal kfree(phba->phwi_ctrlr);
25026733b39aSJayamohan Kallickal return -ENOMEM;
25036733b39aSJayamohan Kallickal }
25046733b39aSJayamohan Kallickal
25056733b39aSJayamohan Kallickal mem_descr = phba->init_mem;
25066733b39aSJayamohan Kallickal for (i = 0; i < SE_MEM_MAX; i++) {
25078a86e833SJayamohan Kallickal if (!phba->mem_req[i]) {
25088a86e833SJayamohan Kallickal mem_descr->mem_array = NULL;
25098a86e833SJayamohan Kallickal mem_descr++;
25108a86e833SJayamohan Kallickal continue;
25118a86e833SJayamohan Kallickal }
25128a86e833SJayamohan Kallickal
25136733b39aSJayamohan Kallickal j = 0;
25146733b39aSJayamohan Kallickal mem_arr = mem_arr_orig;
25156733b39aSJayamohan Kallickal alloc_size = phba->mem_req[i];
25166733b39aSJayamohan Kallickal memset(mem_arr, 0, sizeof(struct mem_array) *
25176733b39aSJayamohan Kallickal BEISCSI_MAX_FRAGS_INIT);
25186733b39aSJayamohan Kallickal curr_alloc_size = min(be_max_phys_size * 1024, alloc_size);
25196733b39aSJayamohan Kallickal do {
252026a4c991SChristoph Hellwig mem_arr->virtual_address =
252126a4c991SChristoph Hellwig dma_alloc_coherent(&phba->pcidev->dev,
252226a4c991SChristoph Hellwig curr_alloc_size, &bus_add, GFP_KERNEL);
25236733b39aSJayamohan Kallickal if (!mem_arr->virtual_address) {
25246733b39aSJayamohan Kallickal if (curr_alloc_size <= BE_MIN_MEM_SIZE)
25256733b39aSJayamohan Kallickal goto free_mem;
25266733b39aSJayamohan Kallickal if (curr_alloc_size -
25276733b39aSJayamohan Kallickal rounddown_pow_of_two(curr_alloc_size))
25286733b39aSJayamohan Kallickal curr_alloc_size = rounddown_pow_of_two
25296733b39aSJayamohan Kallickal (curr_alloc_size);
25306733b39aSJayamohan Kallickal else
25316733b39aSJayamohan Kallickal curr_alloc_size = curr_alloc_size / 2;
25326733b39aSJayamohan Kallickal } else {
25336733b39aSJayamohan Kallickal mem_arr->bus_address.u.
25346733b39aSJayamohan Kallickal a64.address = (__u64) bus_add;
25356733b39aSJayamohan Kallickal mem_arr->size = curr_alloc_size;
25366733b39aSJayamohan Kallickal alloc_size -= curr_alloc_size;
25376733b39aSJayamohan Kallickal curr_alloc_size = min(be_max_phys_size *
25386733b39aSJayamohan Kallickal 1024, alloc_size);
25396733b39aSJayamohan Kallickal j++;
25406733b39aSJayamohan Kallickal mem_arr++;
25416733b39aSJayamohan Kallickal }
25426733b39aSJayamohan Kallickal } while (alloc_size);
25436733b39aSJayamohan Kallickal mem_descr->num_elements = j;
25446733b39aSJayamohan Kallickal mem_descr->size_in_bytes = phba->mem_req[i];
25456da2ec56SKees Cook mem_descr->mem_array = kmalloc_array(j, sizeof(*mem_arr),
25466733b39aSJayamohan Kallickal GFP_KERNEL);
25476733b39aSJayamohan Kallickal if (!mem_descr->mem_array)
25486733b39aSJayamohan Kallickal goto free_mem;
25496733b39aSJayamohan Kallickal
25506733b39aSJayamohan Kallickal memcpy(mem_descr->mem_array, mem_arr_orig,
25516733b39aSJayamohan Kallickal sizeof(struct mem_array) * j);
25526733b39aSJayamohan Kallickal mem_descr++;
25536733b39aSJayamohan Kallickal }
25546733b39aSJayamohan Kallickal kfree(mem_arr_orig);
25556733b39aSJayamohan Kallickal return 0;
25566733b39aSJayamohan Kallickal free_mem:
25576733b39aSJayamohan Kallickal mem_descr->num_elements = j;
25586733b39aSJayamohan Kallickal while ((i) || (j)) {
25596733b39aSJayamohan Kallickal for (j = mem_descr->num_elements; j > 0; j--) {
256026a4c991SChristoph Hellwig dma_free_coherent(&phba->pcidev->dev,
25616733b39aSJayamohan Kallickal mem_descr->mem_array[j - 1].size,
25626733b39aSJayamohan Kallickal mem_descr->mem_array[j - 1].
25636733b39aSJayamohan Kallickal virtual_address,
2564457ff3b7SJayamohan Kallickal (unsigned long)mem_descr->
2565457ff3b7SJayamohan Kallickal mem_array[j - 1].
25666733b39aSJayamohan Kallickal bus_address.u.a64.address);
25676733b39aSJayamohan Kallickal }
25686733b39aSJayamohan Kallickal if (i) {
25696733b39aSJayamohan Kallickal i--;
25706733b39aSJayamohan Kallickal kfree(mem_descr->mem_array);
25716733b39aSJayamohan Kallickal mem_descr--;
25726733b39aSJayamohan Kallickal }
25736733b39aSJayamohan Kallickal }
25746733b39aSJayamohan Kallickal kfree(mem_arr_orig);
25756733b39aSJayamohan Kallickal kfree(phba->init_mem);
2576a7909b39SJayamohan Kallickal kfree(phba->phwi_ctrlr->wrb_context);
25776733b39aSJayamohan Kallickal kfree(phba->phwi_ctrlr);
25786733b39aSJayamohan Kallickal return -ENOMEM;
25796733b39aSJayamohan Kallickal }
25806733b39aSJayamohan Kallickal
beiscsi_get_memory(struct beiscsi_hba * phba)25816733b39aSJayamohan Kallickal static int beiscsi_get_memory(struct beiscsi_hba *phba)
25826733b39aSJayamohan Kallickal {
25836733b39aSJayamohan Kallickal beiscsi_find_mem_req(phba);
25846733b39aSJayamohan Kallickal return beiscsi_alloc_mem(phba);
25856733b39aSJayamohan Kallickal }
25866733b39aSJayamohan Kallickal
iscsi_init_global_templates(struct beiscsi_hba * phba)25876733b39aSJayamohan Kallickal static void iscsi_init_global_templates(struct beiscsi_hba *phba)
25886733b39aSJayamohan Kallickal {
25896733b39aSJayamohan Kallickal struct pdu_data_out *pdata_out;
25906733b39aSJayamohan Kallickal struct pdu_nop_out *pnop_out;
25916733b39aSJayamohan Kallickal struct be_mem_descriptor *mem_descr;
25926733b39aSJayamohan Kallickal
25936733b39aSJayamohan Kallickal mem_descr = phba->init_mem;
25946733b39aSJayamohan Kallickal mem_descr += ISCSI_MEM_GLOBAL_HEADER;
25956733b39aSJayamohan Kallickal pdata_out =
25966733b39aSJayamohan Kallickal (struct pdu_data_out *)mem_descr->mem_array[0].virtual_address;
25976733b39aSJayamohan Kallickal memset(pdata_out, 0, BE_ISCSI_PDU_HEADER_SIZE);
25986733b39aSJayamohan Kallickal
25996733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_pdu_data_out, opcode, pdata_out,
26006733b39aSJayamohan Kallickal IIOC_SCSI_DATA);
26016733b39aSJayamohan Kallickal
26026733b39aSJayamohan Kallickal pnop_out =
26036733b39aSJayamohan Kallickal (struct pdu_nop_out *)((unsigned char *)mem_descr->mem_array[0].
26046733b39aSJayamohan Kallickal virtual_address + BE_ISCSI_PDU_HEADER_SIZE);
26056733b39aSJayamohan Kallickal
26066733b39aSJayamohan Kallickal memset(pnop_out, 0, BE_ISCSI_PDU_HEADER_SIZE);
26076733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_pdu_nop_out, ttt, pnop_out, 0xFFFFFFFF);
26086733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_pdu_nop_out, f_bit, pnop_out, 1);
26096733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_pdu_nop_out, i_bit, pnop_out, 0);
26106733b39aSJayamohan Kallickal }
26116733b39aSJayamohan Kallickal
beiscsi_init_wrb_handle(struct beiscsi_hba * phba)26123ec78271SJayamohan Kallickal static int beiscsi_init_wrb_handle(struct beiscsi_hba *phba)
26136733b39aSJayamohan Kallickal {
26146733b39aSJayamohan Kallickal struct be_mem_descriptor *mem_descr_wrbh, *mem_descr_wrb;
2615a7909b39SJayamohan Kallickal struct hwi_context_memory *phwi_ctxt;
26163ec78271SJayamohan Kallickal struct wrb_handle *pwrb_handle = NULL;
26176733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
26186733b39aSJayamohan Kallickal struct hwi_wrb_context *pwrb_context;
26193ec78271SJayamohan Kallickal struct iscsi_wrb *pwrb = NULL;
26203ec78271SJayamohan Kallickal unsigned int num_cxn_wrbh = 0;
26213ec78271SJayamohan Kallickal unsigned int num_cxn_wrb = 0, j, idx = 0, index;
26226733b39aSJayamohan Kallickal
26236733b39aSJayamohan Kallickal mem_descr_wrbh = phba->init_mem;
26246733b39aSJayamohan Kallickal mem_descr_wrbh += HWI_MEM_WRBH;
26256733b39aSJayamohan Kallickal
26266733b39aSJayamohan Kallickal mem_descr_wrb = phba->init_mem;
26276733b39aSJayamohan Kallickal mem_descr_wrb += HWI_MEM_WRB;
26286733b39aSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
26296733b39aSJayamohan Kallickal
2630a7909b39SJayamohan Kallickal /* Allocate memory for WRBQ */
2631a7909b39SJayamohan Kallickal phwi_ctxt = phwi_ctrlr->phwi_ctxt;
26326396bb22SKees Cook phwi_ctxt->be_wrbq = kcalloc(phba->params.cxns_per_ctrl,
26336396bb22SKees Cook sizeof(struct be_queue_info),
2634a7909b39SJayamohan Kallickal GFP_KERNEL);
2635a7909b39SJayamohan Kallickal if (!phwi_ctxt->be_wrbq) {
2636a7909b39SJayamohan Kallickal beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
2637a7909b39SJayamohan Kallickal "BM_%d : WRBQ Mem Alloc Failed\n");
2638a7909b39SJayamohan Kallickal return -ENOMEM;
2639a7909b39SJayamohan Kallickal }
2640a7909b39SJayamohan Kallickal
2641a7909b39SJayamohan Kallickal for (index = 0; index < phba->params.cxns_per_ctrl; index++) {
26426733b39aSJayamohan Kallickal pwrb_context = &phwi_ctrlr->wrb_context[index];
26436733b39aSJayamohan Kallickal pwrb_context->pwrb_handle_base =
26446396bb22SKees Cook kcalloc(phba->params.wrbs_per_cxn,
26456396bb22SKees Cook sizeof(struct wrb_handle *),
26466396bb22SKees Cook GFP_KERNEL);
26473ec78271SJayamohan Kallickal if (!pwrb_context->pwrb_handle_base) {
264899bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
264999bc5d55SJohn Soni Jose "BM_%d : Mem Alloc Failed. Failing to load\n");
26503ec78271SJayamohan Kallickal goto init_wrb_hndl_failed;
26513ec78271SJayamohan Kallickal }
26526733b39aSJayamohan Kallickal pwrb_context->pwrb_handle_basestd =
26536396bb22SKees Cook kcalloc(phba->params.wrbs_per_cxn,
26546396bb22SKees Cook sizeof(struct wrb_handle *),
26556396bb22SKees Cook GFP_KERNEL);
26563ec78271SJayamohan Kallickal if (!pwrb_context->pwrb_handle_basestd) {
265799bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
265899bc5d55SJohn Soni Jose "BM_%d : Mem Alloc Failed. Failing to load\n");
26593ec78271SJayamohan Kallickal goto init_wrb_hndl_failed;
26606733b39aSJayamohan Kallickal }
26613ec78271SJayamohan Kallickal if (!num_cxn_wrbh) {
26626733b39aSJayamohan Kallickal pwrb_handle =
26636733b39aSJayamohan Kallickal mem_descr_wrbh->mem_array[idx].virtual_address;
26643ec78271SJayamohan Kallickal num_cxn_wrbh = ((mem_descr_wrbh->mem_array[idx].size) /
26656733b39aSJayamohan Kallickal ((sizeof(struct wrb_handle)) *
26666733b39aSJayamohan Kallickal phba->params.wrbs_per_cxn));
26673ec78271SJayamohan Kallickal idx++;
26683ec78271SJayamohan Kallickal }
26696733b39aSJayamohan Kallickal pwrb_context->alloc_index = 0;
26703ec78271SJayamohan Kallickal pwrb_context->wrb_handles_available = 0;
26713ec78271SJayamohan Kallickal pwrb_context->free_index = 0;
26723ec78271SJayamohan Kallickal
26733ec78271SJayamohan Kallickal if (num_cxn_wrbh) {
26746733b39aSJayamohan Kallickal for (j = 0; j < phba->params.wrbs_per_cxn; j++) {
26756733b39aSJayamohan Kallickal pwrb_context->pwrb_handle_base[j] = pwrb_handle;
26766733b39aSJayamohan Kallickal pwrb_context->pwrb_handle_basestd[j] =
26776733b39aSJayamohan Kallickal pwrb_handle;
26786733b39aSJayamohan Kallickal pwrb_context->wrb_handles_available++;
2679bfead3b2SJayamohan Kallickal pwrb_handle->wrb_index = j;
26806733b39aSJayamohan Kallickal pwrb_handle++;
26816733b39aSJayamohan Kallickal }
26826733b39aSJayamohan Kallickal num_cxn_wrbh--;
26836733b39aSJayamohan Kallickal }
2684f64d92e6SJitendra Bhivare spin_lock_init(&pwrb_context->wrb_lock);
26856733b39aSJayamohan Kallickal }
26866733b39aSJayamohan Kallickal idx = 0;
2687a7909b39SJayamohan Kallickal for (index = 0; index < phba->params.cxns_per_ctrl; index++) {
26883ec78271SJayamohan Kallickal pwrb_context = &phwi_ctrlr->wrb_context[index];
26893ec78271SJayamohan Kallickal if (!num_cxn_wrb) {
26906733b39aSJayamohan Kallickal pwrb = mem_descr_wrb->mem_array[idx].virtual_address;
26917c56533cSJayamohan Kallickal num_cxn_wrb = (mem_descr_wrb->mem_array[idx].size) /
26927c56533cSJayamohan Kallickal ((sizeof(struct iscsi_wrb) *
26937c56533cSJayamohan Kallickal phba->params.wrbs_per_cxn));
26943ec78271SJayamohan Kallickal idx++;
26953ec78271SJayamohan Kallickal }
26963ec78271SJayamohan Kallickal
26976733b39aSJayamohan Kallickal if (num_cxn_wrb) {
26986733b39aSJayamohan Kallickal for (j = 0; j < phba->params.wrbs_per_cxn; j++) {
26996733b39aSJayamohan Kallickal pwrb_handle = pwrb_context->pwrb_handle_base[j];
27006733b39aSJayamohan Kallickal pwrb_handle->pwrb = pwrb;
27016733b39aSJayamohan Kallickal pwrb++;
27026733b39aSJayamohan Kallickal }
27036733b39aSJayamohan Kallickal num_cxn_wrb--;
27046733b39aSJayamohan Kallickal }
27056733b39aSJayamohan Kallickal }
27063ec78271SJayamohan Kallickal return 0;
27073ec78271SJayamohan Kallickal init_wrb_hndl_failed:
27083ec78271SJayamohan Kallickal for (j = index; j > 0; j--) {
27093ec78271SJayamohan Kallickal pwrb_context = &phwi_ctrlr->wrb_context[j];
27103ec78271SJayamohan Kallickal kfree(pwrb_context->pwrb_handle_base);
27113ec78271SJayamohan Kallickal kfree(pwrb_context->pwrb_handle_basestd);
27123ec78271SJayamohan Kallickal }
2713*ddc5ad21SDinghao Liu kfree(phwi_ctxt->be_wrbq);
27143ec78271SJayamohan Kallickal return -ENOMEM;
27156733b39aSJayamohan Kallickal }
27166733b39aSJayamohan Kallickal
hwi_init_async_pdu_ctx(struct beiscsi_hba * phba)2717a7909b39SJayamohan Kallickal static int hwi_init_async_pdu_ctx(struct beiscsi_hba *phba)
27186733b39aSJayamohan Kallickal {
27198a86e833SJayamohan Kallickal uint8_t ulp_num;
27206733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
27216733b39aSJayamohan Kallickal struct hba_parameters *p = &phba->params;
2722938f372cSJitendra Bhivare struct hd_async_context *pasync_ctx;
2723938f372cSJitendra Bhivare struct hd_async_handle *pasync_header_h, *pasync_data_h;
2724dc63aac6SJayamohan Kallickal unsigned int index, idx, num_per_mem, num_async_data;
27256733b39aSJayamohan Kallickal struct be_mem_descriptor *mem_descr;
27266733b39aSJayamohan Kallickal
27278a86e833SJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
27288a86e833SJayamohan Kallickal if (test_bit(ulp_num, &phba->fw_config.ulp_supported)) {
2729938f372cSJitendra Bhivare /* get async_ctx for each ULP */
27306733b39aSJayamohan Kallickal mem_descr = (struct be_mem_descriptor *)phba->init_mem;
27318a86e833SJayamohan Kallickal mem_descr += (HWI_MEM_ASYNC_PDU_CONTEXT_ULP0 +
27328a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET));
27336733b39aSJayamohan Kallickal
27346733b39aSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
27358a86e833SJayamohan Kallickal phwi_ctrlr->phwi_ctxt->pasync_ctx[ulp_num] =
2736938f372cSJitendra Bhivare (struct hd_async_context *)
27376733b39aSJayamohan Kallickal mem_descr->mem_array[0].virtual_address;
27388a86e833SJayamohan Kallickal
27398a86e833SJayamohan Kallickal pasync_ctx = phwi_ctrlr->phwi_ctxt->pasync_ctx[ulp_num];
27406733b39aSJayamohan Kallickal memset(pasync_ctx, 0, sizeof(*pasync_ctx));
27416733b39aSJayamohan Kallickal
27428a86e833SJayamohan Kallickal pasync_ctx->async_entry =
2743938f372cSJitendra Bhivare (struct hd_async_entry *)
27448a86e833SJayamohan Kallickal ((long unsigned int)pasync_ctx +
2745938f372cSJitendra Bhivare sizeof(struct hd_async_context));
2746a7909b39SJayamohan Kallickal
2747fecc3824SJitendra Bhivare pasync_ctx->num_entries = BEISCSI_ASYNC_HDQ_SIZE(phba,
27488a86e833SJayamohan Kallickal ulp_num);
2749938f372cSJitendra Bhivare /* setup header buffers */
27506733b39aSJayamohan Kallickal mem_descr = (struct be_mem_descriptor *)phba->init_mem;
27518a86e833SJayamohan Kallickal mem_descr += HWI_MEM_ASYNC_HEADER_BUF_ULP0 +
27528a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET);
27536733b39aSJayamohan Kallickal if (mem_descr->mem_array[0].virtual_address) {
275499bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
275599bc5d55SJohn Soni Jose "BM_%d : hwi_init_async_pdu_ctx"
27568a86e833SJayamohan Kallickal " HWI_MEM_ASYNC_HEADER_BUF_ULP%d va=%p\n",
27578a86e833SJayamohan Kallickal ulp_num,
27588a86e833SJayamohan Kallickal mem_descr->mem_array[0].
27598a86e833SJayamohan Kallickal virtual_address);
27606733b39aSJayamohan Kallickal } else
27618a86e833SJayamohan Kallickal beiscsi_log(phba, KERN_WARNING,
27628a86e833SJayamohan Kallickal BEISCSI_LOG_INIT,
27638a86e833SJayamohan Kallickal "BM_%d : No Virtual address for ULP : %d\n",
27648a86e833SJayamohan Kallickal ulp_num);
27656733b39aSJayamohan Kallickal
27661e2931f1SJitendra Bhivare pasync_ctx->async_header.pi = 0;
2767938f372cSJitendra Bhivare pasync_ctx->async_header.buffer_size = p->defpdu_hdr_sz;
27686733b39aSJayamohan Kallickal pasync_ctx->async_header.va_base =
27696733b39aSJayamohan Kallickal mem_descr->mem_array[0].virtual_address;
27706733b39aSJayamohan Kallickal
27716733b39aSJayamohan Kallickal pasync_ctx->async_header.pa_base.u.a64.address =
27728a86e833SJayamohan Kallickal mem_descr->mem_array[0].
27738a86e833SJayamohan Kallickal bus_address.u.a64.address;
27746733b39aSJayamohan Kallickal
2775938f372cSJitendra Bhivare /* setup header buffer sgls */
27766733b39aSJayamohan Kallickal mem_descr = (struct be_mem_descriptor *)phba->init_mem;
27778a86e833SJayamohan Kallickal mem_descr += HWI_MEM_ASYNC_HEADER_RING_ULP0 +
27788a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET);
27796733b39aSJayamohan Kallickal if (mem_descr->mem_array[0].virtual_address) {
278099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
278199bc5d55SJohn Soni Jose "BM_%d : hwi_init_async_pdu_ctx"
27828a86e833SJayamohan Kallickal " HWI_MEM_ASYNC_HEADER_RING_ULP%d va=%p\n",
27838a86e833SJayamohan Kallickal ulp_num,
27848a86e833SJayamohan Kallickal mem_descr->mem_array[0].
27858a86e833SJayamohan Kallickal virtual_address);
27866733b39aSJayamohan Kallickal } else
27878a86e833SJayamohan Kallickal beiscsi_log(phba, KERN_WARNING,
27888a86e833SJayamohan Kallickal BEISCSI_LOG_INIT,
27898a86e833SJayamohan Kallickal "BM_%d : No Virtual address for ULP : %d\n",
27908a86e833SJayamohan Kallickal ulp_num);
279199bc5d55SJohn Soni Jose
27926733b39aSJayamohan Kallickal pasync_ctx->async_header.ring_base =
27936733b39aSJayamohan Kallickal mem_descr->mem_array[0].virtual_address;
27946733b39aSJayamohan Kallickal
2795938f372cSJitendra Bhivare /* setup header buffer handles */
27966733b39aSJayamohan Kallickal mem_descr = (struct be_mem_descriptor *)phba->init_mem;
27978a86e833SJayamohan Kallickal mem_descr += HWI_MEM_ASYNC_HEADER_HANDLE_ULP0 +
27988a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET);
27996733b39aSJayamohan Kallickal if (mem_descr->mem_array[0].virtual_address) {
280099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
280199bc5d55SJohn Soni Jose "BM_%d : hwi_init_async_pdu_ctx"
28028a86e833SJayamohan Kallickal " HWI_MEM_ASYNC_HEADER_HANDLE_ULP%d va=%p\n",
28038a86e833SJayamohan Kallickal ulp_num,
28048a86e833SJayamohan Kallickal mem_descr->mem_array[0].
28058a86e833SJayamohan Kallickal virtual_address);
28066733b39aSJayamohan Kallickal } else
28078a86e833SJayamohan Kallickal beiscsi_log(phba, KERN_WARNING,
28088a86e833SJayamohan Kallickal BEISCSI_LOG_INIT,
28098a86e833SJayamohan Kallickal "BM_%d : No Virtual address for ULP : %d\n",
28108a86e833SJayamohan Kallickal ulp_num);
28116733b39aSJayamohan Kallickal
28126733b39aSJayamohan Kallickal pasync_ctx->async_header.handle_base =
28136733b39aSJayamohan Kallickal mem_descr->mem_array[0].virtual_address;
28146733b39aSJayamohan Kallickal
2815938f372cSJitendra Bhivare /* setup data buffer sgls */
28166733b39aSJayamohan Kallickal mem_descr = (struct be_mem_descriptor *)phba->init_mem;
28178a86e833SJayamohan Kallickal mem_descr += HWI_MEM_ASYNC_DATA_RING_ULP0 +
28188a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET);
28196733b39aSJayamohan Kallickal if (mem_descr->mem_array[0].virtual_address) {
282099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
282199bc5d55SJohn Soni Jose "BM_%d : hwi_init_async_pdu_ctx"
28228a86e833SJayamohan Kallickal " HWI_MEM_ASYNC_DATA_RING_ULP%d va=%p\n",
28238a86e833SJayamohan Kallickal ulp_num,
28248a86e833SJayamohan Kallickal mem_descr->mem_array[0].
28258a86e833SJayamohan Kallickal virtual_address);
28266733b39aSJayamohan Kallickal } else
28278a86e833SJayamohan Kallickal beiscsi_log(phba, KERN_WARNING,
28288a86e833SJayamohan Kallickal BEISCSI_LOG_INIT,
28298a86e833SJayamohan Kallickal "BM_%d : No Virtual address for ULP : %d\n",
28308a86e833SJayamohan Kallickal ulp_num);
28316733b39aSJayamohan Kallickal
28326733b39aSJayamohan Kallickal pasync_ctx->async_data.ring_base =
28336733b39aSJayamohan Kallickal mem_descr->mem_array[0].virtual_address;
28346733b39aSJayamohan Kallickal
2835938f372cSJitendra Bhivare /* setup data buffer handles */
28366733b39aSJayamohan Kallickal mem_descr = (struct be_mem_descriptor *)phba->init_mem;
28378a86e833SJayamohan Kallickal mem_descr += HWI_MEM_ASYNC_DATA_HANDLE_ULP0 +
28388a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET);
28396733b39aSJayamohan Kallickal if (!mem_descr->mem_array[0].virtual_address)
28408a86e833SJayamohan Kallickal beiscsi_log(phba, KERN_WARNING,
28418a86e833SJayamohan Kallickal BEISCSI_LOG_INIT,
28428a86e833SJayamohan Kallickal "BM_%d : No Virtual address for ULP : %d\n",
28438a86e833SJayamohan Kallickal ulp_num);
28446733b39aSJayamohan Kallickal
28456733b39aSJayamohan Kallickal pasync_ctx->async_data.handle_base =
28466733b39aSJayamohan Kallickal mem_descr->mem_array[0].virtual_address;
28476733b39aSJayamohan Kallickal
28486733b39aSJayamohan Kallickal pasync_header_h =
2849938f372cSJitendra Bhivare (struct hd_async_handle *)
28508a86e833SJayamohan Kallickal pasync_ctx->async_header.handle_base;
28516733b39aSJayamohan Kallickal pasync_data_h =
2852938f372cSJitendra Bhivare (struct hd_async_handle *)
28538a86e833SJayamohan Kallickal pasync_ctx->async_data.handle_base;
28546733b39aSJayamohan Kallickal
2855938f372cSJitendra Bhivare /* setup data buffers */
2856dc63aac6SJayamohan Kallickal mem_descr = (struct be_mem_descriptor *)phba->init_mem;
28578a86e833SJayamohan Kallickal mem_descr += HWI_MEM_ASYNC_DATA_BUF_ULP0 +
28588a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET);
2859dc63aac6SJayamohan Kallickal if (mem_descr->mem_array[0].virtual_address) {
286099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
286199bc5d55SJohn Soni Jose "BM_%d : hwi_init_async_pdu_ctx"
28628a86e833SJayamohan Kallickal " HWI_MEM_ASYNC_DATA_BUF_ULP%d va=%p\n",
28638a86e833SJayamohan Kallickal ulp_num,
28648a86e833SJayamohan Kallickal mem_descr->mem_array[0].
28658a86e833SJayamohan Kallickal virtual_address);
2866dc63aac6SJayamohan Kallickal } else
28678a86e833SJayamohan Kallickal beiscsi_log(phba, KERN_WARNING,
28688a86e833SJayamohan Kallickal BEISCSI_LOG_INIT,
28698a86e833SJayamohan Kallickal "BM_%d : No Virtual address for ULP : %d\n",
28708a86e833SJayamohan Kallickal ulp_num);
287199bc5d55SJohn Soni Jose
2872dc63aac6SJayamohan Kallickal idx = 0;
28731e2931f1SJitendra Bhivare pasync_ctx->async_data.pi = 0;
2874938f372cSJitendra Bhivare pasync_ctx->async_data.buffer_size = p->defpdu_data_sz;
2875dc63aac6SJayamohan Kallickal pasync_ctx->async_data.va_base =
2876dc63aac6SJayamohan Kallickal mem_descr->mem_array[idx].virtual_address;
2877dc63aac6SJayamohan Kallickal pasync_ctx->async_data.pa_base.u.a64.address =
28788a86e833SJayamohan Kallickal mem_descr->mem_array[idx].
28798a86e833SJayamohan Kallickal bus_address.u.a64.address;
2880dc63aac6SJayamohan Kallickal
2881dc63aac6SJayamohan Kallickal num_async_data = ((mem_descr->mem_array[idx].size) /
2882dc63aac6SJayamohan Kallickal phba->params.defpdu_data_sz);
2883dc63aac6SJayamohan Kallickal num_per_mem = 0;
2884dc63aac6SJayamohan Kallickal
2885fecc3824SJitendra Bhivare for (index = 0; index < BEISCSI_ASYNC_HDQ_SIZE
28868a86e833SJayamohan Kallickal (phba, ulp_num); index++) {
28876733b39aSJayamohan Kallickal pasync_header_h->cri = -1;
2888938f372cSJitendra Bhivare pasync_header_h->is_header = 1;
2889938f372cSJitendra Bhivare pasync_header_h->index = index;
28906733b39aSJayamohan Kallickal INIT_LIST_HEAD(&pasync_header_h->link);
28916733b39aSJayamohan Kallickal pasync_header_h->pbuffer =
28926733b39aSJayamohan Kallickal (void *)((unsigned long)
28938a86e833SJayamohan Kallickal (pasync_ctx->
28948a86e833SJayamohan Kallickal async_header.va_base) +
28956733b39aSJayamohan Kallickal (p->defpdu_hdr_sz * index));
28966733b39aSJayamohan Kallickal
28976733b39aSJayamohan Kallickal pasync_header_h->pa.u.a64.address =
28988a86e833SJayamohan Kallickal pasync_ctx->async_header.pa_base.u.a64.
28998a86e833SJayamohan Kallickal address + (p->defpdu_hdr_sz * index);
29006733b39aSJayamohan Kallickal
29011e2931f1SJitendra Bhivare pasync_ctx->async_entry[index].header =
29021e2931f1SJitendra Bhivare pasync_header_h;
29036733b39aSJayamohan Kallickal pasync_header_h++;
2904938f372cSJitendra Bhivare INIT_LIST_HEAD(&pasync_ctx->async_entry[index].
2905938f372cSJitendra Bhivare wq.list);
29066733b39aSJayamohan Kallickal
29076733b39aSJayamohan Kallickal pasync_data_h->cri = -1;
2908938f372cSJitendra Bhivare pasync_data_h->is_header = 0;
2909938f372cSJitendra Bhivare pasync_data_h->index = index;
29106733b39aSJayamohan Kallickal INIT_LIST_HEAD(&pasync_data_h->link);
2911dc63aac6SJayamohan Kallickal
2912dc63aac6SJayamohan Kallickal if (!num_async_data) {
2913dc63aac6SJayamohan Kallickal num_per_mem = 0;
2914dc63aac6SJayamohan Kallickal idx++;
2915dc63aac6SJayamohan Kallickal pasync_ctx->async_data.va_base =
29168a86e833SJayamohan Kallickal mem_descr->mem_array[idx].
29178a86e833SJayamohan Kallickal virtual_address;
29188a86e833SJayamohan Kallickal pasync_ctx->async_data.pa_base.u.
29198a86e833SJayamohan Kallickal a64.address =
2920dc63aac6SJayamohan Kallickal mem_descr->mem_array[idx].
2921dc63aac6SJayamohan Kallickal bus_address.u.a64.address;
29228a86e833SJayamohan Kallickal num_async_data =
29238a86e833SJayamohan Kallickal ((mem_descr->mem_array[idx].
29248a86e833SJayamohan Kallickal size) /
2925dc63aac6SJayamohan Kallickal phba->params.defpdu_data_sz);
2926dc63aac6SJayamohan Kallickal }
29276733b39aSJayamohan Kallickal pasync_data_h->pbuffer =
29286733b39aSJayamohan Kallickal (void *)((unsigned long)
29296733b39aSJayamohan Kallickal (pasync_ctx->async_data.va_base) +
2930dc63aac6SJayamohan Kallickal (p->defpdu_data_sz * num_per_mem));
29316733b39aSJayamohan Kallickal
29326733b39aSJayamohan Kallickal pasync_data_h->pa.u.a64.address =
29338a86e833SJayamohan Kallickal pasync_ctx->async_data.pa_base.u.a64.
29348a86e833SJayamohan Kallickal address + (p->defpdu_data_sz *
29358a86e833SJayamohan Kallickal num_per_mem);
2936dc63aac6SJayamohan Kallickal num_per_mem++;
2937dc63aac6SJayamohan Kallickal num_async_data--;
29386733b39aSJayamohan Kallickal
29391e2931f1SJitendra Bhivare pasync_ctx->async_entry[index].data =
29401e2931f1SJitendra Bhivare pasync_data_h;
29416733b39aSJayamohan Kallickal pasync_data_h++;
29426733b39aSJayamohan Kallickal }
29438a86e833SJayamohan Kallickal }
29448a86e833SJayamohan Kallickal }
2945a7909b39SJayamohan Kallickal
2946a7909b39SJayamohan Kallickal return 0;
29476733b39aSJayamohan Kallickal }
29486733b39aSJayamohan Kallickal
29496733b39aSJayamohan Kallickal static int
be_sgl_create_contiguous(void * virtual_address,u64 physical_address,u32 length,struct be_dma_mem * sgl)29506733b39aSJayamohan Kallickal be_sgl_create_contiguous(void *virtual_address,
29516733b39aSJayamohan Kallickal u64 physical_address, u32 length,
29526733b39aSJayamohan Kallickal struct be_dma_mem *sgl)
29536733b39aSJayamohan Kallickal {
29546733b39aSJayamohan Kallickal WARN_ON(!virtual_address);
29556733b39aSJayamohan Kallickal WARN_ON(!physical_address);
2956dd29dae0STim Gardner WARN_ON(!length);
29576733b39aSJayamohan Kallickal WARN_ON(!sgl);
29586733b39aSJayamohan Kallickal
29596733b39aSJayamohan Kallickal sgl->va = virtual_address;
2960457ff3b7SJayamohan Kallickal sgl->dma = (unsigned long)physical_address;
29616733b39aSJayamohan Kallickal sgl->size = length;
29626733b39aSJayamohan Kallickal
29636733b39aSJayamohan Kallickal return 0;
29646733b39aSJayamohan Kallickal }
29656733b39aSJayamohan Kallickal
be_sgl_destroy_contiguous(struct be_dma_mem * sgl)29666733b39aSJayamohan Kallickal static void be_sgl_destroy_contiguous(struct be_dma_mem *sgl)
29676733b39aSJayamohan Kallickal {
29686733b39aSJayamohan Kallickal memset(sgl, 0, sizeof(*sgl));
29696733b39aSJayamohan Kallickal }
29706733b39aSJayamohan Kallickal
29716733b39aSJayamohan Kallickal static void
hwi_build_be_sgl_arr(struct beiscsi_hba * phba,struct mem_array * pmem,struct be_dma_mem * sgl)29726733b39aSJayamohan Kallickal hwi_build_be_sgl_arr(struct beiscsi_hba *phba,
29736733b39aSJayamohan Kallickal struct mem_array *pmem, struct be_dma_mem *sgl)
29746733b39aSJayamohan Kallickal {
29756733b39aSJayamohan Kallickal if (sgl->va)
29766733b39aSJayamohan Kallickal be_sgl_destroy_contiguous(sgl);
29776733b39aSJayamohan Kallickal
29786733b39aSJayamohan Kallickal be_sgl_create_contiguous(pmem->virtual_address,
29796733b39aSJayamohan Kallickal pmem->bus_address.u.a64.address,
29806733b39aSJayamohan Kallickal pmem->size, sgl);
29816733b39aSJayamohan Kallickal }
29826733b39aSJayamohan Kallickal
29836733b39aSJayamohan Kallickal static void
hwi_build_be_sgl_by_offset(struct beiscsi_hba * phba,struct mem_array * pmem,struct be_dma_mem * sgl)29846733b39aSJayamohan Kallickal hwi_build_be_sgl_by_offset(struct beiscsi_hba *phba,
29856733b39aSJayamohan Kallickal struct mem_array *pmem, struct be_dma_mem *sgl)
29866733b39aSJayamohan Kallickal {
29876733b39aSJayamohan Kallickal if (sgl->va)
29886733b39aSJayamohan Kallickal be_sgl_destroy_contiguous(sgl);
29896733b39aSJayamohan Kallickal
29906733b39aSJayamohan Kallickal be_sgl_create_contiguous((unsigned char *)pmem->virtual_address,
29916733b39aSJayamohan Kallickal pmem->bus_address.u.a64.address,
29926733b39aSJayamohan Kallickal pmem->size, sgl);
29936733b39aSJayamohan Kallickal }
29946733b39aSJayamohan Kallickal
be_fill_queue(struct be_queue_info * q,u16 len,u16 entry_size,void * vaddress)29956733b39aSJayamohan Kallickal static int be_fill_queue(struct be_queue_info *q,
29966733b39aSJayamohan Kallickal u16 len, u16 entry_size, void *vaddress)
29976733b39aSJayamohan Kallickal {
29986733b39aSJayamohan Kallickal struct be_dma_mem *mem = &q->dma_mem;
29996733b39aSJayamohan Kallickal
30006733b39aSJayamohan Kallickal memset(q, 0, sizeof(*q));
30016733b39aSJayamohan Kallickal q->len = len;
30026733b39aSJayamohan Kallickal q->entry_size = entry_size;
30036733b39aSJayamohan Kallickal mem->size = len * entry_size;
30046733b39aSJayamohan Kallickal mem->va = vaddress;
30056733b39aSJayamohan Kallickal if (!mem->va)
30066733b39aSJayamohan Kallickal return -ENOMEM;
30076733b39aSJayamohan Kallickal memset(mem->va, 0, mem->size);
30086733b39aSJayamohan Kallickal return 0;
30096733b39aSJayamohan Kallickal }
30106733b39aSJayamohan Kallickal
beiscsi_create_eqs(struct beiscsi_hba * phba,struct hwi_context_memory * phwi_context)3011bfead3b2SJayamohan Kallickal static int beiscsi_create_eqs(struct beiscsi_hba *phba,
30126733b39aSJayamohan Kallickal struct hwi_context_memory *phwi_context)
30136733b39aSJayamohan Kallickal {
3014deeea8edSChristophe JAILLET int ret = -ENOMEM, eq_for_mcc;
3015bfead3b2SJayamohan Kallickal unsigned int i, num_eq_pages;
30166733b39aSJayamohan Kallickal struct be_queue_info *eq;
30176733b39aSJayamohan Kallickal struct be_dma_mem *mem;
30186733b39aSJayamohan Kallickal void *eq_vaddress;
3019bfead3b2SJayamohan Kallickal dma_addr_t paddr;
30206733b39aSJayamohan Kallickal
3021c7fa2c85SChristophe JAILLET num_eq_pages = PAGES_REQUIRED(phba->params.num_eq_entries *
3022bfead3b2SJayamohan Kallickal sizeof(struct be_eq_entry));
3023bfead3b2SJayamohan Kallickal
302483148866SChristoph Hellwig if (phba->pcidev->msix_enabled)
3025bfead3b2SJayamohan Kallickal eq_for_mcc = 1;
3026bfead3b2SJayamohan Kallickal else
3027bfead3b2SJayamohan Kallickal eq_for_mcc = 0;
3028bfead3b2SJayamohan Kallickal for (i = 0; i < (phba->num_cpus + eq_for_mcc); i++) {
3029bfead3b2SJayamohan Kallickal eq = &phwi_context->be_eq[i].q;
30306733b39aSJayamohan Kallickal mem = &eq->dma_mem;
3031bfead3b2SJayamohan Kallickal phwi_context->be_eq[i].phba = phba;
303226a4c991SChristoph Hellwig eq_vaddress = dma_alloc_coherent(&phba->pcidev->dev,
3033bfead3b2SJayamohan Kallickal num_eq_pages * PAGE_SIZE,
303426a4c991SChristoph Hellwig &paddr, GFP_KERNEL);
303584a261ffSPan Bian if (!eq_vaddress) {
303684a261ffSPan Bian ret = -ENOMEM;
3037bfead3b2SJayamohan Kallickal goto create_eq_error;
303884a261ffSPan Bian }
30396733b39aSJayamohan Kallickal
3040bfead3b2SJayamohan Kallickal mem->va = eq_vaddress;
30416733b39aSJayamohan Kallickal ret = be_fill_queue(eq, phba->params.num_eq_entries,
30426733b39aSJayamohan Kallickal sizeof(struct be_eq_entry), eq_vaddress);
30436733b39aSJayamohan Kallickal if (ret) {
304499bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
304599bc5d55SJohn Soni Jose "BM_%d : be_fill_queue Failed for EQ\n");
3046bfead3b2SJayamohan Kallickal goto create_eq_error;
30476733b39aSJayamohan Kallickal }
30486733b39aSJayamohan Kallickal
3049eeaf06afSDan Carpenter mem->dma = paddr;
30506733b39aSJayamohan Kallickal ret = beiscsi_cmd_eq_create(&phba->ctrl, eq,
305145efc940SJitendra Bhivare BEISCSI_EQ_DELAY_DEF);
30526733b39aSJayamohan Kallickal if (ret) {
305399bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
3054c7fa2c85SChristophe JAILLET "BM_%d : beiscsi_cmd_eq_create Failed for EQ\n");
3055bfead3b2SJayamohan Kallickal goto create_eq_error;
3056bfead3b2SJayamohan Kallickal }
305799bc5d55SJohn Soni Jose
305899bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
305999bc5d55SJohn Soni Jose "BM_%d : eqid = %d\n",
306099bc5d55SJohn Soni Jose phwi_context->be_eq[i].q.id);
3061bfead3b2SJayamohan Kallickal }
3062bfead3b2SJayamohan Kallickal return 0;
3063deeea8edSChristophe JAILLET
3064bfead3b2SJayamohan Kallickal create_eq_error:
3065107dfcbaSJohn Soni Jose for (i = 0; i < (phba->num_cpus + eq_for_mcc); i++) {
3066bfead3b2SJayamohan Kallickal eq = &phwi_context->be_eq[i].q;
3067bfead3b2SJayamohan Kallickal mem = &eq->dma_mem;
3068bfead3b2SJayamohan Kallickal if (mem->va)
306926a4c991SChristoph Hellwig dma_free_coherent(&phba->pcidev->dev, num_eq_pages
3070bfead3b2SJayamohan Kallickal * PAGE_SIZE,
3071bfead3b2SJayamohan Kallickal mem->va, mem->dma);
3072bfead3b2SJayamohan Kallickal }
30736733b39aSJayamohan Kallickal return ret;
30746733b39aSJayamohan Kallickal }
30756733b39aSJayamohan Kallickal
beiscsi_create_cqs(struct beiscsi_hba * phba,struct hwi_context_memory * phwi_context)3076bfead3b2SJayamohan Kallickal static int beiscsi_create_cqs(struct beiscsi_hba *phba,
30776733b39aSJayamohan Kallickal struct hwi_context_memory *phwi_context)
30786733b39aSJayamohan Kallickal {
3079bfead3b2SJayamohan Kallickal unsigned int i, num_cq_pages;
30806733b39aSJayamohan Kallickal struct be_queue_info *cq, *eq;
30816733b39aSJayamohan Kallickal struct be_dma_mem *mem;
3082bfead3b2SJayamohan Kallickal struct be_eq_obj *pbe_eq;
30836733b39aSJayamohan Kallickal void *cq_vaddress;
3084deeea8edSChristophe JAILLET int ret = -ENOMEM;
3085bfead3b2SJayamohan Kallickal dma_addr_t paddr;
30866733b39aSJayamohan Kallickal
3087c7fa2c85SChristophe JAILLET num_cq_pages = PAGES_REQUIRED(phba->params.num_cq_entries *
3088bfead3b2SJayamohan Kallickal sizeof(struct sol_cqe));
3089bfead3b2SJayamohan Kallickal
3090bfead3b2SJayamohan Kallickal for (i = 0; i < phba->num_cpus; i++) {
3091bfead3b2SJayamohan Kallickal cq = &phwi_context->be_cq[i];
3092bfead3b2SJayamohan Kallickal eq = &phwi_context->be_eq[i].q;
3093bfead3b2SJayamohan Kallickal pbe_eq = &phwi_context->be_eq[i];
3094bfead3b2SJayamohan Kallickal pbe_eq->cq = cq;
3095bfead3b2SJayamohan Kallickal pbe_eq->phba = phba;
30966733b39aSJayamohan Kallickal mem = &cq->dma_mem;
309726a4c991SChristoph Hellwig cq_vaddress = dma_alloc_coherent(&phba->pcidev->dev,
3098bfead3b2SJayamohan Kallickal num_cq_pages * PAGE_SIZE,
309926a4c991SChristoph Hellwig &paddr, GFP_KERNEL);
310029b33252SPan Bian if (!cq_vaddress) {
310129b33252SPan Bian ret = -ENOMEM;
3102bfead3b2SJayamohan Kallickal goto create_cq_error;
310329b33252SPan Bian }
3104deeea8edSChristophe JAILLET
31057da50879SJayamohan Kallickal ret = be_fill_queue(cq, phba->params.num_cq_entries,
31066733b39aSJayamohan Kallickal sizeof(struct sol_cqe), cq_vaddress);
31076733b39aSJayamohan Kallickal if (ret) {
310899bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
3109c7fa2c85SChristophe JAILLET "BM_%d : be_fill_queue Failed for ISCSI CQ\n");
3110bfead3b2SJayamohan Kallickal goto create_cq_error;
31116733b39aSJayamohan Kallickal }
31126733b39aSJayamohan Kallickal
3113eeaf06afSDan Carpenter mem->dma = paddr;
3114bfead3b2SJayamohan Kallickal ret = beiscsi_cmd_cq_create(&phba->ctrl, cq, eq, false,
3115bfead3b2SJayamohan Kallickal false, 0);
31166733b39aSJayamohan Kallickal if (ret) {
311799bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
3118c7fa2c85SChristophe JAILLET "BM_%d : beiscsi_cmd_eq_create Failed for ISCSI CQ\n");
3119bfead3b2SJayamohan Kallickal goto create_cq_error;
31206733b39aSJayamohan Kallickal }
312199bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
312299bc5d55SJohn Soni Jose "BM_%d : iscsi cq_id is %d for eq_id %d\n"
312399bc5d55SJohn Soni Jose "iSCSI CQ CREATED\n", cq->id, eq->id);
3124bfead3b2SJayamohan Kallickal }
31256733b39aSJayamohan Kallickal return 0;
3126bfead3b2SJayamohan Kallickal
3127bfead3b2SJayamohan Kallickal create_cq_error:
3128bfead3b2SJayamohan Kallickal for (i = 0; i < phba->num_cpus; i++) {
3129bfead3b2SJayamohan Kallickal cq = &phwi_context->be_cq[i];
3130bfead3b2SJayamohan Kallickal mem = &cq->dma_mem;
3131bfead3b2SJayamohan Kallickal if (mem->va)
313226a4c991SChristoph Hellwig dma_free_coherent(&phba->pcidev->dev, num_cq_pages
3133bfead3b2SJayamohan Kallickal * PAGE_SIZE,
3134bfead3b2SJayamohan Kallickal mem->va, mem->dma);
3135bfead3b2SJayamohan Kallickal }
3136bfead3b2SJayamohan Kallickal return ret;
31376733b39aSJayamohan Kallickal }
31386733b39aSJayamohan Kallickal
31396733b39aSJayamohan Kallickal static int
beiscsi_create_def_hdr(struct beiscsi_hba * phba,struct hwi_context_memory * phwi_context,struct hwi_controller * phwi_ctrlr,unsigned int def_pdu_ring_sz,uint8_t ulp_num)31406733b39aSJayamohan Kallickal beiscsi_create_def_hdr(struct beiscsi_hba *phba,
31416733b39aSJayamohan Kallickal struct hwi_context_memory *phwi_context,
31426733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr,
31438a86e833SJayamohan Kallickal unsigned int def_pdu_ring_sz, uint8_t ulp_num)
31446733b39aSJayamohan Kallickal {
31456733b39aSJayamohan Kallickal unsigned int idx;
31466733b39aSJayamohan Kallickal int ret;
31476733b39aSJayamohan Kallickal struct be_queue_info *dq, *cq;
31486733b39aSJayamohan Kallickal struct be_dma_mem *mem;
31496733b39aSJayamohan Kallickal struct be_mem_descriptor *mem_descr;
31506733b39aSJayamohan Kallickal void *dq_vaddress;
31516733b39aSJayamohan Kallickal
31526733b39aSJayamohan Kallickal idx = 0;
31538a86e833SJayamohan Kallickal dq = &phwi_context->be_def_hdrq[ulp_num];
3154bfead3b2SJayamohan Kallickal cq = &phwi_context->be_cq[0];
31556733b39aSJayamohan Kallickal mem = &dq->dma_mem;
31566733b39aSJayamohan Kallickal mem_descr = phba->init_mem;
31578a86e833SJayamohan Kallickal mem_descr += HWI_MEM_ASYNC_HEADER_RING_ULP0 +
31588a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET);
31596733b39aSJayamohan Kallickal dq_vaddress = mem_descr->mem_array[idx].virtual_address;
31606733b39aSJayamohan Kallickal ret = be_fill_queue(dq, mem_descr->mem_array[0].size /
31616733b39aSJayamohan Kallickal sizeof(struct phys_addr),
31626733b39aSJayamohan Kallickal sizeof(struct phys_addr), dq_vaddress);
31636733b39aSJayamohan Kallickal if (ret) {
316499bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
31658a86e833SJayamohan Kallickal "BM_%d : be_fill_queue Failed for DEF PDU HDR on ULP : %d\n",
31668a86e833SJayamohan Kallickal ulp_num);
31678a86e833SJayamohan Kallickal
31686733b39aSJayamohan Kallickal return ret;
31696733b39aSJayamohan Kallickal }
3170457ff3b7SJayamohan Kallickal mem->dma = (unsigned long)mem_descr->mem_array[idx].
3171457ff3b7SJayamohan Kallickal bus_address.u.a64.address;
31726733b39aSJayamohan Kallickal ret = be_cmd_create_default_pdu_queue(&phba->ctrl, cq, dq,
31736733b39aSJayamohan Kallickal def_pdu_ring_sz,
31748a86e833SJayamohan Kallickal phba->params.defpdu_hdr_sz,
31758a86e833SJayamohan Kallickal BEISCSI_DEFQ_HDR, ulp_num);
31766733b39aSJayamohan Kallickal if (ret) {
317799bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
31788a86e833SJayamohan Kallickal "BM_%d : be_cmd_create_default_pdu_queue Failed DEFHDR on ULP : %d\n",
31798a86e833SJayamohan Kallickal ulp_num);
31808a86e833SJayamohan Kallickal
31816733b39aSJayamohan Kallickal return ret;
31826733b39aSJayamohan Kallickal }
318399bc5d55SJohn Soni Jose
31848a86e833SJayamohan Kallickal beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
31858a86e833SJayamohan Kallickal "BM_%d : iscsi hdr def pdu id for ULP : %d is %d\n",
31868a86e833SJayamohan Kallickal ulp_num,
31878a86e833SJayamohan Kallickal phwi_context->be_def_hdrq[ulp_num].id);
31886733b39aSJayamohan Kallickal return 0;
31896733b39aSJayamohan Kallickal }
31906733b39aSJayamohan Kallickal
31916733b39aSJayamohan Kallickal static int
beiscsi_create_def_data(struct beiscsi_hba * phba,struct hwi_context_memory * phwi_context,struct hwi_controller * phwi_ctrlr,unsigned int def_pdu_ring_sz,uint8_t ulp_num)31926733b39aSJayamohan Kallickal beiscsi_create_def_data(struct beiscsi_hba *phba,
31936733b39aSJayamohan Kallickal struct hwi_context_memory *phwi_context,
31946733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr,
31958a86e833SJayamohan Kallickal unsigned int def_pdu_ring_sz, uint8_t ulp_num)
31966733b39aSJayamohan Kallickal {
31976733b39aSJayamohan Kallickal unsigned int idx;
31986733b39aSJayamohan Kallickal int ret;
31996733b39aSJayamohan Kallickal struct be_queue_info *dataq, *cq;
32006733b39aSJayamohan Kallickal struct be_dma_mem *mem;
32016733b39aSJayamohan Kallickal struct be_mem_descriptor *mem_descr;
32026733b39aSJayamohan Kallickal void *dq_vaddress;
32036733b39aSJayamohan Kallickal
32046733b39aSJayamohan Kallickal idx = 0;
32058a86e833SJayamohan Kallickal dataq = &phwi_context->be_def_dataq[ulp_num];
3206bfead3b2SJayamohan Kallickal cq = &phwi_context->be_cq[0];
32076733b39aSJayamohan Kallickal mem = &dataq->dma_mem;
32086733b39aSJayamohan Kallickal mem_descr = phba->init_mem;
32098a86e833SJayamohan Kallickal mem_descr += HWI_MEM_ASYNC_DATA_RING_ULP0 +
32108a86e833SJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET);
32116733b39aSJayamohan Kallickal dq_vaddress = mem_descr->mem_array[idx].virtual_address;
32126733b39aSJayamohan Kallickal ret = be_fill_queue(dataq, mem_descr->mem_array[0].size /
32136733b39aSJayamohan Kallickal sizeof(struct phys_addr),
32146733b39aSJayamohan Kallickal sizeof(struct phys_addr), dq_vaddress);
32156733b39aSJayamohan Kallickal if (ret) {
321699bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
32178a86e833SJayamohan Kallickal "BM_%d : be_fill_queue Failed for DEF PDU "
32188a86e833SJayamohan Kallickal "DATA on ULP : %d\n",
32198a86e833SJayamohan Kallickal ulp_num);
32208a86e833SJayamohan Kallickal
32216733b39aSJayamohan Kallickal return ret;
32226733b39aSJayamohan Kallickal }
3223457ff3b7SJayamohan Kallickal mem->dma = (unsigned long)mem_descr->mem_array[idx].
3224457ff3b7SJayamohan Kallickal bus_address.u.a64.address;
32256733b39aSJayamohan Kallickal ret = be_cmd_create_default_pdu_queue(&phba->ctrl, cq, dataq,
32266733b39aSJayamohan Kallickal def_pdu_ring_sz,
32278a86e833SJayamohan Kallickal phba->params.defpdu_data_sz,
32288a86e833SJayamohan Kallickal BEISCSI_DEFQ_DATA, ulp_num);
32296733b39aSJayamohan Kallickal if (ret) {
323099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
323199bc5d55SJohn Soni Jose "BM_%d be_cmd_create_default_pdu_queue"
32328a86e833SJayamohan Kallickal " Failed for DEF PDU DATA on ULP : %d\n",
32338a86e833SJayamohan Kallickal ulp_num);
32346733b39aSJayamohan Kallickal return ret;
32356733b39aSJayamohan Kallickal }
323699bc5d55SJohn Soni Jose
323799bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
32388a86e833SJayamohan Kallickal "BM_%d : iscsi def data id on ULP : %d is %d\n",
32398a86e833SJayamohan Kallickal ulp_num,
32408a86e833SJayamohan Kallickal phwi_context->be_def_dataq[ulp_num].id);
32418a86e833SJayamohan Kallickal
32428a86e833SJayamohan Kallickal beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
3243c7fa2c85SChristophe JAILLET "BM_%d : DEFAULT PDU DATA RING CREATED on ULP : %d\n",
3244c7fa2c85SChristophe JAILLET ulp_num);
32456733b39aSJayamohan Kallickal return 0;
32466733b39aSJayamohan Kallickal }
32476733b39aSJayamohan Kallickal
324815a90fe0SJayamohan Kallickal
324915a90fe0SJayamohan Kallickal static int
beiscsi_post_template_hdr(struct beiscsi_hba * phba)325015a90fe0SJayamohan Kallickal beiscsi_post_template_hdr(struct beiscsi_hba *phba)
325115a90fe0SJayamohan Kallickal {
325215a90fe0SJayamohan Kallickal struct be_mem_descriptor *mem_descr;
325315a90fe0SJayamohan Kallickal struct mem_array *pm_arr;
325415a90fe0SJayamohan Kallickal struct be_dma_mem sgl;
3255a129d92fSJayamohan Kallickal int status, ulp_num;
325615a90fe0SJayamohan Kallickal
3257a129d92fSJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
3258a129d92fSJayamohan Kallickal if (test_bit(ulp_num, &phba->fw_config.ulp_supported)) {
3259a129d92fSJayamohan Kallickal mem_descr = (struct be_mem_descriptor *)phba->init_mem;
3260a129d92fSJayamohan Kallickal mem_descr += HWI_MEM_TEMPLATE_HDR_ULP0 +
3261a129d92fSJayamohan Kallickal (ulp_num * MEM_DESCR_OFFSET);
326215a90fe0SJayamohan Kallickal pm_arr = mem_descr->mem_array;
326315a90fe0SJayamohan Kallickal
326415a90fe0SJayamohan Kallickal hwi_build_be_sgl_arr(phba, pm_arr, &sgl);
3265a129d92fSJayamohan Kallickal status = be_cmd_iscsi_post_template_hdr(
3266a129d92fSJayamohan Kallickal &phba->ctrl, &sgl);
326715a90fe0SJayamohan Kallickal
326815a90fe0SJayamohan Kallickal if (status != 0) {
326915a90fe0SJayamohan Kallickal beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
3270a129d92fSJayamohan Kallickal "BM_%d : Post Template HDR Failed for "
3271a129d92fSJayamohan Kallickal "ULP_%d\n", ulp_num);
327215a90fe0SJayamohan Kallickal return status;
327315a90fe0SJayamohan Kallickal }
327415a90fe0SJayamohan Kallickal
327515a90fe0SJayamohan Kallickal beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
3276a129d92fSJayamohan Kallickal "BM_%d : Template HDR Pages Posted for "
3277a129d92fSJayamohan Kallickal "ULP_%d\n", ulp_num);
3278a129d92fSJayamohan Kallickal }
3279a129d92fSJayamohan Kallickal }
328015a90fe0SJayamohan Kallickal return 0;
328115a90fe0SJayamohan Kallickal }
328215a90fe0SJayamohan Kallickal
32836733b39aSJayamohan Kallickal static int
beiscsi_post_pages(struct beiscsi_hba * phba)32846733b39aSJayamohan Kallickal beiscsi_post_pages(struct beiscsi_hba *phba)
32856733b39aSJayamohan Kallickal {
32866733b39aSJayamohan Kallickal struct be_mem_descriptor *mem_descr;
32876733b39aSJayamohan Kallickal struct mem_array *pm_arr;
32886733b39aSJayamohan Kallickal unsigned int page_offset, i;
32896733b39aSJayamohan Kallickal struct be_dma_mem sgl;
3290843ae752SJayamohan Kallickal int status, ulp_num = 0;
32916733b39aSJayamohan Kallickal
32926733b39aSJayamohan Kallickal mem_descr = phba->init_mem;
32936733b39aSJayamohan Kallickal mem_descr += HWI_MEM_SGE;
32946733b39aSJayamohan Kallickal pm_arr = mem_descr->mem_array;
32956733b39aSJayamohan Kallickal
329690622db3SJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++)
329790622db3SJayamohan Kallickal if (test_bit(ulp_num, &phba->fw_config.ulp_supported))
329890622db3SJayamohan Kallickal break;
329990622db3SJayamohan Kallickal
33006733b39aSJayamohan Kallickal page_offset = (sizeof(struct iscsi_sge) * phba->params.num_sge_per_io *
3301843ae752SJayamohan Kallickal phba->fw_config.iscsi_icd_start[ulp_num]) / PAGE_SIZE;
33026733b39aSJayamohan Kallickal for (i = 0; i < mem_descr->num_elements; i++) {
33036733b39aSJayamohan Kallickal hwi_build_be_sgl_arr(phba, pm_arr, &sgl);
33046733b39aSJayamohan Kallickal status = be_cmd_iscsi_post_sgl_pages(&phba->ctrl, &sgl,
33056733b39aSJayamohan Kallickal page_offset,
33066733b39aSJayamohan Kallickal (pm_arr->size / PAGE_SIZE));
33076733b39aSJayamohan Kallickal page_offset += pm_arr->size / PAGE_SIZE;
33086733b39aSJayamohan Kallickal if (status != 0) {
330999bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
331099bc5d55SJohn Soni Jose "BM_%d : post sgl failed.\n");
33116733b39aSJayamohan Kallickal return status;
33126733b39aSJayamohan Kallickal }
33136733b39aSJayamohan Kallickal pm_arr++;
33146733b39aSJayamohan Kallickal }
331599bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
331699bc5d55SJohn Soni Jose "BM_%d : POSTED PAGES\n");
33176733b39aSJayamohan Kallickal return 0;
33186733b39aSJayamohan Kallickal }
33196733b39aSJayamohan Kallickal
be_queue_free(struct beiscsi_hba * phba,struct be_queue_info * q)3320bfead3b2SJayamohan Kallickal static void be_queue_free(struct beiscsi_hba *phba, struct be_queue_info *q)
3321bfead3b2SJayamohan Kallickal {
3322bfead3b2SJayamohan Kallickal struct be_dma_mem *mem = &q->dma_mem;
3323c8b25598SJayamohan Kallickal if (mem->va) {
332426a4c991SChristoph Hellwig dma_free_coherent(&phba->pcidev->dev, mem->size,
3325bfead3b2SJayamohan Kallickal mem->va, mem->dma);
3326c8b25598SJayamohan Kallickal mem->va = NULL;
3327c8b25598SJayamohan Kallickal }
3328bfead3b2SJayamohan Kallickal }
3329bfead3b2SJayamohan Kallickal
be_queue_alloc(struct beiscsi_hba * phba,struct be_queue_info * q,u16 len,u16 entry_size)3330bfead3b2SJayamohan Kallickal static int be_queue_alloc(struct beiscsi_hba *phba, struct be_queue_info *q,
3331bfead3b2SJayamohan Kallickal u16 len, u16 entry_size)
3332bfead3b2SJayamohan Kallickal {
3333bfead3b2SJayamohan Kallickal struct be_dma_mem *mem = &q->dma_mem;
3334bfead3b2SJayamohan Kallickal
3335bfead3b2SJayamohan Kallickal memset(q, 0, sizeof(*q));
3336bfead3b2SJayamohan Kallickal q->len = len;
3337bfead3b2SJayamohan Kallickal q->entry_size = entry_size;
3338bfead3b2SJayamohan Kallickal mem->size = len * entry_size;
3339750afb08SLuis Chamberlain mem->va = dma_alloc_coherent(&phba->pcidev->dev, mem->size, &mem->dma,
334026a4c991SChristoph Hellwig GFP_KERNEL);
3341bfead3b2SJayamohan Kallickal if (!mem->va)
3342d3ad2bb3SJayamohan Kallickal return -ENOMEM;
3343bfead3b2SJayamohan Kallickal return 0;
3344bfead3b2SJayamohan Kallickal }
3345bfead3b2SJayamohan Kallickal
33466733b39aSJayamohan Kallickal static int
beiscsi_create_wrb_rings(struct beiscsi_hba * phba,struct hwi_context_memory * phwi_context,struct hwi_controller * phwi_ctrlr)33476733b39aSJayamohan Kallickal beiscsi_create_wrb_rings(struct beiscsi_hba *phba,
33486733b39aSJayamohan Kallickal struct hwi_context_memory *phwi_context,
33496733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr)
33506733b39aSJayamohan Kallickal {
3351fa1261c4SJitendra Bhivare unsigned int num_wrb_rings;
33526733b39aSJayamohan Kallickal u64 pa_addr_lo;
33534eea99d5SJayamohan Kallickal unsigned int idx, num, i, ulp_num;
33546733b39aSJayamohan Kallickal struct mem_array *pwrb_arr;
33556733b39aSJayamohan Kallickal void *wrb_vaddr;
33566733b39aSJayamohan Kallickal struct be_dma_mem sgl;
33576733b39aSJayamohan Kallickal struct be_mem_descriptor *mem_descr;
3358a7909b39SJayamohan Kallickal struct hwi_wrb_context *pwrb_context;
33596733b39aSJayamohan Kallickal int status;
33604eea99d5SJayamohan Kallickal uint8_t ulp_count = 0, ulp_base_num = 0;
33614eea99d5SJayamohan Kallickal uint16_t cid_count_ulp[BEISCSI_ULP_COUNT] = { 0 };
33626733b39aSJayamohan Kallickal
33636733b39aSJayamohan Kallickal idx = 0;
33646733b39aSJayamohan Kallickal mem_descr = phba->init_mem;
33656733b39aSJayamohan Kallickal mem_descr += HWI_MEM_WRB;
33666da2ec56SKees Cook pwrb_arr = kmalloc_array(phba->params.cxns_per_ctrl,
33676da2ec56SKees Cook sizeof(*pwrb_arr),
33686733b39aSJayamohan Kallickal GFP_KERNEL);
33696733b39aSJayamohan Kallickal if (!pwrb_arr) {
337099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
337199bc5d55SJohn Soni Jose "BM_%d : Memory alloc failed in create wrb ring.\n");
33726733b39aSJayamohan Kallickal return -ENOMEM;
33736733b39aSJayamohan Kallickal }
33746733b39aSJayamohan Kallickal wrb_vaddr = mem_descr->mem_array[idx].virtual_address;
33756733b39aSJayamohan Kallickal pa_addr_lo = mem_descr->mem_array[idx].bus_address.u.a64.address;
33766733b39aSJayamohan Kallickal num_wrb_rings = mem_descr->mem_array[idx].size /
33776733b39aSJayamohan Kallickal (phba->params.wrbs_per_cxn * sizeof(struct iscsi_wrb));
33786733b39aSJayamohan Kallickal
33796733b39aSJayamohan Kallickal for (num = 0; num < phba->params.cxns_per_ctrl; num++) {
33806733b39aSJayamohan Kallickal if (num_wrb_rings) {
33816733b39aSJayamohan Kallickal pwrb_arr[num].virtual_address = wrb_vaddr;
33826733b39aSJayamohan Kallickal pwrb_arr[num].bus_address.u.a64.address = pa_addr_lo;
33836733b39aSJayamohan Kallickal pwrb_arr[num].size = phba->params.wrbs_per_cxn *
33846733b39aSJayamohan Kallickal sizeof(struct iscsi_wrb);
33856733b39aSJayamohan Kallickal wrb_vaddr += pwrb_arr[num].size;
33866733b39aSJayamohan Kallickal pa_addr_lo += pwrb_arr[num].size;
33876733b39aSJayamohan Kallickal num_wrb_rings--;
33886733b39aSJayamohan Kallickal } else {
33896733b39aSJayamohan Kallickal idx++;
33906733b39aSJayamohan Kallickal wrb_vaddr = mem_descr->mem_array[idx].virtual_address;
3391c7fa2c85SChristophe JAILLET pa_addr_lo = mem_descr->mem_array[idx].
33926733b39aSJayamohan Kallickal bus_address.u.a64.address;
33936733b39aSJayamohan Kallickal num_wrb_rings = mem_descr->mem_array[idx].size /
33946733b39aSJayamohan Kallickal (phba->params.wrbs_per_cxn *
33956733b39aSJayamohan Kallickal sizeof(struct iscsi_wrb));
33966733b39aSJayamohan Kallickal pwrb_arr[num].virtual_address = wrb_vaddr;
3397c7fa2c85SChristophe JAILLET pwrb_arr[num].bus_address.u.a64.address = pa_addr_lo;
33986733b39aSJayamohan Kallickal pwrb_arr[num].size = phba->params.wrbs_per_cxn *
33996733b39aSJayamohan Kallickal sizeof(struct iscsi_wrb);
34006733b39aSJayamohan Kallickal wrb_vaddr += pwrb_arr[num].size;
34016733b39aSJayamohan Kallickal pa_addr_lo += pwrb_arr[num].size;
34026733b39aSJayamohan Kallickal num_wrb_rings--;
34036733b39aSJayamohan Kallickal }
34046733b39aSJayamohan Kallickal }
34054eea99d5SJayamohan Kallickal
34064eea99d5SJayamohan Kallickal /* Get the ULP Count */
34074eea99d5SJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++)
34084eea99d5SJayamohan Kallickal if (test_bit(ulp_num, &phba->fw_config.ulp_supported)) {
34094eea99d5SJayamohan Kallickal ulp_count++;
34104eea99d5SJayamohan Kallickal ulp_base_num = ulp_num;
34114eea99d5SJayamohan Kallickal cid_count_ulp[ulp_num] =
34124eea99d5SJayamohan Kallickal BEISCSI_GET_CID_COUNT(phba, ulp_num);
34134eea99d5SJayamohan Kallickal }
34144eea99d5SJayamohan Kallickal
34156733b39aSJayamohan Kallickal for (i = 0; i < phba->params.cxns_per_ctrl; i++) {
34164eea99d5SJayamohan Kallickal if (ulp_count > 1) {
34174eea99d5SJayamohan Kallickal ulp_base_num = (ulp_base_num + 1) % BEISCSI_ULP_COUNT;
34184eea99d5SJayamohan Kallickal
34194eea99d5SJayamohan Kallickal if (!cid_count_ulp[ulp_base_num])
34204eea99d5SJayamohan Kallickal ulp_base_num = (ulp_base_num + 1) %
34214eea99d5SJayamohan Kallickal BEISCSI_ULP_COUNT;
34224eea99d5SJayamohan Kallickal
34234eea99d5SJayamohan Kallickal cid_count_ulp[ulp_base_num]--;
34244eea99d5SJayamohan Kallickal }
34254eea99d5SJayamohan Kallickal
34264eea99d5SJayamohan Kallickal
34276733b39aSJayamohan Kallickal hwi_build_be_sgl_by_offset(phba, &pwrb_arr[i], &sgl);
34286733b39aSJayamohan Kallickal status = be_cmd_wrbq_create(&phba->ctrl, &sgl,
34294eea99d5SJayamohan Kallickal &phwi_context->be_wrbq[i],
34304eea99d5SJayamohan Kallickal &phwi_ctrlr->wrb_context[i],
34314eea99d5SJayamohan Kallickal ulp_base_num);
34326733b39aSJayamohan Kallickal if (status != 0) {
343399bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
343499bc5d55SJohn Soni Jose "BM_%d : wrbq create failed.");
34351462b8ffSDan Carpenter kfree(pwrb_arr);
34366733b39aSJayamohan Kallickal return status;
34376733b39aSJayamohan Kallickal }
3438a7909b39SJayamohan Kallickal pwrb_context = &phwi_ctrlr->wrb_context[i];
3439a7909b39SJayamohan Kallickal BE_SET_CID_TO_CRI(i, pwrb_context->cid);
34406733b39aSJayamohan Kallickal }
34416733b39aSJayamohan Kallickal kfree(pwrb_arr);
34426733b39aSJayamohan Kallickal return 0;
34436733b39aSJayamohan Kallickal }
34446733b39aSJayamohan Kallickal
free_wrb_handles(struct beiscsi_hba * phba)34456733b39aSJayamohan Kallickal static void free_wrb_handles(struct beiscsi_hba *phba)
34466733b39aSJayamohan Kallickal {
34476733b39aSJayamohan Kallickal unsigned int index;
34486733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
34496733b39aSJayamohan Kallickal struct hwi_wrb_context *pwrb_context;
34506733b39aSJayamohan Kallickal
34516733b39aSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
3452a7909b39SJayamohan Kallickal for (index = 0; index < phba->params.cxns_per_ctrl; index++) {
34536733b39aSJayamohan Kallickal pwrb_context = &phwi_ctrlr->wrb_context[index];
34546733b39aSJayamohan Kallickal kfree(pwrb_context->pwrb_handle_base);
34556733b39aSJayamohan Kallickal kfree(pwrb_context->pwrb_handle_basestd);
34566733b39aSJayamohan Kallickal }
34576733b39aSJayamohan Kallickal }
34586733b39aSJayamohan Kallickal
be_mcc_queues_destroy(struct beiscsi_hba * phba)3459bfead3b2SJayamohan Kallickal static void be_mcc_queues_destroy(struct beiscsi_hba *phba)
3460bfead3b2SJayamohan Kallickal {
3461bfead3b2SJayamohan Kallickal struct be_ctrl_info *ctrl = &phba->ctrl;
3462d1d5ca88SJitendra Bhivare struct be_dma_mem *ptag_mem;
3463d1d5ca88SJitendra Bhivare struct be_queue_info *q;
3464d1d5ca88SJitendra Bhivare int i, tag;
3465bfead3b2SJayamohan Kallickal
3466bfead3b2SJayamohan Kallickal q = &phba->ctrl.mcc_obj.q;
3467d1d5ca88SJitendra Bhivare for (i = 0; i < MAX_MCC_CMD; i++) {
3468d1d5ca88SJitendra Bhivare tag = i + 1;
3469d1d5ca88SJitendra Bhivare if (!test_bit(MCC_TAG_STATE_RUNNING,
3470d1d5ca88SJitendra Bhivare &ctrl->ptag_state[tag].tag_state))
3471d1d5ca88SJitendra Bhivare continue;
3472d1d5ca88SJitendra Bhivare
3473d1d5ca88SJitendra Bhivare if (test_bit(MCC_TAG_STATE_TIMEOUT,
3474d1d5ca88SJitendra Bhivare &ctrl->ptag_state[tag].tag_state)) {
3475d1d5ca88SJitendra Bhivare ptag_mem = &ctrl->ptag_state[tag].tag_mem_state;
3476d1d5ca88SJitendra Bhivare if (ptag_mem->size) {
347726a4c991SChristoph Hellwig dma_free_coherent(&ctrl->pdev->dev,
3478d1d5ca88SJitendra Bhivare ptag_mem->size,
3479d1d5ca88SJitendra Bhivare ptag_mem->va,
3480d1d5ca88SJitendra Bhivare ptag_mem->dma);
3481d1d5ca88SJitendra Bhivare ptag_mem->size = 0;
3482d1d5ca88SJitendra Bhivare }
3483d1d5ca88SJitendra Bhivare continue;
3484d1d5ca88SJitendra Bhivare }
3485d1d5ca88SJitendra Bhivare /**
3486d1d5ca88SJitendra Bhivare * If MCC is still active and waiting then wake up the process.
3487d1d5ca88SJitendra Bhivare * We are here only because port is going offline. The process
3488d1d5ca88SJitendra Bhivare * sees that (BEISCSI_HBA_ONLINE is cleared) and EIO error is
3489d1d5ca88SJitendra Bhivare * returned for the operation and allocated memory cleaned up.
3490d1d5ca88SJitendra Bhivare */
3491d1d5ca88SJitendra Bhivare if (waitqueue_active(&ctrl->mcc_wait[tag])) {
3492d1d5ca88SJitendra Bhivare ctrl->mcc_tag_status[tag] = MCC_STATUS_FAILED;
3493d1d5ca88SJitendra Bhivare ctrl->mcc_tag_status[tag] |= CQE_VALID_MASK;
3494d1d5ca88SJitendra Bhivare wake_up_interruptible(&ctrl->mcc_wait[tag]);
3495d1d5ca88SJitendra Bhivare /*
3496d1d5ca88SJitendra Bhivare * Control tag info gets reinitialized in enable
3497d1d5ca88SJitendra Bhivare * so wait for the process to clear running state.
3498d1d5ca88SJitendra Bhivare */
3499d1d5ca88SJitendra Bhivare while (test_bit(MCC_TAG_STATE_RUNNING,
3500d1d5ca88SJitendra Bhivare &ctrl->ptag_state[tag].tag_state))
3501d1d5ca88SJitendra Bhivare schedule_timeout_uninterruptible(HZ);
3502d1d5ca88SJitendra Bhivare }
3503d1d5ca88SJitendra Bhivare /**
3504d1d5ca88SJitendra Bhivare * For MCC with tag_states MCC_TAG_STATE_ASYNC and
3505d1d5ca88SJitendra Bhivare * MCC_TAG_STATE_IGNORE nothing needs to done.
3506d1d5ca88SJitendra Bhivare */
3507d1d5ca88SJitendra Bhivare }
35084e2bdf7aSJohn Soni Jose if (q->created) {
3509bfead3b2SJayamohan Kallickal beiscsi_cmd_q_destroy(ctrl, q, QTYPE_MCCQ);
3510bfead3b2SJayamohan Kallickal be_queue_free(phba, q);
35114e2bdf7aSJohn Soni Jose }
3512bfead3b2SJayamohan Kallickal
3513bfead3b2SJayamohan Kallickal q = &phba->ctrl.mcc_obj.cq;
35144e2bdf7aSJohn Soni Jose if (q->created) {
3515bfead3b2SJayamohan Kallickal beiscsi_cmd_q_destroy(ctrl, q, QTYPE_CQ);
3516bfead3b2SJayamohan Kallickal be_queue_free(phba, q);
3517bfead3b2SJayamohan Kallickal }
35184e2bdf7aSJohn Soni Jose }
3519bfead3b2SJayamohan Kallickal
be_mcc_queues_create(struct beiscsi_hba * phba,struct hwi_context_memory * phwi_context)3520bfead3b2SJayamohan Kallickal static int be_mcc_queues_create(struct beiscsi_hba *phba,
3521bfead3b2SJayamohan Kallickal struct hwi_context_memory *phwi_context)
3522bfead3b2SJayamohan Kallickal {
3523bfead3b2SJayamohan Kallickal struct be_queue_info *q, *cq;
3524bfead3b2SJayamohan Kallickal struct be_ctrl_info *ctrl = &phba->ctrl;
3525bfead3b2SJayamohan Kallickal
3526bfead3b2SJayamohan Kallickal /* Alloc MCC compl queue */
3527bfead3b2SJayamohan Kallickal cq = &phba->ctrl.mcc_obj.cq;
3528bfead3b2SJayamohan Kallickal if (be_queue_alloc(phba, cq, MCC_CQ_LEN,
3529bfead3b2SJayamohan Kallickal sizeof(struct be_mcc_compl)))
3530bfead3b2SJayamohan Kallickal goto err;
3531bfead3b2SJayamohan Kallickal /* Ask BE to create MCC compl queue; */
353283148866SChristoph Hellwig if (phba->pcidev->msix_enabled) {
353345efc940SJitendra Bhivare if (beiscsi_cmd_cq_create(ctrl, cq,
353445efc940SJitendra Bhivare &phwi_context->be_eq[phba->num_cpus].q,
353545efc940SJitendra Bhivare false, true, 0))
3536bfead3b2SJayamohan Kallickal goto mcc_cq_free;
3537bfead3b2SJayamohan Kallickal } else {
3538bfead3b2SJayamohan Kallickal if (beiscsi_cmd_cq_create(ctrl, cq, &phwi_context->be_eq[0].q,
3539bfead3b2SJayamohan Kallickal false, true, 0))
3540bfead3b2SJayamohan Kallickal goto mcc_cq_free;
3541bfead3b2SJayamohan Kallickal }
3542bfead3b2SJayamohan Kallickal
3543bfead3b2SJayamohan Kallickal /* Alloc MCC queue */
3544bfead3b2SJayamohan Kallickal q = &phba->ctrl.mcc_obj.q;
3545bfead3b2SJayamohan Kallickal if (be_queue_alloc(phba, q, MCC_Q_LEN, sizeof(struct be_mcc_wrb)))
3546bfead3b2SJayamohan Kallickal goto mcc_cq_destroy;
3547bfead3b2SJayamohan Kallickal
3548bfead3b2SJayamohan Kallickal /* Ask BE to create MCC queue */
354935e66019SJayamohan Kallickal if (beiscsi_cmd_mccq_create(phba, q, cq))
3550bfead3b2SJayamohan Kallickal goto mcc_q_free;
3551bfead3b2SJayamohan Kallickal
3552bfead3b2SJayamohan Kallickal return 0;
3553bfead3b2SJayamohan Kallickal
3554bfead3b2SJayamohan Kallickal mcc_q_free:
3555bfead3b2SJayamohan Kallickal be_queue_free(phba, q);
3556bfead3b2SJayamohan Kallickal mcc_cq_destroy:
3557bfead3b2SJayamohan Kallickal beiscsi_cmd_q_destroy(ctrl, cq, QTYPE_CQ);
3558bfead3b2SJayamohan Kallickal mcc_cq_free:
3559bfead3b2SJayamohan Kallickal be_queue_free(phba, cq);
3560bfead3b2SJayamohan Kallickal err:
3561d3ad2bb3SJayamohan Kallickal return -ENOMEM;
3562bfead3b2SJayamohan Kallickal }
3563bfead3b2SJayamohan Kallickal
be2iscsi_enable_msix(struct beiscsi_hba * phba)356483148866SChristoph Hellwig static void be2iscsi_enable_msix(struct beiscsi_hba *phba)
3565bfead3b2SJayamohan Kallickal {
356683148866SChristoph Hellwig int nvec = 1;
3567bfead3b2SJayamohan Kallickal
356822abeef0SJohn Soni Jose switch (phba->generation) {
356922abeef0SJohn Soni Jose case BE_GEN2:
357022abeef0SJohn Soni Jose case BE_GEN3:
357183148866SChristoph Hellwig nvec = BEISCSI_MAX_NUM_CPUS + 1;
357222abeef0SJohn Soni Jose break;
357322abeef0SJohn Soni Jose case BE_GEN4:
357483148866SChristoph Hellwig nvec = phba->fw_config.eqid_count;
357522abeef0SJohn Soni Jose break;
357622abeef0SJohn Soni Jose default:
357783148866SChristoph Hellwig nvec = 2;
357883148866SChristoph Hellwig break;
357922abeef0SJohn Soni Jose }
358083148866SChristoph Hellwig
358183148866SChristoph Hellwig /* if eqid_count == 1 fall back to INTX */
358283148866SChristoph Hellwig if (enable_msix && nvec > 1) {
3583c66d4bd1SMing Lei struct irq_affinity desc = { .post_vectors = 1 };
358483148866SChristoph Hellwig
358583148866SChristoph Hellwig if (pci_alloc_irq_vectors_affinity(phba->pcidev, 2, nvec,
358683148866SChristoph Hellwig PCI_IRQ_MSIX | PCI_IRQ_AFFINITY, &desc) < 0) {
358783148866SChristoph Hellwig phba->num_cpus = nvec - 1;
358883148866SChristoph Hellwig return;
358983148866SChristoph Hellwig }
359083148866SChristoph Hellwig }
359183148866SChristoph Hellwig
359283148866SChristoph Hellwig phba->num_cpus = 1;
3593bfead3b2SJayamohan Kallickal }
35946733b39aSJayamohan Kallickal
hwi_purge_eq(struct beiscsi_hba * phba)3595d1d5ca88SJitendra Bhivare static void hwi_purge_eq(struct beiscsi_hba *phba)
3596d1d5ca88SJitendra Bhivare {
3597d1d5ca88SJitendra Bhivare struct hwi_controller *phwi_ctrlr;
3598d1d5ca88SJitendra Bhivare struct hwi_context_memory *phwi_context;
3599d1d5ca88SJitendra Bhivare struct be_queue_info *eq;
3600d1d5ca88SJitendra Bhivare struct be_eq_entry *eqe = NULL;
3601d1d5ca88SJitendra Bhivare int i, eq_msix;
3602d1d5ca88SJitendra Bhivare unsigned int num_processed;
3603d1d5ca88SJitendra Bhivare
3604d1d5ca88SJitendra Bhivare if (beiscsi_hba_in_error(phba))
3605d1d5ca88SJitendra Bhivare return;
3606d1d5ca88SJitendra Bhivare
3607d1d5ca88SJitendra Bhivare phwi_ctrlr = phba->phwi_ctrlr;
3608d1d5ca88SJitendra Bhivare phwi_context = phwi_ctrlr->phwi_ctxt;
360983148866SChristoph Hellwig if (phba->pcidev->msix_enabled)
3610d1d5ca88SJitendra Bhivare eq_msix = 1;
3611d1d5ca88SJitendra Bhivare else
3612d1d5ca88SJitendra Bhivare eq_msix = 0;
3613d1d5ca88SJitendra Bhivare
3614d1d5ca88SJitendra Bhivare for (i = 0; i < (phba->num_cpus + eq_msix); i++) {
3615d1d5ca88SJitendra Bhivare eq = &phwi_context->be_eq[i].q;
3616d1d5ca88SJitendra Bhivare eqe = queue_tail_node(eq);
3617d1d5ca88SJitendra Bhivare num_processed = 0;
3618d1d5ca88SJitendra Bhivare while (eqe->dw[offsetof(struct amap_eq_entry, valid) / 32]
3619d1d5ca88SJitendra Bhivare & EQE_VALID_MASK) {
3620d1d5ca88SJitendra Bhivare AMAP_SET_BITS(struct amap_eq_entry, valid, eqe, 0);
3621d1d5ca88SJitendra Bhivare queue_tail_inc(eq);
3622d1d5ca88SJitendra Bhivare eqe = queue_tail_node(eq);
3623d1d5ca88SJitendra Bhivare num_processed++;
3624d1d5ca88SJitendra Bhivare }
3625d1d5ca88SJitendra Bhivare
3626d1d5ca88SJitendra Bhivare if (num_processed)
3627d1d5ca88SJitendra Bhivare hwi_ring_eq_db(phba, eq->id, 1, num_processed, 1, 1);
3628d1d5ca88SJitendra Bhivare }
3629d1d5ca88SJitendra Bhivare }
3630d1d5ca88SJitendra Bhivare
hwi_cleanup_port(struct beiscsi_hba * phba)3631d1d5ca88SJitendra Bhivare static void hwi_cleanup_port(struct beiscsi_hba *phba)
3632d1d5ca88SJitendra Bhivare {
3633d1d5ca88SJitendra Bhivare struct be_queue_info *q;
3634d1d5ca88SJitendra Bhivare struct be_ctrl_info *ctrl = &phba->ctrl;
3635d1d5ca88SJitendra Bhivare struct hwi_controller *phwi_ctrlr;
3636d1d5ca88SJitendra Bhivare struct hwi_context_memory *phwi_context;
3637d1d5ca88SJitendra Bhivare int i, eq_for_mcc, ulp_num;
3638d1d5ca88SJitendra Bhivare
3639d1d5ca88SJitendra Bhivare for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++)
3640d1d5ca88SJitendra Bhivare if (test_bit(ulp_num, &phba->fw_config.ulp_supported))
3641d1d5ca88SJitendra Bhivare beiscsi_cmd_iscsi_cleanup(phba, ulp_num);
3642d1d5ca88SJitendra Bhivare
3643d1d5ca88SJitendra Bhivare /**
3644d1d5ca88SJitendra Bhivare * Purge all EQ entries that may have been left out. This is to
3645d1d5ca88SJitendra Bhivare * workaround a problem we've seen occasionally where driver gets an
3646d1d5ca88SJitendra Bhivare * interrupt with EQ entry bit set after stopping the controller.
3647d1d5ca88SJitendra Bhivare */
3648d1d5ca88SJitendra Bhivare hwi_purge_eq(phba);
3649d1d5ca88SJitendra Bhivare
3650d1d5ca88SJitendra Bhivare phwi_ctrlr = phba->phwi_ctrlr;
3651d1d5ca88SJitendra Bhivare phwi_context = phwi_ctrlr->phwi_ctxt;
3652d1d5ca88SJitendra Bhivare
3653d1d5ca88SJitendra Bhivare be_cmd_iscsi_remove_template_hdr(ctrl);
3654d1d5ca88SJitendra Bhivare
3655d1d5ca88SJitendra Bhivare for (i = 0; i < phba->params.cxns_per_ctrl; i++) {
3656d1d5ca88SJitendra Bhivare q = &phwi_context->be_wrbq[i];
3657d1d5ca88SJitendra Bhivare if (q->created)
3658d1d5ca88SJitendra Bhivare beiscsi_cmd_q_destroy(ctrl, q, QTYPE_WRBQ);
3659d1d5ca88SJitendra Bhivare }
3660d1d5ca88SJitendra Bhivare kfree(phwi_context->be_wrbq);
3661d1d5ca88SJitendra Bhivare free_wrb_handles(phba);
3662d1d5ca88SJitendra Bhivare
3663d1d5ca88SJitendra Bhivare for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
3664d1d5ca88SJitendra Bhivare if (test_bit(ulp_num, &phba->fw_config.ulp_supported)) {
3665d1d5ca88SJitendra Bhivare
3666d1d5ca88SJitendra Bhivare q = &phwi_context->be_def_hdrq[ulp_num];
3667d1d5ca88SJitendra Bhivare if (q->created)
3668d1d5ca88SJitendra Bhivare beiscsi_cmd_q_destroy(ctrl, q, QTYPE_DPDUQ);
3669d1d5ca88SJitendra Bhivare
3670d1d5ca88SJitendra Bhivare q = &phwi_context->be_def_dataq[ulp_num];
3671d1d5ca88SJitendra Bhivare if (q->created)
3672d1d5ca88SJitendra Bhivare beiscsi_cmd_q_destroy(ctrl, q, QTYPE_DPDUQ);
3673d1d5ca88SJitendra Bhivare }
3674d1d5ca88SJitendra Bhivare }
3675d1d5ca88SJitendra Bhivare
3676d1d5ca88SJitendra Bhivare beiscsi_cmd_q_destroy(ctrl, NULL, QTYPE_SGL);
3677d1d5ca88SJitendra Bhivare
3678d1d5ca88SJitendra Bhivare for (i = 0; i < (phba->num_cpus); i++) {
3679d1d5ca88SJitendra Bhivare q = &phwi_context->be_cq[i];
3680d1d5ca88SJitendra Bhivare if (q->created) {
3681d1d5ca88SJitendra Bhivare be_queue_free(phba, q);
3682d1d5ca88SJitendra Bhivare beiscsi_cmd_q_destroy(ctrl, q, QTYPE_CQ);
3683d1d5ca88SJitendra Bhivare }
3684d1d5ca88SJitendra Bhivare }
3685d1d5ca88SJitendra Bhivare
3686d1d5ca88SJitendra Bhivare be_mcc_queues_destroy(phba);
368783148866SChristoph Hellwig if (phba->pcidev->msix_enabled)
3688d1d5ca88SJitendra Bhivare eq_for_mcc = 1;
3689d1d5ca88SJitendra Bhivare else
3690d1d5ca88SJitendra Bhivare eq_for_mcc = 0;
3691d1d5ca88SJitendra Bhivare for (i = 0; i < (phba->num_cpus + eq_for_mcc); i++) {
3692d1d5ca88SJitendra Bhivare q = &phwi_context->be_eq[i].q;
3693d1d5ca88SJitendra Bhivare if (q->created) {
3694d1d5ca88SJitendra Bhivare be_queue_free(phba, q);
3695d1d5ca88SJitendra Bhivare beiscsi_cmd_q_destroy(ctrl, q, QTYPE_EQ);
3696d1d5ca88SJitendra Bhivare }
3697d1d5ca88SJitendra Bhivare }
36984ee1ec42SJitendra Bhivare /* this ensures complete FW cleanup */
36994ee1ec42SJitendra Bhivare beiscsi_cmd_function_reset(phba);
3700d1d5ca88SJitendra Bhivare /* last communication, indicate driver is unloading */
3701d1d5ca88SJitendra Bhivare beiscsi_cmd_special_wrb(&phba->ctrl, 0);
3702d1d5ca88SJitendra Bhivare }
37034ee1ec42SJitendra Bhivare
hwi_init_port(struct beiscsi_hba * phba)37046733b39aSJayamohan Kallickal static int hwi_init_port(struct beiscsi_hba *phba)
37056733b39aSJayamohan Kallickal {
37066733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
37076733b39aSJayamohan Kallickal struct hwi_context_memory *phwi_context;
37086733b39aSJayamohan Kallickal unsigned int def_pdu_ring_sz;
37096733b39aSJayamohan Kallickal struct be_ctrl_info *ctrl = &phba->ctrl;
37108a86e833SJayamohan Kallickal int status, ulp_num;
37111e2931f1SJitendra Bhivare u16 nbufs;
37126733b39aSJayamohan Kallickal
37136733b39aSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
37146733b39aSJayamohan Kallickal phwi_context = phwi_ctrlr->phwi_ctxt;
37154d2ee1e6SJitendra Bhivare /* set port optic state to unknown */
371653aefe25SJitendra Bhivare phba->optic_state = 0xff;
3717bfead3b2SJayamohan Kallickal
3718bfead3b2SJayamohan Kallickal status = beiscsi_create_eqs(phba, phwi_context);
37196733b39aSJayamohan Kallickal if (status != 0) {
372099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
372199bc5d55SJohn Soni Jose "BM_%d : EQ not created\n");
37226733b39aSJayamohan Kallickal goto error;
37236733b39aSJayamohan Kallickal }
37246733b39aSJayamohan Kallickal
3725bfead3b2SJayamohan Kallickal status = be_mcc_queues_create(phba, phwi_context);
3726bfead3b2SJayamohan Kallickal if (status != 0)
3727bfead3b2SJayamohan Kallickal goto error;
3728bfead3b2SJayamohan Kallickal
3729480195c2SJitendra Bhivare status = beiscsi_check_supported_fw(ctrl, phba);
37306733b39aSJayamohan Kallickal if (status != 0) {
373199bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
373299bc5d55SJohn Soni Jose "BM_%d : Unsupported fw version\n");
37336733b39aSJayamohan Kallickal goto error;
37346733b39aSJayamohan Kallickal }
37356733b39aSJayamohan Kallickal
3736bfead3b2SJayamohan Kallickal status = beiscsi_create_cqs(phba, phwi_context);
37376733b39aSJayamohan Kallickal if (status != 0) {
373899bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
373999bc5d55SJohn Soni Jose "BM_%d : CQ not created\n");
37406733b39aSJayamohan Kallickal goto error;
37416733b39aSJayamohan Kallickal }
37426733b39aSJayamohan Kallickal
37438a86e833SJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
37448a86e833SJayamohan Kallickal if (test_bit(ulp_num, &phba->fw_config.ulp_supported)) {
37451e2931f1SJitendra Bhivare nbufs = phwi_context->pasync_ctx[ulp_num]->num_entries;
37461e2931f1SJitendra Bhivare def_pdu_ring_sz = nbufs * sizeof(struct phys_addr);
37478a86e833SJayamohan Kallickal
37488a86e833SJayamohan Kallickal status = beiscsi_create_def_hdr(phba, phwi_context,
37498a86e833SJayamohan Kallickal phwi_ctrlr,
37508a86e833SJayamohan Kallickal def_pdu_ring_sz,
37518a86e833SJayamohan Kallickal ulp_num);
37526733b39aSJayamohan Kallickal if (status != 0) {
375399bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
37548a86e833SJayamohan Kallickal "BM_%d : Default Header not created for ULP : %d\n",
37558a86e833SJayamohan Kallickal ulp_num);
37566733b39aSJayamohan Kallickal goto error;
37576733b39aSJayamohan Kallickal }
37586733b39aSJayamohan Kallickal
37596733b39aSJayamohan Kallickal status = beiscsi_create_def_data(phba, phwi_context,
37608a86e833SJayamohan Kallickal phwi_ctrlr,
37618a86e833SJayamohan Kallickal def_pdu_ring_sz,
37628a86e833SJayamohan Kallickal ulp_num);
37636733b39aSJayamohan Kallickal if (status != 0) {
376499bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
37658a86e833SJayamohan Kallickal "BM_%d : Default Data not created for ULP : %d\n",
37668a86e833SJayamohan Kallickal ulp_num);
37676733b39aSJayamohan Kallickal goto error;
37686733b39aSJayamohan Kallickal }
3769f79929deSJitendra Bhivare /**
3770f79929deSJitendra Bhivare * Now that the default PDU rings have been created,
3771f79929deSJitendra Bhivare * let EP know about it.
3772f79929deSJitendra Bhivare */
3773938f372cSJitendra Bhivare beiscsi_hdq_post_handles(phba, BEISCSI_DEFQ_HDR,
37741e2931f1SJitendra Bhivare ulp_num, nbufs);
3775938f372cSJitendra Bhivare beiscsi_hdq_post_handles(phba, BEISCSI_DEFQ_DATA,
37761e2931f1SJitendra Bhivare ulp_num, nbufs);
37778a86e833SJayamohan Kallickal }
37788a86e833SJayamohan Kallickal }
37796733b39aSJayamohan Kallickal
37806733b39aSJayamohan Kallickal status = beiscsi_post_pages(phba);
37816733b39aSJayamohan Kallickal if (status != 0) {
378299bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
378399bc5d55SJohn Soni Jose "BM_%d : Post SGL Pages Failed\n");
37846733b39aSJayamohan Kallickal goto error;
37856733b39aSJayamohan Kallickal }
37866733b39aSJayamohan Kallickal
378715a90fe0SJayamohan Kallickal status = beiscsi_post_template_hdr(phba);
378815a90fe0SJayamohan Kallickal if (status != 0) {
378915a90fe0SJayamohan Kallickal beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
379015a90fe0SJayamohan Kallickal "BM_%d : Template HDR Posting for CXN Failed\n");
379115a90fe0SJayamohan Kallickal }
379215a90fe0SJayamohan Kallickal
37936733b39aSJayamohan Kallickal status = beiscsi_create_wrb_rings(phba, phwi_context, phwi_ctrlr);
37946733b39aSJayamohan Kallickal if (status != 0) {
379599bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
379699bc5d55SJohn Soni Jose "BM_%d : WRB Rings not created\n");
37976733b39aSJayamohan Kallickal goto error;
37986733b39aSJayamohan Kallickal }
37996733b39aSJayamohan Kallickal
38008a86e833SJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
38018a86e833SJayamohan Kallickal uint16_t async_arr_idx = 0;
38028a86e833SJayamohan Kallickal
38038a86e833SJayamohan Kallickal if (test_bit(ulp_num, &phba->fw_config.ulp_supported)) {
38048a86e833SJayamohan Kallickal uint16_t cri = 0;
3805938f372cSJitendra Bhivare struct hd_async_context *pasync_ctx;
38068a86e833SJayamohan Kallickal
38078a86e833SJayamohan Kallickal pasync_ctx = HWI_GET_ASYNC_PDU_CTX(
38088a86e833SJayamohan Kallickal phwi_ctrlr, ulp_num);
38098a86e833SJayamohan Kallickal for (cri = 0; cri <
38108a86e833SJayamohan Kallickal phba->params.cxns_per_ctrl; cri++) {
38118a86e833SJayamohan Kallickal if (ulp_num == BEISCSI_GET_ULP_FROM_CRI
38128a86e833SJayamohan Kallickal (phwi_ctrlr, cri))
38138a86e833SJayamohan Kallickal pasync_ctx->cid_to_async_cri_map[
38148a86e833SJayamohan Kallickal phwi_ctrlr->wrb_context[cri].cid] =
38158a86e833SJayamohan Kallickal async_arr_idx++;
38168a86e833SJayamohan Kallickal }
38178a86e833SJayamohan Kallickal }
38188a86e833SJayamohan Kallickal }
38198a86e833SJayamohan Kallickal
382099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
382199bc5d55SJohn Soni Jose "BM_%d : hwi_init_port success\n");
38226733b39aSJayamohan Kallickal return 0;
38236733b39aSJayamohan Kallickal
38246733b39aSJayamohan Kallickal error:
382599bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
382699bc5d55SJohn Soni Jose "BM_%d : hwi_init_port failed");
38274d2ee1e6SJitendra Bhivare hwi_cleanup_port(phba);
3828a49e06d5SJayamohan Kallickal return status;
38296733b39aSJayamohan Kallickal }
38306733b39aSJayamohan Kallickal
hwi_init_controller(struct beiscsi_hba * phba)38316733b39aSJayamohan Kallickal static int hwi_init_controller(struct beiscsi_hba *phba)
38326733b39aSJayamohan Kallickal {
38336733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
38346733b39aSJayamohan Kallickal
38356733b39aSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
38366733b39aSJayamohan Kallickal if (1 == phba->init_mem[HWI_MEM_ADDN_CONTEXT].num_elements) {
38376733b39aSJayamohan Kallickal phwi_ctrlr->phwi_ctxt = (struct hwi_context_memory *)phba->
38386733b39aSJayamohan Kallickal init_mem[HWI_MEM_ADDN_CONTEXT].mem_array[0].virtual_address;
383999bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
384099bc5d55SJohn Soni Jose "BM_%d : phwi_ctrlr->phwi_ctxt=%p\n",
38416733b39aSJayamohan Kallickal phwi_ctrlr->phwi_ctxt);
38426733b39aSJayamohan Kallickal } else {
384399bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
384499bc5d55SJohn Soni Jose "BM_%d : HWI_MEM_ADDN_CONTEXT is more "
384599bc5d55SJohn Soni Jose "than one element.Failing to load\n");
38466733b39aSJayamohan Kallickal return -ENOMEM;
38476733b39aSJayamohan Kallickal }
38486733b39aSJayamohan Kallickal
38496733b39aSJayamohan Kallickal iscsi_init_global_templates(phba);
38503ec78271SJayamohan Kallickal if (beiscsi_init_wrb_handle(phba))
38513ec78271SJayamohan Kallickal return -ENOMEM;
38523ec78271SJayamohan Kallickal
3853a7909b39SJayamohan Kallickal if (hwi_init_async_pdu_ctx(phba)) {
3854a7909b39SJayamohan Kallickal beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
3855a7909b39SJayamohan Kallickal "BM_%d : hwi_init_async_pdu_ctx failed\n");
3856a7909b39SJayamohan Kallickal return -ENOMEM;
3857a7909b39SJayamohan Kallickal }
3858a7909b39SJayamohan Kallickal
38596733b39aSJayamohan Kallickal if (hwi_init_port(phba) != 0) {
386099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
386199bc5d55SJohn Soni Jose "BM_%d : hwi_init_controller failed\n");
386299bc5d55SJohn Soni Jose
38636733b39aSJayamohan Kallickal return -ENOMEM;
38646733b39aSJayamohan Kallickal }
38656733b39aSJayamohan Kallickal return 0;
38666733b39aSJayamohan Kallickal }
38676733b39aSJayamohan Kallickal
beiscsi_free_mem(struct beiscsi_hba * phba)38686733b39aSJayamohan Kallickal static void beiscsi_free_mem(struct beiscsi_hba *phba)
38696733b39aSJayamohan Kallickal {
38706733b39aSJayamohan Kallickal struct be_mem_descriptor *mem_descr;
38716733b39aSJayamohan Kallickal int i, j;
38726733b39aSJayamohan Kallickal
38736733b39aSJayamohan Kallickal mem_descr = phba->init_mem;
38746733b39aSJayamohan Kallickal for (i = 0; i < SE_MEM_MAX; i++) {
38756733b39aSJayamohan Kallickal for (j = mem_descr->num_elements; j > 0; j--) {
387626a4c991SChristoph Hellwig dma_free_coherent(&phba->pcidev->dev,
38776733b39aSJayamohan Kallickal mem_descr->mem_array[j - 1].size,
38786733b39aSJayamohan Kallickal mem_descr->mem_array[j - 1].virtual_address,
3879457ff3b7SJayamohan Kallickal (unsigned long)mem_descr->mem_array[j - 1].
3880457ff3b7SJayamohan Kallickal bus_address.u.a64.address);
38816733b39aSJayamohan Kallickal }
38828a86e833SJayamohan Kallickal
38836733b39aSJayamohan Kallickal kfree(mem_descr->mem_array);
38846733b39aSJayamohan Kallickal mem_descr++;
38856733b39aSJayamohan Kallickal }
38866733b39aSJayamohan Kallickal kfree(phba->init_mem);
3887a7909b39SJayamohan Kallickal kfree(phba->phwi_ctrlr->wrb_context);
38886733b39aSJayamohan Kallickal kfree(phba->phwi_ctrlr);
38896733b39aSJayamohan Kallickal }
38906733b39aSJayamohan Kallickal
beiscsi_init_sgl_handle(struct beiscsi_hba * phba)38916733b39aSJayamohan Kallickal static int beiscsi_init_sgl_handle(struct beiscsi_hba *phba)
38926733b39aSJayamohan Kallickal {
38936733b39aSJayamohan Kallickal struct be_mem_descriptor *mem_descr_sglh, *mem_descr_sg;
38946733b39aSJayamohan Kallickal struct sgl_handle *psgl_handle;
38956733b39aSJayamohan Kallickal struct iscsi_sge *pfrag;
389690622db3SJayamohan Kallickal unsigned int arr_index, i, idx;
389790622db3SJayamohan Kallickal unsigned int ulp_icd_start, ulp_num = 0;
38986733b39aSJayamohan Kallickal
38996733b39aSJayamohan Kallickal phba->io_sgl_hndl_avbl = 0;
39006733b39aSJayamohan Kallickal phba->eh_sgl_hndl_avbl = 0;
3901bfead3b2SJayamohan Kallickal
39026733b39aSJayamohan Kallickal mem_descr_sglh = phba->init_mem;
39036733b39aSJayamohan Kallickal mem_descr_sglh += HWI_MEM_SGLH;
39046733b39aSJayamohan Kallickal if (1 == mem_descr_sglh->num_elements) {
39056396bb22SKees Cook phba->io_sgl_hndl_base = kcalloc(phba->params.ios_per_ctrl,
39066396bb22SKees Cook sizeof(struct sgl_handle *),
39076733b39aSJayamohan Kallickal GFP_KERNEL);
39086733b39aSJayamohan Kallickal if (!phba->io_sgl_hndl_base) {
390999bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
391099bc5d55SJohn Soni Jose "BM_%d : Mem Alloc Failed. Failing to load\n");
39116733b39aSJayamohan Kallickal return -ENOMEM;
39126733b39aSJayamohan Kallickal }
39136396bb22SKees Cook phba->eh_sgl_hndl_base =
39146396bb22SKees Cook kcalloc(phba->params.icds_per_ctrl -
39156396bb22SKees Cook phba->params.ios_per_ctrl,
39166396bb22SKees Cook sizeof(struct sgl_handle *), GFP_KERNEL);
39176733b39aSJayamohan Kallickal if (!phba->eh_sgl_hndl_base) {
39186733b39aSJayamohan Kallickal kfree(phba->io_sgl_hndl_base);
391999bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
392099bc5d55SJohn Soni Jose "BM_%d : Mem Alloc Failed. Failing to load\n");
39216733b39aSJayamohan Kallickal return -ENOMEM;
39226733b39aSJayamohan Kallickal }
39236733b39aSJayamohan Kallickal } else {
392499bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
392599bc5d55SJohn Soni Jose "BM_%d : HWI_MEM_SGLH is more than one element."
39266733b39aSJayamohan Kallickal "Failing to load\n");
39276733b39aSJayamohan Kallickal return -ENOMEM;
39286733b39aSJayamohan Kallickal }
39296733b39aSJayamohan Kallickal
39306733b39aSJayamohan Kallickal arr_index = 0;
39316733b39aSJayamohan Kallickal idx = 0;
39326733b39aSJayamohan Kallickal while (idx < mem_descr_sglh->num_elements) {
39336733b39aSJayamohan Kallickal psgl_handle = mem_descr_sglh->mem_array[idx].virtual_address;
39346733b39aSJayamohan Kallickal
39356733b39aSJayamohan Kallickal for (i = 0; i < (mem_descr_sglh->mem_array[idx].size /
39366733b39aSJayamohan Kallickal sizeof(struct sgl_handle)); i++) {
39376733b39aSJayamohan Kallickal if (arr_index < phba->params.ios_per_ctrl) {
39386733b39aSJayamohan Kallickal phba->io_sgl_hndl_base[arr_index] = psgl_handle;
39396733b39aSJayamohan Kallickal phba->io_sgl_hndl_avbl++;
39406733b39aSJayamohan Kallickal arr_index++;
39416733b39aSJayamohan Kallickal } else {
39426733b39aSJayamohan Kallickal phba->eh_sgl_hndl_base[arr_index -
39436733b39aSJayamohan Kallickal phba->params.ios_per_ctrl] =
39446733b39aSJayamohan Kallickal psgl_handle;
39456733b39aSJayamohan Kallickal arr_index++;
39466733b39aSJayamohan Kallickal phba->eh_sgl_hndl_avbl++;
39476733b39aSJayamohan Kallickal }
39486733b39aSJayamohan Kallickal psgl_handle++;
39496733b39aSJayamohan Kallickal }
39506733b39aSJayamohan Kallickal idx++;
39516733b39aSJayamohan Kallickal }
395299bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
395399bc5d55SJohn Soni Jose "BM_%d : phba->io_sgl_hndl_avbl=%d "
39546733b39aSJayamohan Kallickal "phba->eh_sgl_hndl_avbl=%d\n",
39556733b39aSJayamohan Kallickal phba->io_sgl_hndl_avbl,
39566733b39aSJayamohan Kallickal phba->eh_sgl_hndl_avbl);
395799bc5d55SJohn Soni Jose
39586733b39aSJayamohan Kallickal mem_descr_sg = phba->init_mem;
39596733b39aSJayamohan Kallickal mem_descr_sg += HWI_MEM_SGE;
396099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
396199bc5d55SJohn Soni Jose "\n BM_%d : mem_descr_sg->num_elements=%d\n",
39626733b39aSJayamohan Kallickal mem_descr_sg->num_elements);
396399bc5d55SJohn Soni Jose
396490622db3SJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++)
396590622db3SJayamohan Kallickal if (test_bit(ulp_num, &phba->fw_config.ulp_supported))
396690622db3SJayamohan Kallickal break;
396790622db3SJayamohan Kallickal
396890622db3SJayamohan Kallickal ulp_icd_start = phba->fw_config.iscsi_icd_start[ulp_num];
396990622db3SJayamohan Kallickal
39706733b39aSJayamohan Kallickal arr_index = 0;
39716733b39aSJayamohan Kallickal idx = 0;
39726733b39aSJayamohan Kallickal while (idx < mem_descr_sg->num_elements) {
39736733b39aSJayamohan Kallickal pfrag = mem_descr_sg->mem_array[idx].virtual_address;
39746733b39aSJayamohan Kallickal
39756733b39aSJayamohan Kallickal for (i = 0;
39766733b39aSJayamohan Kallickal i < (mem_descr_sg->mem_array[idx].size) /
39776733b39aSJayamohan Kallickal (sizeof(struct iscsi_sge) * phba->params.num_sge_per_io);
39786733b39aSJayamohan Kallickal i++) {
39796733b39aSJayamohan Kallickal if (arr_index < phba->params.ios_per_ctrl)
39806733b39aSJayamohan Kallickal psgl_handle = phba->io_sgl_hndl_base[arr_index];
39816733b39aSJayamohan Kallickal else
39826733b39aSJayamohan Kallickal psgl_handle = phba->eh_sgl_hndl_base[arr_index -
39836733b39aSJayamohan Kallickal phba->params.ios_per_ctrl];
39846733b39aSJayamohan Kallickal psgl_handle->pfrag = pfrag;
39856733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, addr_hi, pfrag, 0);
39866733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_sge, addr_lo, pfrag, 0);
39876733b39aSJayamohan Kallickal pfrag += phba->params.num_sge_per_io;
398890622db3SJayamohan Kallickal psgl_handle->sgl_index = ulp_icd_start + arr_index++;
39896733b39aSJayamohan Kallickal }
39906733b39aSJayamohan Kallickal idx++;
39916733b39aSJayamohan Kallickal }
39926733b39aSJayamohan Kallickal phba->io_sgl_free_index = 0;
39936733b39aSJayamohan Kallickal phba->io_sgl_alloc_index = 0;
39946733b39aSJayamohan Kallickal phba->eh_sgl_free_index = 0;
39956733b39aSJayamohan Kallickal phba->eh_sgl_alloc_index = 0;
39966733b39aSJayamohan Kallickal return 0;
39976733b39aSJayamohan Kallickal }
39986733b39aSJayamohan Kallickal
hba_setup_cid_tbls(struct beiscsi_hba * phba)39996733b39aSJayamohan Kallickal static int hba_setup_cid_tbls(struct beiscsi_hba *phba)
40006733b39aSJayamohan Kallickal {
40010a3db7c0SJayamohan Kallickal int ret;
40020a3db7c0SJayamohan Kallickal uint16_t i, ulp_num;
40030a3db7c0SJayamohan Kallickal struct ulp_cid_info *ptr_cid_info = NULL;
40046733b39aSJayamohan Kallickal
40050a3db7c0SJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
40060a3db7c0SJayamohan Kallickal if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) {
40070a3db7c0SJayamohan Kallickal ptr_cid_info = kzalloc(sizeof(struct ulp_cid_info),
40086733b39aSJayamohan Kallickal GFP_KERNEL);
40090a3db7c0SJayamohan Kallickal
40100a3db7c0SJayamohan Kallickal if (!ptr_cid_info) {
40110a3db7c0SJayamohan Kallickal ret = -ENOMEM;
40120a3db7c0SJayamohan Kallickal goto free_memory;
40130a3db7c0SJayamohan Kallickal }
40140a3db7c0SJayamohan Kallickal
40150a3db7c0SJayamohan Kallickal /* Allocate memory for CID array */
4016413f3656SJitendra Bhivare ptr_cid_info->cid_array =
4017413f3656SJitendra Bhivare kcalloc(BEISCSI_GET_CID_COUNT(phba, ulp_num),
4018413f3656SJitendra Bhivare sizeof(*ptr_cid_info->cid_array),
4019413f3656SJitendra Bhivare GFP_KERNEL);
40200a3db7c0SJayamohan Kallickal if (!ptr_cid_info->cid_array) {
40210a3db7c0SJayamohan Kallickal kfree(ptr_cid_info);
40220a3db7c0SJayamohan Kallickal ptr_cid_info = NULL;
40230a3db7c0SJayamohan Kallickal ret = -ENOMEM;
40240a3db7c0SJayamohan Kallickal
40250a3db7c0SJayamohan Kallickal goto free_memory;
40260a3db7c0SJayamohan Kallickal }
40270a3db7c0SJayamohan Kallickal ptr_cid_info->avlbl_cids = BEISCSI_GET_CID_COUNT(
40280a3db7c0SJayamohan Kallickal phba, ulp_num);
40290a3db7c0SJayamohan Kallickal
40300a3db7c0SJayamohan Kallickal /* Save the cid_info_array ptr */
40310a3db7c0SJayamohan Kallickal phba->cid_array_info[ulp_num] = ptr_cid_info;
40320a3db7c0SJayamohan Kallickal }
40336733b39aSJayamohan Kallickal }
40346396bb22SKees Cook phba->ep_array = kcalloc(phba->params.cxns_per_ctrl,
40356396bb22SKees Cook sizeof(struct iscsi_endpoint *),
40366396bb22SKees Cook GFP_KERNEL);
40376733b39aSJayamohan Kallickal if (!phba->ep_array) {
40380a3db7c0SJayamohan Kallickal ret = -ENOMEM;
40390a3db7c0SJayamohan Kallickal
40400a3db7c0SJayamohan Kallickal goto free_memory;
40416733b39aSJayamohan Kallickal }
4042a7909b39SJayamohan Kallickal
40436396bb22SKees Cook phba->conn_table = kcalloc(phba->params.cxns_per_ctrl,
40446396bb22SKees Cook sizeof(struct beiscsi_conn *),
40456396bb22SKees Cook GFP_KERNEL);
4046a7909b39SJayamohan Kallickal if (!phba->conn_table) {
4047a7909b39SJayamohan Kallickal kfree(phba->ep_array);
4048a7909b39SJayamohan Kallickal phba->ep_array = NULL;
40490a3db7c0SJayamohan Kallickal ret = -ENOMEM;
40505f2d25efSTomas Henzl
40515f2d25efSTomas Henzl goto free_memory;
40526733b39aSJayamohan Kallickal }
4053a7909b39SJayamohan Kallickal
40540a3db7c0SJayamohan Kallickal for (i = 0; i < phba->params.cxns_per_ctrl; i++) {
40550a3db7c0SJayamohan Kallickal ulp_num = phba->phwi_ctrlr->wrb_context[i].ulp_num;
4056a7909b39SJayamohan Kallickal
40570a3db7c0SJayamohan Kallickal ptr_cid_info = phba->cid_array_info[ulp_num];
40580a3db7c0SJayamohan Kallickal ptr_cid_info->cid_array[ptr_cid_info->cid_alloc++] =
40590a3db7c0SJayamohan Kallickal phba->phwi_ctrlr->wrb_context[i].cid;
40600a3db7c0SJayamohan Kallickal
40610a3db7c0SJayamohan Kallickal }
40620a3db7c0SJayamohan Kallickal
40630a3db7c0SJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
40640a3db7c0SJayamohan Kallickal if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) {
40650a3db7c0SJayamohan Kallickal ptr_cid_info = phba->cid_array_info[ulp_num];
40660a3db7c0SJayamohan Kallickal
40670a3db7c0SJayamohan Kallickal ptr_cid_info->cid_alloc = 0;
40680a3db7c0SJayamohan Kallickal ptr_cid_info->cid_free = 0;
40690a3db7c0SJayamohan Kallickal }
40700a3db7c0SJayamohan Kallickal }
40716733b39aSJayamohan Kallickal return 0;
40720a3db7c0SJayamohan Kallickal
40730a3db7c0SJayamohan Kallickal free_memory:
40740a3db7c0SJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
40750a3db7c0SJayamohan Kallickal if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) {
40760a3db7c0SJayamohan Kallickal ptr_cid_info = phba->cid_array_info[ulp_num];
40770a3db7c0SJayamohan Kallickal
40780a3db7c0SJayamohan Kallickal if (ptr_cid_info) {
40790a3db7c0SJayamohan Kallickal kfree(ptr_cid_info->cid_array);
40800a3db7c0SJayamohan Kallickal kfree(ptr_cid_info);
40810a3db7c0SJayamohan Kallickal phba->cid_array_info[ulp_num] = NULL;
40820a3db7c0SJayamohan Kallickal }
40830a3db7c0SJayamohan Kallickal }
40840a3db7c0SJayamohan Kallickal }
40850a3db7c0SJayamohan Kallickal
40860a3db7c0SJayamohan Kallickal return ret;
40876733b39aSJayamohan Kallickal }
40886733b39aSJayamohan Kallickal
hwi_enable_intr(struct beiscsi_hba * phba)4089238f6b72SJayamohan Kallickal static void hwi_enable_intr(struct beiscsi_hba *phba)
40906733b39aSJayamohan Kallickal {
40916733b39aSJayamohan Kallickal struct be_ctrl_info *ctrl = &phba->ctrl;
40926733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
40936733b39aSJayamohan Kallickal struct hwi_context_memory *phwi_context;
40946733b39aSJayamohan Kallickal struct be_queue_info *eq;
40956733b39aSJayamohan Kallickal u8 __iomem *addr;
4096bfead3b2SJayamohan Kallickal u32 reg, i;
40976733b39aSJayamohan Kallickal u32 enabled;
40986733b39aSJayamohan Kallickal
40996733b39aSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
41006733b39aSJayamohan Kallickal phwi_context = phwi_ctrlr->phwi_ctxt;
41016733b39aSJayamohan Kallickal
41026733b39aSJayamohan Kallickal addr = (u8 __iomem *) ((u8 __iomem *) ctrl->pcicfg +
41036733b39aSJayamohan Kallickal PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET);
41046733b39aSJayamohan Kallickal reg = ioread32(addr);
41056733b39aSJayamohan Kallickal
41066733b39aSJayamohan Kallickal enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
41076733b39aSJayamohan Kallickal if (!enabled) {
41086733b39aSJayamohan Kallickal reg |= MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
410999bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
411099bc5d55SJohn Soni Jose "BM_%d : reg =x%08x addr=%p\n", reg, addr);
41116733b39aSJayamohan Kallickal iowrite32(reg, addr);
4112665d6d94SJayamohan Kallickal }
4113665d6d94SJayamohan Kallickal
411483148866SChristoph Hellwig if (!phba->pcidev->msix_enabled) {
4115c03af1aeSJayamohan Kallickal eq = &phwi_context->be_eq[0].q;
411699bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
411799bc5d55SJohn Soni Jose "BM_%d : eq->id=%d\n", eq->id);
411899bc5d55SJohn Soni Jose
4119c03af1aeSJayamohan Kallickal hwi_ring_eq_db(phba, eq->id, 0, 0, 1, 1);
4120c03af1aeSJayamohan Kallickal } else {
4121bfead3b2SJayamohan Kallickal for (i = 0; i <= phba->num_cpus; i++) {
4122bfead3b2SJayamohan Kallickal eq = &phwi_context->be_eq[i].q;
412399bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
412499bc5d55SJohn Soni Jose "BM_%d : eq->id=%d\n", eq->id);
41256733b39aSJayamohan Kallickal hwi_ring_eq_db(phba, eq->id, 0, 0, 1, 1);
4126bfead3b2SJayamohan Kallickal }
4127c03af1aeSJayamohan Kallickal }
4128c03af1aeSJayamohan Kallickal }
41296733b39aSJayamohan Kallickal
hwi_disable_intr(struct beiscsi_hba * phba)41306733b39aSJayamohan Kallickal static void hwi_disable_intr(struct beiscsi_hba *phba)
41316733b39aSJayamohan Kallickal {
41326733b39aSJayamohan Kallickal struct be_ctrl_info *ctrl = &phba->ctrl;
41336733b39aSJayamohan Kallickal
41346733b39aSJayamohan Kallickal u8 __iomem *addr = ctrl->pcicfg + PCICFG_MEMBAR_CTRL_INT_CTRL_OFFSET;
41356733b39aSJayamohan Kallickal u32 reg = ioread32(addr);
41366733b39aSJayamohan Kallickal
41376733b39aSJayamohan Kallickal u32 enabled = reg & MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
41386733b39aSJayamohan Kallickal if (enabled) {
41396733b39aSJayamohan Kallickal reg &= ~MEMBAR_CTRL_INT_CTRL_HOSTINTR_MASK;
41406733b39aSJayamohan Kallickal iowrite32(reg, addr);
41416733b39aSJayamohan Kallickal } else
414299bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT,
414399bc5d55SJohn Soni Jose "BM_%d : In hwi_disable_intr, Already Disabled\n");
41446733b39aSJayamohan Kallickal }
41456733b39aSJayamohan Kallickal
beiscsi_init_port(struct beiscsi_hba * phba)41466733b39aSJayamohan Kallickal static int beiscsi_init_port(struct beiscsi_hba *phba)
41476733b39aSJayamohan Kallickal {
41486733b39aSJayamohan Kallickal int ret;
41496733b39aSJayamohan Kallickal
4150dd940972SJitendra Bhivare ret = hwi_init_controller(phba);
41516733b39aSJayamohan Kallickal if (ret < 0) {
415299bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
4153dd940972SJitendra Bhivare "BM_%d : init controller failed\n");
41546733b39aSJayamohan Kallickal return ret;
41556733b39aSJayamohan Kallickal }
41566733b39aSJayamohan Kallickal ret = beiscsi_init_sgl_handle(phba);
41576733b39aSJayamohan Kallickal if (ret < 0) {
415899bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
4159dd940972SJitendra Bhivare "BM_%d : init sgl handles failed\n");
4160dd940972SJitendra Bhivare goto cleanup_port;
41616733b39aSJayamohan Kallickal }
41626733b39aSJayamohan Kallickal
4163deeea8edSChristophe JAILLET ret = hba_setup_cid_tbls(phba);
4164deeea8edSChristophe JAILLET if (ret < 0) {
416599bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
4166dd940972SJitendra Bhivare "BM_%d : setup CID table failed\n");
41676733b39aSJayamohan Kallickal kfree(phba->io_sgl_hndl_base);
41686733b39aSJayamohan Kallickal kfree(phba->eh_sgl_hndl_base);
4169dd940972SJitendra Bhivare goto cleanup_port;
41706733b39aSJayamohan Kallickal }
41716733b39aSJayamohan Kallickal return ret;
41726733b39aSJayamohan Kallickal
4173dd940972SJitendra Bhivare cleanup_port:
41744d2ee1e6SJitendra Bhivare hwi_cleanup_port(phba);
41756733b39aSJayamohan Kallickal return ret;
41766733b39aSJayamohan Kallickal }
41776733b39aSJayamohan Kallickal
beiscsi_cleanup_port(struct beiscsi_hba * phba)41784d2ee1e6SJitendra Bhivare static void beiscsi_cleanup_port(struct beiscsi_hba *phba)
41796733b39aSJayamohan Kallickal {
41800a3db7c0SJayamohan Kallickal struct ulp_cid_info *ptr_cid_info = NULL;
4181f79929deSJitendra Bhivare int ulp_num;
41826733b39aSJayamohan Kallickal
41836733b39aSJayamohan Kallickal kfree(phba->io_sgl_hndl_base);
41846733b39aSJayamohan Kallickal kfree(phba->eh_sgl_hndl_base);
41856733b39aSJayamohan Kallickal kfree(phba->ep_array);
4186a7909b39SJayamohan Kallickal kfree(phba->conn_table);
41870a3db7c0SJayamohan Kallickal
41880a3db7c0SJayamohan Kallickal for (ulp_num = 0; ulp_num < BEISCSI_ULP_COUNT; ulp_num++) {
41890a3db7c0SJayamohan Kallickal if (test_bit(ulp_num, (void *)&phba->fw_config.ulp_supported)) {
41900a3db7c0SJayamohan Kallickal ptr_cid_info = phba->cid_array_info[ulp_num];
41910a3db7c0SJayamohan Kallickal
41920a3db7c0SJayamohan Kallickal if (ptr_cid_info) {
41930a3db7c0SJayamohan Kallickal kfree(ptr_cid_info->cid_array);
41940a3db7c0SJayamohan Kallickal kfree(ptr_cid_info);
41950a3db7c0SJayamohan Kallickal phba->cid_array_info[ulp_num] = NULL;
41960a3db7c0SJayamohan Kallickal }
41970a3db7c0SJayamohan Kallickal }
41980a3db7c0SJayamohan Kallickal }
41996733b39aSJayamohan Kallickal }
42006733b39aSJayamohan Kallickal
4201d629c471SJohn Soni Jose /**
420243f388b0SJayamohan Kallickal * beiscsi_free_mgmt_task_handles()- Free driver CXN resources
420343f388b0SJayamohan Kallickal * @beiscsi_conn: ptr to the conn to be cleaned up
42044a4a11b9SJayamohan Kallickal * @task: ptr to iscsi_task resource to be freed.
420543f388b0SJayamohan Kallickal *
420643f388b0SJayamohan Kallickal * Free driver mgmt resources binded to CXN.
420743f388b0SJayamohan Kallickal **/
420843f388b0SJayamohan Kallickal void
beiscsi_free_mgmt_task_handles(struct beiscsi_conn * beiscsi_conn,struct iscsi_task * task)42094a4a11b9SJayamohan Kallickal beiscsi_free_mgmt_task_handles(struct beiscsi_conn *beiscsi_conn,
42104a4a11b9SJayamohan Kallickal struct iscsi_task *task)
421143f388b0SJayamohan Kallickal {
421243f388b0SJayamohan Kallickal struct beiscsi_io_task *io_task;
421343f388b0SJayamohan Kallickal struct beiscsi_hba *phba = beiscsi_conn->phba;
421443f388b0SJayamohan Kallickal struct hwi_wrb_context *pwrb_context;
421543f388b0SJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
4216a7909b39SJayamohan Kallickal uint16_t cri_index = BE_GET_CRI_FROM_CID(
4217a7909b39SJayamohan Kallickal beiscsi_conn->beiscsi_conn_cid);
421843f388b0SJayamohan Kallickal
421943f388b0SJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
4220a7909b39SJayamohan Kallickal pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
4221a7909b39SJayamohan Kallickal
42224a4a11b9SJayamohan Kallickal io_task = task->dd_data;
422343f388b0SJayamohan Kallickal
422443f388b0SJayamohan Kallickal if (io_task->pwrb_handle) {
4225e1f9d31eSJitendra Bhivare free_wrb_handle(phba, pwrb_context, io_task->pwrb_handle);
422643f388b0SJayamohan Kallickal io_task->pwrb_handle = NULL;
422743f388b0SJayamohan Kallickal }
422843f388b0SJayamohan Kallickal
422943f388b0SJayamohan Kallickal if (io_task->psgl_handle) {
4230e1f9d31eSJitendra Bhivare free_mgmt_sgl_handle(phba, io_task->psgl_handle);
423143f388b0SJayamohan Kallickal io_task->psgl_handle = NULL;
423243f388b0SJayamohan Kallickal }
423343f388b0SJayamohan Kallickal
4234eb1c4692SJohn Soni Jose if (io_task->mtask_addr) {
423526a4c991SChristoph Hellwig dma_unmap_single(&phba->pcidev->dev,
423643f388b0SJayamohan Kallickal io_task->mtask_addr,
423743f388b0SJayamohan Kallickal io_task->mtask_data_count,
423826a4c991SChristoph Hellwig DMA_TO_DEVICE);
4239eb1c4692SJohn Soni Jose io_task->mtask_addr = 0;
4240eb1c4692SJohn Soni Jose }
424143f388b0SJayamohan Kallickal }
424243f388b0SJayamohan Kallickal
424343f388b0SJayamohan Kallickal /**
4244d629c471SJohn Soni Jose * beiscsi_cleanup_task()- Free driver resources of the task
4245d629c471SJohn Soni Jose * @task: ptr to the iscsi task
4246d629c471SJohn Soni Jose *
4247d629c471SJohn Soni Jose **/
beiscsi_cleanup_task(struct iscsi_task * task)42481282ab76SMike Christie static void beiscsi_cleanup_task(struct iscsi_task *task)
42491282ab76SMike Christie {
42501282ab76SMike Christie struct beiscsi_io_task *io_task = task->dd_data;
42511282ab76SMike Christie struct iscsi_conn *conn = task->conn;
42521282ab76SMike Christie struct beiscsi_conn *beiscsi_conn = conn->dd_data;
42531282ab76SMike Christie struct beiscsi_hba *phba = beiscsi_conn->phba;
42541282ab76SMike Christie struct beiscsi_session *beiscsi_sess = beiscsi_conn->beiscsi_sess;
42551282ab76SMike Christie struct hwi_wrb_context *pwrb_context;
42561282ab76SMike Christie struct hwi_controller *phwi_ctrlr;
4257a7909b39SJayamohan Kallickal uint16_t cri_index = BE_GET_CRI_FROM_CID(
4258a7909b39SJayamohan Kallickal beiscsi_conn->beiscsi_conn_cid);
42591282ab76SMike Christie
42601282ab76SMike Christie phwi_ctrlr = phba->phwi_ctrlr;
4261a7909b39SJayamohan Kallickal pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
42621282ab76SMike Christie
42631282ab76SMike Christie if (io_task->cmd_bhs) {
4264af007b02SRomain Perier dma_pool_free(beiscsi_sess->bhs_pool, io_task->cmd_bhs,
42651282ab76SMike Christie io_task->bhs_pa.u.a64.address);
42661282ab76SMike Christie io_task->cmd_bhs = NULL;
4267e1f9d31eSJitendra Bhivare task->hdr = NULL;
42681282ab76SMike Christie }
42691282ab76SMike Christie
42701282ab76SMike Christie if (task->sc) {
42711282ab76SMike Christie if (io_task->pwrb_handle) {
42721282ab76SMike Christie free_wrb_handle(phba, pwrb_context,
42731282ab76SMike Christie io_task->pwrb_handle);
42741282ab76SMike Christie io_task->pwrb_handle = NULL;
42751282ab76SMike Christie }
42761282ab76SMike Christie
42771282ab76SMike Christie if (io_task->psgl_handle) {
42781282ab76SMike Christie free_io_sgl_handle(phba, io_task->psgl_handle);
42791282ab76SMike Christie io_task->psgl_handle = NULL;
42801282ab76SMike Christie }
4281da334977SJayamohan Kallickal
4282da334977SJayamohan Kallickal if (io_task->scsi_cmnd) {
42839122e991SJitendra Bhivare if (io_task->num_sg)
4284da334977SJayamohan Kallickal scsi_dma_unmap(io_task->scsi_cmnd);
4285da334977SJayamohan Kallickal io_task->scsi_cmnd = NULL;
4286da334977SJayamohan Kallickal }
42871282ab76SMike Christie } else {
428843f388b0SJayamohan Kallickal if (!beiscsi_conn->login_in_progress)
42894a4a11b9SJayamohan Kallickal beiscsi_free_mgmt_task_handles(beiscsi_conn, task);
42901282ab76SMike Christie }
42911282ab76SMike Christie }
42921282ab76SMike Christie
42936733b39aSJayamohan Kallickal void
beiscsi_offload_connection(struct beiscsi_conn * beiscsi_conn,struct beiscsi_offload_params * params)42946733b39aSJayamohan Kallickal beiscsi_offload_connection(struct beiscsi_conn *beiscsi_conn,
42956733b39aSJayamohan Kallickal struct beiscsi_offload_params *params)
42966733b39aSJayamohan Kallickal {
42976733b39aSJayamohan Kallickal struct wrb_handle *pwrb_handle;
4298340c99e9SJohn Soni Jose struct hwi_wrb_context *pwrb_context = NULL;
42996733b39aSJayamohan Kallickal struct beiscsi_hba *phba = beiscsi_conn->phba;
43001282ab76SMike Christie struct iscsi_task *task = beiscsi_conn->task;
43011282ab76SMike Christie struct iscsi_session *session = task->conn->session;
43026733b39aSJayamohan Kallickal u32 doorbell = 0;
43036733b39aSJayamohan Kallickal
43046733b39aSJayamohan Kallickal /*
43056733b39aSJayamohan Kallickal * We can always use 0 here because it is reserved by libiscsi for
43066733b39aSJayamohan Kallickal * login/startup related tasks.
43076733b39aSJayamohan Kallickal */
43081282ab76SMike Christie beiscsi_conn->login_in_progress = 0;
4309659743b0SShlomo Pongratz spin_lock_bh(&session->back_lock);
43101282ab76SMike Christie beiscsi_cleanup_task(task);
4311659743b0SShlomo Pongratz spin_unlock_bh(&session->back_lock);
43121282ab76SMike Christie
4313340c99e9SJohn Soni Jose pwrb_handle = alloc_wrb_handle(phba, beiscsi_conn->beiscsi_conn_cid,
4314340c99e9SJohn Soni Jose &pwrb_context);
43156733b39aSJayamohan Kallickal
4316acb9693cSJohn Soni Jose /* Check for the adapter family */
43172c9dfd36SJayamohan Kallickal if (is_chip_be2_be3r(phba))
4318acb9693cSJohn Soni Jose beiscsi_offload_cxn_v0(params, pwrb_handle,
4319340c99e9SJohn Soni Jose phba->init_mem,
4320340c99e9SJohn Soni Jose pwrb_context);
43212c9dfd36SJayamohan Kallickal else
4322340c99e9SJohn Soni Jose beiscsi_offload_cxn_v2(params, pwrb_handle,
4323340c99e9SJohn Soni Jose pwrb_context);
43246733b39aSJayamohan Kallickal
4325acb9693cSJohn Soni Jose be_dws_le_to_cpu(pwrb_handle->pwrb,
4326acb9693cSJohn Soni Jose sizeof(struct iscsi_target_context_update_wrb));
43276733b39aSJayamohan Kallickal
43286733b39aSJayamohan Kallickal doorbell |= beiscsi_conn->beiscsi_conn_cid & DB_WRB_POST_CID_MASK;
4329bfead3b2SJayamohan Kallickal doorbell |= (pwrb_handle->wrb_index & DB_DEF_PDU_WRB_INDEX_MASK)
4330bfead3b2SJayamohan Kallickal << DB_DEF_PDU_WRB_INDEX_SHIFT;
43316733b39aSJayamohan Kallickal doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;
43321e4be6ffSJayamohan Kallickal iowrite32(doorbell, phba->db_va +
43331e4be6ffSJayamohan Kallickal beiscsi_conn->doorbell_offset);
4334cb564c6bSJitendra Bhivare
4335cb564c6bSJitendra Bhivare /*
4336cb564c6bSJitendra Bhivare * There is no completion for CONTEXT_UPDATE. The completion of next
4337cb564c6bSJitendra Bhivare * WRB posted guarantees FW's processing and DMA'ing of it.
4338cb564c6bSJitendra Bhivare * Use beiscsi_put_wrb_handle to put it back in the pool which makes
4339cb564c6bSJitendra Bhivare * sure zero'ing or reuse of the WRB only after wrbs_per_cxn.
4340cb564c6bSJitendra Bhivare */
4341cb564c6bSJitendra Bhivare beiscsi_put_wrb_handle(pwrb_context, pwrb_handle,
4342cb564c6bSJitendra Bhivare phba->params.wrbs_per_cxn);
4343cb564c6bSJitendra Bhivare beiscsi_log(phba, KERN_INFO,
4344cb564c6bSJitendra Bhivare BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
4345cb564c6bSJitendra Bhivare "BM_%d : put CONTEXT_UPDATE pwrb_handle=%p free_index=0x%x wrb_handles_available=%d\n",
4346cb564c6bSJitendra Bhivare pwrb_handle, pwrb_context->free_index,
4347cb564c6bSJitendra Bhivare pwrb_context->wrb_handles_available);
43486733b39aSJayamohan Kallickal }
43496733b39aSJayamohan Kallickal
beiscsi_parse_pdu(struct iscsi_conn * conn,itt_t itt,int * index,int * age)43506733b39aSJayamohan Kallickal static void beiscsi_parse_pdu(struct iscsi_conn *conn, itt_t itt,
43516733b39aSJayamohan Kallickal int *index, int *age)
43526733b39aSJayamohan Kallickal {
4353bfead3b2SJayamohan Kallickal *index = (int)itt;
43546733b39aSJayamohan Kallickal if (age)
43556733b39aSJayamohan Kallickal *age = conn->session->age;
43566733b39aSJayamohan Kallickal }
43576733b39aSJayamohan Kallickal
43586733b39aSJayamohan Kallickal /**
43596733b39aSJayamohan Kallickal * beiscsi_alloc_pdu - allocates pdu and related resources
43606733b39aSJayamohan Kallickal * @task: libiscsi task
43616733b39aSJayamohan Kallickal * @opcode: opcode of pdu for task
43626733b39aSJayamohan Kallickal *
43636733b39aSJayamohan Kallickal * This is called with the session lock held. It will allocate
43646733b39aSJayamohan Kallickal * the wrb and sgl if needed for the command. And it will prep
43656733b39aSJayamohan Kallickal * the pdu's itt. beiscsi_parse_pdu will later translate
43666733b39aSJayamohan Kallickal * the pdu itt to the libiscsi task itt.
43676733b39aSJayamohan Kallickal */
beiscsi_alloc_pdu(struct iscsi_task * task,uint8_t opcode)43686733b39aSJayamohan Kallickal static int beiscsi_alloc_pdu(struct iscsi_task *task, uint8_t opcode)
43696733b39aSJayamohan Kallickal {
43706733b39aSJayamohan Kallickal struct beiscsi_io_task *io_task = task->dd_data;
43716733b39aSJayamohan Kallickal struct iscsi_conn *conn = task->conn;
43726733b39aSJayamohan Kallickal struct beiscsi_conn *beiscsi_conn = conn->dd_data;
43736733b39aSJayamohan Kallickal struct beiscsi_hba *phba = beiscsi_conn->phba;
43746733b39aSJayamohan Kallickal struct hwi_wrb_context *pwrb_context;
43756733b39aSJayamohan Kallickal struct hwi_controller *phwi_ctrlr;
43766733b39aSJayamohan Kallickal itt_t itt;
4377a7909b39SJayamohan Kallickal uint16_t cri_index = 0;
43782afc95bfSJayamohan Kallickal struct beiscsi_session *beiscsi_sess = beiscsi_conn->beiscsi_sess;
43792afc95bfSJayamohan Kallickal dma_addr_t paddr;
43806733b39aSJayamohan Kallickal
4381af007b02SRomain Perier io_task->cmd_bhs = dma_pool_alloc(beiscsi_sess->bhs_pool,
4382bc7accecSMike Christie GFP_ATOMIC, &paddr);
43832afc95bfSJayamohan Kallickal if (!io_task->cmd_bhs)
43842afc95bfSJayamohan Kallickal return -ENOMEM;
43852afc95bfSJayamohan Kallickal io_task->bhs_pa.u.a64.address = paddr;
4386bfead3b2SJayamohan Kallickal io_task->libiscsi_itt = (itt_t)task->itt;
43876733b39aSJayamohan Kallickal io_task->conn = beiscsi_conn;
43886733b39aSJayamohan Kallickal
43896733b39aSJayamohan Kallickal task->hdr = (struct iscsi_hdr *)&io_task->cmd_bhs->iscsi_hdr;
43906733b39aSJayamohan Kallickal task->hdr_max = sizeof(struct be_cmd_bhs);
4391d2cecf0dSJayamohan Kallickal io_task->psgl_handle = NULL;
43923ec78271SJayamohan Kallickal io_task->pwrb_handle = NULL;
43936733b39aSJayamohan Kallickal
43946733b39aSJayamohan Kallickal if (task->sc) {
43956733b39aSJayamohan Kallickal io_task->psgl_handle = alloc_io_sgl_handle(phba);
43968359c79bSJohn Soni Jose if (!io_task->psgl_handle) {
43978359c79bSJohn Soni Jose beiscsi_log(phba, KERN_ERR,
43988359c79bSJohn Soni Jose BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
43998359c79bSJohn Soni Jose "BM_%d : Alloc of IO_SGL_ICD Failed "
44008359c79bSJohn Soni Jose "for the CID : %d\n",
44018359c79bSJohn Soni Jose beiscsi_conn->beiscsi_conn_cid);
44022afc95bfSJayamohan Kallickal goto free_hndls;
44038359c79bSJohn Soni Jose }
4404d2cecf0dSJayamohan Kallickal io_task->pwrb_handle = alloc_wrb_handle(phba,
4405340c99e9SJohn Soni Jose beiscsi_conn->beiscsi_conn_cid,
4406340c99e9SJohn Soni Jose &io_task->pwrb_context);
44078359c79bSJohn Soni Jose if (!io_task->pwrb_handle) {
44088359c79bSJohn Soni Jose beiscsi_log(phba, KERN_ERR,
44098359c79bSJohn Soni Jose BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
44108359c79bSJohn Soni Jose "BM_%d : Alloc of WRB_HANDLE Failed "
44118359c79bSJohn Soni Jose "for the CID : %d\n",
44128359c79bSJohn Soni Jose beiscsi_conn->beiscsi_conn_cid);
4413d2cecf0dSJayamohan Kallickal goto free_io_hndls;
44148359c79bSJohn Soni Jose }
44156733b39aSJayamohan Kallickal } else {
44166733b39aSJayamohan Kallickal io_task->scsi_cmnd = NULL;
4417d7aea67bSJayamohan Kallickal if ((opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGIN) {
441843f388b0SJayamohan Kallickal beiscsi_conn->task = task;
44196733b39aSJayamohan Kallickal if (!beiscsi_conn->login_in_progress) {
44206733b39aSJayamohan Kallickal io_task->psgl_handle = (struct sgl_handle *)
44216733b39aSJayamohan Kallickal alloc_mgmt_sgl_handle(phba);
44228359c79bSJohn Soni Jose if (!io_task->psgl_handle) {
44238359c79bSJohn Soni Jose beiscsi_log(phba, KERN_ERR,
44248359c79bSJohn Soni Jose BEISCSI_LOG_IO |
44258359c79bSJohn Soni Jose BEISCSI_LOG_CONFIG,
44268359c79bSJohn Soni Jose "BM_%d : Alloc of MGMT_SGL_ICD Failed "
44278359c79bSJohn Soni Jose "for the CID : %d\n",
4428c7fa2c85SChristophe JAILLET beiscsi_conn->beiscsi_conn_cid);
44292afc95bfSJayamohan Kallickal goto free_hndls;
44308359c79bSJohn Soni Jose }
44312afc95bfSJayamohan Kallickal
44326733b39aSJayamohan Kallickal beiscsi_conn->login_in_progress = 1;
44336733b39aSJayamohan Kallickal beiscsi_conn->plogin_sgl_handle =
44346733b39aSJayamohan Kallickal io_task->psgl_handle;
4435d2cecf0dSJayamohan Kallickal io_task->pwrb_handle =
4436d2cecf0dSJayamohan Kallickal alloc_wrb_handle(phba,
4437340c99e9SJohn Soni Jose beiscsi_conn->beiscsi_conn_cid,
4438340c99e9SJohn Soni Jose &io_task->pwrb_context);
44398359c79bSJohn Soni Jose if (!io_task->pwrb_handle) {
44408359c79bSJohn Soni Jose beiscsi_log(phba, KERN_ERR,
44418359c79bSJohn Soni Jose BEISCSI_LOG_IO |
44428359c79bSJohn Soni Jose BEISCSI_LOG_CONFIG,
44438359c79bSJohn Soni Jose "BM_%d : Alloc of WRB_HANDLE Failed "
44448359c79bSJohn Soni Jose "for the CID : %d\n",
4445c7fa2c85SChristophe JAILLET beiscsi_conn->beiscsi_conn_cid);
44468359c79bSJohn Soni Jose goto free_mgmt_hndls;
44478359c79bSJohn Soni Jose }
4448d2cecf0dSJayamohan Kallickal beiscsi_conn->plogin_wrb_handle =
4449d2cecf0dSJayamohan Kallickal io_task->pwrb_handle;
4450d2cecf0dSJayamohan Kallickal
44516733b39aSJayamohan Kallickal } else {
44526733b39aSJayamohan Kallickal io_task->psgl_handle =
44536733b39aSJayamohan Kallickal beiscsi_conn->plogin_sgl_handle;
4454d2cecf0dSJayamohan Kallickal io_task->pwrb_handle =
4455d2cecf0dSJayamohan Kallickal beiscsi_conn->plogin_wrb_handle;
44566733b39aSJayamohan Kallickal }
44576733b39aSJayamohan Kallickal } else {
44586733b39aSJayamohan Kallickal io_task->psgl_handle = alloc_mgmt_sgl_handle(phba);
44598359c79bSJohn Soni Jose if (!io_task->psgl_handle) {
44608359c79bSJohn Soni Jose beiscsi_log(phba, KERN_ERR,
44618359c79bSJohn Soni Jose BEISCSI_LOG_IO |
44628359c79bSJohn Soni Jose BEISCSI_LOG_CONFIG,
44638359c79bSJohn Soni Jose "BM_%d : Alloc of MGMT_SGL_ICD Failed "
44648359c79bSJohn Soni Jose "for the CID : %d\n",
4465c7fa2c85SChristophe JAILLET beiscsi_conn->beiscsi_conn_cid);
44662afc95bfSJayamohan Kallickal goto free_hndls;
44678359c79bSJohn Soni Jose }
4468d2cecf0dSJayamohan Kallickal io_task->pwrb_handle =
4469d2cecf0dSJayamohan Kallickal alloc_wrb_handle(phba,
4470340c99e9SJohn Soni Jose beiscsi_conn->beiscsi_conn_cid,
4471340c99e9SJohn Soni Jose &io_task->pwrb_context);
44728359c79bSJohn Soni Jose if (!io_task->pwrb_handle) {
44738359c79bSJohn Soni Jose beiscsi_log(phba, KERN_ERR,
44748359c79bSJohn Soni Jose BEISCSI_LOG_IO | BEISCSI_LOG_CONFIG,
44758359c79bSJohn Soni Jose "BM_%d : Alloc of WRB_HANDLE Failed "
44768359c79bSJohn Soni Jose "for the CID : %d\n",
44778359c79bSJohn Soni Jose beiscsi_conn->beiscsi_conn_cid);
4478d2cecf0dSJayamohan Kallickal goto free_mgmt_hndls;
44798359c79bSJohn Soni Jose }
4480d2cecf0dSJayamohan Kallickal
44816733b39aSJayamohan Kallickal }
44826733b39aSJayamohan Kallickal }
4483bfead3b2SJayamohan Kallickal itt = (itt_t) cpu_to_be32(((unsigned int)io_task->pwrb_handle->
4484bfead3b2SJayamohan Kallickal wrb_index << 16) | (unsigned int)
4485bfead3b2SJayamohan Kallickal (io_task->psgl_handle->sgl_index));
4486bfead3b2SJayamohan Kallickal io_task->pwrb_handle->pio_handle = task;
4487bfead3b2SJayamohan Kallickal
44886733b39aSJayamohan Kallickal io_task->cmd_bhs->iscsi_hdr.itt = itt;
44896733b39aSJayamohan Kallickal return 0;
44902afc95bfSJayamohan Kallickal
4491d2cecf0dSJayamohan Kallickal free_io_hndls:
4492d2cecf0dSJayamohan Kallickal free_io_sgl_handle(phba, io_task->psgl_handle);
4493d2cecf0dSJayamohan Kallickal goto free_hndls;
4494d2cecf0dSJayamohan Kallickal free_mgmt_hndls:
4495d2cecf0dSJayamohan Kallickal free_mgmt_sgl_handle(phba, io_task->psgl_handle);
4496a7909b39SJayamohan Kallickal io_task->psgl_handle = NULL;
44972afc95bfSJayamohan Kallickal free_hndls:
44982afc95bfSJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
4499a7909b39SJayamohan Kallickal cri_index = BE_GET_CRI_FROM_CID(
4500a7909b39SJayamohan Kallickal beiscsi_conn->beiscsi_conn_cid);
4501a7909b39SJayamohan Kallickal pwrb_context = &phwi_ctrlr->wrb_context[cri_index];
4502d2cecf0dSJayamohan Kallickal if (io_task->pwrb_handle)
45032afc95bfSJayamohan Kallickal free_wrb_handle(phba, pwrb_context, io_task->pwrb_handle);
45042afc95bfSJayamohan Kallickal io_task->pwrb_handle = NULL;
4505af007b02SRomain Perier dma_pool_free(beiscsi_sess->bhs_pool, io_task->cmd_bhs,
45062afc95bfSJayamohan Kallickal io_task->bhs_pa.u.a64.address);
45071282ab76SMike Christie io_task->cmd_bhs = NULL;
45082afc95bfSJayamohan Kallickal return -ENOMEM;
45096733b39aSJayamohan Kallickal }
beiscsi_iotask_v2(struct iscsi_task * task,struct scatterlist * sg,unsigned int num_sg,unsigned int xferlen,unsigned int writedir)45100825b8eeSBaoyou Xie static int beiscsi_iotask_v2(struct iscsi_task *task, struct scatterlist *sg,
451109a1093aSJohn Soni Jose unsigned int num_sg, unsigned int xferlen,
451209a1093aSJohn Soni Jose unsigned int writedir)
451309a1093aSJohn Soni Jose {
451409a1093aSJohn Soni Jose
451509a1093aSJohn Soni Jose struct beiscsi_io_task *io_task = task->dd_data;
451609a1093aSJohn Soni Jose struct iscsi_conn *conn = task->conn;
451709a1093aSJohn Soni Jose struct beiscsi_conn *beiscsi_conn = conn->dd_data;
451809a1093aSJohn Soni Jose struct beiscsi_hba *phba = beiscsi_conn->phba;
451909a1093aSJohn Soni Jose struct iscsi_wrb *pwrb = NULL;
452009a1093aSJohn Soni Jose unsigned int doorbell = 0;
452109a1093aSJohn Soni Jose
452209a1093aSJohn Soni Jose pwrb = io_task->pwrb_handle->pwrb;
452309a1093aSJohn Soni Jose
452409a1093aSJohn Soni Jose io_task->bhs_len = sizeof(struct be_cmd_bhs);
452509a1093aSJohn Soni Jose
452609a1093aSJohn Soni Jose if (writedir) {
452709a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, type, pwrb,
452809a1093aSJohn Soni Jose INI_WR_CMD);
452909a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, dsp, pwrb, 1);
453009a1093aSJohn Soni Jose } else {
453109a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, type, pwrb,
453209a1093aSJohn Soni Jose INI_RD_CMD);
453309a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, dsp, pwrb, 0);
453409a1093aSJohn Soni Jose }
453509a1093aSJohn Soni Jose
453609a1093aSJohn Soni Jose io_task->wrb_type = AMAP_GET_BITS(struct amap_iscsi_wrb_v2,
453709a1093aSJohn Soni Jose type, pwrb);
453809a1093aSJohn Soni Jose
453909a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, lun, pwrb,
454009a1093aSJohn Soni Jose cpu_to_be16(*(unsigned short *)
454109a1093aSJohn Soni Jose &io_task->cmd_bhs->iscsi_hdr.lun));
454209a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, r2t_exp_dtl, pwrb, xferlen);
454309a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, wrb_idx, pwrb,
454409a1093aSJohn Soni Jose io_task->pwrb_handle->wrb_index);
454509a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, cmdsn_itt, pwrb,
454609a1093aSJohn Soni Jose be32_to_cpu(task->cmdsn));
454709a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sgl_idx, pwrb,
454809a1093aSJohn Soni Jose io_task->psgl_handle->sgl_index);
454909a1093aSJohn Soni Jose
455009a1093aSJohn Soni Jose hwi_write_sgl_v2(pwrb, sg, num_sg, io_task);
455109a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, ptr2nextwrb, pwrb,
4552340c99e9SJohn Soni Jose io_task->pwrb_handle->wrb_index);
4553340c99e9SJohn Soni Jose if (io_task->pwrb_context->plast_wrb)
4554340c99e9SJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, ptr2nextwrb,
4555340c99e9SJohn Soni Jose io_task->pwrb_context->plast_wrb,
4556340c99e9SJohn Soni Jose io_task->pwrb_handle->wrb_index);
4557340c99e9SJohn Soni Jose io_task->pwrb_context->plast_wrb = pwrb;
455809a1093aSJohn Soni Jose
455909a1093aSJohn Soni Jose be_dws_le_to_cpu(pwrb, sizeof(struct iscsi_wrb));
456009a1093aSJohn Soni Jose
456109a1093aSJohn Soni Jose doorbell |= beiscsi_conn->beiscsi_conn_cid & DB_WRB_POST_CID_MASK;
456209a1093aSJohn Soni Jose doorbell |= (io_task->pwrb_handle->wrb_index &
456309a1093aSJohn Soni Jose DB_DEF_PDU_WRB_INDEX_MASK) <<
456409a1093aSJohn Soni Jose DB_DEF_PDU_WRB_INDEX_SHIFT;
456509a1093aSJohn Soni Jose doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;
45661e4be6ffSJayamohan Kallickal iowrite32(doorbell, phba->db_va +
45671e4be6ffSJayamohan Kallickal beiscsi_conn->doorbell_offset);
456809a1093aSJohn Soni Jose return 0;
456909a1093aSJohn Soni Jose }
45706733b39aSJayamohan Kallickal
beiscsi_iotask(struct iscsi_task * task,struct scatterlist * sg,unsigned int num_sg,unsigned int xferlen,unsigned int writedir)45716733b39aSJayamohan Kallickal static int beiscsi_iotask(struct iscsi_task *task, struct scatterlist *sg,
45726733b39aSJayamohan Kallickal unsigned int num_sg, unsigned int xferlen,
45736733b39aSJayamohan Kallickal unsigned int writedir)
45746733b39aSJayamohan Kallickal {
45756733b39aSJayamohan Kallickal
45766733b39aSJayamohan Kallickal struct beiscsi_io_task *io_task = task->dd_data;
45776733b39aSJayamohan Kallickal struct iscsi_conn *conn = task->conn;
45786733b39aSJayamohan Kallickal struct beiscsi_conn *beiscsi_conn = conn->dd_data;
45796733b39aSJayamohan Kallickal struct beiscsi_hba *phba = beiscsi_conn->phba;
45806733b39aSJayamohan Kallickal struct iscsi_wrb *pwrb = NULL;
45816733b39aSJayamohan Kallickal unsigned int doorbell = 0;
45826733b39aSJayamohan Kallickal
45836733b39aSJayamohan Kallickal pwrb = io_task->pwrb_handle->pwrb;
45846733b39aSJayamohan Kallickal io_task->bhs_len = sizeof(struct be_cmd_bhs);
45856733b39aSJayamohan Kallickal
45866733b39aSJayamohan Kallickal if (writedir) {
4587bfead3b2SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
4588bfead3b2SJayamohan Kallickal INI_WR_CMD);
45896733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 1);
45906733b39aSJayamohan Kallickal } else {
4591bfead3b2SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, type, pwrb,
4592bfead3b2SJayamohan Kallickal INI_RD_CMD);
45936733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, dsp, pwrb, 0);
45946733b39aSJayamohan Kallickal }
45956733b39aSJayamohan Kallickal
459609a1093aSJohn Soni Jose io_task->wrb_type = AMAP_GET_BITS(struct amap_iscsi_wrb,
459709a1093aSJohn Soni Jose type, pwrb);
459809a1093aSJohn Soni Jose
45996733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, lun, pwrb,
4600dc63aac6SJayamohan Kallickal cpu_to_be16(*(unsigned short *)
4601dc63aac6SJayamohan Kallickal &io_task->cmd_bhs->iscsi_hdr.lun));
46026733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, r2t_exp_dtl, pwrb, xferlen);
46036733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, wrb_idx, pwrb,
46046733b39aSJayamohan Kallickal io_task->pwrb_handle->wrb_index);
46056733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt, pwrb,
46066733b39aSJayamohan Kallickal be32_to_cpu(task->cmdsn));
46076733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sgl_icd_idx, pwrb,
46086733b39aSJayamohan Kallickal io_task->psgl_handle->sgl_index);
46096733b39aSJayamohan Kallickal
46106733b39aSJayamohan Kallickal hwi_write_sgl(pwrb, sg, num_sg, io_task);
46116733b39aSJayamohan Kallickal
46126733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, ptr2nextwrb, pwrb,
4613340c99e9SJohn Soni Jose io_task->pwrb_handle->wrb_index);
4614340c99e9SJohn Soni Jose if (io_task->pwrb_context->plast_wrb)
4615340c99e9SJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb, ptr2nextwrb,
4616340c99e9SJohn Soni Jose io_task->pwrb_context->plast_wrb,
4617340c99e9SJohn Soni Jose io_task->pwrb_handle->wrb_index);
4618340c99e9SJohn Soni Jose io_task->pwrb_context->plast_wrb = pwrb;
4619340c99e9SJohn Soni Jose
46206733b39aSJayamohan Kallickal be_dws_le_to_cpu(pwrb, sizeof(struct iscsi_wrb));
46216733b39aSJayamohan Kallickal
46226733b39aSJayamohan Kallickal doorbell |= beiscsi_conn->beiscsi_conn_cid & DB_WRB_POST_CID_MASK;
46236733b39aSJayamohan Kallickal doorbell |= (io_task->pwrb_handle->wrb_index &
46246733b39aSJayamohan Kallickal DB_DEF_PDU_WRB_INDEX_MASK) << DB_DEF_PDU_WRB_INDEX_SHIFT;
46256733b39aSJayamohan Kallickal doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;
46266733b39aSJayamohan Kallickal
46271e4be6ffSJayamohan Kallickal iowrite32(doorbell, phba->db_va +
46281e4be6ffSJayamohan Kallickal beiscsi_conn->doorbell_offset);
46296733b39aSJayamohan Kallickal return 0;
46306733b39aSJayamohan Kallickal }
46316733b39aSJayamohan Kallickal
beiscsi_mtask(struct iscsi_task * task)46326733b39aSJayamohan Kallickal static int beiscsi_mtask(struct iscsi_task *task)
46336733b39aSJayamohan Kallickal {
4634dafab8e0SJayamohan Kallickal struct beiscsi_io_task *io_task = task->dd_data;
46356733b39aSJayamohan Kallickal struct iscsi_conn *conn = task->conn;
46366733b39aSJayamohan Kallickal struct beiscsi_conn *beiscsi_conn = conn->dd_data;
46376733b39aSJayamohan Kallickal struct beiscsi_hba *phba = beiscsi_conn->phba;
46386733b39aSJayamohan Kallickal struct iscsi_wrb *pwrb = NULL;
46396733b39aSJayamohan Kallickal unsigned int doorbell = 0;
4640dafab8e0SJayamohan Kallickal unsigned int cid;
464109a1093aSJohn Soni Jose unsigned int pwrb_typeoffset = 0;
4642e0493627SAlexey Khoroshilov int ret = 0;
46436733b39aSJayamohan Kallickal
4644bfead3b2SJayamohan Kallickal cid = beiscsi_conn->beiscsi_conn_cid;
46456733b39aSJayamohan Kallickal pwrb = io_task->pwrb_handle->pwrb;
464609a1093aSJohn Soni Jose
46472c9dfd36SJayamohan Kallickal if (is_chip_be2_be3r(phba)) {
46486733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt, pwrb,
46496733b39aSJayamohan Kallickal be32_to_cpu(task->cmdsn));
46506733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, wrb_idx, pwrb,
46516733b39aSJayamohan Kallickal io_task->pwrb_handle->wrb_index);
46526733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, sgl_icd_idx, pwrb,
46536733b39aSJayamohan Kallickal io_task->psgl_handle->sgl_index);
465409a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb, r2t_exp_dtl, pwrb,
465509a1093aSJohn Soni Jose task->data_count);
465609a1093aSJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb, ptr2nextwrb, pwrb,
4657340c99e9SJohn Soni Jose io_task->pwrb_handle->wrb_index);
4658340c99e9SJohn Soni Jose if (io_task->pwrb_context->plast_wrb)
4659340c99e9SJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb, ptr2nextwrb,
4660340c99e9SJohn Soni Jose io_task->pwrb_context->plast_wrb,
4661340c99e9SJohn Soni Jose io_task->pwrb_handle->wrb_index);
4662340c99e9SJohn Soni Jose io_task->pwrb_context->plast_wrb = pwrb;
4663340c99e9SJohn Soni Jose
466409a1093aSJohn Soni Jose pwrb_typeoffset = BE_WRB_TYPE_OFFSET;
46652c9dfd36SJayamohan Kallickal } else {
46662c9dfd36SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb_v2, cmdsn_itt, pwrb,
46672c9dfd36SJayamohan Kallickal be32_to_cpu(task->cmdsn));
46682c9dfd36SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb_v2, wrb_idx, pwrb,
46692c9dfd36SJayamohan Kallickal io_task->pwrb_handle->wrb_index);
46702c9dfd36SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb_v2, sgl_idx, pwrb,
46712c9dfd36SJayamohan Kallickal io_task->psgl_handle->sgl_index);
46722c9dfd36SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb_v2, r2t_exp_dtl, pwrb,
46732c9dfd36SJayamohan Kallickal task->data_count);
46742c9dfd36SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb_v2, ptr2nextwrb, pwrb,
4675340c99e9SJohn Soni Jose io_task->pwrb_handle->wrb_index);
4676340c99e9SJohn Soni Jose if (io_task->pwrb_context->plast_wrb)
4677340c99e9SJohn Soni Jose AMAP_SET_BITS(struct amap_iscsi_wrb_v2, ptr2nextwrb,
4678340c99e9SJohn Soni Jose io_task->pwrb_context->plast_wrb,
4679340c99e9SJohn Soni Jose io_task->pwrb_handle->wrb_index);
4680340c99e9SJohn Soni Jose io_task->pwrb_context->plast_wrb = pwrb;
4681340c99e9SJohn Soni Jose
46822c9dfd36SJayamohan Kallickal pwrb_typeoffset = SKH_WRB_TYPE_OFFSET;
468309a1093aSJohn Soni Jose }
468409a1093aSJohn Soni Jose
4685dafab8e0SJayamohan Kallickal
46866733b39aSJayamohan Kallickal switch (task->hdr->opcode & ISCSI_OPCODE_MASK) {
46876733b39aSJayamohan Kallickal case ISCSI_OP_LOGIN:
46886733b39aSJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb, cmdsn_itt, pwrb, 1);
468909a1093aSJohn Soni Jose ADAPTER_SET_WRB_TYPE(pwrb, TGT_DM_CMD, pwrb_typeoffset);
4690e0493627SAlexey Khoroshilov ret = hwi_write_buffer(pwrb, task);
46916733b39aSJayamohan Kallickal break;
46926733b39aSJayamohan Kallickal case ISCSI_OP_NOOP_OUT:
46931390b01bSJayamohan Kallickal if (task->hdr->ttt != ISCSI_RESERVED_TAG) {
469409a1093aSJohn Soni Jose ADAPTER_SET_WRB_TYPE(pwrb, TGT_DM_CMD, pwrb_typeoffset);
46952c9dfd36SJayamohan Kallickal if (is_chip_be2_be3r(phba))
46962c9dfd36SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb,
469709a1093aSJohn Soni Jose dmsg, pwrb, 1);
469809a1093aSJohn Soni Jose else
46992c9dfd36SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb_v2,
470009a1093aSJohn Soni Jose dmsg, pwrb, 1);
47011390b01bSJayamohan Kallickal } else {
470209a1093aSJohn Soni Jose ADAPTER_SET_WRB_TYPE(pwrb, INI_RD_CMD, pwrb_typeoffset);
47032c9dfd36SJayamohan Kallickal if (is_chip_be2_be3r(phba))
47042c9dfd36SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb,
470509a1093aSJohn Soni Jose dmsg, pwrb, 0);
470609a1093aSJohn Soni Jose else
47072c9dfd36SJayamohan Kallickal AMAP_SET_BITS(struct amap_iscsi_wrb_v2,
470809a1093aSJohn Soni Jose dmsg, pwrb, 0);
47091390b01bSJayamohan Kallickal }
4710e0493627SAlexey Khoroshilov ret = hwi_write_buffer(pwrb, task);
47116733b39aSJayamohan Kallickal break;
47126733b39aSJayamohan Kallickal case ISCSI_OP_TEXT:
471309a1093aSJohn Soni Jose ADAPTER_SET_WRB_TYPE(pwrb, TGT_DM_CMD, pwrb_typeoffset);
4714e0493627SAlexey Khoroshilov ret = hwi_write_buffer(pwrb, task);
47156733b39aSJayamohan Kallickal break;
47166733b39aSJayamohan Kallickal case ISCSI_OP_SCSI_TMFUNC:
471709a1093aSJohn Soni Jose ADAPTER_SET_WRB_TYPE(pwrb, INI_TMF_CMD, pwrb_typeoffset);
4718e0493627SAlexey Khoroshilov ret = hwi_write_buffer(pwrb, task);
47196733b39aSJayamohan Kallickal break;
47206733b39aSJayamohan Kallickal case ISCSI_OP_LOGOUT:
472109a1093aSJohn Soni Jose ADAPTER_SET_WRB_TYPE(pwrb, HWH_TYPE_LOGOUT, pwrb_typeoffset);
4722e0493627SAlexey Khoroshilov ret = hwi_write_buffer(pwrb, task);
47236733b39aSJayamohan Kallickal break;
47246733b39aSJayamohan Kallickal
47256733b39aSJayamohan Kallickal default:
472699bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
472799bc5d55SJohn Soni Jose "BM_%d : opcode =%d Not supported\n",
47286733b39aSJayamohan Kallickal task->hdr->opcode & ISCSI_OPCODE_MASK);
472999bc5d55SJohn Soni Jose
47306733b39aSJayamohan Kallickal return -EINVAL;
47316733b39aSJayamohan Kallickal }
47326733b39aSJayamohan Kallickal
4733e0493627SAlexey Khoroshilov if (ret)
4734e0493627SAlexey Khoroshilov return ret;
4735e0493627SAlexey Khoroshilov
473609a1093aSJohn Soni Jose /* Set the task type */
47372c9dfd36SJayamohan Kallickal io_task->wrb_type = (is_chip_be2_be3r(phba)) ?
47382c9dfd36SJayamohan Kallickal AMAP_GET_BITS(struct amap_iscsi_wrb, type, pwrb) :
47392c9dfd36SJayamohan Kallickal AMAP_GET_BITS(struct amap_iscsi_wrb_v2, type, pwrb);
47406733b39aSJayamohan Kallickal
4741bfead3b2SJayamohan Kallickal doorbell |= cid & DB_WRB_POST_CID_MASK;
47426733b39aSJayamohan Kallickal doorbell |= (io_task->pwrb_handle->wrb_index &
47436733b39aSJayamohan Kallickal DB_DEF_PDU_WRB_INDEX_MASK) << DB_DEF_PDU_WRB_INDEX_SHIFT;
47446733b39aSJayamohan Kallickal doorbell |= 1 << DB_DEF_PDU_NUM_POSTED_SHIFT;
47451e4be6ffSJayamohan Kallickal iowrite32(doorbell, phba->db_va +
47461e4be6ffSJayamohan Kallickal beiscsi_conn->doorbell_offset);
47476733b39aSJayamohan Kallickal return 0;
47486733b39aSJayamohan Kallickal }
47496733b39aSJayamohan Kallickal
beiscsi_task_xmit(struct iscsi_task * task)47506733b39aSJayamohan Kallickal static int beiscsi_task_xmit(struct iscsi_task *task)
47516733b39aSJayamohan Kallickal {
47526733b39aSJayamohan Kallickal struct beiscsi_io_task *io_task = task->dd_data;
47536733b39aSJayamohan Kallickal struct scsi_cmnd *sc = task->sc;
47541868379bSJitendra Bhivare struct beiscsi_hba *phba;
47556733b39aSJayamohan Kallickal struct scatterlist *sg;
47566733b39aSJayamohan Kallickal int num_sg;
47576733b39aSJayamohan Kallickal unsigned int writedir = 0, xferlen = 0;
47586733b39aSJayamohan Kallickal
47599122e991SJitendra Bhivare phba = io_task->conn->phba;
47609122e991SJitendra Bhivare /**
47619122e991SJitendra Bhivare * HBA in error includes BEISCSI_HBA_FW_TIMEOUT. IO path might be
47629122e991SJitendra Bhivare * operational if FW still gets heartbeat from EP FW. Is management
47639122e991SJitendra Bhivare * path really needed to continue further?
47649122e991SJitendra Bhivare */
4765d1d5ca88SJitendra Bhivare if (!beiscsi_hba_is_online(phba))
47669122e991SJitendra Bhivare return -EIO;
47679122e991SJitendra Bhivare
47681868379bSJitendra Bhivare if (!io_task->conn->login_in_progress)
47691868379bSJitendra Bhivare task->hdr->exp_statsn = 0;
477009a1093aSJohn Soni Jose
47716733b39aSJayamohan Kallickal if (!sc)
47726733b39aSJayamohan Kallickal return beiscsi_mtask(task);
47736733b39aSJayamohan Kallickal
47746733b39aSJayamohan Kallickal io_task->scsi_cmnd = sc;
47759122e991SJitendra Bhivare io_task->num_sg = 0;
47766733b39aSJayamohan Kallickal num_sg = scsi_dma_map(sc);
47776733b39aSJayamohan Kallickal if (num_sg < 0) {
4778afb96058SJayamohan Kallickal beiscsi_log(phba, KERN_ERR,
4779afb96058SJayamohan Kallickal BEISCSI_LOG_IO | BEISCSI_LOG_ISCSI,
4780afb96058SJayamohan Kallickal "BM_%d : scsi_dma_map Failed "
4781afb96058SJayamohan Kallickal "Driver_ITT : 0x%x ITT : 0x%x Xferlen : 0x%x\n",
4782afb96058SJayamohan Kallickal be32_to_cpu(io_task->cmd_bhs->iscsi_hdr.itt),
4783afb96058SJayamohan Kallickal io_task->libiscsi_itt, scsi_bufflen(sc));
478499bc5d55SJohn Soni Jose
47856733b39aSJayamohan Kallickal return num_sg;
47866733b39aSJayamohan Kallickal }
47879122e991SJitendra Bhivare /**
47889122e991SJitendra Bhivare * For scsi cmd task, check num_sg before unmapping in cleanup_task.
47899122e991SJitendra Bhivare * For management task, cleanup_task checks mtask_addr before unmapping.
47909122e991SJitendra Bhivare */
47919122e991SJitendra Bhivare io_task->num_sg = num_sg;
47926733b39aSJayamohan Kallickal xferlen = scsi_bufflen(sc);
47936733b39aSJayamohan Kallickal sg = scsi_sglist(sc);
479499bc5d55SJohn Soni Jose if (sc->sc_data_direction == DMA_TO_DEVICE)
47956733b39aSJayamohan Kallickal writedir = 1;
479699bc5d55SJohn Soni Jose else
47976733b39aSJayamohan Kallickal writedir = 0;
479899bc5d55SJohn Soni Jose
479909a1093aSJohn Soni Jose return phba->iotask_fn(task, sg, num_sg, xferlen, writedir);
48006733b39aSJayamohan Kallickal }
48016733b39aSJayamohan Kallickal
4802ffce3e2eSJayamohan Kallickal /**
4803ffce3e2eSJayamohan Kallickal * beiscsi_bsg_request - handle bsg request from ISCSI transport
4804ffce3e2eSJayamohan Kallickal * @job: job to handle
4805ffce3e2eSJayamohan Kallickal */
beiscsi_bsg_request(struct bsg_job * job)4806ffce3e2eSJayamohan Kallickal static int beiscsi_bsg_request(struct bsg_job *job)
4807ffce3e2eSJayamohan Kallickal {
4808ffce3e2eSJayamohan Kallickal struct Scsi_Host *shost;
4809ffce3e2eSJayamohan Kallickal struct beiscsi_hba *phba;
4810ffce3e2eSJayamohan Kallickal struct iscsi_bsg_request *bsg_req = job->request;
4811ffce3e2eSJayamohan Kallickal int rc = -EINVAL;
4812ffce3e2eSJayamohan Kallickal unsigned int tag;
4813ffce3e2eSJayamohan Kallickal struct be_dma_mem nonemb_cmd;
4814ffce3e2eSJayamohan Kallickal struct be_cmd_resp_hdr *resp;
4815ffce3e2eSJayamohan Kallickal struct iscsi_bsg_reply *bsg_reply = job->reply;
4816ffce3e2eSJayamohan Kallickal unsigned short status, extd_status;
4817ffce3e2eSJayamohan Kallickal
4818ffce3e2eSJayamohan Kallickal shost = iscsi_job_to_shost(job);
4819ffce3e2eSJayamohan Kallickal phba = iscsi_host_priv(shost);
4820ffce3e2eSJayamohan Kallickal
4821d1d5ca88SJitendra Bhivare if (!beiscsi_hba_is_online(phba)) {
48229122e991SJitendra Bhivare beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_CONFIG,
48239122e991SJitendra Bhivare "BM_%d : HBA in error 0x%lx\n", phba->state);
48249122e991SJitendra Bhivare return -ENXIO;
48259122e991SJitendra Bhivare }
48269122e991SJitendra Bhivare
4827ffce3e2eSJayamohan Kallickal switch (bsg_req->msgcode) {
4828ffce3e2eSJayamohan Kallickal case ISCSI_BSG_HST_VENDOR:
482926a4c991SChristoph Hellwig nonemb_cmd.va = dma_alloc_coherent(&phba->ctrl.pdev->dev,
4830ffce3e2eSJayamohan Kallickal job->request_payload.payload_len,
483126a4c991SChristoph Hellwig &nonemb_cmd.dma, GFP_KERNEL);
4832ffce3e2eSJayamohan Kallickal if (nonemb_cmd.va == NULL) {
483399bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
483499bc5d55SJohn Soni Jose "BM_%d : Failed to allocate memory for "
4835ffce3e2eSJayamohan Kallickal "beiscsi_bsg_request\n");
48368359c79bSJohn Soni Jose return -ENOMEM;
4837ffce3e2eSJayamohan Kallickal }
4838ffce3e2eSJayamohan Kallickal tag = mgmt_vendor_specific_fw_cmd(&phba->ctrl, phba, job,
4839ffce3e2eSJayamohan Kallickal &nonemb_cmd);
4840ffce3e2eSJayamohan Kallickal if (!tag) {
484199bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
48428359c79bSJohn Soni Jose "BM_%d : MBX Tag Allocation Failed\n");
484399bc5d55SJohn Soni Jose
484426a4c991SChristoph Hellwig dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
4845ffce3e2eSJayamohan Kallickal nonemb_cmd.va, nonemb_cmd.dma);
4846ffce3e2eSJayamohan Kallickal return -EAGAIN;
4847e175defeSJohn Soni Jose }
4848e175defeSJohn Soni Jose
4849e175defeSJohn Soni Jose rc = wait_event_interruptible_timeout(
4850e175defeSJohn Soni Jose phba->ctrl.mcc_wait[tag],
485167296ad9SJitendra Bhivare phba->ctrl.mcc_tag_status[tag],
4852e175defeSJohn Soni Jose msecs_to_jiffies(
4853e175defeSJohn Soni Jose BEISCSI_HOST_MBX_TIMEOUT));
4854d1d5ca88SJitendra Bhivare
4855d1d5ca88SJitendra Bhivare if (!test_bit(BEISCSI_HBA_ONLINE, &phba->state)) {
4856d1d5ca88SJitendra Bhivare clear_bit(MCC_TAG_STATE_RUNNING,
4857d1d5ca88SJitendra Bhivare &phba->ctrl.ptag_state[tag].tag_state);
485826a4c991SChristoph Hellwig dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
4859d1d5ca88SJitendra Bhivare nonemb_cmd.va, nonemb_cmd.dma);
4860d1d5ca88SJitendra Bhivare return -EIO;
4861d1d5ca88SJitendra Bhivare }
486267296ad9SJitendra Bhivare extd_status = (phba->ctrl.mcc_tag_status[tag] &
486367296ad9SJitendra Bhivare CQE_STATUS_ADDL_MASK) >> CQE_STATUS_ADDL_SHIFT;
486467296ad9SJitendra Bhivare status = phba->ctrl.mcc_tag_status[tag] & CQE_STATUS_MASK;
4865090e2184SJitendra Bhivare free_mcc_wrb(&phba->ctrl, tag);
4866ffce3e2eSJayamohan Kallickal resp = (struct be_cmd_resp_hdr *)nonemb_cmd.va;
4867ffce3e2eSJayamohan Kallickal sg_copy_from_buffer(job->reply_payload.sg_list,
4868ffce3e2eSJayamohan Kallickal job->reply_payload.sg_cnt,
4869ffce3e2eSJayamohan Kallickal nonemb_cmd.va, (resp->response_length
4870ffce3e2eSJayamohan Kallickal + sizeof(*resp)));
4871ffce3e2eSJayamohan Kallickal bsg_reply->reply_payload_rcv_len = resp->response_length;
4872ffce3e2eSJayamohan Kallickal bsg_reply->result = status;
4873ffce3e2eSJayamohan Kallickal bsg_job_done(job, bsg_reply->result,
4874ffce3e2eSJayamohan Kallickal bsg_reply->reply_payload_rcv_len);
487526a4c991SChristoph Hellwig dma_free_coherent(&phba->ctrl.pdev->dev, nonemb_cmd.size,
4876ffce3e2eSJayamohan Kallickal nonemb_cmd.va, nonemb_cmd.dma);
4877ffce3e2eSJayamohan Kallickal if (status || extd_status) {
487899bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
48798359c79bSJohn Soni Jose "BM_%d : MBX Cmd Failed"
4880ffce3e2eSJayamohan Kallickal " status = %d extd_status = %d\n",
4881ffce3e2eSJayamohan Kallickal status, extd_status);
488299bc5d55SJohn Soni Jose
4883ffce3e2eSJayamohan Kallickal return -EIO;
48848359c79bSJohn Soni Jose } else {
48858359c79bSJohn Soni Jose rc = 0;
4886ffce3e2eSJayamohan Kallickal }
4887ffce3e2eSJayamohan Kallickal break;
4888ffce3e2eSJayamohan Kallickal
4889ffce3e2eSJayamohan Kallickal default:
489099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
489199bc5d55SJohn Soni Jose "BM_%d : Unsupported bsg command: 0x%x\n",
4892ffce3e2eSJayamohan Kallickal bsg_req->msgcode);
4893ffce3e2eSJayamohan Kallickal break;
4894ffce3e2eSJayamohan Kallickal }
4895ffce3e2eSJayamohan Kallickal
4896ffce3e2eSJayamohan Kallickal return rc;
4897ffce3e2eSJayamohan Kallickal }
4898ffce3e2eSJayamohan Kallickal
beiscsi_hba_attrs_init(struct beiscsi_hba * phba)48990825b8eeSBaoyou Xie static void beiscsi_hba_attrs_init(struct beiscsi_hba *phba)
490099bc5d55SJohn Soni Jose {
490199bc5d55SJohn Soni Jose /* Set the logging parameter */
490299bc5d55SJohn Soni Jose beiscsi_log_enable_init(phba, beiscsi_log_enable);
490399bc5d55SJohn Soni Jose }
490499bc5d55SJohn Soni Jose
beiscsi_start_boot_work(struct beiscsi_hba * phba,unsigned int s_handle)490550a4b824SJitendra Bhivare void beiscsi_start_boot_work(struct beiscsi_hba *phba, unsigned int s_handle)
490650a4b824SJitendra Bhivare {
490750a4b824SJitendra Bhivare if (phba->boot_struct.boot_kset)
490850a4b824SJitendra Bhivare return;
490950a4b824SJitendra Bhivare
491050a4b824SJitendra Bhivare /* skip if boot work is already in progress */
491150a4b824SJitendra Bhivare if (test_and_set_bit(BEISCSI_HBA_BOOT_WORK, &phba->state))
491250a4b824SJitendra Bhivare return;
491350a4b824SJitendra Bhivare
491450a4b824SJitendra Bhivare phba->boot_struct.retry = 3;
491550a4b824SJitendra Bhivare phba->boot_struct.tag = 0;
491650a4b824SJitendra Bhivare phba->boot_struct.s_handle = s_handle;
491750a4b824SJitendra Bhivare phba->boot_struct.action = BEISCSI_BOOT_GET_SHANDLE;
491850a4b824SJitendra Bhivare schedule_work(&phba->boot_work);
491950a4b824SJitendra Bhivare }
492050a4b824SJitendra Bhivare
4921f1d50e8eSLee Jones #define BEISCSI_SYSFS_ISCSI_BOOT_FLAGS 3
4922a90a8c60SLee Jones /*
4923a905a1dcSLee Jones * beiscsi_show_boot_tgt_info()
49248d9ecd49SJitendra Bhivare * Boot flag info for iscsi-utilities
49258d9ecd49SJitendra Bhivare * Bit 0 Block valid flag
49268d9ecd49SJitendra Bhivare * Bit 1 Firmware booting selected
49278d9ecd49SJitendra Bhivare */
beiscsi_show_boot_tgt_info(void * data,int type,char * buf)492850a4b824SJitendra Bhivare static ssize_t beiscsi_show_boot_tgt_info(void *data, int type, char *buf)
492950a4b824SJitendra Bhivare {
493050a4b824SJitendra Bhivare struct beiscsi_hba *phba = data;
493150a4b824SJitendra Bhivare struct mgmt_session_info *boot_sess = &phba->boot_struct.boot_sess;
493250a4b824SJitendra Bhivare struct mgmt_conn_info *boot_conn = &boot_sess->conn_list[0];
493350a4b824SJitendra Bhivare char *str = buf;
493450a4b824SJitendra Bhivare int rc = -EPERM;
493550a4b824SJitendra Bhivare
493650a4b824SJitendra Bhivare switch (type) {
493750a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_NAME:
493850a4b824SJitendra Bhivare rc = sprintf(buf, "%.*s\n",
493950a4b824SJitendra Bhivare (int)strlen(boot_sess->target_name),
494050a4b824SJitendra Bhivare (char *)&boot_sess->target_name);
494150a4b824SJitendra Bhivare break;
494250a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_IP_ADDR:
494350a4b824SJitendra Bhivare if (boot_conn->dest_ipaddr.ip_type == BEISCSI_IP_TYPE_V4)
494450a4b824SJitendra Bhivare rc = sprintf(buf, "%pI4\n",
494550a4b824SJitendra Bhivare (char *)&boot_conn->dest_ipaddr.addr);
494650a4b824SJitendra Bhivare else
494750a4b824SJitendra Bhivare rc = sprintf(str, "%pI6\n",
494850a4b824SJitendra Bhivare (char *)&boot_conn->dest_ipaddr.addr);
494950a4b824SJitendra Bhivare break;
495050a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_PORT:
495150a4b824SJitendra Bhivare rc = sprintf(str, "%d\n", boot_conn->dest_port);
495250a4b824SJitendra Bhivare break;
495350a4b824SJitendra Bhivare
495450a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_CHAP_NAME:
495550a4b824SJitendra Bhivare rc = sprintf(str, "%.*s\n",
495650a4b824SJitendra Bhivare boot_conn->negotiated_login_options.auth_data.chap.
495750a4b824SJitendra Bhivare target_chap_name_length,
495850a4b824SJitendra Bhivare (char *)&boot_conn->negotiated_login_options.
495950a4b824SJitendra Bhivare auth_data.chap.target_chap_name);
496050a4b824SJitendra Bhivare break;
496150a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_CHAP_SECRET:
496250a4b824SJitendra Bhivare rc = sprintf(str, "%.*s\n",
496350a4b824SJitendra Bhivare boot_conn->negotiated_login_options.auth_data.chap.
496450a4b824SJitendra Bhivare target_secret_length,
496550a4b824SJitendra Bhivare (char *)&boot_conn->negotiated_login_options.
496650a4b824SJitendra Bhivare auth_data.chap.target_secret);
496750a4b824SJitendra Bhivare break;
496850a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_REV_CHAP_NAME:
496950a4b824SJitendra Bhivare rc = sprintf(str, "%.*s\n",
497050a4b824SJitendra Bhivare boot_conn->negotiated_login_options.auth_data.chap.
497150a4b824SJitendra Bhivare intr_chap_name_length,
497250a4b824SJitendra Bhivare (char *)&boot_conn->negotiated_login_options.
497350a4b824SJitendra Bhivare auth_data.chap.intr_chap_name);
497450a4b824SJitendra Bhivare break;
497550a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_REV_CHAP_SECRET:
497650a4b824SJitendra Bhivare rc = sprintf(str, "%.*s\n",
497750a4b824SJitendra Bhivare boot_conn->negotiated_login_options.auth_data.chap.
497850a4b824SJitendra Bhivare intr_secret_length,
497950a4b824SJitendra Bhivare (char *)&boot_conn->negotiated_login_options.
498050a4b824SJitendra Bhivare auth_data.chap.intr_secret);
498150a4b824SJitendra Bhivare break;
498250a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_FLAGS:
49838d9ecd49SJitendra Bhivare rc = sprintf(str, "%d\n", BEISCSI_SYSFS_ISCSI_BOOT_FLAGS);
498450a4b824SJitendra Bhivare break;
498550a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_NIC_ASSOC:
498650a4b824SJitendra Bhivare rc = sprintf(str, "0\n");
498750a4b824SJitendra Bhivare break;
498850a4b824SJitendra Bhivare }
498950a4b824SJitendra Bhivare return rc;
499050a4b824SJitendra Bhivare }
499150a4b824SJitendra Bhivare
beiscsi_show_boot_ini_info(void * data,int type,char * buf)499250a4b824SJitendra Bhivare static ssize_t beiscsi_show_boot_ini_info(void *data, int type, char *buf)
499350a4b824SJitendra Bhivare {
499450a4b824SJitendra Bhivare struct beiscsi_hba *phba = data;
499550a4b824SJitendra Bhivare char *str = buf;
499650a4b824SJitendra Bhivare int rc = -EPERM;
499750a4b824SJitendra Bhivare
499850a4b824SJitendra Bhivare switch (type) {
499950a4b824SJitendra Bhivare case ISCSI_BOOT_INI_INITIATOR_NAME:
500050a4b824SJitendra Bhivare rc = sprintf(str, "%s\n",
500150a4b824SJitendra Bhivare phba->boot_struct.boot_sess.initiator_iscsiname);
500250a4b824SJitendra Bhivare break;
500350a4b824SJitendra Bhivare }
500450a4b824SJitendra Bhivare return rc;
500550a4b824SJitendra Bhivare }
500650a4b824SJitendra Bhivare
beiscsi_show_boot_eth_info(void * data,int type,char * buf)500750a4b824SJitendra Bhivare static ssize_t beiscsi_show_boot_eth_info(void *data, int type, char *buf)
500850a4b824SJitendra Bhivare {
500950a4b824SJitendra Bhivare struct beiscsi_hba *phba = data;
501050a4b824SJitendra Bhivare char *str = buf;
501150a4b824SJitendra Bhivare int rc = -EPERM;
501250a4b824SJitendra Bhivare
501350a4b824SJitendra Bhivare switch (type) {
501450a4b824SJitendra Bhivare case ISCSI_BOOT_ETH_FLAGS:
50158d9ecd49SJitendra Bhivare rc = sprintf(str, "%d\n", BEISCSI_SYSFS_ISCSI_BOOT_FLAGS);
501650a4b824SJitendra Bhivare break;
501750a4b824SJitendra Bhivare case ISCSI_BOOT_ETH_INDEX:
501850a4b824SJitendra Bhivare rc = sprintf(str, "0\n");
501950a4b824SJitendra Bhivare break;
502050a4b824SJitendra Bhivare case ISCSI_BOOT_ETH_MAC:
502150a4b824SJitendra Bhivare rc = beiscsi_get_macaddr(str, phba);
502250a4b824SJitendra Bhivare break;
502350a4b824SJitendra Bhivare }
502450a4b824SJitendra Bhivare return rc;
502550a4b824SJitendra Bhivare }
502650a4b824SJitendra Bhivare
beiscsi_tgt_get_attr_visibility(void * data,int type)502750a4b824SJitendra Bhivare static umode_t beiscsi_tgt_get_attr_visibility(void *data, int type)
502850a4b824SJitendra Bhivare {
502950a4b824SJitendra Bhivare umode_t rc = 0;
503050a4b824SJitendra Bhivare
503150a4b824SJitendra Bhivare switch (type) {
503250a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_NAME:
503350a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_IP_ADDR:
503450a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_PORT:
503550a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_CHAP_NAME:
503650a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_CHAP_SECRET:
503750a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_REV_CHAP_NAME:
503850a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_REV_CHAP_SECRET:
503950a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_NIC_ASSOC:
504050a4b824SJitendra Bhivare case ISCSI_BOOT_TGT_FLAGS:
504150a4b824SJitendra Bhivare rc = S_IRUGO;
504250a4b824SJitendra Bhivare break;
504350a4b824SJitendra Bhivare }
504450a4b824SJitendra Bhivare return rc;
504550a4b824SJitendra Bhivare }
504650a4b824SJitendra Bhivare
beiscsi_ini_get_attr_visibility(void * data,int type)504750a4b824SJitendra Bhivare static umode_t beiscsi_ini_get_attr_visibility(void *data, int type)
504850a4b824SJitendra Bhivare {
504950a4b824SJitendra Bhivare umode_t rc = 0;
505050a4b824SJitendra Bhivare
505150a4b824SJitendra Bhivare switch (type) {
505250a4b824SJitendra Bhivare case ISCSI_BOOT_INI_INITIATOR_NAME:
505350a4b824SJitendra Bhivare rc = S_IRUGO;
505450a4b824SJitendra Bhivare break;
505550a4b824SJitendra Bhivare }
505650a4b824SJitendra Bhivare return rc;
505750a4b824SJitendra Bhivare }
505850a4b824SJitendra Bhivare
beiscsi_eth_get_attr_visibility(void * data,int type)505950a4b824SJitendra Bhivare static umode_t beiscsi_eth_get_attr_visibility(void *data, int type)
506050a4b824SJitendra Bhivare {
506150a4b824SJitendra Bhivare umode_t rc = 0;
506250a4b824SJitendra Bhivare
506350a4b824SJitendra Bhivare switch (type) {
506450a4b824SJitendra Bhivare case ISCSI_BOOT_ETH_FLAGS:
506550a4b824SJitendra Bhivare case ISCSI_BOOT_ETH_MAC:
506650a4b824SJitendra Bhivare case ISCSI_BOOT_ETH_INDEX:
506750a4b824SJitendra Bhivare rc = S_IRUGO;
506850a4b824SJitendra Bhivare break;
506950a4b824SJitendra Bhivare }
507050a4b824SJitendra Bhivare return rc;
507150a4b824SJitendra Bhivare }
507250a4b824SJitendra Bhivare
beiscsi_boot_kobj_release(void * data)507350a4b824SJitendra Bhivare static void beiscsi_boot_kobj_release(void *data)
507450a4b824SJitendra Bhivare {
507550a4b824SJitendra Bhivare struct beiscsi_hba *phba = data;
507650a4b824SJitendra Bhivare
507750a4b824SJitendra Bhivare scsi_host_put(phba->shost);
507850a4b824SJitendra Bhivare }
507950a4b824SJitendra Bhivare
beiscsi_boot_create_kset(struct beiscsi_hba * phba)508050a4b824SJitendra Bhivare static int beiscsi_boot_create_kset(struct beiscsi_hba *phba)
508150a4b824SJitendra Bhivare {
508250a4b824SJitendra Bhivare struct boot_struct *bs = &phba->boot_struct;
508350a4b824SJitendra Bhivare struct iscsi_boot_kobj *boot_kobj;
508450a4b824SJitendra Bhivare
508550a4b824SJitendra Bhivare if (bs->boot_kset) {
508650a4b824SJitendra Bhivare __beiscsi_log(phba, KERN_ERR,
508750a4b824SJitendra Bhivare "BM_%d: boot_kset already created\n");
508850a4b824SJitendra Bhivare return 0;
508950a4b824SJitendra Bhivare }
509050a4b824SJitendra Bhivare
509150a4b824SJitendra Bhivare bs->boot_kset = iscsi_boot_create_host_kset(phba->shost->host_no);
509250a4b824SJitendra Bhivare if (!bs->boot_kset) {
509350a4b824SJitendra Bhivare __beiscsi_log(phba, KERN_ERR,
509450a4b824SJitendra Bhivare "BM_%d: boot_kset alloc failed\n");
509550a4b824SJitendra Bhivare return -ENOMEM;
509650a4b824SJitendra Bhivare }
509750a4b824SJitendra Bhivare
509850a4b824SJitendra Bhivare /* get shost ref because the show function will refer phba */
509950a4b824SJitendra Bhivare if (!scsi_host_get(phba->shost))
510050a4b824SJitendra Bhivare goto free_kset;
510150a4b824SJitendra Bhivare
510250a4b824SJitendra Bhivare boot_kobj = iscsi_boot_create_target(bs->boot_kset, 0, phba,
510350a4b824SJitendra Bhivare beiscsi_show_boot_tgt_info,
510450a4b824SJitendra Bhivare beiscsi_tgt_get_attr_visibility,
510550a4b824SJitendra Bhivare beiscsi_boot_kobj_release);
510650a4b824SJitendra Bhivare if (!boot_kobj)
510750a4b824SJitendra Bhivare goto put_shost;
510850a4b824SJitendra Bhivare
510950a4b824SJitendra Bhivare if (!scsi_host_get(phba->shost))
511050a4b824SJitendra Bhivare goto free_kset;
511150a4b824SJitendra Bhivare
511250a4b824SJitendra Bhivare boot_kobj = iscsi_boot_create_initiator(bs->boot_kset, 0, phba,
511350a4b824SJitendra Bhivare beiscsi_show_boot_ini_info,
511450a4b824SJitendra Bhivare beiscsi_ini_get_attr_visibility,
511550a4b824SJitendra Bhivare beiscsi_boot_kobj_release);
511650a4b824SJitendra Bhivare if (!boot_kobj)
511750a4b824SJitendra Bhivare goto put_shost;
511850a4b824SJitendra Bhivare
511950a4b824SJitendra Bhivare if (!scsi_host_get(phba->shost))
512050a4b824SJitendra Bhivare goto free_kset;
512150a4b824SJitendra Bhivare
512250a4b824SJitendra Bhivare boot_kobj = iscsi_boot_create_ethernet(bs->boot_kset, 0, phba,
512350a4b824SJitendra Bhivare beiscsi_show_boot_eth_info,
512450a4b824SJitendra Bhivare beiscsi_eth_get_attr_visibility,
512550a4b824SJitendra Bhivare beiscsi_boot_kobj_release);
512650a4b824SJitendra Bhivare if (!boot_kobj)
512750a4b824SJitendra Bhivare goto put_shost;
512850a4b824SJitendra Bhivare
512950a4b824SJitendra Bhivare return 0;
513050a4b824SJitendra Bhivare
513150a4b824SJitendra Bhivare put_shost:
513250a4b824SJitendra Bhivare scsi_host_put(phba->shost);
513350a4b824SJitendra Bhivare free_kset:
513450a4b824SJitendra Bhivare iscsi_boot_destroy_kset(bs->boot_kset);
513550a4b824SJitendra Bhivare bs->boot_kset = NULL;
513650a4b824SJitendra Bhivare return -ENOMEM;
513750a4b824SJitendra Bhivare }
513850a4b824SJitendra Bhivare
beiscsi_boot_work(struct work_struct * work)513950a4b824SJitendra Bhivare static void beiscsi_boot_work(struct work_struct *work)
514050a4b824SJitendra Bhivare {
514150a4b824SJitendra Bhivare struct beiscsi_hba *phba =
514250a4b824SJitendra Bhivare container_of(work, struct beiscsi_hba, boot_work);
514350a4b824SJitendra Bhivare struct boot_struct *bs = &phba->boot_struct;
514450a4b824SJitendra Bhivare unsigned int tag = 0;
514550a4b824SJitendra Bhivare
5146d1d5ca88SJitendra Bhivare if (!beiscsi_hba_is_online(phba))
514750a4b824SJitendra Bhivare return;
514850a4b824SJitendra Bhivare
514950a4b824SJitendra Bhivare beiscsi_log(phba, KERN_INFO,
515050a4b824SJitendra Bhivare BEISCSI_LOG_CONFIG | BEISCSI_LOG_MBOX,
515150a4b824SJitendra Bhivare "BM_%d : %s action %d\n",
515250a4b824SJitendra Bhivare __func__, phba->boot_struct.action);
515350a4b824SJitendra Bhivare
515450a4b824SJitendra Bhivare switch (phba->boot_struct.action) {
515550a4b824SJitendra Bhivare case BEISCSI_BOOT_REOPEN_SESS:
515650a4b824SJitendra Bhivare tag = beiscsi_boot_reopen_sess(phba);
515750a4b824SJitendra Bhivare break;
515850a4b824SJitendra Bhivare case BEISCSI_BOOT_GET_SHANDLE:
515950a4b824SJitendra Bhivare tag = __beiscsi_boot_get_shandle(phba, 1);
516050a4b824SJitendra Bhivare break;
516150a4b824SJitendra Bhivare case BEISCSI_BOOT_GET_SINFO:
516250a4b824SJitendra Bhivare tag = beiscsi_boot_get_sinfo(phba);
516350a4b824SJitendra Bhivare break;
516450a4b824SJitendra Bhivare case BEISCSI_BOOT_LOGOUT_SESS:
516550a4b824SJitendra Bhivare tag = beiscsi_boot_logout_sess(phba);
516650a4b824SJitendra Bhivare break;
516750a4b824SJitendra Bhivare case BEISCSI_BOOT_CREATE_KSET:
516850a4b824SJitendra Bhivare beiscsi_boot_create_kset(phba);
516950a4b824SJitendra Bhivare /**
517050a4b824SJitendra Bhivare * updated boot_kset is made visible to all before
517150a4b824SJitendra Bhivare * ending the boot work.
517250a4b824SJitendra Bhivare */
517350a4b824SJitendra Bhivare mb();
517450a4b824SJitendra Bhivare clear_bit(BEISCSI_HBA_BOOT_WORK, &phba->state);
517550a4b824SJitendra Bhivare return;
517650a4b824SJitendra Bhivare }
517750a4b824SJitendra Bhivare if (!tag) {
517850a4b824SJitendra Bhivare if (bs->retry--)
517950a4b824SJitendra Bhivare schedule_work(&phba->boot_work);
518050a4b824SJitendra Bhivare else
518150a4b824SJitendra Bhivare clear_bit(BEISCSI_HBA_BOOT_WORK, &phba->state);
518250a4b824SJitendra Bhivare }
518350a4b824SJitendra Bhivare }
518450a4b824SJitendra Bhivare
beiscsi_eqd_update_work(struct work_struct * work)518510bcd47dSJitendra Bhivare static void beiscsi_eqd_update_work(struct work_struct *work)
518610bcd47dSJitendra Bhivare {
518710bcd47dSJitendra Bhivare struct hwi_context_memory *phwi_context;
518810bcd47dSJitendra Bhivare struct be_set_eqd set_eqd[MAX_CPUS];
518910bcd47dSJitendra Bhivare struct hwi_controller *phwi_ctrlr;
519010bcd47dSJitendra Bhivare struct be_eq_obj *pbe_eq;
519110bcd47dSJitendra Bhivare struct beiscsi_hba *phba;
519210bcd47dSJitendra Bhivare unsigned int pps, delta;
519310bcd47dSJitendra Bhivare struct be_aic_obj *aic;
519410bcd47dSJitendra Bhivare int eqd, i, num = 0;
519510bcd47dSJitendra Bhivare unsigned long now;
519610bcd47dSJitendra Bhivare
519710bcd47dSJitendra Bhivare phba = container_of(work, struct beiscsi_hba, eqd_update.work);
5198d1d5ca88SJitendra Bhivare if (!beiscsi_hba_is_online(phba))
51999122e991SJitendra Bhivare return;
52009122e991SJitendra Bhivare
520173af08e1SJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
520273af08e1SJayamohan Kallickal phwi_context = phwi_ctrlr->phwi_ctxt;
520373af08e1SJayamohan Kallickal
520473af08e1SJayamohan Kallickal for (i = 0; i <= phba->num_cpus; i++) {
520573af08e1SJayamohan Kallickal aic = &phba->aic_obj[i];
520673af08e1SJayamohan Kallickal pbe_eq = &phwi_context->be_eq[i];
520773af08e1SJayamohan Kallickal now = jiffies;
520810bcd47dSJitendra Bhivare if (!aic->jiffies || time_before(now, aic->jiffies) ||
520973af08e1SJayamohan Kallickal pbe_eq->cq_count < aic->eq_prev) {
521010bcd47dSJitendra Bhivare aic->jiffies = now;
521173af08e1SJayamohan Kallickal aic->eq_prev = pbe_eq->cq_count;
521273af08e1SJayamohan Kallickal continue;
521373af08e1SJayamohan Kallickal }
521410bcd47dSJitendra Bhivare delta = jiffies_to_msecs(now - aic->jiffies);
521573af08e1SJayamohan Kallickal pps = (((u32)(pbe_eq->cq_count - aic->eq_prev) * 1000) / delta);
521673af08e1SJayamohan Kallickal eqd = (pps / 1500) << 2;
521773af08e1SJayamohan Kallickal
521873af08e1SJayamohan Kallickal if (eqd < 8)
521973af08e1SJayamohan Kallickal eqd = 0;
522045efc940SJitendra Bhivare eqd = min_t(u32, eqd, BEISCSI_EQ_DELAY_MAX);
522145efc940SJitendra Bhivare eqd = max_t(u32, eqd, BEISCSI_EQ_DELAY_MIN);
522273af08e1SJayamohan Kallickal
522310bcd47dSJitendra Bhivare aic->jiffies = now;
522473af08e1SJayamohan Kallickal aic->eq_prev = pbe_eq->cq_count;
522573af08e1SJayamohan Kallickal
522673af08e1SJayamohan Kallickal if (eqd != aic->prev_eqd) {
522773af08e1SJayamohan Kallickal set_eqd[num].delay_multiplier = (eqd * 65)/100;
522873af08e1SJayamohan Kallickal set_eqd[num].eq_id = pbe_eq->q.id;
522973af08e1SJayamohan Kallickal aic->prev_eqd = eqd;
523073af08e1SJayamohan Kallickal num++;
523173af08e1SJayamohan Kallickal }
523273af08e1SJayamohan Kallickal }
523310bcd47dSJitendra Bhivare if (num)
523410bcd47dSJitendra Bhivare /* completion of this is ignored */
523510bcd47dSJitendra Bhivare beiscsi_modify_eq_delay(phba, set_eqd, num);
523673af08e1SJayamohan Kallickal
523710bcd47dSJitendra Bhivare schedule_delayed_work(&phba->eqd_update,
523810bcd47dSJitendra Bhivare msecs_to_jiffies(BEISCSI_EQD_UPDATE_INTERVAL));
52397a158003SJohn Soni Jose }
52407a158003SJohn Soni Jose
beiscsi_hw_tpe_check(struct timer_list * t)5241b386eec6SKees Cook static void beiscsi_hw_tpe_check(struct timer_list *t)
5242d1d5ca88SJitendra Bhivare {
5243b386eec6SKees Cook struct beiscsi_hba *phba = from_timer(phba, t, hw_check);
5244d1d5ca88SJitendra Bhivare u32 wait;
5245d1d5ca88SJitendra Bhivare
5246d1d5ca88SJitendra Bhivare /* if not TPE, do nothing */
5247d1d5ca88SJitendra Bhivare if (!beiscsi_detect_tpe(phba))
5248d1d5ca88SJitendra Bhivare return;
5249d1d5ca88SJitendra Bhivare
5250d1d5ca88SJitendra Bhivare /* wait default 4000ms before recovering */
5251d1d5ca88SJitendra Bhivare wait = 4000;
5252d1d5ca88SJitendra Bhivare if (phba->ue2rp > BEISCSI_UE_DETECT_INTERVAL)
5253d1d5ca88SJitendra Bhivare wait = phba->ue2rp - BEISCSI_UE_DETECT_INTERVAL;
5254d1d5ca88SJitendra Bhivare queue_delayed_work(phba->wq, &phba->recover_port,
5255d1d5ca88SJitendra Bhivare msecs_to_jiffies(wait));
5256d1d5ca88SJitendra Bhivare }
5257d1d5ca88SJitendra Bhivare
beiscsi_hw_health_check(struct timer_list * t)5258b386eec6SKees Cook static void beiscsi_hw_health_check(struct timer_list *t)
5259d1d5ca88SJitendra Bhivare {
5260b386eec6SKees Cook struct beiscsi_hba *phba = from_timer(phba, t, hw_check);
5261d1d5ca88SJitendra Bhivare
5262d1d5ca88SJitendra Bhivare beiscsi_detect_ue(phba);
5263d1d5ca88SJitendra Bhivare if (beiscsi_detect_ue(phba)) {
5264d1d5ca88SJitendra Bhivare __beiscsi_log(phba, KERN_ERR,
5265d1d5ca88SJitendra Bhivare "BM_%d : port in error: %lx\n", phba->state);
526610e1a44aSJitendra Bhivare /* sessions are no longer valid, so first fail the sessions */
526710e1a44aSJitendra Bhivare queue_work(phba->wq, &phba->sess_work);
526810e1a44aSJitendra Bhivare
526910e1a44aSJitendra Bhivare /* detect UER supported */
5270d1d5ca88SJitendra Bhivare if (!test_bit(BEISCSI_HBA_UER_SUPP, &phba->state))
5271d1d5ca88SJitendra Bhivare return;
5272d1d5ca88SJitendra Bhivare /* modify this timer to check TPE */
5273841b86f3SKees Cook phba->hw_check.function = beiscsi_hw_tpe_check;
5274d1d5ca88SJitendra Bhivare }
5275d1d5ca88SJitendra Bhivare
5276d1d5ca88SJitendra Bhivare mod_timer(&phba->hw_check,
5277d1d5ca88SJitendra Bhivare jiffies + msecs_to_jiffies(BEISCSI_UE_DETECT_INTERVAL));
5278d1d5ca88SJitendra Bhivare }
5279d1d5ca88SJitendra Bhivare
5280d1d5ca88SJitendra Bhivare /*
5281d1d5ca88SJitendra Bhivare * beiscsi_enable_port()- Enables the disabled port.
5282d1d5ca88SJitendra Bhivare * Only port resources freed in disable function are reallocated.
5283d1d5ca88SJitendra Bhivare * This is called in HBA error handling path.
5284d1d5ca88SJitendra Bhivare *
5285d1d5ca88SJitendra Bhivare * @phba: Instance of driver private structure
5286d1d5ca88SJitendra Bhivare *
5287d1d5ca88SJitendra Bhivare **/
beiscsi_enable_port(struct beiscsi_hba * phba)5288d1d5ca88SJitendra Bhivare static int beiscsi_enable_port(struct beiscsi_hba *phba)
5289d1d5ca88SJitendra Bhivare {
5290d1d5ca88SJitendra Bhivare struct hwi_context_memory *phwi_context;
5291d1d5ca88SJitendra Bhivare struct hwi_controller *phwi_ctrlr;
5292d1d5ca88SJitendra Bhivare struct be_eq_obj *pbe_eq;
5293d1d5ca88SJitendra Bhivare int ret, i;
5294d1d5ca88SJitendra Bhivare
5295d1d5ca88SJitendra Bhivare if (test_bit(BEISCSI_HBA_ONLINE, &phba->state)) {
5296d1d5ca88SJitendra Bhivare __beiscsi_log(phba, KERN_ERR,
5297d1d5ca88SJitendra Bhivare "BM_%d : %s : port is online %lx\n",
5298d1d5ca88SJitendra Bhivare __func__, phba->state);
5299d1d5ca88SJitendra Bhivare return 0;
5300d1d5ca88SJitendra Bhivare }
5301d1d5ca88SJitendra Bhivare
5302d1d5ca88SJitendra Bhivare ret = beiscsi_init_sliport(phba);
5303d1d5ca88SJitendra Bhivare if (ret)
5304d1d5ca88SJitendra Bhivare return ret;
5305d1d5ca88SJitendra Bhivare
530683148866SChristoph Hellwig be2iscsi_enable_msix(phba);
5307d1d5ca88SJitendra Bhivare
5308d1d5ca88SJitendra Bhivare beiscsi_get_params(phba);
53091cb3c3fdSJitendra Bhivare beiscsi_set_host_data(phba);
5310d1d5ca88SJitendra Bhivare /* Re-enable UER. If different TPE occurs then it is recoverable. */
5311d1d5ca88SJitendra Bhivare beiscsi_set_uer_feature(phba);
5312d1d5ca88SJitendra Bhivare
5313bdd4aad7SMike Christie phba->shost->max_id = phba->params.cxns_per_ctrl - 1;
5314d1d5ca88SJitendra Bhivare phba->shost->can_queue = phba->params.ios_per_ctrl;
5315dd940972SJitendra Bhivare ret = beiscsi_init_port(phba);
5316dd940972SJitendra Bhivare if (ret < 0) {
5317d1d5ca88SJitendra Bhivare __beiscsi_log(phba, KERN_ERR,
5318dd940972SJitendra Bhivare "BM_%d : init port failed\n");
5319d1d5ca88SJitendra Bhivare goto disable_msix;
5320d1d5ca88SJitendra Bhivare }
5321d1d5ca88SJitendra Bhivare
5322d1d5ca88SJitendra Bhivare for (i = 0; i < MAX_MCC_CMD; i++) {
5323d1d5ca88SJitendra Bhivare init_waitqueue_head(&phba->ctrl.mcc_wait[i + 1]);
5324d1d5ca88SJitendra Bhivare phba->ctrl.mcc_tag[i] = i + 1;
5325d1d5ca88SJitendra Bhivare phba->ctrl.mcc_tag_status[i + 1] = 0;
5326d1d5ca88SJitendra Bhivare phba->ctrl.mcc_tag_available++;
5327d1d5ca88SJitendra Bhivare }
5328d1d5ca88SJitendra Bhivare
5329d1d5ca88SJitendra Bhivare phwi_ctrlr = phba->phwi_ctrlr;
5330d1d5ca88SJitendra Bhivare phwi_context = phwi_ctrlr->phwi_ctxt;
5331d1d5ca88SJitendra Bhivare for (i = 0; i < phba->num_cpus; i++) {
5332d1d5ca88SJitendra Bhivare pbe_eq = &phwi_context->be_eq[i];
5333d1d5ca88SJitendra Bhivare irq_poll_init(&pbe_eq->iopoll, be_iopoll_budget, be_iopoll);
5334d1d5ca88SJitendra Bhivare }
5335d1d5ca88SJitendra Bhivare
533683148866SChristoph Hellwig i = (phba->pcidev->msix_enabled) ? i : 0;
5337d1d5ca88SJitendra Bhivare /* Work item for MCC handling */
5338d1d5ca88SJitendra Bhivare pbe_eq = &phwi_context->be_eq[i];
5339d1d5ca88SJitendra Bhivare INIT_WORK(&pbe_eq->mcc_work, beiscsi_mcc_work);
5340d1d5ca88SJitendra Bhivare
5341d1d5ca88SJitendra Bhivare ret = beiscsi_init_irqs(phba);
5342d1d5ca88SJitendra Bhivare if (ret < 0) {
5343d1d5ca88SJitendra Bhivare __beiscsi_log(phba, KERN_ERR,
5344d1d5ca88SJitendra Bhivare "BM_%d : setup IRQs failed %d\n", ret);
5345d1d5ca88SJitendra Bhivare goto cleanup_port;
5346d1d5ca88SJitendra Bhivare }
5347d1d5ca88SJitendra Bhivare hwi_enable_intr(phba);
5348d1d5ca88SJitendra Bhivare /* port operational: clear all error bits */
5349d1d5ca88SJitendra Bhivare set_bit(BEISCSI_HBA_ONLINE, &phba->state);
5350d1d5ca88SJitendra Bhivare __beiscsi_log(phba, KERN_INFO,
5351d1d5ca88SJitendra Bhivare "BM_%d : port online: 0x%lx\n", phba->state);
5352d1d5ca88SJitendra Bhivare
5353d1d5ca88SJitendra Bhivare /* start hw_check timer and eqd_update work */
5354d1d5ca88SJitendra Bhivare schedule_delayed_work(&phba->eqd_update,
5355d1d5ca88SJitendra Bhivare msecs_to_jiffies(BEISCSI_EQD_UPDATE_INTERVAL));
5356d1d5ca88SJitendra Bhivare
5357d1d5ca88SJitendra Bhivare /**
5358d1d5ca88SJitendra Bhivare * Timer function gets modified for TPE detection.
5359d1d5ca88SJitendra Bhivare * Always reinit to do health check first.
5360d1d5ca88SJitendra Bhivare */
5361841b86f3SKees Cook phba->hw_check.function = beiscsi_hw_health_check;
5362d1d5ca88SJitendra Bhivare mod_timer(&phba->hw_check,
5363d1d5ca88SJitendra Bhivare jiffies + msecs_to_jiffies(BEISCSI_UE_DETECT_INTERVAL));
5364d1d5ca88SJitendra Bhivare return 0;
5365d1d5ca88SJitendra Bhivare
5366d1d5ca88SJitendra Bhivare cleanup_port:
5367d1d5ca88SJitendra Bhivare for (i = 0; i < phba->num_cpus; i++) {
5368d1d5ca88SJitendra Bhivare pbe_eq = &phwi_context->be_eq[i];
5369d1d5ca88SJitendra Bhivare irq_poll_disable(&pbe_eq->iopoll);
5370d1d5ca88SJitendra Bhivare }
5371d1d5ca88SJitendra Bhivare hwi_cleanup_port(phba);
5372d1d5ca88SJitendra Bhivare
5373d1d5ca88SJitendra Bhivare disable_msix:
537483148866SChristoph Hellwig pci_free_irq_vectors(phba->pcidev);
5375d1d5ca88SJitendra Bhivare return ret;
5376d1d5ca88SJitendra Bhivare }
5377d1d5ca88SJitendra Bhivare
5378d1d5ca88SJitendra Bhivare /*
5379d1d5ca88SJitendra Bhivare * beiscsi_disable_port()- Disable port and cleanup driver resources.
5380d1d5ca88SJitendra Bhivare * This is called in HBA error handling and driver removal.
5381d1d5ca88SJitendra Bhivare * @phba: Instance Priv structure
5382d1d5ca88SJitendra Bhivare * @unload: indicate driver is unloading
5383d1d5ca88SJitendra Bhivare *
5384d1d5ca88SJitendra Bhivare * Free the OS and HW resources held by the driver
5385d1d5ca88SJitendra Bhivare **/
beiscsi_disable_port(struct beiscsi_hba * phba,int unload)5386d1d5ca88SJitendra Bhivare static void beiscsi_disable_port(struct beiscsi_hba *phba, int unload)
5387d1d5ca88SJitendra Bhivare {
5388d1d5ca88SJitendra Bhivare struct hwi_context_memory *phwi_context;
5389d1d5ca88SJitendra Bhivare struct hwi_controller *phwi_ctrlr;
5390d1d5ca88SJitendra Bhivare struct be_eq_obj *pbe_eq;
539183148866SChristoph Hellwig unsigned int i;
5392d1d5ca88SJitendra Bhivare
5393d1d5ca88SJitendra Bhivare if (!test_and_clear_bit(BEISCSI_HBA_ONLINE, &phba->state))
5394d1d5ca88SJitendra Bhivare return;
5395d1d5ca88SJitendra Bhivare
5396d1d5ca88SJitendra Bhivare phwi_ctrlr = phba->phwi_ctrlr;
5397d1d5ca88SJitendra Bhivare phwi_context = phwi_ctrlr->phwi_ctxt;
5398d1d5ca88SJitendra Bhivare hwi_disable_intr(phba);
539945371aa3SJitendra Bhivare beiscsi_free_irqs(phba);
540083148866SChristoph Hellwig pci_free_irq_vectors(phba->pcidev);
5401d1d5ca88SJitendra Bhivare
5402d1d5ca88SJitendra Bhivare for (i = 0; i < phba->num_cpus; i++) {
5403d1d5ca88SJitendra Bhivare pbe_eq = &phwi_context->be_eq[i];
5404d1d5ca88SJitendra Bhivare irq_poll_disable(&pbe_eq->iopoll);
5405d1d5ca88SJitendra Bhivare }
5406d1d5ca88SJitendra Bhivare cancel_delayed_work_sync(&phba->eqd_update);
5407d1d5ca88SJitendra Bhivare cancel_work_sync(&phba->boot_work);
5408d1d5ca88SJitendra Bhivare /* WQ might be running cancel queued mcc_work if we are not exiting */
5409d1d5ca88SJitendra Bhivare if (!unload && beiscsi_hba_in_error(phba)) {
5410d1d5ca88SJitendra Bhivare pbe_eq = &phwi_context->be_eq[i];
5411d1d5ca88SJitendra Bhivare cancel_work_sync(&pbe_eq->mcc_work);
5412d1d5ca88SJitendra Bhivare }
5413d1d5ca88SJitendra Bhivare hwi_cleanup_port(phba);
5414dd940972SJitendra Bhivare beiscsi_cleanup_port(phba);
5415d1d5ca88SJitendra Bhivare }
5416d1d5ca88SJitendra Bhivare
beiscsi_sess_work(struct work_struct * work)541710e1a44aSJitendra Bhivare static void beiscsi_sess_work(struct work_struct *work)
541810e1a44aSJitendra Bhivare {
541910e1a44aSJitendra Bhivare struct beiscsi_hba *phba;
542010e1a44aSJitendra Bhivare
542110e1a44aSJitendra Bhivare phba = container_of(work, struct beiscsi_hba, sess_work);
542210e1a44aSJitendra Bhivare /*
542310e1a44aSJitendra Bhivare * This work gets scheduled only in case of HBA error.
542410e1a44aSJitendra Bhivare * Old sessions are gone so need to be re-established.
542510e1a44aSJitendra Bhivare * iscsi_session_failure needs process context hence this work.
542610e1a44aSJitendra Bhivare */
542710e1a44aSJitendra Bhivare iscsi_host_for_each_session(phba->shost, beiscsi_session_fail);
542810e1a44aSJitendra Bhivare }
542910e1a44aSJitendra Bhivare
beiscsi_recover_port(struct work_struct * work)5430d1d5ca88SJitendra Bhivare static void beiscsi_recover_port(struct work_struct *work)
5431d1d5ca88SJitendra Bhivare {
5432d1d5ca88SJitendra Bhivare struct beiscsi_hba *phba;
5433d1d5ca88SJitendra Bhivare
5434d1d5ca88SJitendra Bhivare phba = container_of(work, struct beiscsi_hba, recover_port.work);
5435d1d5ca88SJitendra Bhivare beiscsi_disable_port(phba, 0);
5436d1d5ca88SJitendra Bhivare beiscsi_enable_port(phba);
5437d1d5ca88SJitendra Bhivare }
54383567f36aSJayamohan Kallickal
beiscsi_eeh_err_detected(struct pci_dev * pdev,pci_channel_state_t state)54393567f36aSJayamohan Kallickal static pci_ers_result_t beiscsi_eeh_err_detected(struct pci_dev *pdev,
54403567f36aSJayamohan Kallickal pci_channel_state_t state)
54413567f36aSJayamohan Kallickal {
54423567f36aSJayamohan Kallickal struct beiscsi_hba *phba = NULL;
54433567f36aSJayamohan Kallickal
54443567f36aSJayamohan Kallickal phba = (struct beiscsi_hba *)pci_get_drvdata(pdev);
54459122e991SJitendra Bhivare set_bit(BEISCSI_HBA_PCI_ERR, &phba->state);
54463567f36aSJayamohan Kallickal
54473567f36aSJayamohan Kallickal beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
54483567f36aSJayamohan Kallickal "BM_%d : EEH error detected\n");
54493567f36aSJayamohan Kallickal
5450d1d5ca88SJitendra Bhivare /* first stop UE detection when PCI error detected */
5451d1d5ca88SJitendra Bhivare del_timer_sync(&phba->hw_check);
5452d1d5ca88SJitendra Bhivare cancel_delayed_work_sync(&phba->recover_port);
5453d1d5ca88SJitendra Bhivare
545410e1a44aSJitendra Bhivare /* sessions are no longer valid, so first fail the sessions */
545510e1a44aSJitendra Bhivare iscsi_host_for_each_session(phba->shost, beiscsi_session_fail);
5456d1d5ca88SJitendra Bhivare beiscsi_disable_port(phba, 0);
54573567f36aSJayamohan Kallickal
54583567f36aSJayamohan Kallickal if (state == pci_channel_io_perm_failure) {
54593567f36aSJayamohan Kallickal beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
54603567f36aSJayamohan Kallickal "BM_%d : EEH : State PERM Failure");
54613567f36aSJayamohan Kallickal return PCI_ERS_RESULT_DISCONNECT;
54623567f36aSJayamohan Kallickal }
54633567f36aSJayamohan Kallickal
54643567f36aSJayamohan Kallickal pci_disable_device(pdev);
54653567f36aSJayamohan Kallickal
54663567f36aSJayamohan Kallickal /* The error could cause the FW to trigger a flash debug dump.
54673567f36aSJayamohan Kallickal * Resetting the card while flash dump is in progress
54683567f36aSJayamohan Kallickal * can cause it not to recover; wait for it to finish.
54693567f36aSJayamohan Kallickal * Wait only for first function as it is needed only once per
54703567f36aSJayamohan Kallickal * adapter.
54713567f36aSJayamohan Kallickal **/
54723567f36aSJayamohan Kallickal if (pdev->devfn == 0)
54733567f36aSJayamohan Kallickal ssleep(30);
54743567f36aSJayamohan Kallickal
54753567f36aSJayamohan Kallickal return PCI_ERS_RESULT_NEED_RESET;
54763567f36aSJayamohan Kallickal }
54773567f36aSJayamohan Kallickal
beiscsi_eeh_reset(struct pci_dev * pdev)54783567f36aSJayamohan Kallickal static pci_ers_result_t beiscsi_eeh_reset(struct pci_dev *pdev)
54793567f36aSJayamohan Kallickal {
54803567f36aSJayamohan Kallickal struct beiscsi_hba *phba = NULL;
54813567f36aSJayamohan Kallickal int status = 0;
54823567f36aSJayamohan Kallickal
54833567f36aSJayamohan Kallickal phba = (struct beiscsi_hba *)pci_get_drvdata(pdev);
54843567f36aSJayamohan Kallickal
54853567f36aSJayamohan Kallickal beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
54863567f36aSJayamohan Kallickal "BM_%d : EEH Reset\n");
54873567f36aSJayamohan Kallickal
54883567f36aSJayamohan Kallickal status = pci_enable_device(pdev);
54893567f36aSJayamohan Kallickal if (status)
54903567f36aSJayamohan Kallickal return PCI_ERS_RESULT_DISCONNECT;
54913567f36aSJayamohan Kallickal
54923567f36aSJayamohan Kallickal pci_set_master(pdev);
54933567f36aSJayamohan Kallickal pci_set_power_state(pdev, PCI_D0);
54943567f36aSJayamohan Kallickal pci_restore_state(pdev);
54953567f36aSJayamohan Kallickal
54964d2ee1e6SJitendra Bhivare status = beiscsi_check_fw_rdy(phba);
54974d2ee1e6SJitendra Bhivare if (status) {
54983567f36aSJayamohan Kallickal beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT,
54993567f36aSJayamohan Kallickal "BM_%d : EEH Reset Completed\n");
55003567f36aSJayamohan Kallickal } else {
55013567f36aSJayamohan Kallickal beiscsi_log(phba, KERN_WARNING, BEISCSI_LOG_INIT,
55023567f36aSJayamohan Kallickal "BM_%d : EEH Reset Completion Failure\n");
55033567f36aSJayamohan Kallickal return PCI_ERS_RESULT_DISCONNECT;
55043567f36aSJayamohan Kallickal }
55053567f36aSJayamohan Kallickal
55063567f36aSJayamohan Kallickal return PCI_ERS_RESULT_RECOVERED;
55073567f36aSJayamohan Kallickal }
55083567f36aSJayamohan Kallickal
beiscsi_eeh_resume(struct pci_dev * pdev)55093567f36aSJayamohan Kallickal static void beiscsi_eeh_resume(struct pci_dev *pdev)
55103567f36aSJayamohan Kallickal {
5511d1d5ca88SJitendra Bhivare struct beiscsi_hba *phba;
5512d1d5ca88SJitendra Bhivare int ret;
55133567f36aSJayamohan Kallickal
55143567f36aSJayamohan Kallickal phba = (struct beiscsi_hba *)pci_get_drvdata(pdev);
55153567f36aSJayamohan Kallickal pci_save_state(pdev);
55163567f36aSJayamohan Kallickal
5517d1d5ca88SJitendra Bhivare ret = beiscsi_enable_port(phba);
55184d2ee1e6SJitendra Bhivare if (ret)
5519d1d5ca88SJitendra Bhivare __beiscsi_log(phba, KERN_ERR,
5520d1d5ca88SJitendra Bhivare "BM_%d : AER EEH resume failed\n");
55213567f36aSJayamohan Kallickal }
55223567f36aSJayamohan Kallickal
beiscsi_dev_probe(struct pci_dev * pcidev,const struct pci_device_id * id)55236f039790SGreg Kroah-Hartman static int beiscsi_dev_probe(struct pci_dev *pcidev,
55246733b39aSJayamohan Kallickal const struct pci_device_id *id)
55256733b39aSJayamohan Kallickal {
5526bfead3b2SJayamohan Kallickal struct hwi_context_memory *phwi_context;
552729e80b7cSJitendra Bhivare struct hwi_controller *phwi_ctrlr;
552829e80b7cSJitendra Bhivare struct beiscsi_hba *phba = NULL;
5529bfead3b2SJayamohan Kallickal struct be_eq_obj *pbe_eq;
553050a4b824SJitendra Bhivare unsigned int s_handle;
553129e80b7cSJitendra Bhivare char wq_name[20];
5532deeea8edSChristophe JAILLET int ret, i;
55336733b39aSJayamohan Kallickal
55346733b39aSJayamohan Kallickal ret = beiscsi_enable_pci(pcidev);
55356733b39aSJayamohan Kallickal if (ret < 0) {
553699bc5d55SJohn Soni Jose dev_err(&pcidev->dev,
553799bc5d55SJohn Soni Jose "beiscsi_dev_probe - Failed to enable pci device\n");
55386733b39aSJayamohan Kallickal return ret;
55396733b39aSJayamohan Kallickal }
55406733b39aSJayamohan Kallickal
55416733b39aSJayamohan Kallickal phba = beiscsi_hba_alloc(pcidev);
55426733b39aSJayamohan Kallickal if (!phba) {
554399bc5d55SJohn Soni Jose dev_err(&pcidev->dev,
554499bc5d55SJohn Soni Jose "beiscsi_dev_probe - Failed in beiscsi_hba_alloc\n");
5545deeea8edSChristophe JAILLET ret = -ENOMEM;
55466733b39aSJayamohan Kallickal goto disable_pci;
55476733b39aSJayamohan Kallickal }
55486733b39aSJayamohan Kallickal
55493567f36aSJayamohan Kallickal pci_save_state(pcidev);
55503567f36aSJayamohan Kallickal
555199bc5d55SJohn Soni Jose /* Initialize Driver configuration Paramters */
555299bc5d55SJohn Soni Jose beiscsi_hba_attrs_init(phba);
555399bc5d55SJohn Soni Jose
55546c83185aSJayamohan Kallickal phba->mac_addr_set = false;
5555e175defeSJohn Soni Jose
5556f98c96b0SJayamohan Kallickal switch (pcidev->device) {
5557f98c96b0SJayamohan Kallickal case BE_DEVICE_ID1:
5558f98c96b0SJayamohan Kallickal case OC_DEVICE_ID1:
5559f98c96b0SJayamohan Kallickal case OC_DEVICE_ID2:
5560f98c96b0SJayamohan Kallickal phba->generation = BE_GEN2;
556109a1093aSJohn Soni Jose phba->iotask_fn = beiscsi_iotask;
55625fa7db21SKetan Mukadam dev_warn(&pcidev->dev,
55635fa7db21SKetan Mukadam "Obsolete/Unsupported BE2 Adapter Family\n");
5564f98c96b0SJayamohan Kallickal break;
5565f98c96b0SJayamohan Kallickal case BE_DEVICE_ID2:
5566f98c96b0SJayamohan Kallickal case OC_DEVICE_ID3:
5567f98c96b0SJayamohan Kallickal phba->generation = BE_GEN3;
556809a1093aSJohn Soni Jose phba->iotask_fn = beiscsi_iotask;
5569f98c96b0SJayamohan Kallickal break;
5570139a1b1eSJohn Soni Jose case OC_SKH_ID1:
5571139a1b1eSJohn Soni Jose phba->generation = BE_GEN4;
557209a1093aSJohn Soni Jose phba->iotask_fn = beiscsi_iotask_v2;
5573bf9131cbSJayamohan Kallickal break;
5574f98c96b0SJayamohan Kallickal default:
5575f98c96b0SJayamohan Kallickal phba->generation = 0;
5576f98c96b0SJayamohan Kallickal }
5577f98c96b0SJayamohan Kallickal
55786733b39aSJayamohan Kallickal ret = be_ctrl_init(phba, pcidev);
55796733b39aSJayamohan Kallickal if (ret) {
558099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
55814d2ee1e6SJitendra Bhivare "BM_%d : be_ctrl_init failed\n");
558245371aa3SJitendra Bhivare goto free_hba;
55836733b39aSJayamohan Kallickal }
55846733b39aSJayamohan Kallickal
55854d2ee1e6SJitendra Bhivare ret = beiscsi_init_sliport(phba);
55864d2ee1e6SJitendra Bhivare if (ret)
558745371aa3SJitendra Bhivare goto free_hba;
55884d2ee1e6SJitendra Bhivare
55896733b39aSJayamohan Kallickal spin_lock_init(&phba->io_sgl_lock);
55906733b39aSJayamohan Kallickal spin_lock_init(&phba->mgmt_sgl_lock);
55918f09a3b9SJayamohan Kallickal spin_lock_init(&phba->async_pdu_lock);
5592480195c2SJitendra Bhivare ret = beiscsi_get_fw_config(&phba->ctrl, phba);
55937da50879SJayamohan Kallickal if (ret != 0) {
559499bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
559599bc5d55SJohn Soni Jose "BM_%d : Error getting fw config\n");
55967da50879SJayamohan Kallickal goto free_port;
55977da50879SJayamohan Kallickal }
5598480195c2SJitendra Bhivare beiscsi_get_port_name(&phba->ctrl, phba);
55994570f161SJitendra Bhivare beiscsi_get_params(phba);
56001cb3c3fdSJitendra Bhivare beiscsi_set_host_data(phba);
56016694095bSJitendra Bhivare beiscsi_set_uer_feature(phba);
560268c26a3aSJayamohan Kallickal
560383148866SChristoph Hellwig be2iscsi_enable_msix(phba);
560468c26a3aSJayamohan Kallickal
560568c26a3aSJayamohan Kallickal beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
560668c26a3aSJayamohan Kallickal "BM_%d : num_cpus = %d\n",
560768c26a3aSJayamohan Kallickal phba->num_cpus);
560868c26a3aSJayamohan Kallickal
5609843ae752SJayamohan Kallickal phba->shost->max_id = phba->params.cxns_per_ctrl;
5610aa874f07SJayamohan Kallickal phba->shost->can_queue = phba->params.ios_per_ctrl;
5611dd940972SJitendra Bhivare ret = beiscsi_get_memory(phba);
5612dd940972SJitendra Bhivare if (ret < 0) {
5613dd940972SJitendra Bhivare beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
5614dd940972SJitendra Bhivare "BM_%d : alloc host mem failed\n");
5615dd940972SJitendra Bhivare goto free_port;
5616dd940972SJitendra Bhivare }
5617dd940972SJitendra Bhivare
56186733b39aSJayamohan Kallickal ret = beiscsi_init_port(phba);
56196733b39aSJayamohan Kallickal if (ret < 0) {
562099bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
5621dd940972SJitendra Bhivare "BM_%d : init port failed\n");
5622dd940972SJitendra Bhivare beiscsi_free_mem(phba);
56236733b39aSJayamohan Kallickal goto free_port;
56246733b39aSJayamohan Kallickal }
56256733b39aSJayamohan Kallickal
5626756d29c8SJayamohan Kallickal for (i = 0; i < MAX_MCC_CMD; i++) {
5627756d29c8SJayamohan Kallickal init_waitqueue_head(&phba->ctrl.mcc_wait[i + 1]);
5628756d29c8SJayamohan Kallickal phba->ctrl.mcc_tag[i] = i + 1;
562967296ad9SJitendra Bhivare phba->ctrl.mcc_tag_status[i + 1] = 0;
5630756d29c8SJayamohan Kallickal phba->ctrl.mcc_tag_available++;
56311957aa7fSJayamohan Kallickal memset(&phba->ctrl.ptag_state[i].tag_mem_state, 0,
56328fc01eaaSJayamohan Kallickal sizeof(struct be_dma_mem));
5633756d29c8SJayamohan Kallickal }
5634756d29c8SJayamohan Kallickal
5635756d29c8SJayamohan Kallickal phba->ctrl.mcc_alloc_index = phba->ctrl.mcc_free_index = 0;
5636756d29c8SJayamohan Kallickal
563729e80b7cSJitendra Bhivare snprintf(wq_name, sizeof(wq_name), "beiscsi_%02x_wq",
56386733b39aSJayamohan Kallickal phba->shost->host_no);
563929e80b7cSJitendra Bhivare phba->wq = alloc_workqueue("%s", WQ_MEM_RECLAIM, 1, wq_name);
56406733b39aSJayamohan Kallickal if (!phba->wq) {
564199bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
564299bc5d55SJohn Soni Jose "BM_%d : beiscsi_dev_probe-"
56436733b39aSJayamohan Kallickal "Failed to allocate work queue\n");
5644deeea8edSChristophe JAILLET ret = -ENOMEM;
56456733b39aSJayamohan Kallickal goto free_twq;
56466733b39aSJayamohan Kallickal }
56476733b39aSJayamohan Kallickal
564810bcd47dSJitendra Bhivare INIT_DELAYED_WORK(&phba->eqd_update, beiscsi_eqd_update_work);
56496733b39aSJayamohan Kallickal
5650bfead3b2SJayamohan Kallickal phwi_ctrlr = phba->phwi_ctrlr;
5651bfead3b2SJayamohan Kallickal phwi_context = phwi_ctrlr->phwi_ctxt;
565272fb46a9SJohn Soni Jose
5653bfead3b2SJayamohan Kallickal for (i = 0; i < phba->num_cpus; i++) {
5654bfead3b2SJayamohan Kallickal pbe_eq = &phwi_context->be_eq[i];
5655d1d5ca88SJitendra Bhivare irq_poll_init(&pbe_eq->iopoll, be_iopoll_budget, be_iopoll);
56566733b39aSJayamohan Kallickal }
565772fb46a9SJohn Soni Jose
565883148866SChristoph Hellwig i = (phba->pcidev->msix_enabled) ? i : 0;
565972fb46a9SJohn Soni Jose /* Work item for MCC handling */
566072fb46a9SJohn Soni Jose pbe_eq = &phwi_context->be_eq[i];
5661a3095016SJitendra Bhivare INIT_WORK(&pbe_eq->mcc_work, beiscsi_mcc_work);
566272fb46a9SJohn Soni Jose
56636733b39aSJayamohan Kallickal ret = beiscsi_init_irqs(phba);
56646733b39aSJayamohan Kallickal if (ret < 0) {
566599bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_INIT,
566699bc5d55SJohn Soni Jose "BM_%d : beiscsi_dev_probe-"
56676733b39aSJayamohan Kallickal "Failed to beiscsi_init_irqs\n");
566845371aa3SJitendra Bhivare goto disable_iopoll;
56696733b39aSJayamohan Kallickal }
5670238f6b72SJayamohan Kallickal hwi_enable_intr(phba);
5671f457a46fSMike Christie
5672d1d5ca88SJitendra Bhivare ret = iscsi_host_add(phba->shost, &phba->pcidev->dev);
5673d1d5ca88SJitendra Bhivare if (ret)
567445371aa3SJitendra Bhivare goto free_irqs;
56750598b8afSJayamohan Kallickal
5676d1d5ca88SJitendra Bhivare /* set online bit after port is operational */
5677d1d5ca88SJitendra Bhivare set_bit(BEISCSI_HBA_ONLINE, &phba->state);
5678d1d5ca88SJitendra Bhivare __beiscsi_log(phba, KERN_INFO,
5679d1d5ca88SJitendra Bhivare "BM_%d : port online: 0x%lx\n", phba->state);
5680d1d5ca88SJitendra Bhivare
568150a4b824SJitendra Bhivare INIT_WORK(&phba->boot_work, beiscsi_boot_work);
568250a4b824SJitendra Bhivare ret = beiscsi_boot_get_shandle(phba, &s_handle);
568350a4b824SJitendra Bhivare if (ret > 0) {
568450a4b824SJitendra Bhivare beiscsi_start_boot_work(phba, s_handle);
568550a4b824SJitendra Bhivare /**
568650a4b824SJitendra Bhivare * Set this bit after starting the work to let
568750a4b824SJitendra Bhivare * probe handle it first.
568850a4b824SJitendra Bhivare * ASYNC event can too schedule this work.
5689f457a46fSMike Christie */
569050a4b824SJitendra Bhivare set_bit(BEISCSI_HBA_BOOT_FOUND, &phba->state);
569150a4b824SJitendra Bhivare }
5692f457a46fSMike Christie
569396b48b92SJitendra Bhivare beiscsi_iface_create_default(phba);
569410bcd47dSJitendra Bhivare schedule_delayed_work(&phba->eqd_update,
569510bcd47dSJitendra Bhivare msecs_to_jiffies(BEISCSI_EQD_UPDATE_INTERVAL));
5696d1d5ca88SJitendra Bhivare
569710e1a44aSJitendra Bhivare INIT_WORK(&phba->sess_work, beiscsi_sess_work);
5698d1d5ca88SJitendra Bhivare INIT_DELAYED_WORK(&phba->recover_port, beiscsi_recover_port);
569910bcd47dSJitendra Bhivare /**
570010bcd47dSJitendra Bhivare * Start UE detection here. UE before this will cause stall in probe
570110bcd47dSJitendra Bhivare * and eventually fail the probe.
570210bcd47dSJitendra Bhivare */
5703b386eec6SKees Cook timer_setup(&phba->hw_check, beiscsi_hw_health_check, 0);
570410bcd47dSJitendra Bhivare mod_timer(&phba->hw_check,
570510bcd47dSJitendra Bhivare jiffies + msecs_to_jiffies(BEISCSI_UE_DETECT_INTERVAL));
570699bc5d55SJohn Soni Jose beiscsi_log(phba, KERN_INFO, BEISCSI_LOG_INIT,
570799bc5d55SJohn Soni Jose "\n\n\n BM_%d : SUCCESS - DRIVER LOADED\n\n\n");
57086733b39aSJayamohan Kallickal return 0;
57096733b39aSJayamohan Kallickal
571045371aa3SJitendra Bhivare free_irqs:
571145371aa3SJitendra Bhivare hwi_disable_intr(phba);
571245371aa3SJitendra Bhivare beiscsi_free_irqs(phba);
571345371aa3SJitendra Bhivare disable_iopoll:
5714bfead3b2SJayamohan Kallickal for (i = 0; i < phba->num_cpus; i++) {
5715bfead3b2SJayamohan Kallickal pbe_eq = &phwi_context->be_eq[i];
5716511cbce2SChristoph Hellwig irq_poll_disable(&pbe_eq->iopoll);
5717bfead3b2SJayamohan Kallickal }
571845371aa3SJitendra Bhivare destroy_workqueue(phba->wq);
57196733b39aSJayamohan Kallickal free_twq:
5720d1d5ca88SJitendra Bhivare hwi_cleanup_port(phba);
57214d2ee1e6SJitendra Bhivare beiscsi_cleanup_port(phba);
57226733b39aSJayamohan Kallickal beiscsi_free_mem(phba);
57236733b39aSJayamohan Kallickal free_port:
572426a4c991SChristoph Hellwig dma_free_coherent(&phba->pcidev->dev,
57256733b39aSJayamohan Kallickal phba->ctrl.mbox_mem_alloced.size,
57266733b39aSJayamohan Kallickal phba->ctrl.mbox_mem_alloced.va,
57276733b39aSJayamohan Kallickal phba->ctrl.mbox_mem_alloced.dma);
57286733b39aSJayamohan Kallickal beiscsi_unmap_pci_function(phba);
572945371aa3SJitendra Bhivare free_hba:
5730238f6b72SJayamohan Kallickal pci_disable_msix(phba->pcidev);
57316733b39aSJayamohan Kallickal pci_dev_put(phba->pcidev);
57326733b39aSJayamohan Kallickal iscsi_host_free(phba->shost);
57332e7cee02SJohn Soni Jose pci_set_drvdata(pcidev, NULL);
57346733b39aSJayamohan Kallickal disable_pci:
5735e307f3acSJohn Soni Jose pci_release_regions(pcidev);
57366733b39aSJayamohan Kallickal pci_disable_device(pcidev);
57376733b39aSJayamohan Kallickal return ret;
57386733b39aSJayamohan Kallickal }
57396733b39aSJayamohan Kallickal
beiscsi_remove(struct pci_dev * pcidev)5740d1d5ca88SJitendra Bhivare static void beiscsi_remove(struct pci_dev *pcidev)
5741d1d5ca88SJitendra Bhivare {
5742d1d5ca88SJitendra Bhivare struct beiscsi_hba *phba = NULL;
5743d1d5ca88SJitendra Bhivare
5744d1d5ca88SJitendra Bhivare phba = pci_get_drvdata(pcidev);
5745d1d5ca88SJitendra Bhivare if (!phba) {
5746d1d5ca88SJitendra Bhivare dev_err(&pcidev->dev, "beiscsi_remove called with no phba\n");
5747d1d5ca88SJitendra Bhivare return;
5748d1d5ca88SJitendra Bhivare }
5749d1d5ca88SJitendra Bhivare
5750d1d5ca88SJitendra Bhivare /* first stop UE detection before unloading */
5751d1d5ca88SJitendra Bhivare del_timer_sync(&phba->hw_check);
5752d1d5ca88SJitendra Bhivare cancel_delayed_work_sync(&phba->recover_port);
575310e1a44aSJitendra Bhivare cancel_work_sync(&phba->sess_work);
5754d1d5ca88SJitendra Bhivare
5755d1d5ca88SJitendra Bhivare beiscsi_iface_destroy_default(phba);
575631500e90SMike Christie iscsi_host_remove(phba->shost, false);
5757d1d5ca88SJitendra Bhivare beiscsi_disable_port(phba, 1);
5758d1d5ca88SJitendra Bhivare
5759d1d5ca88SJitendra Bhivare /* after cancelling boot_work */
5760d1d5ca88SJitendra Bhivare iscsi_boot_destroy_kset(phba->boot_struct.boot_kset);
5761d1d5ca88SJitendra Bhivare
5762d1d5ca88SJitendra Bhivare /* free all resources */
5763d1d5ca88SJitendra Bhivare destroy_workqueue(phba->wq);
5764d1d5ca88SJitendra Bhivare beiscsi_free_mem(phba);
5765d1d5ca88SJitendra Bhivare
5766d1d5ca88SJitendra Bhivare /* ctrl uninit */
5767d1d5ca88SJitendra Bhivare beiscsi_unmap_pci_function(phba);
576826a4c991SChristoph Hellwig dma_free_coherent(&phba->pcidev->dev,
5769d1d5ca88SJitendra Bhivare phba->ctrl.mbox_mem_alloced.size,
5770d1d5ca88SJitendra Bhivare phba->ctrl.mbox_mem_alloced.va,
5771d1d5ca88SJitendra Bhivare phba->ctrl.mbox_mem_alloced.dma);
5772d1d5ca88SJitendra Bhivare
5773d1d5ca88SJitendra Bhivare pci_dev_put(phba->pcidev);
5774d1d5ca88SJitendra Bhivare iscsi_host_free(phba->shost);
5775d1d5ca88SJitendra Bhivare pci_set_drvdata(pcidev, NULL);
5776d1d5ca88SJitendra Bhivare pci_release_regions(pcidev);
5777d1d5ca88SJitendra Bhivare pci_disable_device(pcidev);
5778d1d5ca88SJitendra Bhivare }
5779d1d5ca88SJitendra Bhivare
5780d1d5ca88SJitendra Bhivare
57813567f36aSJayamohan Kallickal static struct pci_error_handlers beiscsi_eeh_handlers = {
57823567f36aSJayamohan Kallickal .error_detected = beiscsi_eeh_err_detected,
57833567f36aSJayamohan Kallickal .slot_reset = beiscsi_eeh_reset,
57843567f36aSJayamohan Kallickal .resume = beiscsi_eeh_resume,
57853567f36aSJayamohan Kallickal };
57863567f36aSJayamohan Kallickal
57876733b39aSJayamohan Kallickal struct iscsi_transport beiscsi_iscsi_transport = {
57886733b39aSJayamohan Kallickal .owner = THIS_MODULE,
57896733b39aSJayamohan Kallickal .name = DRV_NAME,
57909db0fb3aSJayamohan Kallickal .caps = CAP_RECOVERY_L0 | CAP_HDRDGST | CAP_TEXT_NEGO |
57916733b39aSJayamohan Kallickal CAP_MULTI_R2T | CAP_DATADGST | CAP_DATA_PATH_OFFLOAD,
57926733b39aSJayamohan Kallickal .create_session = beiscsi_session_create,
57936733b39aSJayamohan Kallickal .destroy_session = beiscsi_session_destroy,
57946733b39aSJayamohan Kallickal .create_conn = beiscsi_conn_create,
57956733b39aSJayamohan Kallickal .bind_conn = beiscsi_conn_bind,
5796891e2639SMike Christie .unbind_conn = iscsi_conn_unbind,
57976733b39aSJayamohan Kallickal .destroy_conn = iscsi_conn_teardown,
579896b48b92SJitendra Bhivare .attr_is_visible = beiscsi_attr_is_visible,
579996b48b92SJitendra Bhivare .set_iface_param = beiscsi_iface_set_param,
580096b48b92SJitendra Bhivare .get_iface_param = beiscsi_iface_get_param,
58016733b39aSJayamohan Kallickal .set_param = beiscsi_set_param,
5802c7f7fd5bSMike Christie .get_conn_param = iscsi_conn_get_param,
58036733b39aSJayamohan Kallickal .get_session_param = iscsi_session_get_param,
58046733b39aSJayamohan Kallickal .get_host_param = beiscsi_get_host_param,
58056733b39aSJayamohan Kallickal .start_conn = beiscsi_conn_start,
5806fa95d206SMike Christie .stop_conn = iscsi_conn_stop,
58076733b39aSJayamohan Kallickal .send_pdu = iscsi_conn_send_pdu,
58086733b39aSJayamohan Kallickal .xmit_task = beiscsi_task_xmit,
58096733b39aSJayamohan Kallickal .cleanup_task = beiscsi_cleanup_task,
58106733b39aSJayamohan Kallickal .alloc_pdu = beiscsi_alloc_pdu,
58116733b39aSJayamohan Kallickal .parse_pdu_itt = beiscsi_parse_pdu,
58126733b39aSJayamohan Kallickal .get_stats = beiscsi_conn_get_stats,
5813c7f7fd5bSMike Christie .get_ep_param = beiscsi_ep_get_param,
58146733b39aSJayamohan Kallickal .ep_connect = beiscsi_ep_connect,
58156733b39aSJayamohan Kallickal .ep_poll = beiscsi_ep_poll,
58166733b39aSJayamohan Kallickal .ep_disconnect = beiscsi_ep_disconnect,
58176733b39aSJayamohan Kallickal .session_recovery_timedout = iscsi_session_recovery_timedout,
5818ffce3e2eSJayamohan Kallickal .bsg_request = beiscsi_bsg_request,
58196733b39aSJayamohan Kallickal };
58206733b39aSJayamohan Kallickal
58216733b39aSJayamohan Kallickal static struct pci_driver beiscsi_pci_driver = {
58226733b39aSJayamohan Kallickal .name = DRV_NAME,
58236733b39aSJayamohan Kallickal .probe = beiscsi_dev_probe,
58246733b39aSJayamohan Kallickal .remove = beiscsi_remove,
58253567f36aSJayamohan Kallickal .id_table = beiscsi_pci_id_table,
58263567f36aSJayamohan Kallickal .err_handler = &beiscsi_eeh_handlers
58276733b39aSJayamohan Kallickal };
58286733b39aSJayamohan Kallickal
beiscsi_module_init(void)58296733b39aSJayamohan Kallickal static int __init beiscsi_module_init(void)
58306733b39aSJayamohan Kallickal {
58316733b39aSJayamohan Kallickal int ret;
58326733b39aSJayamohan Kallickal
58336733b39aSJayamohan Kallickal beiscsi_scsi_transport =
58346733b39aSJayamohan Kallickal iscsi_register_transport(&beiscsi_iscsi_transport);
58356733b39aSJayamohan Kallickal if (!beiscsi_scsi_transport) {
583699bc5d55SJohn Soni Jose printk(KERN_ERR
583799bc5d55SJohn Soni Jose "beiscsi_module_init - Unable to register beiscsi transport.\n");
5838f55a24f2SJayamohan Kallickal return -ENOMEM;
58396733b39aSJayamohan Kallickal }
584099bc5d55SJohn Soni Jose printk(KERN_INFO "In beiscsi_module_init, tt=%p\n",
58416733b39aSJayamohan Kallickal &beiscsi_iscsi_transport);
58426733b39aSJayamohan Kallickal
58436733b39aSJayamohan Kallickal ret = pci_register_driver(&beiscsi_pci_driver);
58446733b39aSJayamohan Kallickal if (ret) {
584599bc5d55SJohn Soni Jose printk(KERN_ERR
584699bc5d55SJohn Soni Jose "beiscsi_module_init - Unable to register beiscsi pci driver.\n");
58476733b39aSJayamohan Kallickal goto unregister_iscsi_transport;
58486733b39aSJayamohan Kallickal }
58496733b39aSJayamohan Kallickal return 0;
58506733b39aSJayamohan Kallickal
58516733b39aSJayamohan Kallickal unregister_iscsi_transport:
58526733b39aSJayamohan Kallickal iscsi_unregister_transport(&beiscsi_iscsi_transport);
58536733b39aSJayamohan Kallickal return ret;
58546733b39aSJayamohan Kallickal }
58556733b39aSJayamohan Kallickal
beiscsi_module_exit(void)58566733b39aSJayamohan Kallickal static void __exit beiscsi_module_exit(void)
58576733b39aSJayamohan Kallickal {
58586733b39aSJayamohan Kallickal pci_unregister_driver(&beiscsi_pci_driver);
58596733b39aSJayamohan Kallickal iscsi_unregister_transport(&beiscsi_iscsi_transport);
58606733b39aSJayamohan Kallickal }
58616733b39aSJayamohan Kallickal
58626733b39aSJayamohan Kallickal module_init(beiscsi_module_init);
58636733b39aSJayamohan Kallickal module_exit(beiscsi_module_exit);
5864