2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2005-10-27 12:10:08 -06:00
|
|
|
* QLogic Fibre Channel HBA Driver
|
2014-04-11 14:54:24 -06:00
|
|
|
* Copyright (c) 2003-2014 QLogic Corporation
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2005-10-27 12:10:08 -06:00
|
|
|
* See LICENSE.qla2xxx for copyright and licensing details.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
#include "qla_def.h"
|
2012-05-15 12:34:28 -06:00
|
|
|
#include "qla_target.h"
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#include <linux/delay.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/gfp.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2017-03-15 10:48:52 -06:00
|
|
|
static struct mb_cmd_name {
|
|
|
|
uint16_t cmd;
|
|
|
|
const char *str;
|
|
|
|
} mb_str[] = {
|
|
|
|
{MBC_GET_PORT_DATABASE, "GPDB"},
|
|
|
|
{MBC_GET_ID_LIST, "GIDList"},
|
|
|
|
{MBC_GET_LINK_PRIV_STATS, "Stats"},
|
2017-12-28 13:33:23 -07:00
|
|
|
{MBC_GET_RESOURCE_COUNTS, "ResCnt"},
|
2017-03-15 10:48:52 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static const char *mb_to_str(uint16_t cmd)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct mb_cmd_name *e;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(mb_str); i++) {
|
|
|
|
e = mb_str + i;
|
|
|
|
if (cmd == e->cmd)
|
|
|
|
return e->str;
|
|
|
|
}
|
|
|
|
return "unknown";
|
|
|
|
}
|
|
|
|
|
2017-01-17 10:34:14 -07:00
|
|
|
static struct rom_cmd {
|
2016-12-12 15:40:05 -07:00
|
|
|
uint16_t cmd;
|
|
|
|
} rom_cmds[] = {
|
|
|
|
{ MBC_LOAD_RAM },
|
|
|
|
{ MBC_EXECUTE_FIRMWARE },
|
|
|
|
{ MBC_READ_RAM_WORD },
|
|
|
|
{ MBC_MAILBOX_REGISTER_TEST },
|
|
|
|
{ MBC_VERIFY_CHECKSUM },
|
|
|
|
{ MBC_GET_FIRMWARE_VERSION },
|
|
|
|
{ MBC_LOAD_RISC_RAM },
|
|
|
|
{ MBC_DUMP_RISC_RAM },
|
|
|
|
{ MBC_LOAD_RISC_RAM_EXTENDED },
|
|
|
|
{ MBC_DUMP_RISC_RAM_EXTENDED },
|
|
|
|
{ MBC_WRITE_RAM_WORD_EXTENDED },
|
|
|
|
{ MBC_READ_RAM_EXTENDED },
|
|
|
|
{ MBC_GET_RESOURCE_COUNTS },
|
|
|
|
{ MBC_SET_FIRMWARE_OPTION },
|
|
|
|
{ MBC_MID_INITIALIZE_FIRMWARE },
|
|
|
|
{ MBC_GET_FIRMWARE_STATE },
|
|
|
|
{ MBC_GET_MEM_OFFLOAD_CNTRL_STAT },
|
|
|
|
{ MBC_GET_RETRY_COUNT },
|
|
|
|
{ MBC_TRACE_CONTROL },
|
2017-08-23 16:04:56 -06:00
|
|
|
{ MBC_INITIALIZE_MULTIQ },
|
2017-08-23 16:05:03 -06:00
|
|
|
{ MBC_IOCB_COMMAND_A64 },
|
|
|
|
{ MBC_GET_ADAPTER_LOOP_ID },
|
2017-08-23 16:05:07 -06:00
|
|
|
{ MBC_READ_SFP },
|
2016-12-12 15:40:05 -07:00
|
|
|
};
|
|
|
|
|
|
|
|
static int is_rom_cmd(uint16_t cmd)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
struct rom_cmd *wc;
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(rom_cmds); i++) {
|
|
|
|
wc = rom_cmds + i;
|
|
|
|
if (wc->cmd == cmd)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_mailbox_command
|
|
|
|
* Issue mailbox command and waits for completion.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* mcp = driver internal mbx struct pointer.
|
|
|
|
*
|
|
|
|
* Output:
|
|
|
|
* mb[MAX_MAILBOX_REGISTER_COUNT] = returned mailbox data.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* 0 : QLA_SUCCESS = cmd performed success
|
|
|
|
* 1 : QLA_FUNCTION_FAILED (error encountered)
|
|
|
|
* 6 : QLA_FUNCTION_TIMEOUT (timeout condition encountered)
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
static int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_mailbox_command(scsi_qla_host_t *vha, mbx_cmd_t *mcp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2015-04-09 13:00:03 -06:00
|
|
|
int rval, i;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long flags = 0;
|
2014-02-26 02:15:06 -07:00
|
|
|
device_reg_t *reg;
|
2005-07-06 11:30:57 -06:00
|
|
|
uint8_t abort_active;
|
2007-07-05 14:16:51 -06:00
|
|
|
uint8_t io_lock_on;
|
2010-05-28 16:08:25 -06:00
|
|
|
uint16_t command = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
uint16_t *iptr;
|
|
|
|
uint16_t __iomem *optr;
|
|
|
|
uint32_t cnt;
|
|
|
|
uint32_t mboxes;
|
|
|
|
unsigned long wait_time;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
scsi_qla_host_t *base_vha = pci_get_drvdata(ha->pdev);
|
2007-07-05 14:16:51 -06:00
|
|
|
|
2015-04-09 13:00:03 -06:00
|
|
|
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1000, "Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
|
|
|
if (ha->pdev->error_state > pci_channel_io_frozen) {
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_log(ql_log_warn, vha, 0x1001,
|
2011-07-14 13:00:13 -06:00
|
|
|
"error_state is greater than pci_channel_io_frozen, "
|
|
|
|
"exiting.\n");
|
2009-03-24 10:08:18 -06:00
|
|
|
return QLA_FUNCTION_TIMEOUT;
|
2011-07-14 13:00:13 -06:00
|
|
|
}
|
2009-03-24 10:08:18 -06:00
|
|
|
|
2010-04-12 18:59:55 -06:00
|
|
|
if (vha->device_flags & DFLG_DEV_FAILED) {
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_log(ql_log_warn, vha, 0x1002,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Device in failed state, exiting.\n");
|
2010-04-12 18:59:55 -06:00
|
|
|
return QLA_FUNCTION_TIMEOUT;
|
|
|
|
}
|
|
|
|
|
2017-01-11 16:58:58 -07:00
|
|
|
/* if PCI error, then avoid mbx processing.*/
|
2017-06-02 10:11:58 -06:00
|
|
|
if (test_bit(PFLG_DISCONNECTED, &base_vha->dpc_flags) &&
|
|
|
|
test_bit(UNLOADING, &base_vha->dpc_flags)) {
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0xd04e,
|
2016-07-06 09:14:25 -06:00
|
|
|
"PCI error, exiting.\n");
|
|
|
|
return QLA_FUNCTION_TIMEOUT;
|
2017-01-11 16:58:58 -07:00
|
|
|
}
|
2016-07-06 09:14:25 -06:00
|
|
|
|
2007-07-05 14:16:51 -06:00
|
|
|
reg = ha->iobase;
|
2008-11-06 11:40:19 -07:00
|
|
|
io_lock_on = base_vha->flags.init_done;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
rval = QLA_SUCCESS;
|
2008-11-06 11:40:19 -07:00
|
|
|
abort_active = test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-12-15 22:29:46 -07:00
|
|
|
if (ha->flags.pci_channel_io_perm_failure) {
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_log(ql_log_warn, vha, 0x1003,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Perm failure on EEH timeout MBX, exiting.\n");
|
2009-12-15 22:29:46 -07:00
|
|
|
return QLA_FUNCTION_TIMEOUT;
|
|
|
|
}
|
|
|
|
|
2013-08-26 23:37:28 -06:00
|
|
|
if (IS_P3P_TYPE(ha) && ha->flags.isp82xx_fw_hung) {
|
2011-02-23 16:27:11 -07:00
|
|
|
/* Setting Link-Down error */
|
|
|
|
mcp->mb[0] = MBS_LINK_DOWN_ERROR;
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_log(ql_log_warn, vha, 0x1004,
|
2011-07-14 13:00:13 -06:00
|
|
|
"FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
|
2011-11-18 10:02:15 -07:00
|
|
|
return QLA_FUNCTION_TIMEOUT;
|
2011-02-23 16:27:11 -07:00
|
|
|
}
|
|
|
|
|
2016-12-12 15:40:05 -07:00
|
|
|
/* check if ISP abort is active and return cmd with timeout */
|
|
|
|
if ((test_bit(ABORT_ISP_ACTIVE, &base_vha->dpc_flags) ||
|
|
|
|
test_bit(ISP_ABORT_RETRY, &base_vha->dpc_flags) ||
|
|
|
|
test_bit(ISP_ABORT_NEEDED, &base_vha->dpc_flags)) &&
|
|
|
|
!is_rom_cmd(mcp->mb[0])) {
|
|
|
|
ql_log(ql_log_info, vha, 0x1005,
|
|
|
|
"Cmd 0x%x aborted with timeout since ISP Abort is pending\n",
|
|
|
|
mcp->mb[0]);
|
|
|
|
return QLA_FUNCTION_TIMEOUT;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2005-07-06 11:30:57 -06:00
|
|
|
* Wait for active mailbox commands to finish by waiting at most tov
|
|
|
|
* seconds. This is to serialize actual issuing of mailbox cmds during
|
|
|
|
* non ISP abort time.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2009-01-22 10:45:31 -07:00
|
|
|
if (!wait_for_completion_timeout(&ha->mbx_cmd_comp, mcp->tov * HZ)) {
|
|
|
|
/* Timeout occurred. Return error. */
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0xd035,
|
2012-02-09 12:15:46 -07:00
|
|
|
"Cmd access timeout, cmd=0x%x, Exiting.\n",
|
|
|
|
mcp->mb[0]);
|
2009-01-22 10:45:31 -07:00
|
|
|
return QLA_FUNCTION_TIMEOUT;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
ha->flags.mbox_busy = 1;
|
|
|
|
/* Save mailbox command for debug */
|
|
|
|
ha->mcp = mcp;
|
|
|
|
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1006,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Prepare to issue mbox cmd=0x%x.\n", mcp->mb[0]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
spin_lock_irqsave(&ha->hardware_lock, flags);
|
|
|
|
|
|
|
|
/* Load mailbox registers. */
|
2013-08-26 23:37:28 -06:00
|
|
|
if (IS_P3P_TYPE(ha))
|
2010-04-12 18:59:55 -06:00
|
|
|
optr = (uint16_t __iomem *)®->isp82.mailbox_in[0];
|
2013-08-26 23:37:28 -06:00
|
|
|
else if (IS_FWI2_CAPABLE(ha) && !(IS_P3P_TYPE(ha)))
|
2005-07-06 11:30:57 -06:00
|
|
|
optr = (uint16_t __iomem *)®->isp24.mailbox0;
|
|
|
|
else
|
|
|
|
optr = (uint16_t __iomem *)MAILBOX_REG(ha, ®->isp, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
iptr = mcp->mb;
|
|
|
|
command = mcp->mb[0];
|
|
|
|
mboxes = mcp->out_mb;
|
|
|
|
|
2014-09-25 03:16:43 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1111,
|
2013-08-23 08:25:37 -06:00
|
|
|
"Mailbox registers (OUT):\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
for (cnt = 0; cnt < ha->mbx_count; cnt++) {
|
|
|
|
if (IS_QLA2200(ha) && cnt == 8)
|
2005-07-06 11:30:57 -06:00
|
|
|
optr =
|
|
|
|
(uint16_t __iomem *)MAILBOX_REG(ha, ®->isp, 8);
|
2013-08-23 08:25:37 -06:00
|
|
|
if (mboxes & BIT_0) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1112,
|
|
|
|
"mbox[%d]<-0x%04x\n", cnt, *iptr);
|
2005-04-16 16:20:36 -06:00
|
|
|
WRT_REG_WORD(optr, *iptr);
|
2013-08-23 08:25:37 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mboxes >>= 1;
|
|
|
|
optr++;
|
|
|
|
iptr++;
|
|
|
|
}
|
|
|
|
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1117,
|
2011-07-14 13:00:13 -06:00
|
|
|
"I/O Address = %p.\n", optr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Issue set host interrupt command to send cmd out. */
|
|
|
|
ha->flags.mbox_int = 0;
|
|
|
|
clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
|
|
|
|
|
|
|
|
/* Unlock mbx registers and wait for interrupt */
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x100f,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Going to unlock irq & waiting for interrupts. "
|
|
|
|
"jiffies=%lx.\n", jiffies);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Wait for mbx cmd completion until timeout */
|
|
|
|
|
2009-01-05 12:18:06 -07:00
|
|
|
if ((!abort_active && io_lock_on) || IS_NOPOLLING_TYPE(ha)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
set_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
|
|
|
|
|
2013-08-26 23:37:28 -06:00
|
|
|
if (IS_P3P_TYPE(ha)) {
|
2010-04-12 18:59:55 -06:00
|
|
|
if (RD_REG_DWORD(®->isp82.hint) &
|
|
|
|
HINT_MBX_INT_PENDING) {
|
|
|
|
spin_unlock_irqrestore(&ha->hardware_lock,
|
|
|
|
flags);
|
2011-11-18 10:02:18 -07:00
|
|
|
ha->flags.mbox_busy = 0;
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1010,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Pending mailbox timeout, exiting.\n");
|
2010-05-28 16:08:25 -06:00
|
|
|
rval = QLA_FUNCTION_TIMEOUT;
|
|
|
|
goto premature_exit;
|
2010-04-12 18:59:55 -06:00
|
|
|
}
|
|
|
|
WRT_REG_DWORD(®->isp82.hint, HINT_MBX_INT_PENDING);
|
|
|
|
} else if (IS_FWI2_CAPABLE(ha))
|
2005-07-06 11:30:57 -06:00
|
|
|
WRT_REG_DWORD(®->isp24.hccr, HCCRX_SET_HOST_INT);
|
|
|
|
else
|
|
|
|
WRT_REG_WORD(®->isp.hccr, HCCR_SET_HOST_INT);
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_irqrestore(&ha->hardware_lock, flags);
|
|
|
|
|
2016-12-12 15:40:05 -07:00
|
|
|
wait_time = jiffies;
|
2013-06-25 09:27:16 -06:00
|
|
|
if (!wait_for_completion_timeout(&ha->mbx_intr_comp,
|
|
|
|
mcp->tov * HZ)) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x117a,
|
|
|
|
"cmd=%x Timeout.\n", command);
|
|
|
|
spin_lock_irqsave(&ha->hardware_lock, flags);
|
|
|
|
clear_bit(MBX_INTR_WAIT, &ha->mbx_cmd_flags);
|
|
|
|
spin_unlock_irqrestore(&ha->hardware_lock, flags);
|
|
|
|
}
|
2016-12-12 15:40:05 -07:00
|
|
|
if (time_after(jiffies, wait_time + 5 * HZ))
|
|
|
|
ql_log(ql_log_warn, vha, 0x1015, "cmd=0x%x, waited %d msecs\n",
|
|
|
|
command, jiffies_to_msecs(jiffies - wait_time));
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1011,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Cmd=%x Polling Mode.\n", command);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-08-26 23:37:28 -06:00
|
|
|
if (IS_P3P_TYPE(ha)) {
|
2010-04-12 18:59:55 -06:00
|
|
|
if (RD_REG_DWORD(®->isp82.hint) &
|
|
|
|
HINT_MBX_INT_PENDING) {
|
|
|
|
spin_unlock_irqrestore(&ha->hardware_lock,
|
|
|
|
flags);
|
2011-11-18 10:02:18 -07:00
|
|
|
ha->flags.mbox_busy = 0;
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1012,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Pending mailbox timeout, exiting.\n");
|
2010-05-28 16:08:25 -06:00
|
|
|
rval = QLA_FUNCTION_TIMEOUT;
|
|
|
|
goto premature_exit;
|
2010-04-12 18:59:55 -06:00
|
|
|
}
|
|
|
|
WRT_REG_DWORD(®->isp82.hint, HINT_MBX_INT_PENDING);
|
|
|
|
} else if (IS_FWI2_CAPABLE(ha))
|
2005-07-06 11:30:57 -06:00
|
|
|
WRT_REG_DWORD(®->isp24.hccr, HCCRX_SET_HOST_INT);
|
|
|
|
else
|
|
|
|
WRT_REG_WORD(®->isp.hccr, HCCR_SET_HOST_INT);
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_irqrestore(&ha->hardware_lock, flags);
|
|
|
|
|
|
|
|
wait_time = jiffies + mcp->tov * HZ; /* wait at most tov secs */
|
|
|
|
while (!ha->flags.mbox_int) {
|
|
|
|
if (time_after(jiffies, wait_time))
|
|
|
|
break;
|
|
|
|
|
2018-05-28 11:58:44 -06:00
|
|
|
/*
|
|
|
|
* Check if it's UNLOADING, cause we cannot poll in
|
|
|
|
* this case, or else a NULL pointer dereference
|
|
|
|
* is triggered.
|
|
|
|
*/
|
|
|
|
if (unlikely(test_bit(UNLOADING, &base_vha->dpc_flags)))
|
|
|
|
return QLA_FUNCTION_TIMEOUT;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Check for pending interrupts. */
|
2008-12-09 17:45:39 -07:00
|
|
|
qla2x00_poll(ha->rsp_q_map[0]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-12-15 22:29:46 -07:00
|
|
|
if (!ha->flags.mbox_int &&
|
|
|
|
!(IS_QLA2200(ha) &&
|
|
|
|
command == MBC_LOAD_RISC_RAM_EXTENDED))
|
2006-01-13 18:05:10 -07:00
|
|
|
msleep(10);
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* while */
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1013,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Waited %d sec.\n",
|
|
|
|
(uint)((jiffies - (wait_time - (mcp->tov * HZ)))/HZ));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Check whether we timed out */
|
|
|
|
if (ha->flags.mbox_int) {
|
|
|
|
uint16_t *iptr2;
|
|
|
|
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1014,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Cmd=%x completed.\n", command);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Got interrupt. Clear the flag. */
|
|
|
|
ha->flags.mbox_int = 0;
|
|
|
|
clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
|
|
|
|
|
2013-08-26 23:37:28 -06:00
|
|
|
if (IS_P3P_TYPE(ha) && ha->flags.isp82xx_fw_hung) {
|
2010-05-28 16:08:25 -06:00
|
|
|
ha->flags.mbox_busy = 0;
|
|
|
|
/* Setting Link-Down error */
|
|
|
|
mcp->mb[0] = MBS_LINK_DOWN_ERROR;
|
|
|
|
ha->mcp = NULL;
|
|
|
|
rval = QLA_FUNCTION_FAILED;
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0xd048,
|
2011-07-14 13:00:13 -06:00
|
|
|
"FW hung = %d.\n", ha->flags.isp82xx_fw_hung);
|
2010-05-28 16:08:25 -06:00
|
|
|
goto premature_exit;
|
|
|
|
}
|
|
|
|
|
2005-04-23 00:47:27 -06:00
|
|
|
if (ha->mailbox_out[0] != MBS_COMMAND_COMPLETE)
|
2005-04-16 16:20:36 -06:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
/* Load return mailbox registers. */
|
|
|
|
iptr2 = mcp->mb;
|
|
|
|
iptr = (uint16_t *)&ha->mailbox_out[0];
|
|
|
|
mboxes = mcp->in_mb;
|
2013-08-23 08:25:37 -06:00
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1113,
|
|
|
|
"Mailbox registers (IN):\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
for (cnt = 0; cnt < ha->mbx_count; cnt++) {
|
2013-08-23 08:25:37 -06:00
|
|
|
if (mboxes & BIT_0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
*iptr2 = *iptr;
|
2013-08-23 08:25:37 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1114,
|
|
|
|
"mbox[%d]->0x%04x\n", cnt, *iptr2);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mboxes >>= 1;
|
|
|
|
iptr2++;
|
|
|
|
iptr++;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
|
2016-12-23 19:06:09 -07:00
|
|
|
uint16_t mb[8];
|
|
|
|
uint32_t ictrl, host_status, hccr;
|
2016-07-06 09:14:25 -06:00
|
|
|
uint16_t w;
|
2005-07-06 11:30:57 -06:00
|
|
|
|
2007-07-19 16:05:56 -06:00
|
|
|
if (IS_FWI2_CAPABLE(ha)) {
|
2016-12-23 19:06:09 -07:00
|
|
|
mb[0] = RD_REG_WORD(®->isp24.mailbox0);
|
|
|
|
mb[1] = RD_REG_WORD(®->isp24.mailbox1);
|
|
|
|
mb[2] = RD_REG_WORD(®->isp24.mailbox2);
|
|
|
|
mb[3] = RD_REG_WORD(®->isp24.mailbox3);
|
|
|
|
mb[7] = RD_REG_WORD(®->isp24.mailbox7);
|
2005-07-06 11:30:57 -06:00
|
|
|
ictrl = RD_REG_DWORD(®->isp24.ictrl);
|
2016-12-23 19:06:09 -07:00
|
|
|
host_status = RD_REG_DWORD(®->isp24.host_status);
|
|
|
|
hccr = RD_REG_DWORD(®->isp24.hccr);
|
|
|
|
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0xd04c,
|
2016-12-23 19:06:09 -07:00
|
|
|
"MBX Command timeout for cmd %x, iocontrol=%x jiffies=%lx "
|
|
|
|
"mb[0-3]=[0x%x 0x%x 0x%x 0x%x] mb7 0x%x host_status 0x%x hccr 0x%x\n",
|
|
|
|
command, ictrl, jiffies, mb[0], mb[1], mb[2], mb[3],
|
|
|
|
mb[7], host_status, hccr);
|
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
} else {
|
2016-12-23 19:06:09 -07:00
|
|
|
mb[0] = RD_MAILBOX_REG(ha, ®->isp, 0);
|
2005-07-06 11:30:57 -06:00
|
|
|
ictrl = RD_REG_WORD(®->isp.ictrl);
|
2016-12-23 19:06:09 -07:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1119,
|
|
|
|
"MBX Command timeout for cmd %x, iocontrol=%x jiffies=%lx "
|
|
|
|
"mb[0]=0x%x\n", command, ictrl, jiffies, mb[0]);
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dump_regs(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1019);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-07-06 09:14:25 -06:00
|
|
|
/* Capture FW dump only, if PCI device active */
|
|
|
|
if (!pci_channel_offline(vha->hw->pdev)) {
|
|
|
|
pci_read_config_word(ha->pdev, PCI_VENDOR_ID, &w);
|
|
|
|
if (w == 0xffff || ictrl == 0xffffffff) {
|
|
|
|
/* This is special case if there is unload
|
|
|
|
* of driver happening and if PCI device go
|
|
|
|
* into bad state due to PCI error condition
|
|
|
|
* then only PCI ERR flag would be set.
|
|
|
|
* we will do premature exit for above case.
|
|
|
|
*/
|
|
|
|
ha->flags.mbox_busy = 0;
|
|
|
|
rval = QLA_FUNCTION_TIMEOUT;
|
|
|
|
goto premature_exit;
|
|
|
|
}
|
2012-02-09 12:15:53 -07:00
|
|
|
|
2016-07-06 09:14:25 -06:00
|
|
|
/* Attempt to capture firmware dump for further
|
|
|
|
* anallysis of the current formware state. we do not
|
|
|
|
* need to do this if we are intentionally generating
|
|
|
|
* a dump
|
|
|
|
*/
|
|
|
|
if (mcp->mb[0] != MBC_GEN_SYSTEM_ERROR)
|
|
|
|
ha->isp_ops->fw_dump(vha, 0);
|
|
|
|
rval = QLA_FUNCTION_TIMEOUT;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
ha->flags.mbox_busy = 0;
|
|
|
|
|
|
|
|
/* Clean up */
|
|
|
|
ha->mcp = NULL;
|
|
|
|
|
2009-01-05 12:18:06 -07:00
|
|
|
if ((abort_active || !io_lock_on) && !IS_NOPOLLING_TYPE(ha)) {
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x101a,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Checking for additional resp interrupt.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* polling mode for non isp_abort commands. */
|
2008-12-09 17:45:39 -07:00
|
|
|
qla2x00_poll(ha->rsp_q_map[0]);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
if (rval == QLA_FUNCTION_TIMEOUT &&
|
|
|
|
mcp->mb[0] != MBC_GEN_SYSTEM_ERROR) {
|
2009-12-15 22:29:46 -07:00
|
|
|
if (!io_lock_on || (mcp->flags & IOCTL_CMD) ||
|
|
|
|
ha->flags.eeh_busy) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* not in dpc. schedule it for dpc to take over. */
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x101b,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Timeout, schedule isp_abort_needed.\n");
|
2010-05-28 16:08:25 -06:00
|
|
|
|
|
|
|
if (!test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) &&
|
|
|
|
!test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
|
|
|
|
!test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
|
2011-11-18 10:02:19 -07:00
|
|
|
if (IS_QLA82XX(ha)) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x112a,
|
|
|
|
"disabling pause transmit on port "
|
|
|
|
"0 & 1.\n");
|
|
|
|
qla82xx_wr_32(ha,
|
|
|
|
QLA82XX_CRB_NIU + 0x98,
|
|
|
|
CRB_NIU_XG_PAUSE_CTL_P0|
|
|
|
|
CRB_NIU_XG_PAUSE_CTL_P1);
|
|
|
|
}
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_log(ql_log_info, base_vha, 0x101c,
|
2012-05-15 12:34:10 -06:00
|
|
|
"Mailbox cmd timeout occurred, cmd=0x%x, "
|
2012-02-09 12:15:46 -07:00
|
|
|
"mb[0]=0x%x, eeh_busy=0x%x. Scheduling ISP "
|
|
|
|
"abort.\n", command, mcp->mb[0],
|
|
|
|
ha->flags.eeh_busy);
|
2010-05-28 16:08:25 -06:00
|
|
|
set_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
|
|
|
|
qla2xxx_wake_dpc(vha);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
} else if (!abort_active) {
|
|
|
|
/* call abort directly since we are in the DPC thread */
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x101d,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Timeout, calling abort_isp.\n");
|
2010-05-28 16:08:25 -06:00
|
|
|
|
|
|
|
if (!test_bit(ISP_ABORT_NEEDED, &vha->dpc_flags) &&
|
|
|
|
!test_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags) &&
|
|
|
|
!test_bit(ISP_ABORT_RETRY, &vha->dpc_flags)) {
|
2011-11-18 10:02:19 -07:00
|
|
|
if (IS_QLA82XX(ha)) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x112b,
|
|
|
|
"disabling pause transmit on port "
|
|
|
|
"0 & 1.\n");
|
|
|
|
qla82xx_wr_32(ha,
|
|
|
|
QLA82XX_CRB_NIU + 0x98,
|
|
|
|
CRB_NIU_XG_PAUSE_CTL_P0|
|
|
|
|
CRB_NIU_XG_PAUSE_CTL_P1);
|
|
|
|
}
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_log(ql_log_info, base_vha, 0x101e,
|
2012-05-15 12:34:10 -06:00
|
|
|
"Mailbox cmd timeout occurred, cmd=0x%x, "
|
2012-02-09 12:15:46 -07:00
|
|
|
"mb[0]=0x%x. Scheduling ISP abort ",
|
|
|
|
command, mcp->mb[0]);
|
2010-05-28 16:08:25 -06:00
|
|
|
set_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
|
|
|
|
clear_bit(ISP_ABORT_NEEDED, &vha->dpc_flags);
|
2012-02-09 12:14:10 -07:00
|
|
|
/* Allow next mbx cmd to come in. */
|
|
|
|
complete(&ha->mbx_cmd_comp);
|
2010-05-28 16:08:25 -06:00
|
|
|
if (ha->isp_ops->abort_isp(vha)) {
|
|
|
|
/* Failed. retry later. */
|
|
|
|
set_bit(ISP_ABORT_NEEDED,
|
|
|
|
&vha->dpc_flags);
|
|
|
|
}
|
|
|
|
clear_bit(ABORT_ISP_ACTIVE, &vha->dpc_flags);
|
2012-02-09 12:15:51 -07:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x101f,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Finished abort_isp.\n");
|
2012-02-09 12:14:10 -07:00
|
|
|
goto mbx_done;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-05-28 16:08:25 -06:00
|
|
|
premature_exit:
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Allow next mbx cmd to come in. */
|
2009-01-22 10:45:31 -07:00
|
|
|
complete(&ha->mbx_cmd_comp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-02-09 12:14:10 -07:00
|
|
|
mbx_done:
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rval) {
|
2017-08-23 16:05:14 -06:00
|
|
|
if (ql2xextended_error_logging & (ql_dbg_disc|ql_dbg_mbx)) {
|
|
|
|
pr_warn("%s [%s]-%04x:%ld: **** Failed", QL_MSGHDR,
|
|
|
|
dev_name(&ha->pdev->dev), 0x1020+0x800,
|
|
|
|
vha->host_no);
|
|
|
|
mboxes = mcp->in_mb;
|
|
|
|
cnt = 4;
|
|
|
|
for (i = 0; i < ha->mbx_count && cnt; i++, mboxes >>= 1)
|
|
|
|
if (mboxes & BIT_0) {
|
|
|
|
printk(" mb[%u]=%x", i, mcp->mb[i]);
|
|
|
|
cnt--;
|
|
|
|
}
|
|
|
|
pr_warn(" cmd=%x ****\n", command);
|
|
|
|
}
|
2018-03-08 06:44:07 -07:00
|
|
|
if (IS_FWI2_CAPABLE(ha) && !(IS_P3P_TYPE(ha))) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1198,
|
|
|
|
"host_status=%#x intr_ctrl=%#x intr_status=%#x\n",
|
|
|
|
RD_REG_DWORD(®->isp24.host_status),
|
|
|
|
RD_REG_DWORD(®->isp24.ictrl),
|
|
|
|
RD_REG_DWORD(®->isp24.istatus));
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1206,
|
|
|
|
"ctrl_status=%#x ictrl=%#x istatus=%#x\n",
|
|
|
|
RD_REG_WORD(®->isp.ctrl_status),
|
|
|
|
RD_REG_WORD(®->isp.ictrl),
|
|
|
|
RD_REG_WORD(®->isp.istatus));
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, base_vha, 0x1021, "Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_load_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t risc_addr,
|
2006-01-13 18:05:37 -07:00
|
|
|
uint32_t risc_code_size)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2005-04-16 16:20:36 -06:00
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1022,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-07-19 16:05:56 -06:00
|
|
|
if (MSW(risc_addr) || IS_FWI2_CAPABLE(ha)) {
|
2006-01-13 18:05:37 -07:00
|
|
|
mcp->mb[0] = MBC_LOAD_RISC_RAM_EXTENDED;
|
|
|
|
mcp->mb[8] = MSW(risc_addr);
|
|
|
|
mcp->out_mb = MBX_8|MBX_0;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2006-01-13 18:05:37 -07:00
|
|
|
mcp->mb[0] = MBC_LOAD_RISC_RAM;
|
|
|
|
mcp->out_mb = MBX_0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
mcp->mb[1] = LSW(risc_addr);
|
|
|
|
mcp->mb[2] = MSW(req_dma);
|
|
|
|
mcp->mb[3] = LSW(req_dma);
|
|
|
|
mcp->mb[6] = MSW(MSD(req_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(req_dma));
|
2006-01-13 18:05:37 -07:00
|
|
|
mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
|
2007-07-19 16:05:56 -06:00
|
|
|
if (IS_FWI2_CAPABLE(ha)) {
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->mb[4] = MSW(risc_code_size);
|
|
|
|
mcp->mb[5] = LSW(risc_code_size);
|
|
|
|
mcp->out_mb |= MBX_5|MBX_4;
|
|
|
|
} else {
|
|
|
|
mcp->mb[4] = LSW(risc_code_size);
|
|
|
|
mcp->out_mb |= MBX_4;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->in_mb = MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1023,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1024,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2010-03-19 17:59:16 -06:00
|
|
|
#define EXTENDED_BB_CREDITS BIT_0
|
2017-06-21 14:48:43 -06:00
|
|
|
#define NVME_ENABLE_FLAG BIT_3
|
2017-08-23 16:05:17 -06:00
|
|
|
static inline uint16_t qla25xx_set_sfp_lr_dist(struct qla_hw_data *ha)
|
|
|
|
{
|
|
|
|
uint16_t mb4 = BIT_0;
|
|
|
|
|
|
|
|
if (IS_QLA83XX(ha) || IS_QLA27XX(ha))
|
|
|
|
mb4 |= ha->long_range_distance << LR_DIST_FW_POS;
|
|
|
|
|
|
|
|
return mb4;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline uint16_t qla25xx_set_nvr_lr_dist(struct qla_hw_data *ha)
|
|
|
|
{
|
|
|
|
uint16_t mb4 = BIT_0;
|
|
|
|
|
|
|
|
if (IS_QLA83XX(ha) || IS_QLA27XX(ha)) {
|
|
|
|
struct nvram_81xx *nv = ha->nvram;
|
|
|
|
|
|
|
|
mb4 |= LR_DIST_FW_FIELD(nv->enhanced_features);
|
|
|
|
}
|
|
|
|
|
|
|
|
return mb4;
|
|
|
|
}
|
2017-06-21 14:48:43 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* qla2x00_execute_fw
|
2005-07-06 11:30:57 -06:00
|
|
|
* Start adapter firmware.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Input:
|
2005-07-06 11:30:57 -06:00
|
|
|
* ha = adapter block pointer.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Returns:
|
2005-07-06 11:30:57 -06:00
|
|
|
* qla2x00 local function return status code.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
* Context:
|
2005-07-06 11:30:57 -06:00
|
|
|
* Kernel context.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_execute_fw(scsi_qla_host_t *vha, uint32_t risc_addr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2005-04-16 16:20:36 -06:00
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1025,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_EXECUTE_FIRMWARE;
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->out_mb = MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
2007-07-19 16:05:56 -06:00
|
|
|
if (IS_FWI2_CAPABLE(ha)) {
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->mb[1] = MSW(risc_addr);
|
|
|
|
mcp->mb[2] = LSW(risc_addr);
|
|
|
|
mcp->mb[3] = 0;
|
2017-08-23 16:05:07 -06:00
|
|
|
mcp->mb[4] = 0;
|
2017-08-23 16:05:17 -06:00
|
|
|
ha->flags.using_lr_setting = 0;
|
2014-02-26 02:15:06 -07:00
|
|
|
if (IS_QLA25XX(ha) || IS_QLA81XX(ha) || IS_QLA83XX(ha) ||
|
|
|
|
IS_QLA27XX(ha)) {
|
2017-08-23 16:05:07 -06:00
|
|
|
if (ql2xautodetectsfp) {
|
|
|
|
if (ha->flags.detected_lr_sfp) {
|
2017-08-23 16:05:17 -06:00
|
|
|
mcp->mb[4] |=
|
|
|
|
qla25xx_set_sfp_lr_dist(ha);
|
2017-08-23 16:05:07 -06:00
|
|
|
ha->flags.using_lr_setting = 1;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
struct nvram_81xx *nv = ha->nvram;
|
2017-08-23 16:05:17 -06:00
|
|
|
/* set LR distance if specified in nvram */
|
2017-08-23 16:05:07 -06:00
|
|
|
if (nv->enhanced_features &
|
2017-08-23 16:05:17 -06:00
|
|
|
NEF_LR_DIST_ENABLE) {
|
|
|
|
mcp->mb[4] |=
|
|
|
|
qla25xx_set_nvr_lr_dist(ha);
|
2017-08-23 16:05:07 -06:00
|
|
|
ha->flags.using_lr_setting = 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-12-17 12:56:56 -07:00
|
|
|
|
2017-06-21 14:48:43 -06:00
|
|
|
if (ql2xnvmeenable && IS_QLA27XX(ha))
|
|
|
|
mcp->mb[4] |= NVME_ENABLE_FLAG;
|
|
|
|
|
2017-08-23 16:05:16 -06:00
|
|
|
if (IS_QLA83XX(ha) || IS_QLA27XX(ha)) {
|
|
|
|
struct nvram_81xx *nv = ha->nvram;
|
|
|
|
/* set minimum speed if specified in nvram */
|
|
|
|
if (nv->min_link_speed >= 2 &&
|
|
|
|
nv->min_link_speed <= 5) {
|
|
|
|
mcp->mb[4] |= BIT_4;
|
|
|
|
mcp->mb[11] = nv->min_link_speed;
|
|
|
|
mcp->out_mb |= MBX_11;
|
|
|
|
mcp->in_mb |= BIT_5;
|
|
|
|
vha->min_link_speed_feat = nv->min_link_speed;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-17 12:56:56 -07:00
|
|
|
if (ha->flags.exlogins_enabled)
|
|
|
|
mcp->mb[4] |= ENABLE_EXTENDED_LOGIN;
|
|
|
|
|
2015-12-17 12:56:57 -07:00
|
|
|
if (ha->flags.exchoffld_enabled)
|
|
|
|
mcp->mb[4] |= ENABLE_EXCHANGE_OFFLD;
|
|
|
|
|
2007-09-20 15:07:48 -06:00
|
|
|
mcp->out_mb |= MBX_4|MBX_3|MBX_2|MBX_1;
|
2017-08-23 16:05:17 -06:00
|
|
|
mcp->in_mb |= MBX_3 | MBX_2 | MBX_1;
|
2005-07-06 11:30:57 -06:00
|
|
|
} else {
|
|
|
|
mcp->mb[1] = LSW(risc_addr);
|
|
|
|
mcp->out_mb |= MBX_1;
|
|
|
|
if (IS_QLA2322(ha) || IS_QLA6322(ha)) {
|
|
|
|
mcp->mb[2] = 0;
|
|
|
|
mcp->out_mb |= MBX_2;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1026,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2005-07-06 11:30:57 -06:00
|
|
|
} else {
|
2007-07-19 16:05:56 -06:00
|
|
|
if (IS_FWI2_CAPABLE(ha)) {
|
2017-08-23 16:05:17 -06:00
|
|
|
ha->fw_ability_mask = mcp->mb[3] << 16 | mcp->mb[2];
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x119a,
|
|
|
|
"fw_ability_mask=%x.\n", ha->fw_ability_mask);
|
2017-08-23 16:05:16 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1027,
|
|
|
|
"exchanges=%x.\n", mcp->mb[1]);
|
2017-08-23 16:05:17 -06:00
|
|
|
if (IS_QLA83XX(ha) || IS_QLA27XX(ha)) {
|
|
|
|
ha->max_speed_sup = mcp->mb[2] & BIT_0;
|
2017-08-23 16:05:16 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x119b,
|
|
|
|
"Maximum speed supported=%s.\n",
|
|
|
|
ha->max_speed_sup ? "32Gps" : "16Gps");
|
|
|
|
if (vha->min_link_speed_feat) {
|
|
|
|
ha->min_link_speed = mcp->mb[5];
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x119c,
|
|
|
|
"Minimum speed set=%s.\n",
|
|
|
|
mcp->mb[5] == 5 ? "32Gps" :
|
|
|
|
mcp->mb[5] == 4 ? "16Gps" :
|
|
|
|
mcp->mb[5] == 3 ? "8Gps" :
|
|
|
|
mcp->mb[5] == 2 ? "4Gps" :
|
2017-08-23 16:05:17 -06:00
|
|
|
"unknown");
|
2017-08-23 16:05:16 -06:00
|
|
|
}
|
|
|
|
}
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
2017-08-23 16:05:17 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1028,
|
|
|
|
"Done.\n");
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2015-12-17 12:56:56 -07:00
|
|
|
/*
|
|
|
|
* qla_get_exlogin_status
|
|
|
|
* Get extended login status
|
|
|
|
* uses the memory offload control/status Mailbox
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha: adapter state pointer.
|
|
|
|
* fwopt: firmware options
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function status
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
#define FETCH_XLOGINS_STAT 0x8
|
|
|
|
int
|
|
|
|
qla_get_exlogin_status(scsi_qla_host_t *vha, uint16_t *buf_sz,
|
|
|
|
uint16_t *ex_logins_cnt)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x118f,
|
|
|
|
"Entered %s\n", __func__);
|
|
|
|
|
|
|
|
memset(mcp->mb, 0 , sizeof(mcp->mb));
|
|
|
|
mcp->mb[0] = MBC_GET_MEM_OFFLOAD_CNTRL_STAT;
|
|
|
|
mcp->mb[1] = FETCH_XLOGINS_STAT;
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_10|MBX_4|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1115, "Failed=%x.\n", rval);
|
|
|
|
} else {
|
|
|
|
*buf_sz = mcp->mb[4];
|
|
|
|
*ex_logins_cnt = mcp->mb[10];
|
|
|
|
|
|
|
|
ql_log(ql_log_info, vha, 0x1190,
|
|
|
|
"buffer size 0x%x, exchange login count=%d\n",
|
|
|
|
mcp->mb[4], mcp->mb[10]);
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1116,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla_set_exlogin_mem_cfg
|
|
|
|
* set extended login memory configuration
|
|
|
|
* Mbx needs to be issues before init_cb is set
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha: adapter state pointer.
|
|
|
|
* buffer: buffer pointer
|
|
|
|
* phys_addr: physical address of buffer
|
|
|
|
* size: size of buffer
|
|
|
|
* TARGET_QUEUE_LOCK must be released
|
|
|
|
* ADAPTER_STATE_LOCK must be release
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local funxtion status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
#define CONFIG_XLOGINS_MEM 0x3
|
|
|
|
int
|
|
|
|
qla_set_exlogin_mem_cfg(scsi_qla_host_t *vha, dma_addr_t phys_addr)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x111a,
|
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
memset(mcp->mb, 0 , sizeof(mcp->mb));
|
|
|
|
mcp->mb[0] = MBC_GET_MEM_OFFLOAD_CNTRL_STAT;
|
|
|
|
mcp->mb[1] = CONFIG_XLOGINS_MEM;
|
|
|
|
mcp->mb[2] = MSW(phys_addr);
|
|
|
|
mcp->mb[3] = LSW(phys_addr);
|
|
|
|
mcp->mb[6] = MSW(MSD(phys_addr));
|
|
|
|
mcp->mb[7] = LSW(MSD(phys_addr));
|
|
|
|
mcp->mb[8] = MSW(ha->exlogin_size);
|
|
|
|
mcp->mb[9] = LSW(ha->exlogin_size);
|
|
|
|
mcp->out_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_11|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x111b, "Failed=%x.\n", rval);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x118c,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2015-12-17 12:56:57 -07:00
|
|
|
/*
|
|
|
|
* qla_get_exchoffld_status
|
|
|
|
* Get exchange offload status
|
|
|
|
* uses the memory offload control/status Mailbox
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha: adapter state pointer.
|
|
|
|
* fwopt: firmware options
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function status
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
#define FETCH_XCHOFFLD_STAT 0x2
|
|
|
|
int
|
|
|
|
qla_get_exchoffld_status(scsi_qla_host_t *vha, uint16_t *buf_sz,
|
|
|
|
uint16_t *ex_logins_cnt)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1019,
|
|
|
|
"Entered %s\n", __func__);
|
|
|
|
|
|
|
|
memset(mcp->mb, 0 , sizeof(mcp->mb));
|
|
|
|
mcp->mb[0] = MBC_GET_MEM_OFFLOAD_CNTRL_STAT;
|
|
|
|
mcp->mb[1] = FETCH_XCHOFFLD_STAT;
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_10|MBX_4|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1155, "Failed=%x.\n", rval);
|
|
|
|
} else {
|
|
|
|
*buf_sz = mcp->mb[4];
|
|
|
|
*ex_logins_cnt = mcp->mb[10];
|
|
|
|
|
|
|
|
ql_log(ql_log_info, vha, 0x118e,
|
|
|
|
"buffer size 0x%x, exchange offload count=%d\n",
|
|
|
|
mcp->mb[4], mcp->mb[10]);
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1156,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla_set_exchoffld_mem_cfg
|
|
|
|
* Set exchange offload memory configuration
|
|
|
|
* Mbx needs to be issues before init_cb is set
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha: adapter state pointer.
|
|
|
|
* buffer: buffer pointer
|
|
|
|
* phys_addr: physical address of buffer
|
|
|
|
* size: size of buffer
|
|
|
|
* TARGET_QUEUE_LOCK must be released
|
|
|
|
* ADAPTER_STATE_LOCK must be release
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local funxtion status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
#define CONFIG_XCHOFFLD_MEM 0x3
|
|
|
|
int
|
2017-06-02 10:12:03 -06:00
|
|
|
qla_set_exchoffld_mem_cfg(scsi_qla_host_t *vha)
|
2015-12-17 12:56:57 -07:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1157,
|
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
memset(mcp->mb, 0 , sizeof(mcp->mb));
|
|
|
|
mcp->mb[0] = MBC_GET_MEM_OFFLOAD_CNTRL_STAT;
|
|
|
|
mcp->mb[1] = CONFIG_XCHOFFLD_MEM;
|
2017-06-02 10:12:03 -06:00
|
|
|
mcp->mb[2] = MSW(ha->exchoffld_buf_dma);
|
|
|
|
mcp->mb[3] = LSW(ha->exchoffld_buf_dma);
|
|
|
|
mcp->mb[6] = MSW(MSD(ha->exchoffld_buf_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(ha->exchoffld_buf_dma));
|
|
|
|
mcp->mb[8] = MSW(ha->exchoffld_size);
|
|
|
|
mcp->mb[9] = LSW(ha->exchoffld_size);
|
2015-12-17 12:56:57 -07:00
|
|
|
mcp->out_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_11|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1158, "Failed=%x.\n", rval);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1192,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* qla2x00_get_fw_version
|
|
|
|
* Get firmware version.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha: adapter state pointer.
|
|
|
|
* major: pointer for major number.
|
|
|
|
* minor: pointer for minor number.
|
|
|
|
* subminor: pointer for subminor number.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
2009-06-03 10:55:20 -06:00
|
|
|
int
|
2012-02-09 12:15:34 -07:00
|
|
|
qla2x00_get_fw_version(scsi_qla_host_t *vha)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2012-02-09 12:15:34 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1029,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_FIRMWARE_VERSION;
|
|
|
|
mcp->out_mb = MBX_0;
|
|
|
|
mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
2013-08-26 23:37:28 -06:00
|
|
|
if (IS_QLA81XX(vha->hw) || IS_QLA8031(ha) || IS_QLA8044(ha))
|
2009-03-24 10:08:03 -06:00
|
|
|
mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8;
|
2012-08-22 12:21:28 -06:00
|
|
|
if (IS_FWI2_CAPABLE(ha))
|
2012-02-09 12:15:34 -07:00
|
|
|
mcp->in_mb |= MBX_17|MBX_16|MBX_15;
|
2014-02-26 02:15:06 -07:00
|
|
|
if (IS_QLA27XX(ha))
|
2016-07-06 09:14:18 -06:00
|
|
|
mcp->in_mb |=
|
|
|
|
MBX_25|MBX_24|MBX_23|MBX_22|MBX_21|MBX_20|MBX_19|MBX_18|
|
|
|
|
MBX_14|MBX_13|MBX_11|MBX_10|MBX_9|MBX_8;
|
2015-08-04 11:37:59 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2009-06-03 10:55:20 -06:00
|
|
|
if (rval != QLA_SUCCESS)
|
|
|
|
goto failed;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Return mailbox data. */
|
2012-02-09 12:15:34 -07:00
|
|
|
ha->fw_major_version = mcp->mb[1];
|
|
|
|
ha->fw_minor_version = mcp->mb[2];
|
|
|
|
ha->fw_subminor_version = mcp->mb[3];
|
|
|
|
ha->fw_attributes = mcp->mb[6];
|
2008-11-06 11:40:19 -07:00
|
|
|
if (IS_QLA2100(vha->hw) || IS_QLA2200(vha->hw))
|
2012-02-09 12:15:34 -07:00
|
|
|
ha->fw_memory_size = 0x1FFFF; /* Defaults to 128KB. */
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2012-02-09 12:15:34 -07:00
|
|
|
ha->fw_memory_size = (mcp->mb[5] << 16) | mcp->mb[4];
|
2015-08-04 11:37:59 -06:00
|
|
|
|
2013-08-26 23:37:28 -06:00
|
|
|
if (IS_QLA81XX(vha->hw) || IS_QLA8031(vha->hw) || IS_QLA8044(ha)) {
|
2012-02-09 12:15:34 -07:00
|
|
|
ha->mpi_version[0] = mcp->mb[10] & 0xff;
|
|
|
|
ha->mpi_version[1] = mcp->mb[11] >> 8;
|
|
|
|
ha->mpi_version[2] = mcp->mb[11] & 0xff;
|
|
|
|
ha->mpi_capabilities = (mcp->mb[12] << 16) | mcp->mb[13];
|
|
|
|
ha->phy_version[0] = mcp->mb[8] & 0xff;
|
|
|
|
ha->phy_version[1] = mcp->mb[9] >> 8;
|
|
|
|
ha->phy_version[2] = mcp->mb[9] & 0xff;
|
|
|
|
}
|
2015-08-04 11:37:59 -06:00
|
|
|
|
2012-08-22 12:21:04 -06:00
|
|
|
if (IS_FWI2_CAPABLE(ha)) {
|
|
|
|
ha->fw_attributes_h = mcp->mb[15];
|
|
|
|
ha->fw_attributes_ext[0] = mcp->mb[16];
|
|
|
|
ha->fw_attributes_ext[1] = mcp->mb[17];
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1139,
|
|
|
|
"%s: FW_attributes Upper: 0x%x, Lower: 0x%x.\n",
|
|
|
|
__func__, mcp->mb[15], mcp->mb[6]);
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x112f,
|
|
|
|
"%s: Ext_FwAttributes Upper: 0x%x, Lower: 0x%x.\n",
|
|
|
|
__func__, mcp->mb[17], mcp->mb[16]);
|
2015-12-17 12:56:57 -07:00
|
|
|
|
2015-12-17 12:56:56 -07:00
|
|
|
if (ha->fw_attributes_h & 0x4)
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x118d,
|
|
|
|
"%s: Firmware supports Extended Login 0x%x\n",
|
|
|
|
__func__, ha->fw_attributes_h);
|
2015-12-17 12:56:57 -07:00
|
|
|
|
|
|
|
if (ha->fw_attributes_h & 0x8)
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1191,
|
|
|
|
"%s: Firmware supports Exchange Offload 0x%x\n",
|
|
|
|
__func__, ha->fw_attributes_h);
|
2017-06-21 14:48:43 -06:00
|
|
|
|
2017-07-21 10:32:25 -06:00
|
|
|
/*
|
|
|
|
* FW supports nvme and driver load parameter requested nvme.
|
|
|
|
* BIT 26 of fw_attributes indicates NVMe support.
|
|
|
|
*/
|
2018-03-21 00:09:37 -06:00
|
|
|
if ((ha->fw_attributes_h & 0x400) && ql2xnvmeenable) {
|
2017-06-21 14:48:43 -06:00
|
|
|
vha->flags.nvme_enabled = 1;
|
2018-03-21 00:09:37 -06:00
|
|
|
ql_log(ql_log_info, vha, 0xd302,
|
|
|
|
"%s: FC-NVMe is Enabled (0x%x)\n",
|
|
|
|
__func__, ha->fw_attributes_h);
|
|
|
|
}
|
2009-01-05 12:18:11 -07:00
|
|
|
}
|
2015-08-04 11:37:59 -06:00
|
|
|
|
2014-02-26 02:15:06 -07:00
|
|
|
if (IS_QLA27XX(ha)) {
|
2015-08-04 11:37:59 -06:00
|
|
|
ha->mpi_version[0] = mcp->mb[10] & 0xff;
|
|
|
|
ha->mpi_version[1] = mcp->mb[11] >> 8;
|
|
|
|
ha->mpi_version[2] = mcp->mb[11] & 0xff;
|
|
|
|
ha->pep_version[0] = mcp->mb[13] & 0xff;
|
|
|
|
ha->pep_version[1] = mcp->mb[14] >> 8;
|
|
|
|
ha->pep_version[2] = mcp->mb[14] & 0xff;
|
2014-02-26 02:15:06 -07:00
|
|
|
ha->fw_shared_ram_start = (mcp->mb[19] << 16) | mcp->mb[18];
|
|
|
|
ha->fw_shared_ram_end = (mcp->mb[21] << 16) | mcp->mb[20];
|
2016-07-06 09:14:18 -06:00
|
|
|
ha->fw_ddr_ram_start = (mcp->mb[23] << 16) | mcp->mb[22];
|
|
|
|
ha->fw_ddr_ram_end = (mcp->mb[25] << 16) | mcp->mb[24];
|
2014-02-26 02:15:06 -07:00
|
|
|
}
|
2012-02-09 12:15:34 -07:00
|
|
|
|
2009-06-03 10:55:20 -06:00
|
|
|
failed:
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x102a, "Failed=%x.\n", rval);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*EMPTY*/
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102b,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-06-03 10:55:20 -06:00
|
|
|
return rval;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_get_fw_options
|
|
|
|
* Set firmware options.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* fwopt = pointer for firmware options.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_get_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102c,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_FIRMWARE_OPTION;
|
|
|
|
mcp->out_mb = MBX_0;
|
|
|
|
mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x102d, "Failed=%x.\n", rval);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2005-07-06 11:30:57 -06:00
|
|
|
fwopts[0] = mcp->mb[0];
|
2005-04-16 16:20:36 -06:00
|
|
|
fwopts[1] = mcp->mb[1];
|
|
|
|
fwopts[2] = mcp->mb[2];
|
|
|
|
fwopts[3] = mcp->mb[3];
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102e,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_set_fw_options
|
|
|
|
* Set firmware options.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* fwopt = pointer for firmware options.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_set_fw_options(scsi_qla_host_t *vha, uint16_t *fwopts)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x102f,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_SET_FIRMWARE_OPTION;
|
|
|
|
mcp->mb[1] = fwopts[1];
|
|
|
|
mcp->mb[2] = fwopts[2];
|
|
|
|
mcp->mb[3] = fwopts[3];
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->in_mb = MBX_0;
|
2008-11-06 11:40:19 -07:00
|
|
|
if (IS_FWI2_CAPABLE(vha->hw)) {
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->in_mb |= MBX_1;
|
2017-06-02 10:12:05 -06:00
|
|
|
mcp->mb[10] = fwopts[10];
|
|
|
|
mcp->out_mb |= MBX_10;
|
2005-07-06 11:30:57 -06:00
|
|
|
} else {
|
|
|
|
mcp->mb[10] = fwopts[10];
|
|
|
|
mcp->mb[11] = fwopts[11];
|
|
|
|
mcp->mb[12] = 0; /* Undocumented, but used */
|
|
|
|
mcp->out_mb |= MBX_12|MBX_11|MBX_10;
|
|
|
|
}
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
fwopts[0] = mcp->mb[0];
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1030,
|
|
|
|
"Failed=%x (%x/%x).\n", rval, mcp->mb[0], mcp->mb[1]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*EMPTY*/
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1031,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_mbx_reg_test
|
|
|
|
* Mailbox register wrap test.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_mbx_reg_test(scsi_qla_host_t *vha)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1032,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_MAILBOX_REGISTER_TEST;
|
|
|
|
mcp->mb[1] = 0xAAAA;
|
|
|
|
mcp->mb[2] = 0x5555;
|
|
|
|
mcp->mb[3] = 0xAA55;
|
|
|
|
mcp->mb[4] = 0x55AA;
|
|
|
|
mcp->mb[5] = 0xA5A5;
|
|
|
|
mcp->mb[6] = 0x5A5A;
|
|
|
|
mcp->mb[7] = 0x2525;
|
|
|
|
mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval == QLA_SUCCESS) {
|
|
|
|
if (mcp->mb[1] != 0xAAAA || mcp->mb[2] != 0x5555 ||
|
|
|
|
mcp->mb[3] != 0xAA55 || mcp->mb[4] != 0x55AA)
|
|
|
|
rval = QLA_FUNCTION_FAILED;
|
|
|
|
if (mcp->mb[5] != 0xA5A5 || mcp->mb[6] != 0x5A5A ||
|
|
|
|
mcp->mb[7] != 0x2525)
|
|
|
|
rval = QLA_FUNCTION_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1033, "Failed=%x.\n", rval);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*EMPTY*/
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1034,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_verify_checksum
|
|
|
|
* Verify firmware checksum.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_verify_checksum(scsi_qla_host_t *vha, uint32_t risc_addr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1035,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_VERIFY_CHECKSUM;
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->out_mb = MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
2008-11-06 11:40:19 -07:00
|
|
|
if (IS_FWI2_CAPABLE(vha->hw)) {
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->mb[1] = MSW(risc_addr);
|
|
|
|
mcp->mb[2] = LSW(risc_addr);
|
|
|
|
mcp->out_mb |= MBX_2|MBX_1;
|
|
|
|
mcp->in_mb |= MBX_2|MBX_1;
|
|
|
|
} else {
|
|
|
|
mcp->mb[1] = LSW(risc_addr);
|
|
|
|
mcp->out_mb |= MBX_1;
|
|
|
|
mcp->in_mb |= MBX_1;
|
|
|
|
}
|
|
|
|
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1036,
|
|
|
|
"Failed=%x chm sum=%x.\n", rval, IS_FWI2_CAPABLE(vha->hw) ?
|
|
|
|
(mcp->mb[2] << 16) | mcp->mb[1] : mcp->mb[1]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1037,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_issue_iocb
|
|
|
|
* Issue IOCB using mailbox command
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter state pointer.
|
|
|
|
* buffer = buffer pointer.
|
|
|
|
* phys_addr = physical address of buffer.
|
|
|
|
* size = size of buffer.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
2010-03-19 18:03:58 -06:00
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_issue_iocb_timeout(scsi_qla_host_t *vha, void *buffer,
|
2008-04-03 14:13:26 -06:00
|
|
|
dma_addr_t phys_addr, size_t size, uint32_t tov)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1038,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->mb[0] = MBC_IOCB_COMMAND_A64;
|
|
|
|
mcp->mb[1] = 0;
|
|
|
|
mcp->mb[2] = MSW(phys_addr);
|
|
|
|
mcp->mb[3] = LSW(phys_addr);
|
|
|
|
mcp->mb[6] = MSW(MSD(phys_addr));
|
|
|
|
mcp->mb[7] = LSW(MSD(phys_addr));
|
|
|
|
mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_2|MBX_0;
|
2008-04-03 14:13:26 -06:00
|
|
|
mcp->tov = tov;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1039, "Failed=%x.\n", rval);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2005-07-06 11:30:47 -06:00
|
|
|
sts_entry_t *sts_entry = (sts_entry_t *) buffer;
|
|
|
|
|
|
|
|
/* Mask reserved bits. */
|
|
|
|
sts_entry->entry_status &=
|
2008-11-06 11:40:19 -07:00
|
|
|
IS_FWI2_CAPABLE(vha->hw) ? RF_MASK_24XX : RF_MASK;
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103a,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2008-04-03 14:13:26 -06:00
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_issue_iocb(scsi_qla_host_t *vha, void *buffer, dma_addr_t phys_addr,
|
2008-04-03 14:13:26 -06:00
|
|
|
size_t size)
|
|
|
|
{
|
2008-11-06 11:40:19 -07:00
|
|
|
return qla2x00_issue_iocb_timeout(vha, buffer, phys_addr, size,
|
2008-04-03 14:13:26 -06:00
|
|
|
MBX_TOV_SECONDS);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* qla2x00_abort_command
|
|
|
|
* Abort command aborts a specified IOCB.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* sp = SB structure pointer.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2009-04-06 23:33:40 -06:00
|
|
|
qla2x00_abort_command(srb_t *sp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
unsigned long flags = 0;
|
|
|
|
int rval;
|
2008-12-09 17:45:39 -07:00
|
|
|
uint32_t handle = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2009-04-06 23:33:40 -06:00
|
|
|
fc_port_t *fcport = sp->fcport;
|
|
|
|
scsi_qla_host_t *vha = fcport->vha;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2016-12-12 15:40:07 -07:00
|
|
|
struct req_que *req;
|
2012-02-09 12:15:36 -07:00
|
|
|
struct scsi_cmnd *cmd = GET_CMD_SP(sp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103b,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2016-12-12 15:40:07 -07:00
|
|
|
if (vha->flags.qpairs_available && sp->qpair)
|
|
|
|
req = sp->qpair->req;
|
|
|
|
else
|
|
|
|
req = vha->req;
|
|
|
|
|
2008-07-24 09:31:49 -06:00
|
|
|
spin_lock_irqsave(&ha->hardware_lock, flags);
|
2013-01-30 01:34:37 -07:00
|
|
|
for (handle = 1; handle < req->num_outstanding_cmds; handle++) {
|
2008-11-06 11:40:19 -07:00
|
|
|
if (req->outstanding_cmds[handle] == sp)
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
2008-07-24 09:31:49 -06:00
|
|
|
spin_unlock_irqrestore(&ha->hardware_lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-01-30 01:34:37 -07:00
|
|
|
if (handle == req->num_outstanding_cmds) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* command not found */
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_ABORT_COMMAND;
|
|
|
|
if (HAS_EXTENDED_IDS(ha))
|
|
|
|
mcp->mb[1] = fcport->loop_id;
|
|
|
|
else
|
|
|
|
mcp->mb[1] = fcport->loop_id << 8;
|
|
|
|
mcp->mb[2] = (uint16_t)handle;
|
|
|
|
mcp->mb[3] = (uint16_t)(handle >> 16);
|
2012-02-09 12:15:36 -07:00
|
|
|
mcp->mb[6] = (uint16_t)cmd->device->lun;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->out_mb = MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x103c, "Failed=%x.\n", rval);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103d,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2014-06-25 07:27:36 -06:00
|
|
|
qla2x00_abort_target(struct fc_port *fcport, uint64_t l, int tag)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-04-03 14:13:24 -06:00
|
|
|
int rval, rval2;
|
2005-04-16 16:20:36 -06:00
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2008-11-06 11:40:19 -07:00
|
|
|
scsi_qla_host_t *vha;
|
2008-12-09 17:45:39 -07:00
|
|
|
struct req_que *req;
|
|
|
|
struct rsp_que *rsp;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-03 14:13:24 -06:00
|
|
|
l = l;
|
2008-11-06 11:40:19 -07:00
|
|
|
vha = fcport->vha;
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103e,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2010-05-28 16:08:17 -06:00
|
|
|
req = vha->hw->req_q_map[0];
|
|
|
|
rsp = req->rsp;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->mb[0] = MBC_ABORT_TARGET;
|
2008-04-03 14:13:24 -06:00
|
|
|
mcp->out_mb = MBX_9|MBX_2|MBX_1|MBX_0;
|
2008-11-06 11:40:19 -07:00
|
|
|
if (HAS_EXTENDED_IDS(vha->hw)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->mb[1] = fcport->loop_id;
|
|
|
|
mcp->mb[10] = 0;
|
|
|
|
mcp->out_mb |= MBX_10;
|
|
|
|
} else {
|
|
|
|
mcp->mb[1] = fcport->loop_id << 8;
|
|
|
|
}
|
2008-11-06 11:40:19 -07:00
|
|
|
mcp->mb[2] = vha->hw->loop_reset_delay;
|
|
|
|
mcp->mb[9] = vha->vp_idx;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->in_mb = MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2008-04-03 14:13:24 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x103f,
|
|
|
|
"Failed=%x.\n", rval);
|
2008-04-03 14:13:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Issue marker IOCB. */
|
2008-12-09 17:45:39 -07:00
|
|
|
rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, 0,
|
|
|
|
MK_SYNC_ID);
|
2008-04-03 14:13:24 -06:00
|
|
|
if (rval2 != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1040,
|
|
|
|
"Failed to issue marker IOCB (%x).\n", rval2);
|
2008-04-03 14:13:24 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1041,
|
|
|
|
"Done %s.\n", __func__);
|
2008-04-03 14:13:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2014-06-25 07:27:36 -06:00
|
|
|
qla2x00_lun_reset(struct fc_port *fcport, uint64_t l, int tag)
|
2008-04-03 14:13:24 -06:00
|
|
|
{
|
|
|
|
int rval, rval2;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2008-11-06 11:40:19 -07:00
|
|
|
scsi_qla_host_t *vha;
|
2008-12-09 17:45:39 -07:00
|
|
|
struct req_que *req;
|
|
|
|
struct rsp_que *rsp;
|
2008-04-03 14:13:24 -06:00
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
vha = fcport->vha;
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1042,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2010-05-28 16:08:17 -06:00
|
|
|
req = vha->hw->req_q_map[0];
|
|
|
|
rsp = req->rsp;
|
2008-04-03 14:13:24 -06:00
|
|
|
mcp->mb[0] = MBC_LUN_RESET;
|
|
|
|
mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
|
2008-11-06 11:40:19 -07:00
|
|
|
if (HAS_EXTENDED_IDS(vha->hw))
|
2008-04-03 14:13:24 -06:00
|
|
|
mcp->mb[1] = fcport->loop_id;
|
|
|
|
else
|
|
|
|
mcp->mb[1] = fcport->loop_id << 8;
|
2014-06-25 07:27:36 -06:00
|
|
|
mcp->mb[2] = (u32)l;
|
2008-04-03 14:13:24 -06:00
|
|
|
mcp->mb[3] = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
mcp->mb[9] = vha->vp_idx;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-03 14:13:24 -06:00
|
|
|
mcp->in_mb = MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2008-04-03 14:13:24 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1043, "Failed=%x.\n", rval);
|
2008-04-03 14:13:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Issue marker IOCB. */
|
2008-12-09 17:45:39 -07:00
|
|
|
rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
|
|
|
|
MK_SYNC_ID_LUN);
|
2008-04-03 14:13:24 -06:00
|
|
|
if (rval2 != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1044,
|
|
|
|
"Failed to issue marker IOCB (%x).\n", rval2);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1045,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_get_adapter_id
|
|
|
|
* Get adapter ID and topology.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* id = pointer for loop ID.
|
|
|
|
* al_pa = pointer for AL_PA.
|
|
|
|
* area = pointer for area.
|
|
|
|
* domain = pointer for domain.
|
|
|
|
* top = pointer for topology.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_get_adapter_id(scsi_qla_host_t *vha, uint16_t *id, uint8_t *al_pa,
|
2007-07-05 14:16:51 -06:00
|
|
|
uint8_t *area, uint8_t *domain, uint16_t *top, uint16_t *sw_cap)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1046,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_ADAPTER_LOOP_ID;
|
2008-11-06 11:40:19 -07:00
|
|
|
mcp->mb[9] = vha->vp_idx;
|
2007-11-12 11:30:58 -07:00
|
|
|
mcp->out_mb = MBX_9|MBX_0;
|
2007-07-05 14:16:51 -06:00
|
|
|
mcp->in_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
2012-02-09 12:15:34 -07:00
|
|
|
if (IS_CNA_CAPABLE(vha->hw))
|
2009-04-06 23:33:38 -06:00
|
|
|
mcp->in_mb |= MBX_13|MBX_12|MBX_11|MBX_10;
|
2014-09-25 03:16:47 -06:00
|
|
|
if (IS_FWI2_CAPABLE(vha->hw))
|
|
|
|
mcp->in_mb |= MBX_19|MBX_18|MBX_17|MBX_16;
|
2016-01-27 10:03:32 -07:00
|
|
|
if (IS_QLA27XX(vha->hw))
|
|
|
|
mcp->in_mb |= MBX_15;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-11-08 15:37:20 -07:00
|
|
|
if (mcp->mb[0] == MBS_COMMAND_ERROR)
|
|
|
|
rval = QLA_COMMAND_ERROR;
|
2008-07-10 17:56:01 -06:00
|
|
|
else if (mcp->mb[0] == MBS_INVALID_COMMAND)
|
|
|
|
rval = QLA_INVALID_COMMAND;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Return data. */
|
|
|
|
*id = mcp->mb[1];
|
|
|
|
*al_pa = LSB(mcp->mb[2]);
|
|
|
|
*area = MSB(mcp->mb[2]);
|
|
|
|
*domain = LSB(mcp->mb[3]);
|
|
|
|
*top = mcp->mb[6];
|
2007-07-05 14:16:51 -06:00
|
|
|
*sw_cap = mcp->mb[7];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1047, "Failed=%x.\n", rval);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1048,
|
|
|
|
"Done %s.\n", __func__);
|
2009-04-06 23:33:38 -06:00
|
|
|
|
2012-02-09 12:15:34 -07:00
|
|
|
if (IS_CNA_CAPABLE(vha->hw)) {
|
2009-04-06 23:33:38 -06:00
|
|
|
vha->fcoe_vlan_id = mcp->mb[9] & 0xfff;
|
|
|
|
vha->fcoe_fcf_idx = mcp->mb[10];
|
|
|
|
vha->fcoe_vn_port_mac[5] = mcp->mb[11] >> 8;
|
|
|
|
vha->fcoe_vn_port_mac[4] = mcp->mb[11] & 0xff;
|
|
|
|
vha->fcoe_vn_port_mac[3] = mcp->mb[12] >> 8;
|
|
|
|
vha->fcoe_vn_port_mac[2] = mcp->mb[12] & 0xff;
|
|
|
|
vha->fcoe_vn_port_mac[1] = mcp->mb[13] >> 8;
|
|
|
|
vha->fcoe_vn_port_mac[0] = mcp->mb[13] & 0xff;
|
|
|
|
}
|
2014-09-25 03:16:47 -06:00
|
|
|
/* If FA-WWN supported */
|
2015-08-04 11:37:55 -06:00
|
|
|
if (IS_FAWWN_CAPABLE(vha->hw)) {
|
|
|
|
if (mcp->mb[7] & BIT_14) {
|
|
|
|
vha->port_name[0] = MSB(mcp->mb[16]);
|
|
|
|
vha->port_name[1] = LSB(mcp->mb[16]);
|
|
|
|
vha->port_name[2] = MSB(mcp->mb[17]);
|
|
|
|
vha->port_name[3] = LSB(mcp->mb[17]);
|
|
|
|
vha->port_name[4] = MSB(mcp->mb[18]);
|
|
|
|
vha->port_name[5] = LSB(mcp->mb[18]);
|
|
|
|
vha->port_name[6] = MSB(mcp->mb[19]);
|
|
|
|
vha->port_name[7] = LSB(mcp->mb[19]);
|
|
|
|
fc_host_port_name(vha->host) =
|
|
|
|
wwn_to_u64(vha->port_name);
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10ca,
|
|
|
|
"FA-WWN acquired %016llx\n",
|
|
|
|
wwn_to_u64(vha->port_name));
|
|
|
|
}
|
2014-09-25 03:16:47 -06:00
|
|
|
}
|
2016-01-27 10:03:32 -07:00
|
|
|
|
|
|
|
if (IS_QLA27XX(vha->hw))
|
|
|
|
vha->bbcr = mcp->mb[15];
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_get_retry_cnt
|
|
|
|
* Get current firmware login retry count and delay.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* retry_cnt = pointer to login retry count.
|
|
|
|
* tov = pointer to login timeout value.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_get_retry_cnt(scsi_qla_host_t *vha, uint8_t *retry_cnt, uint8_t *tov,
|
2005-04-16 16:20:36 -06:00
|
|
|
uint16_t *r_a_tov)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
uint16_t ratov;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1049,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_RETRY_COUNT;
|
|
|
|
mcp->out_mb = MBX_0;
|
|
|
|
mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x104a,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/* Convert returned data and check our values. */
|
|
|
|
*r_a_tov = mcp->mb[3] / 2;
|
|
|
|
ratov = (mcp->mb[3]/2) / 10; /* mb[3] value is in 100ms */
|
|
|
|
if (mcp->mb[1] * ratov > (*retry_cnt) * (*tov)) {
|
|
|
|
/* Update to the larger values */
|
|
|
|
*retry_cnt = (uint8_t)mcp->mb[1];
|
|
|
|
*tov = ratov;
|
|
|
|
}
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104b,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Done %s mb3=%d ratov=%d.\n", __func__, mcp->mb[3], ratov);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_init_firmware
|
|
|
|
* Initialize adapter firmware.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* dptr = Initialization control block pointer.
|
|
|
|
* size = size of initialization control block.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_init_firmware(scsi_qla_host_t *vha, uint16_t size)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104c,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2013-08-26 23:37:28 -06:00
|
|
|
if (IS_P3P_TYPE(ha) && ql2xdbwr)
|
2015-07-09 08:24:50 -06:00
|
|
|
qla82xx_wr_32(ha, (uintptr_t __force)ha->nxdb_wr_ptr,
|
2010-04-12 18:59:55 -06:00
|
|
|
(0x04 | (ha->portnum << 5) | (0 << 8) | (0 << 16)));
|
|
|
|
|
2008-01-31 13:33:53 -07:00
|
|
|
if (ha->flags.npiv_supported)
|
2007-07-05 14:16:51 -06:00
|
|
|
mcp->mb[0] = MBC_MID_INITIALIZE_FIRMWARE;
|
|
|
|
else
|
|
|
|
mcp->mb[0] = MBC_INITIALIZE_FIRMWARE;
|
|
|
|
|
2009-03-24 10:08:01 -06:00
|
|
|
mcp->mb[1] = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->mb[2] = MSW(ha->init_cb_dma);
|
|
|
|
mcp->mb[3] = LSW(ha->init_cb_dma);
|
|
|
|
mcp->mb[6] = MSW(MSD(ha->init_cb_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(ha->init_cb_dma));
|
2009-03-24 10:08:01 -06:00
|
|
|
mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
2013-10-30 01:38:11 -06:00
|
|
|
if (ha->ex_init_cb && ha->ex_init_cb->ex_version) {
|
2009-03-24 10:08:01 -06:00
|
|
|
mcp->mb[1] = BIT_0;
|
|
|
|
mcp->mb[10] = MSW(ha->ex_init_cb_dma);
|
|
|
|
mcp->mb[11] = LSW(ha->ex_init_cb_dma);
|
|
|
|
mcp->mb[12] = MSW(MSD(ha->ex_init_cb_dma));
|
|
|
|
mcp->mb[13] = LSW(MSD(ha->ex_init_cb_dma));
|
|
|
|
mcp->mb[14] = sizeof(*ha->ex_init_cb);
|
|
|
|
mcp->out_mb |= MBX_14|MBX_13|MBX_12|MBX_11|MBX_10;
|
|
|
|
}
|
2012-02-09 12:15:34 -07:00
|
|
|
/* 1 and 2 should normally be captured. */
|
|
|
|
mcp->in_mb = MBX_2|MBX_1|MBX_0;
|
2014-02-26 02:15:06 -07:00
|
|
|
if (IS_QLA83XX(ha) || IS_QLA27XX(ha))
|
2012-02-09 12:15:34 -07:00
|
|
|
/* mb3 is additional info about the installed SFP. */
|
|
|
|
mcp->in_mb |= MBX_3;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->buf_size = size;
|
|
|
|
mcp->flags = MBX_DMA_OUT;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x104d,
|
2012-02-09 12:15:34 -07:00
|
|
|
"Failed=%x mb[0]=%x, mb[1]=%x, mb[2]=%x, mb[3]=%x,.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1], mcp->mb[2], mcp->mb[3]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2017-08-23 16:05:16 -06:00
|
|
|
if (IS_QLA27XX(ha)) {
|
|
|
|
if (mcp->mb[2] == 6 || mcp->mb[3] == 2)
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x119d,
|
|
|
|
"Invalid SFP/Validation Failed\n");
|
|
|
|
}
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104e,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2012-05-15 12:34:28 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* qla2x00_get_port_database
|
|
|
|
* Issue normal/enhanced get port database mailbox command
|
|
|
|
* and copy device name as necessary.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter state pointer.
|
|
|
|
* dev = structure pointer.
|
|
|
|
* opt = enhanced cmd option byte.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_get_port_database(scsi_qla_host_t *vha, fc_port_t *fcport, uint8_t opt)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
port_database_t *pd;
|
2005-07-06 11:30:57 -06:00
|
|
|
struct port_database_24xx *pd24;
|
2005-04-16 16:20:36 -06:00
|
|
|
dma_addr_t pd_dma;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x104f,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
pd24 = NULL;
|
2017-09-21 00:15:26 -06:00
|
|
|
pd = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pd == NULL) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0x1050,
|
|
|
|
"Failed to allocate port database structure.\n");
|
2017-10-13 10:34:06 -06:00
|
|
|
fcport->query = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
return QLA_MEMORY_ALLOC_FAILED;
|
|
|
|
}
|
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->mb[0] = MBC_GET_PORT_DATABASE;
|
2007-07-19 16:05:56 -06:00
|
|
|
if (opt != 0 && !IS_FWI2_CAPABLE(ha))
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->mb[0] = MBC_ENHANCED_GET_PORT_DATABASE;
|
|
|
|
mcp->mb[2] = MSW(pd_dma);
|
|
|
|
mcp->mb[3] = LSW(pd_dma);
|
|
|
|
mcp->mb[6] = MSW(MSD(pd_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(pd_dma));
|
2008-11-06 11:40:19 -07:00
|
|
|
mcp->mb[9] = vha->vp_idx;
|
2007-07-05 14:16:51 -06:00
|
|
|
mcp->out_mb = MBX_9|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->in_mb = MBX_0;
|
2007-07-19 16:05:56 -06:00
|
|
|
if (IS_FWI2_CAPABLE(ha)) {
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->mb[1] = fcport->loop_id;
|
|
|
|
mcp->mb[10] = opt;
|
|
|
|
mcp->out_mb |= MBX_10|MBX_1;
|
|
|
|
mcp->in_mb |= MBX_1;
|
|
|
|
} else if (HAS_EXTENDED_IDS(ha)) {
|
|
|
|
mcp->mb[1] = fcport->loop_id;
|
|
|
|
mcp->mb[10] = opt;
|
|
|
|
mcp->out_mb |= MBX_10|MBX_1;
|
|
|
|
} else {
|
|
|
|
mcp->mb[1] = fcport->loop_id << 8 | opt;
|
|
|
|
mcp->out_mb |= MBX_1;
|
|
|
|
}
|
2007-07-19 16:05:56 -06:00
|
|
|
mcp->buf_size = IS_FWI2_CAPABLE(ha) ?
|
|
|
|
PORT_DATABASE_24XX_SIZE : PORT_DATABASE_SIZE;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = MBX_DMA_IN;
|
|
|
|
mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rval != QLA_SUCCESS)
|
|
|
|
goto gpd_error_out;
|
|
|
|
|
2007-07-19 16:05:56 -06:00
|
|
|
if (IS_FWI2_CAPABLE(ha)) {
|
2012-02-09 12:15:58 -07:00
|
|
|
uint64_t zero = 0;
|
2017-10-13 10:34:05 -06:00
|
|
|
u8 current_login_state, last_login_state;
|
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
pd24 = (struct port_database_24xx *) pd;
|
|
|
|
|
|
|
|
/* Check for logged in state. */
|
2017-10-13 10:34:05 -06:00
|
|
|
if (fcport->fc4f_nvme) {
|
|
|
|
current_login_state = pd24->current_login_state >> 4;
|
|
|
|
last_login_state = pd24->last_login_state >> 4;
|
|
|
|
} else {
|
|
|
|
current_login_state = pd24->current_login_state & 0xf;
|
|
|
|
last_login_state = pd24->last_login_state & 0xf;
|
|
|
|
}
|
|
|
|
fcport->current_login_state = pd24->current_login_state;
|
|
|
|
fcport->last_login_state = pd24->last_login_state;
|
|
|
|
|
|
|
|
/* Check for logged in state. */
|
|
|
|
if (current_login_state != PDS_PRLI_COMPLETE &&
|
|
|
|
last_login_state != PDS_PRLI_COMPLETE) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x119a,
|
|
|
|
"Unable to verify login-state (%x/%x) for loop_id %x.\n",
|
|
|
|
current_login_state, last_login_state,
|
|
|
|
fcport->loop_id);
|
2005-07-06 11:30:57 -06:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
2017-10-13 10:34:05 -06:00
|
|
|
|
|
|
|
if (!fcport->query)
|
|
|
|
goto gpd_error_out;
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-02-09 12:15:58 -07:00
|
|
|
if (fcport->loop_id == FC_NO_LOOP_ID ||
|
|
|
|
(memcmp(fcport->port_name, (uint8_t *)&zero, 8) &&
|
|
|
|
memcmp(fcport->port_name, pd24->port_name, 8))) {
|
|
|
|
/* We lost the device mid way. */
|
|
|
|
rval = QLA_NOT_LOGGED_IN;
|
|
|
|
goto gpd_error_out;
|
|
|
|
}
|
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
/* Names are little-endian. */
|
|
|
|
memcpy(fcport->node_name, pd24->node_name, WWN_SIZE);
|
|
|
|
memcpy(fcport->port_name, pd24->port_name, WWN_SIZE);
|
|
|
|
|
|
|
|
/* Get port_id of device. */
|
|
|
|
fcport->d_id.b.domain = pd24->port_id[0];
|
|
|
|
fcport->d_id.b.area = pd24->port_id[1];
|
|
|
|
fcport->d_id.b.al_pa = pd24->port_id[2];
|
|
|
|
fcport->d_id.b.rsvd_1 = 0;
|
|
|
|
|
|
|
|
/* If not target must be initiator or unknown type. */
|
|
|
|
if ((pd24->prli_svc_param_word_3[0] & BIT_4) == 0)
|
|
|
|
fcport->port_type = FCT_INITIATOR;
|
|
|
|
else
|
|
|
|
fcport->port_type = FCT_TARGET;
|
2012-05-15 12:34:28 -06:00
|
|
|
|
|
|
|
/* Passback COS information. */
|
|
|
|
fcport->supported_classes = (pd24->flags & PDF_CLASS_2) ?
|
|
|
|
FC_COS_CLASS2 : FC_COS_CLASS3;
|
|
|
|
|
|
|
|
if (pd24->prli_svc_param_word_3[0] & BIT_7)
|
|
|
|
fcport->flags |= FCF_CONF_COMP_SUPPORTED;
|
2005-07-06 11:30:57 -06:00
|
|
|
} else {
|
2012-02-09 12:15:58 -07:00
|
|
|
uint64_t zero = 0;
|
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
/* Check for logged in state. */
|
|
|
|
if (pd->master_state != PD_STATE_PORT_LOGGED_IN &&
|
|
|
|
pd->slave_state != PD_STATE_PORT_LOGGED_IN) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x100a,
|
|
|
|
"Unable to verify login-state (%x/%x) - "
|
|
|
|
"portid=%02x%02x%02x.\n", pd->master_state,
|
|
|
|
pd->slave_state, fcport->d_id.b.domain,
|
|
|
|
fcport->d_id.b.area, fcport->d_id.b.al_pa);
|
2005-07-06 11:30:57 -06:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
|
|
|
goto gpd_error_out;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-02-09 12:15:58 -07:00
|
|
|
if (fcport->loop_id == FC_NO_LOOP_ID ||
|
|
|
|
(memcmp(fcport->port_name, (uint8_t *)&zero, 8) &&
|
|
|
|
memcmp(fcport->port_name, pd->port_name, 8))) {
|
|
|
|
/* We lost the device mid way. */
|
|
|
|
rval = QLA_NOT_LOGGED_IN;
|
|
|
|
goto gpd_error_out;
|
|
|
|
}
|
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
/* Names are little-endian. */
|
|
|
|
memcpy(fcport->node_name, pd->node_name, WWN_SIZE);
|
|
|
|
memcpy(fcport->port_name, pd->port_name, WWN_SIZE);
|
|
|
|
|
|
|
|
/* Get port_id of device. */
|
|
|
|
fcport->d_id.b.domain = pd->port_id[0];
|
|
|
|
fcport->d_id.b.area = pd->port_id[3];
|
|
|
|
fcport->d_id.b.al_pa = pd->port_id[2];
|
|
|
|
fcport->d_id.b.rsvd_1 = 0;
|
|
|
|
|
|
|
|
/* If not target must be initiator or unknown type. */
|
|
|
|
if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0)
|
|
|
|
fcport->port_type = FCT_INITIATOR;
|
|
|
|
else
|
|
|
|
fcport->port_type = FCT_TARGET;
|
2005-08-26 20:08:10 -06:00
|
|
|
|
|
|
|
/* Passback COS information. */
|
|
|
|
fcport->supported_classes = (pd->options & BIT_4) ?
|
|
|
|
FC_COS_CLASS2: FC_COS_CLASS3;
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
gpd_error_out:
|
|
|
|
dma_pool_free(ha->s_dma_pool, pd, pd_dma);
|
2017-10-13 10:34:06 -06:00
|
|
|
fcport->query = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1052,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x.\n", rval,
|
|
|
|
mcp->mb[0], mcp->mb[1]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1053,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_get_firmware_state
|
|
|
|
* Get adapter firmware state.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* dptr = pointer for firmware state.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_get_firmware_state(scsi_qla_host_t *vha, uint16_t *states)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2017-08-23 16:05:16 -06:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1054,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_FIRMWARE_STATE;
|
|
|
|
mcp->out_mb = MBX_0;
|
2009-06-17 11:30:30 -06:00
|
|
|
if (IS_FWI2_CAPABLE(vha->hw))
|
2014-09-25 03:16:48 -06:00
|
|
|
mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
2009-06-17 11:30:30 -06:00
|
|
|
else
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-04-03 14:13:26 -06:00
|
|
|
/* Return firmware states. */
|
|
|
|
states[0] = mcp->mb[1];
|
2009-06-17 11:30:30 -06:00
|
|
|
if (IS_FWI2_CAPABLE(vha->hw)) {
|
|
|
|
states[1] = mcp->mb[2];
|
2016-07-06 09:14:26 -06:00
|
|
|
states[2] = mcp->mb[3]; /* SFP info */
|
2009-06-17 11:30:30 -06:00
|
|
|
states[3] = mcp->mb[4];
|
|
|
|
states[4] = mcp->mb[5];
|
2014-09-25 03:16:48 -06:00
|
|
|
states[5] = mcp->mb[6]; /* DPORT status */
|
2009-06-17 11:30:30 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1055, "Failed=%x.\n", rval);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2017-08-23 16:05:16 -06:00
|
|
|
if (IS_QLA27XX(ha)) {
|
|
|
|
if (mcp->mb[2] == 6 || mcp->mb[3] == 2)
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x119e,
|
|
|
|
"Invalid SFP/Validation Failed\n");
|
|
|
|
}
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1056,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_get_port_name
|
|
|
|
* Issue get port name mailbox command.
|
|
|
|
* Returned name is in big endian format.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* loop_id = loop ID of device.
|
|
|
|
* name = pointer for name.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_get_port_name(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t *name,
|
2005-04-16 16:20:36 -06:00
|
|
|
uint8_t opt)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1057,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_PORT_NAME;
|
2008-11-06 11:40:19 -07:00
|
|
|
mcp->mb[9] = vha->vp_idx;
|
2007-07-05 14:16:51 -06:00
|
|
|
mcp->out_mb = MBX_9|MBX_1|MBX_0;
|
2008-11-06 11:40:19 -07:00
|
|
|
if (HAS_EXTENDED_IDS(vha->hw)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->mb[1] = loop_id;
|
|
|
|
mcp->mb[10] = opt;
|
|
|
|
mcp->out_mb |= MBX_10;
|
|
|
|
} else {
|
|
|
|
mcp->mb[1] = loop_id << 8 | opt;
|
|
|
|
}
|
|
|
|
|
|
|
|
mcp->in_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1058, "Failed=%x.\n", rval);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
if (name != NULL) {
|
|
|
|
/* This function returns name in big endian. */
|
2007-03-22 09:53:19 -06:00
|
|
|
name[0] = MSB(mcp->mb[2]);
|
|
|
|
name[1] = LSB(mcp->mb[2]);
|
|
|
|
name[2] = MSB(mcp->mb[3]);
|
|
|
|
name[3] = LSB(mcp->mb[3]);
|
|
|
|
name[4] = MSB(mcp->mb[6]);
|
|
|
|
name[5] = LSB(mcp->mb[6]);
|
|
|
|
name[6] = MSB(mcp->mb[7]);
|
|
|
|
name[7] = LSB(mcp->mb[7]);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1059,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2013-02-07 23:57:48 -07:00
|
|
|
/*
|
|
|
|
* qla24xx_link_initialization
|
|
|
|
* Issue link initialization mailbox command.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
qla24xx_link_initialize(scsi_qla_host_t *vha)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1152,
|
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
if (!IS_FWI2_CAPABLE(vha->hw) || IS_CNA_CAPABLE(vha->hw))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_LINK_INITIALIZATION;
|
2013-08-26 23:37:49 -06:00
|
|
|
mcp->mb[1] = BIT_4;
|
|
|
|
if (vha->hw->operating_mode == LOOP)
|
|
|
|
mcp->mb[1] |= BIT_6;
|
|
|
|
else
|
|
|
|
mcp->mb[1] |= BIT_5;
|
2013-02-07 23:57:48 -07:00
|
|
|
mcp->mb[2] = 0;
|
|
|
|
mcp->mb[3] = 0;
|
|
|
|
mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1153, "Failed=%x.\n", rval);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1154,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* qla2x00_lip_reset
|
|
|
|
* Issue LIP reset mailbox command.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_lip_reset(scsi_qla_host_t *vha)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105a,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-02-09 12:15:34 -07:00
|
|
|
if (IS_CNA_CAPABLE(vha->hw)) {
|
2009-01-05 12:18:11 -07:00
|
|
|
/* Logout across all FCFs. */
|
|
|
|
mcp->mb[0] = MBC_LIP_FULL_LOGIN;
|
|
|
|
mcp->mb[1] = BIT_1;
|
|
|
|
mcp->mb[2] = 0;
|
|
|
|
mcp->out_mb = MBX_2|MBX_1|MBX_0;
|
|
|
|
} else if (IS_FWI2_CAPABLE(vha->hw)) {
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->mb[0] = MBC_LIP_FULL_LOGIN;
|
2006-12-13 20:20:30 -07:00
|
|
|
mcp->mb[1] = BIT_6;
|
|
|
|
mcp->mb[2] = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
mcp->mb[3] = vha->hw->loop_reset_delay;
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->mb[0] = MBC_LIP_RESET;
|
|
|
|
mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
2008-11-06 11:40:19 -07:00
|
|
|
if (HAS_EXTENDED_IDS(vha->hw)) {
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->mb[1] = 0x00ff;
|
|
|
|
mcp->mb[10] = 0;
|
|
|
|
mcp->out_mb |= MBX_10;
|
|
|
|
} else {
|
|
|
|
mcp->mb[1] = 0xff00;
|
|
|
|
}
|
2008-11-06 11:40:19 -07:00
|
|
|
mcp->mb[2] = vha->hw->loop_reset_delay;
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->mb[3] = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
mcp->in_mb = MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x105b, "Failed=%x.\n", rval);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*EMPTY*/
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105c,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_send_sns
|
|
|
|
* Send SNS command.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* sns = pointer for command.
|
|
|
|
* cmd_size = command size.
|
|
|
|
* buf_size = response/command size.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_send_sns(scsi_qla_host_t *vha, dma_addr_t sns_phys_address,
|
2005-04-16 16:20:36 -06:00
|
|
|
uint16_t cmd_size, size_t buf_size)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105d,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x105e,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Retry cnt=%d ratov=%d total tov=%d.\n",
|
|
|
|
vha->hw->retry_count, vha->hw->login_timeout, mcp->tov);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_SEND_SNS_COMMAND;
|
|
|
|
mcp->mb[1] = cmd_size;
|
|
|
|
mcp->mb[2] = MSW(sns_phys_address);
|
|
|
|
mcp->mb[3] = LSW(sns_phys_address);
|
|
|
|
mcp->mb[6] = MSW(MSD(sns_phys_address));
|
|
|
|
mcp->mb[7] = LSW(MSD(sns_phys_address));
|
|
|
|
mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0|MBX_1;
|
|
|
|
mcp->buf_size = buf_size;
|
|
|
|
mcp->flags = MBX_DMA_OUT|MBX_DMA_IN;
|
2008-11-06 11:40:19 -07:00
|
|
|
mcp->tov = (vha->hw->login_timeout * 2) + (vha->hw->login_timeout / 2);
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x105f,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*EMPTY*/
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1060,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla24xx_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
|
2005-07-06 11:30:57 -06:00
|
|
|
uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
|
|
|
|
struct logio_entry_24xx *lg;
|
|
|
|
dma_addr_t lg_dma;
|
|
|
|
uint32_t iop[2];
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2009-04-06 23:33:40 -06:00
|
|
|
struct req_que *req;
|
2005-07-06 11:30:57 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1061,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
2016-12-12 15:40:07 -07:00
|
|
|
if (vha->vp_idx && vha->qpair)
|
|
|
|
req = vha->qpair->req;
|
2009-04-06 23:33:41 -06:00
|
|
|
else
|
2016-12-12 15:40:07 -07:00
|
|
|
req = ha->req_q_map[0];
|
2009-04-06 23:33:40 -06:00
|
|
|
|
2017-09-21 00:15:26 -06:00
|
|
|
lg = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
|
2005-07-06 11:30:57 -06:00
|
|
|
if (lg == NULL) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0x1062,
|
|
|
|
"Failed to allocate login IOCB.\n");
|
2005-07-06 11:30:57 -06:00
|
|
|
return QLA_MEMORY_ALLOC_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
|
|
|
|
lg->entry_count = 1;
|
2009-04-06 23:33:40 -06:00
|
|
|
lg->handle = MAKE_HANDLE(req->id, lg->handle);
|
2005-07-06 11:30:57 -06:00
|
|
|
lg->nport_handle = cpu_to_le16(loop_id);
|
2015-07-09 08:24:08 -06:00
|
|
|
lg->control_flags = cpu_to_le16(LCF_COMMAND_PLOGI);
|
2005-07-06 11:30:57 -06:00
|
|
|
if (opt & BIT_0)
|
2015-07-09 08:24:08 -06:00
|
|
|
lg->control_flags |= cpu_to_le16(LCF_COND_PLOGI);
|
2006-06-23 17:10:44 -06:00
|
|
|
if (opt & BIT_1)
|
2015-07-09 08:24:08 -06:00
|
|
|
lg->control_flags |= cpu_to_le16(LCF_SKIP_PRLI);
|
2005-07-06 11:30:57 -06:00
|
|
|
lg->port_id[0] = al_pa;
|
|
|
|
lg->port_id[1] = area;
|
|
|
|
lg->port_id[2] = domain;
|
2008-11-06 11:40:19 -07:00
|
|
|
lg->vp_index = vha->vp_idx;
|
2012-02-09 12:15:45 -07:00
|
|
|
rval = qla2x00_issue_iocb_timeout(vha, lg, lg_dma, 0,
|
|
|
|
(ha->r_a_tov / 10 * 2) + 2);
|
2005-07-06 11:30:57 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1063,
|
|
|
|
"Failed to issue login IOCB (%x).\n", rval);
|
2005-07-06 11:30:57 -06:00
|
|
|
} else if (lg->entry_status != 0) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1064,
|
|
|
|
"Failed to complete IOCB -- error status (%x).\n",
|
|
|
|
lg->entry_status);
|
2005-07-06 11:30:57 -06:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
2015-07-09 08:24:08 -06:00
|
|
|
} else if (lg->comp_status != cpu_to_le16(CS_COMPLETE)) {
|
2005-07-06 11:30:57 -06:00
|
|
|
iop[0] = le32_to_cpu(lg->io_parameter[0]);
|
|
|
|
iop[1] = le32_to_cpu(lg->io_parameter[1]);
|
|
|
|
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1065,
|
|
|
|
"Failed to complete IOCB -- completion status (%x) "
|
|
|
|
"ioparam=%x/%x.\n", le16_to_cpu(lg->comp_status),
|
|
|
|
iop[0], iop[1]);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
|
|
|
switch (iop[0]) {
|
|
|
|
case LSC_SCODE_PORTID_USED:
|
|
|
|
mb[0] = MBS_PORT_ID_USED;
|
|
|
|
mb[1] = LSW(iop[1]);
|
|
|
|
break;
|
|
|
|
case LSC_SCODE_NPORT_USED:
|
|
|
|
mb[0] = MBS_LOOP_ID_USED;
|
|
|
|
break;
|
|
|
|
case LSC_SCODE_NOLINK:
|
|
|
|
case LSC_SCODE_NOIOCB:
|
|
|
|
case LSC_SCODE_NOXCB:
|
|
|
|
case LSC_SCODE_CMD_FAILED:
|
|
|
|
case LSC_SCODE_NOFABRIC:
|
|
|
|
case LSC_SCODE_FW_NOT_READY:
|
|
|
|
case LSC_SCODE_NOT_LOGGED_IN:
|
|
|
|
case LSC_SCODE_NOPCB:
|
|
|
|
case LSC_SCODE_ELS_REJECT:
|
|
|
|
case LSC_SCODE_CMD_PARAM_ERR:
|
|
|
|
case LSC_SCODE_NONPORT:
|
|
|
|
case LSC_SCODE_LOGGED_IN:
|
|
|
|
case LSC_SCODE_NOFLOGI_ACC:
|
|
|
|
default:
|
|
|
|
mb[0] = MBS_COMMAND_ERROR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1066,
|
|
|
|
"Done %s.\n", __func__);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
|
|
|
iop[0] = le32_to_cpu(lg->io_parameter[0]);
|
|
|
|
|
|
|
|
mb[0] = MBS_COMMAND_COMPLETE;
|
|
|
|
mb[1] = 0;
|
|
|
|
if (iop[0] & BIT_4) {
|
|
|
|
if (iop[0] & BIT_8)
|
|
|
|
mb[1] |= BIT_1;
|
|
|
|
} else
|
|
|
|
mb[1] = BIT_0;
|
2005-08-26 20:08:10 -06:00
|
|
|
|
|
|
|
/* Passback COS information. */
|
|
|
|
mb[10] = 0;
|
|
|
|
if (lg->io_parameter[7] || lg->io_parameter[8])
|
|
|
|
mb[10] |= BIT_0; /* Class 2. */
|
|
|
|
if (lg->io_parameter[9] || lg->io_parameter[10])
|
|
|
|
mb[10] |= BIT_1; /* Class 3. */
|
2015-07-09 08:24:08 -06:00
|
|
|
if (lg->io_parameter[0] & cpu_to_le32(BIT_7))
|
2012-05-15 12:34:28 -06:00
|
|
|
mb[10] |= BIT_7; /* Confirmed Completion
|
|
|
|
* Allowed
|
|
|
|
*/
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
dma_pool_free(ha->s_dma_pool, lg, lg_dma);
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* qla2x00_login_fabric
|
|
|
|
* Issue login fabric port mailbox command.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* loop_id = device loop ID.
|
|
|
|
* domain = device domain.
|
|
|
|
* area = device area.
|
|
|
|
* al_pa = device AL_PA.
|
|
|
|
* status = pointer for return status.
|
|
|
|
* opt = command options.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_login_fabric(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
|
2005-04-16 16:20:36 -06:00
|
|
|
uint8_t area, uint8_t al_pa, uint16_t *mb, uint8_t opt)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1067,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_LOGIN_FABRIC_PORT;
|
|
|
|
mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
if (HAS_EXTENDED_IDS(ha)) {
|
|
|
|
mcp->mb[1] = loop_id;
|
|
|
|
mcp->mb[10] = opt;
|
|
|
|
mcp->out_mb |= MBX_10;
|
|
|
|
} else {
|
|
|
|
mcp->mb[1] = (loop_id << 8) | opt;
|
|
|
|
}
|
|
|
|
mcp->mb[2] = domain;
|
|
|
|
mcp->mb[3] = area << 8 | al_pa;
|
|
|
|
|
|
|
|
mcp->in_mb = MBX_7|MBX_6|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
|
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Return mailbox statuses. */
|
|
|
|
if (mb != NULL) {
|
|
|
|
mb[0] = mcp->mb[0];
|
|
|
|
mb[1] = mcp->mb[1];
|
|
|
|
mb[2] = mcp->mb[2];
|
|
|
|
mb[6] = mcp->mb[6];
|
|
|
|
mb[7] = mcp->mb[7];
|
2005-08-26 20:08:10 -06:00
|
|
|
/* COS retrieved from Get-Port-Database mailbox command. */
|
|
|
|
mb[10] = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/* RLU tmp code: need to change main mailbox_command function to
|
|
|
|
* return ok even when the mailbox completion value is not
|
|
|
|
* SUCCESS. The caller needs to be responsible to interpret
|
|
|
|
* the return values of this mailbox command if we're not
|
|
|
|
* to change too much of the existing code.
|
|
|
|
*/
|
|
|
|
if (mcp->mb[0] == 0x4001 || mcp->mb[0] == 0x4002 ||
|
|
|
|
mcp->mb[0] == 0x4003 || mcp->mb[0] == 0x4005 ||
|
|
|
|
mcp->mb[0] == 0x4006)
|
|
|
|
rval = QLA_SUCCESS;
|
|
|
|
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1068,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*EMPTY*/
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1069,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_login_local_device
|
|
|
|
* Issue login loop port mailbox command.
|
2005-07-06 11:32:07 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* loop_id = device loop ID.
|
|
|
|
* opt = command options.
|
2005-07-06 11:32:07 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Returns:
|
|
|
|
* Return status code.
|
2005-07-06 11:32:07 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
2005-07-06 11:32:07 -06:00
|
|
|
*
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_login_local_device(scsi_qla_host_t *vha, fc_port_t *fcport,
|
2005-04-16 16:20:36 -06:00
|
|
|
uint16_t *mb_ret, uint8_t opt)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x106a,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2007-07-19 16:05:56 -06:00
|
|
|
if (IS_FWI2_CAPABLE(ha))
|
2008-11-06 11:40:19 -07:00
|
|
|
return qla24xx_login_fabric(vha, fcport->loop_id,
|
2006-03-09 15:27:44 -07:00
|
|
|
fcport->d_id.b.domain, fcport->d_id.b.area,
|
|
|
|
fcport->d_id.b.al_pa, mb_ret, opt);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->mb[0] = MBC_LOGIN_LOOP_PORT;
|
|
|
|
if (HAS_EXTENDED_IDS(ha))
|
2006-03-09 15:27:44 -07:00
|
|
|
mcp->mb[1] = fcport->loop_id;
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
2006-03-09 15:27:44 -07:00
|
|
|
mcp->mb[1] = fcport->loop_id << 8;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->mb[2] = opt;
|
|
|
|
mcp->out_mb = MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_7|MBX_6|MBX_1|MBX_0;
|
|
|
|
mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
|
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Return mailbox statuses. */
|
|
|
|
if (mb_ret != NULL) {
|
|
|
|
mb_ret[0] = mcp->mb[0];
|
|
|
|
mb_ret[1] = mcp->mb[1];
|
|
|
|
mb_ret[6] = mcp->mb[6];
|
|
|
|
mb_ret[7] = mcp->mb[7];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/* AV tmp code: need to change main mailbox_command function to
|
|
|
|
* return ok even when the mailbox completion value is not
|
|
|
|
* SUCCESS. The caller needs to be responsible to interpret
|
|
|
|
* the return values of this mailbox command if we're not
|
|
|
|
* to change too much of the existing code.
|
|
|
|
*/
|
|
|
|
if (mcp->mb[0] == 0x4005 || mcp->mb[0] == 0x4006)
|
|
|
|
rval = QLA_SUCCESS;
|
|
|
|
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x106b,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x mb[6]=%x mb[7]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1], mcp->mb[6], mcp->mb[7]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*EMPTY*/
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x106c,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return (rval);
|
|
|
|
}
|
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla24xx_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
|
2005-07-06 11:30:57 -06:00
|
|
|
uint8_t area, uint8_t al_pa)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
struct logio_entry_24xx *lg;
|
|
|
|
dma_addr_t lg_dma;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2009-04-06 23:33:40 -06:00
|
|
|
struct req_que *req;
|
2005-07-06 11:30:57 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x106d,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
2017-09-21 00:15:26 -06:00
|
|
|
lg = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &lg_dma);
|
2005-07-06 11:30:57 -06:00
|
|
|
if (lg == NULL) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0x106e,
|
|
|
|
"Failed to allocate logout IOCB.\n");
|
2005-07-06 11:30:57 -06:00
|
|
|
return QLA_MEMORY_ALLOC_FAILED;
|
|
|
|
}
|
|
|
|
|
2016-12-12 15:40:07 -07:00
|
|
|
req = vha->req;
|
2005-07-06 11:30:57 -06:00
|
|
|
lg->entry_type = LOGINOUT_PORT_IOCB_TYPE;
|
|
|
|
lg->entry_count = 1;
|
2009-04-06 23:33:40 -06:00
|
|
|
lg->handle = MAKE_HANDLE(req->id, lg->handle);
|
2005-07-06 11:30:57 -06:00
|
|
|
lg->nport_handle = cpu_to_le16(loop_id);
|
|
|
|
lg->control_flags =
|
2015-07-09 08:24:08 -06:00
|
|
|
cpu_to_le16(LCF_COMMAND_LOGO|LCF_IMPL_LOGO|
|
2011-03-30 12:46:21 -06:00
|
|
|
LCF_FREE_NPORT);
|
2005-07-06 11:30:57 -06:00
|
|
|
lg->port_id[0] = al_pa;
|
|
|
|
lg->port_id[1] = area;
|
|
|
|
lg->port_id[2] = domain;
|
2008-11-06 11:40:19 -07:00
|
|
|
lg->vp_index = vha->vp_idx;
|
2012-02-09 12:15:45 -07:00
|
|
|
rval = qla2x00_issue_iocb_timeout(vha, lg, lg_dma, 0,
|
|
|
|
(ha->r_a_tov / 10 * 2) + 2);
|
2005-07-06 11:30:57 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x106f,
|
|
|
|
"Failed to issue logout IOCB (%x).\n", rval);
|
2005-07-06 11:30:57 -06:00
|
|
|
} else if (lg->entry_status != 0) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1070,
|
|
|
|
"Failed to complete IOCB -- error status (%x).\n",
|
|
|
|
lg->entry_status);
|
2005-07-06 11:30:57 -06:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
2015-07-09 08:24:08 -06:00
|
|
|
} else if (lg->comp_status != cpu_to_le16(CS_COMPLETE)) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1071,
|
|
|
|
"Failed to complete IOCB -- completion status (%x) "
|
|
|
|
"ioparam=%x/%x.\n", le16_to_cpu(lg->comp_status),
|
2005-07-06 11:30:57 -06:00
|
|
|
le32_to_cpu(lg->io_parameter[0]),
|
2011-07-14 13:00:13 -06:00
|
|
|
le32_to_cpu(lg->io_parameter[1]));
|
2005-07-06 11:30:57 -06:00
|
|
|
} else {
|
|
|
|
/*EMPTY*/
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1072,
|
|
|
|
"Done %s.\n", __func__);
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
dma_pool_free(ha->s_dma_pool, lg, lg_dma);
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* qla2x00_fabric_logout
|
|
|
|
* Issue logout fabric port mailbox command.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* loop_id = device loop ID.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_fabric_logout(scsi_qla_host_t *vha, uint16_t loop_id, uint8_t domain,
|
2005-07-06 11:30:57 -06:00
|
|
|
uint8_t area, uint8_t al_pa)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1073,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_LOGOUT_FABRIC_PORT;
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
2008-11-06 11:40:19 -07:00
|
|
|
if (HAS_EXTENDED_IDS(vha->hw)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->mb[1] = loop_id;
|
|
|
|
mcp->mb[10] = 0;
|
|
|
|
mcp->out_mb |= MBX_10;
|
|
|
|
} else {
|
|
|
|
mcp->mb[1] = loop_id << 8;
|
|
|
|
}
|
|
|
|
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1074,
|
|
|
|
"Failed=%x mb[1]=%x.\n", rval, mcp->mb[1]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*EMPTY*/
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1075,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_full_login_lip
|
|
|
|
* Issue full login LIP mailbox command.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* TARGET_QUEUE_LOCK must be released.
|
|
|
|
* ADAPTER_STATE_LOCK must be released.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_full_login_lip(scsi_qla_host_t *vha)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1076,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_LIP_FULL_LOGIN;
|
2008-11-06 11:40:19 -07:00
|
|
|
mcp->mb[1] = IS_FWI2_CAPABLE(vha->hw) ? BIT_3 : 0;
|
2006-12-13 20:20:30 -07:00
|
|
|
mcp->mb[2] = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->mb[3] = 0;
|
|
|
|
mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1077, "Failed=%x.\n", rval);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
/*EMPTY*/
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1078,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_get_id_list
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_get_id_list(scsi_qla_host_t *vha, void *id_list, dma_addr_t id_list_dma,
|
2005-04-16 16:20:36 -06:00
|
|
|
uint16_t *entries)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1079,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (id_list == NULL)
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_ID_LIST;
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->out_mb = MBX_0;
|
2008-11-06 11:40:19 -07:00
|
|
|
if (IS_FWI2_CAPABLE(vha->hw)) {
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->mb[2] = MSW(id_list_dma);
|
|
|
|
mcp->mb[3] = LSW(id_list_dma);
|
|
|
|
mcp->mb[6] = MSW(MSD(id_list_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(id_list_dma));
|
2006-02-07 09:45:40 -07:00
|
|
|
mcp->mb[8] = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
mcp->mb[9] = vha->vp_idx;
|
2007-07-05 14:16:51 -06:00
|
|
|
mcp->out_mb |= MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2;
|
2005-07-06 11:30:57 -06:00
|
|
|
} else {
|
|
|
|
mcp->mb[1] = MSW(id_list_dma);
|
|
|
|
mcp->mb[2] = LSW(id_list_dma);
|
|
|
|
mcp->mb[3] = MSW(MSD(id_list_dma));
|
|
|
|
mcp->mb[6] = LSW(MSD(id_list_dma));
|
|
|
|
mcp->out_mb |= MBX_6|MBX_3|MBX_2|MBX_1;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x107a, "Failed=%x.\n", rval);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
*entries = mcp->mb[1];
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x107b,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_get_resource_cnts
|
|
|
|
* Get current firmware resource counts.
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2015-12-17 12:56:59 -07:00
|
|
|
qla2x00_get_resource_cnts(scsi_qla_host_t *vha)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2015-12-17 12:56:59 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2005-04-16 16:20:36 -06:00
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x107c,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_RESOURCE_COUNTS;
|
|
|
|
mcp->out_mb = MBX_0;
|
2007-09-20 15:07:43 -06:00
|
|
|
mcp->in_mb = MBX_11|MBX_10|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
2014-02-26 02:15:06 -07:00
|
|
|
if (IS_QLA81XX(vha->hw) || IS_QLA83XX(vha->hw) || IS_QLA27XX(vha->hw))
|
2009-10-13 16:16:49 -06:00
|
|
|
mcp->in_mb |= MBX_12;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-04-16 16:20:36 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x107d,
|
|
|
|
"Failed mb[0]=%x.\n", mcp->mb[0]);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x107e,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Done %s mb1=%x mb2=%x mb3=%x mb6=%x mb7=%x mb10=%x "
|
|
|
|
"mb11=%x mb12=%x.\n", __func__, mcp->mb[1], mcp->mb[2],
|
|
|
|
mcp->mb[3], mcp->mb[6], mcp->mb[7], mcp->mb[10],
|
|
|
|
mcp->mb[11], mcp->mb[12]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2015-12-17 12:56:59 -07:00
|
|
|
ha->orig_fw_tgt_xcb_count = mcp->mb[1];
|
|
|
|
ha->cur_fw_tgt_xcb_count = mcp->mb[2];
|
|
|
|
ha->cur_fw_xcb_count = mcp->mb[3];
|
|
|
|
ha->orig_fw_xcb_count = mcp->mb[6];
|
|
|
|
ha->cur_fw_iocb_count = mcp->mb[7];
|
|
|
|
ha->orig_fw_iocb_count = mcp->mb[10];
|
|
|
|
if (ha->flags.npiv_supported)
|
|
|
|
ha->max_npiv_vports = mcp->mb[11];
|
|
|
|
if (IS_QLA81XX(ha) || IS_QLA83XX(ha) || IS_QLA27XX(ha))
|
|
|
|
ha->fw_max_fcf_count = mcp->mb[12];
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return (rval);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_get_fcal_position_map
|
|
|
|
* Get FCAL (LILP) position map using mailbox command
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter state pointer.
|
|
|
|
* pos_map = buffer pointer (can be NULL).
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_get_fcal_position_map(scsi_qla_host_t *vha, char *pos_map)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
char *pmap;
|
|
|
|
dma_addr_t pmap_dma;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x107f,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2017-09-21 00:15:26 -06:00
|
|
|
pmap = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &pmap_dma);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (pmap == NULL) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0x1080,
|
|
|
|
"Memory alloc failed.\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return QLA_MEMORY_ALLOC_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_FC_AL_POSITION_MAP;
|
|
|
|
mcp->mb[2] = MSW(pmap_dma);
|
|
|
|
mcp->mb[3] = LSW(pmap_dma);
|
|
|
|
mcp->mb[6] = MSW(MSD(pmap_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(pmap_dma));
|
|
|
|
mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
|
|
|
mcp->buf_size = FCAL_MAP_SIZE;
|
|
|
|
mcp->flags = MBX_DMA_IN;
|
|
|
|
mcp->tov = (ha->login_timeout * 2) + (ha->login_timeout / 2);
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (rval == QLA_SUCCESS) {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1081,
|
2011-07-14 13:00:13 -06:00
|
|
|
"mb0/mb1=%x/%X FC/AL position map size (%x).\n",
|
|
|
|
mcp->mb[0], mcp->mb[1], (unsigned)pmap[0]);
|
|
|
|
ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111d,
|
|
|
|
pmap, pmap[0] + 1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (pos_map)
|
|
|
|
memcpy(pos_map, pmap, FCAL_MAP_SIZE);
|
|
|
|
}
|
|
|
|
dma_pool_free(ha->s_dma_pool, pmap, pmap_dma);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1082, "Failed=%x.\n", rval);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1083,
|
|
|
|
"Done %s.\n", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2006-01-31 17:05:02 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_get_link_status
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer.
|
|
|
|
* loop_id = device loop ID.
|
|
|
|
* ret_buf = pointer to link status return buffer.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* 0 = success.
|
|
|
|
* BIT_0 = mem alloc error.
|
|
|
|
* BIT_1 = mailbox error.
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_get_link_status(scsi_qla_host_t *vha, uint16_t loop_id,
|
2008-01-17 10:02:08 -07:00
|
|
|
struct link_statistics *stats, dma_addr_t stats_dma)
|
2006-01-31 17:05:02 -07:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2016-07-06 09:14:24 -06:00
|
|
|
uint32_t *iter = (void *)stats;
|
|
|
|
ushort dwords = offsetof(typeof(*stats), link_up_cnt)/sizeof(*iter);
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2006-01-31 17:05:02 -07:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1084,
|
|
|
|
"Entered %s.\n", __func__);
|
2006-01-31 17:05:02 -07:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_LINK_STATUS;
|
2016-07-06 09:14:24 -06:00
|
|
|
mcp->mb[2] = MSW(LSD(stats_dma));
|
|
|
|
mcp->mb[3] = LSW(LSD(stats_dma));
|
2008-01-17 10:02:08 -07:00
|
|
|
mcp->mb[6] = MSW(MSD(stats_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(stats_dma));
|
2006-01-31 17:05:02 -07:00
|
|
|
mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
2007-07-19 16:05:56 -06:00
|
|
|
if (IS_FWI2_CAPABLE(ha)) {
|
2006-01-31 17:05:02 -07:00
|
|
|
mcp->mb[1] = loop_id;
|
|
|
|
mcp->mb[4] = 0;
|
|
|
|
mcp->mb[10] = 0;
|
|
|
|
mcp->out_mb |= MBX_10|MBX_4|MBX_1;
|
|
|
|
mcp->in_mb |= MBX_1;
|
|
|
|
} else if (HAS_EXTENDED_IDS(ha)) {
|
|
|
|
mcp->mb[1] = loop_id;
|
|
|
|
mcp->mb[10] = 0;
|
|
|
|
mcp->out_mb |= MBX_10|MBX_1;
|
|
|
|
} else {
|
|
|
|
mcp->mb[1] = loop_id << 8;
|
|
|
|
mcp->out_mb |= MBX_1;
|
|
|
|
}
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2006-01-31 17:05:02 -07:00
|
|
|
mcp->flags = IOCTL_CMD;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2006-01-31 17:05:02 -07:00
|
|
|
|
|
|
|
if (rval == QLA_SUCCESS) {
|
|
|
|
if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1085,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2008-01-17 10:02:08 -07:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
2006-01-31 17:05:02 -07:00
|
|
|
} else {
|
2016-07-06 09:14:24 -06:00
|
|
|
/* Re-endianize - firmware data is le32. */
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1086,
|
|
|
|
"Done %s.\n", __func__);
|
2016-01-27 10:03:34 -07:00
|
|
|
for ( ; dwords--; iter++)
|
|
|
|
le32_to_cpus(iter);
|
2006-01-31 17:05:02 -07:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Failed. */
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1087, "Failed=%x.\n", rval);
|
2006-01-31 17:05:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla24xx_get_isp_stats(scsi_qla_host_t *vha, struct link_statistics *stats,
|
2017-03-15 10:48:52 -06:00
|
|
|
dma_addr_t stats_dma, uint16_t options)
|
2005-07-06 11:30:57 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2016-01-27 10:03:34 -07:00
|
|
|
uint32_t *iter, dwords;
|
2005-07-06 11:30:57 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1088,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
2017-03-15 10:48:52 -06:00
|
|
|
memset(&mc, 0, sizeof(mc));
|
|
|
|
mc.mb[0] = MBC_GET_LINK_PRIV_STATS;
|
|
|
|
mc.mb[2] = MSW(stats_dma);
|
|
|
|
mc.mb[3] = LSW(stats_dma);
|
|
|
|
mc.mb[6] = MSW(MSD(stats_dma));
|
|
|
|
mc.mb[7] = LSW(MSD(stats_dma));
|
|
|
|
mc.mb[8] = sizeof(struct link_statistics) / 4;
|
|
|
|
mc.mb[9] = cpu_to_le16(vha->vp_idx);
|
|
|
|
mc.mb[10] = cpu_to_le16(options);
|
|
|
|
|
|
|
|
rval = qla24xx_send_mb_cmd(vha, &mc);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
|
|
|
if (rval == QLA_SUCCESS) {
|
|
|
|
if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1089,
|
|
|
|
"Failed mb[0]=%x.\n", mcp->mb[0]);
|
2008-01-17 10:02:08 -07:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
2005-07-06 11:30:57 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x108a,
|
|
|
|
"Done %s.\n", __func__);
|
2016-07-06 09:14:24 -06:00
|
|
|
/* Re-endianize - firmware data is le32. */
|
2008-01-17 10:02:08 -07:00
|
|
|
dwords = sizeof(struct link_statistics) / 4;
|
2016-01-27 10:03:34 -07:00
|
|
|
iter = &stats->link_fail_cnt;
|
|
|
|
for ( ; dwords--; iter++)
|
|
|
|
le32_to_cpus(iter);
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
/* Failed. */
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x108b, "Failed=%x.\n", rval);
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2009-04-06 23:33:40 -06:00
|
|
|
qla24xx_abort_command(srb_t *sp)
|
2005-07-06 11:30:57 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
unsigned long flags = 0;
|
|
|
|
|
|
|
|
struct abort_entry_24xx *abt;
|
|
|
|
dma_addr_t abt_dma;
|
|
|
|
uint32_t handle;
|
2009-04-06 23:33:40 -06:00
|
|
|
fc_port_t *fcport = sp->fcport;
|
|
|
|
struct scsi_qla_host *vha = fcport->vha;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2009-04-06 23:33:42 -06:00
|
|
|
struct req_que *req = vha->req;
|
2005-07-06 11:30:57 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x108c,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
2016-12-12 15:40:07 -07:00
|
|
|
if (vha->flags.qpairs_available && sp->qpair)
|
|
|
|
req = sp->qpair->req;
|
|
|
|
|
2014-02-26 02:15:18 -07:00
|
|
|
if (ql2xasynctmfenable)
|
|
|
|
return qla24xx_async_abort_command(sp);
|
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
spin_lock_irqsave(&ha->hardware_lock, flags);
|
2013-01-30 01:34:37 -07:00
|
|
|
for (handle = 1; handle < req->num_outstanding_cmds; handle++) {
|
2008-11-06 11:40:19 -07:00
|
|
|
if (req->outstanding_cmds[handle] == sp)
|
2005-07-06 11:30:57 -06:00
|
|
|
break;
|
|
|
|
}
|
2008-11-06 11:40:19 -07:00
|
|
|
spin_unlock_irqrestore(&ha->hardware_lock, flags);
|
2013-01-30 01:34:37 -07:00
|
|
|
if (handle == req->num_outstanding_cmds) {
|
2005-07-06 11:30:57 -06:00
|
|
|
/* Command not found. */
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
}
|
|
|
|
|
2017-09-21 00:15:26 -06:00
|
|
|
abt = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &abt_dma);
|
2005-07-06 11:30:57 -06:00
|
|
|
if (abt == NULL) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0x108d,
|
|
|
|
"Failed to allocate abort IOCB.\n");
|
2005-07-06 11:30:57 -06:00
|
|
|
return QLA_MEMORY_ALLOC_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
abt->entry_type = ABORT_IOCB_TYPE;
|
|
|
|
abt->entry_count = 1;
|
2009-04-06 23:33:40 -06:00
|
|
|
abt->handle = MAKE_HANDLE(req->id, abt->handle);
|
2005-07-06 11:30:57 -06:00
|
|
|
abt->nport_handle = cpu_to_le16(fcport->loop_id);
|
2011-03-30 12:46:20 -06:00
|
|
|
abt->handle_to_abort = MAKE_HANDLE(req->id, handle);
|
2005-07-06 11:30:57 -06:00
|
|
|
abt->port_id[0] = fcport->d_id.b.al_pa;
|
|
|
|
abt->port_id[1] = fcport->d_id.b.area;
|
|
|
|
abt->port_id[2] = fcport->d_id.b.domain;
|
2012-05-15 12:34:20 -06:00
|
|
|
abt->vp_index = fcport->vha->vp_idx;
|
2008-12-09 17:45:39 -07:00
|
|
|
|
|
|
|
abt->req_que_no = cpu_to_le16(req->id);
|
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_issue_iocb(vha, abt, abt_dma, 0);
|
2005-07-06 11:30:57 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x108e,
|
|
|
|
"Failed to issue IOCB (%x).\n", rval);
|
2005-07-06 11:30:57 -06:00
|
|
|
} else if (abt->entry_status != 0) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x108f,
|
|
|
|
"Failed to complete IOCB -- error status (%x).\n",
|
|
|
|
abt->entry_status);
|
2005-07-06 11:30:57 -06:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
2015-07-09 08:24:08 -06:00
|
|
|
} else if (abt->nport_handle != cpu_to_le16(0)) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1090,
|
|
|
|
"Failed to complete IOCB -- completion status (%x).\n",
|
|
|
|
le16_to_cpu(abt->nport_handle));
|
2014-04-11 14:54:31 -06:00
|
|
|
if (abt->nport_handle == CS_IOCB_ERROR)
|
|
|
|
rval = QLA_FUNCTION_PARAMETER_ERROR;
|
|
|
|
else
|
|
|
|
rval = QLA_FUNCTION_FAILED;
|
2005-07-06 11:30:57 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1091,
|
|
|
|
"Done %s.\n", __func__);
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
dma_pool_free(ha->s_dma_pool, abt, abt_dma);
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct tsk_mgmt_cmd {
|
|
|
|
union {
|
|
|
|
struct tsk_mgmt_entry tsk;
|
|
|
|
struct sts_entry_24xx sts;
|
|
|
|
} p;
|
|
|
|
};
|
|
|
|
|
2008-04-03 14:13:24 -06:00
|
|
|
static int
|
|
|
|
__qla24xx_issue_tmf(char *name, uint32_t type, struct fc_port *fcport,
|
2014-06-25 07:27:36 -06:00
|
|
|
uint64_t l, int tag)
|
2005-07-06 11:30:57 -06:00
|
|
|
{
|
2008-04-03 14:13:24 -06:00
|
|
|
int rval, rval2;
|
2005-07-06 11:30:57 -06:00
|
|
|
struct tsk_mgmt_cmd *tsk;
|
2009-10-13 16:16:50 -06:00
|
|
|
struct sts_entry_24xx *sts;
|
2005-07-06 11:30:57 -06:00
|
|
|
dma_addr_t tsk_dma;
|
2008-11-06 11:40:19 -07:00
|
|
|
scsi_qla_host_t *vha;
|
|
|
|
struct qla_hw_data *ha;
|
2008-12-09 17:45:39 -07:00
|
|
|
struct req_que *req;
|
|
|
|
struct rsp_que *rsp;
|
2016-12-12 15:40:07 -07:00
|
|
|
struct qla_qpair *qpair;
|
2005-07-06 11:30:57 -06:00
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
vha = fcport->vha;
|
|
|
|
ha = vha->hw;
|
2009-04-06 23:33:40 -06:00
|
|
|
req = vha->req;
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1092,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2016-12-12 15:40:07 -07:00
|
|
|
if (vha->vp_idx && vha->qpair) {
|
|
|
|
/* NPIV port */
|
|
|
|
qpair = vha->qpair;
|
|
|
|
rsp = qpair->rsp;
|
|
|
|
req = qpair->req;
|
|
|
|
} else {
|
2009-04-06 23:33:41 -06:00
|
|
|
rsp = req->rsp;
|
2016-12-12 15:40:07 -07:00
|
|
|
}
|
|
|
|
|
2017-09-21 00:15:26 -06:00
|
|
|
tsk = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &tsk_dma);
|
2005-07-06 11:30:57 -06:00
|
|
|
if (tsk == NULL) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0x1093,
|
|
|
|
"Failed to allocate task management IOCB.\n");
|
2005-07-06 11:30:57 -06:00
|
|
|
return QLA_MEMORY_ALLOC_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
tsk->p.tsk.entry_type = TSK_MGMT_IOCB_TYPE;
|
|
|
|
tsk->p.tsk.entry_count = 1;
|
2009-04-06 23:33:40 -06:00
|
|
|
tsk->p.tsk.handle = MAKE_HANDLE(req->id, tsk->p.tsk.handle);
|
2005-07-06 11:30:57 -06:00
|
|
|
tsk->p.tsk.nport_handle = cpu_to_le16(fcport->loop_id);
|
2008-02-28 15:06:11 -07:00
|
|
|
tsk->p.tsk.timeout = cpu_to_le16(ha->r_a_tov / 10 * 2);
|
2008-04-03 14:13:24 -06:00
|
|
|
tsk->p.tsk.control_flags = cpu_to_le32(type);
|
2005-07-06 11:30:57 -06:00
|
|
|
tsk->p.tsk.port_id[0] = fcport->d_id.b.al_pa;
|
|
|
|
tsk->p.tsk.port_id[1] = fcport->d_id.b.area;
|
|
|
|
tsk->p.tsk.port_id[2] = fcport->d_id.b.domain;
|
2012-05-15 12:34:20 -06:00
|
|
|
tsk->p.tsk.vp_index = fcport->vha->vp_idx;
|
2008-04-03 14:13:24 -06:00
|
|
|
if (type == TCF_LUN_RESET) {
|
|
|
|
int_to_scsilun(l, &tsk->p.tsk.lun);
|
|
|
|
host_to_fcp_swap((uint8_t *)&tsk->p.tsk.lun,
|
|
|
|
sizeof(tsk->p.tsk.lun));
|
|
|
|
}
|
2007-07-05 14:16:51 -06:00
|
|
|
|
2009-10-13 16:16:50 -06:00
|
|
|
sts = &tsk->p.sts;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_issue_iocb(vha, tsk, tsk_dma, 0);
|
2005-07-06 11:30:57 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1094,
|
|
|
|
"Failed to issue %s reset IOCB (%x).\n", name, rval);
|
2009-10-13 16:16:50 -06:00
|
|
|
} else if (sts->entry_status != 0) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1095,
|
|
|
|
"Failed to complete IOCB -- error status (%x).\n",
|
|
|
|
sts->entry_status);
|
2005-07-06 11:30:57 -06:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
2015-07-09 08:24:08 -06:00
|
|
|
} else if (sts->comp_status != cpu_to_le16(CS_COMPLETE)) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1096,
|
|
|
|
"Failed to complete IOCB -- completion status (%x).\n",
|
|
|
|
le16_to_cpu(sts->comp_status));
|
2009-10-13 16:16:50 -06:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
2011-02-23 16:27:14 -07:00
|
|
|
} else if (le16_to_cpu(sts->scsi_status) &
|
|
|
|
SS_RESPONSE_INFO_LEN_VALID) {
|
|
|
|
if (le32_to_cpu(sts->rsp_data_len) < 4) {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1097,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Ignoring inconsistent data length -- not enough "
|
|
|
|
"response info (%d).\n",
|
|
|
|
le32_to_cpu(sts->rsp_data_len));
|
2011-02-23 16:27:14 -07:00
|
|
|
} else if (sts->data[3]) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1098,
|
|
|
|
"Failed to complete IOCB -- response (%x).\n",
|
|
|
|
sts->data[3]);
|
2011-02-23 16:27:14 -07:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
|
|
|
}
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Issue marker IOCB. */
|
2008-12-09 17:45:39 -07:00
|
|
|
rval2 = qla2x00_marker(vha, req, rsp, fcport->loop_id, l,
|
2008-04-03 14:13:24 -06:00
|
|
|
type == TCF_LUN_RESET ? MK_SYNC_ID_LUN: MK_SYNC_ID);
|
|
|
|
if (rval2 != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1099,
|
|
|
|
"Failed to issue marker IOCB (%x).\n", rval2);
|
2005-07-06 11:30:57 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x109a,
|
|
|
|
"Done %s.\n", __func__);
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
dma_pool_free(ha->s_dma_pool, tsk, tsk_dma);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2008-04-03 14:13:24 -06:00
|
|
|
int
|
2014-06-25 07:27:36 -06:00
|
|
|
qla24xx_abort_target(struct fc_port *fcport, uint64_t l, int tag)
|
2008-04-03 14:13:24 -06:00
|
|
|
{
|
2010-05-04 16:01:29 -06:00
|
|
|
struct qla_hw_data *ha = fcport->vha->hw;
|
|
|
|
|
|
|
|
if ((ql2xasynctmfenable) && IS_FWI2_CAPABLE(ha))
|
|
|
|
return qla2x00_async_tm_cmd(fcport, TCF_TARGET_RESET, l, tag);
|
|
|
|
|
2009-04-06 23:33:40 -06:00
|
|
|
return __qla24xx_issue_tmf("Target", TCF_TARGET_RESET, fcport, l, tag);
|
2008-04-03 14:13:24 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2014-06-25 07:27:36 -06:00
|
|
|
qla24xx_lun_reset(struct fc_port *fcport, uint64_t l, int tag)
|
2008-04-03 14:13:24 -06:00
|
|
|
{
|
2010-05-04 16:01:29 -06:00
|
|
|
struct qla_hw_data *ha = fcport->vha->hw;
|
|
|
|
|
|
|
|
if ((ql2xasynctmfenable) && IS_FWI2_CAPABLE(ha))
|
|
|
|
return qla2x00_async_tm_cmd(fcport, TCF_LUN_RESET, l, tag);
|
|
|
|
|
2009-04-06 23:33:40 -06:00
|
|
|
return __qla24xx_issue_tmf("Lun", TCF_LUN_RESET, fcport, l, tag);
|
2008-04-03 14:13:24 -06:00
|
|
|
}
|
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_system_error(scsi_qla_host_t *vha)
|
2005-07-06 11:30:57 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2005-07-06 11:30:57 -06:00
|
|
|
|
2008-05-12 23:21:13 -06:00
|
|
|
if (!IS_QLA23XX(ha) && !IS_FWI2_CAPABLE(ha))
|
2005-07-06 11:30:57 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x109b,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GEN_SYSTEM_ERROR;
|
|
|
|
mcp->out_mb = MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = 5;
|
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x109c, "Failed=%x.\n", rval);
|
2005-07-06 11:30:57 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x109d,
|
|
|
|
"Done %s.\n", __func__);
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2013-10-30 01:38:18 -06:00
|
|
|
int
|
|
|
|
qla2x00_write_serdes_word(scsi_qla_host_t *vha, uint16_t addr, uint16_t data)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2015-08-04 11:37:51 -06:00
|
|
|
if (!IS_QLA25XX(vha->hw) && !IS_QLA2031(vha->hw) &&
|
|
|
|
!IS_QLA27XX(vha->hw))
|
2013-10-30 01:38:18 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1182,
|
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_WRITE_SERDES;
|
|
|
|
mcp->mb[1] = addr;
|
2015-04-09 13:00:02 -06:00
|
|
|
if (IS_QLA2031(vha->hw))
|
|
|
|
mcp->mb[2] = data & 0xff;
|
|
|
|
else
|
|
|
|
mcp->mb[2] = data;
|
|
|
|
|
2013-10-30 01:38:18 -06:00
|
|
|
mcp->mb[3] = 0;
|
|
|
|
mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1183,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1184,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
qla2x00_read_serdes_word(scsi_qla_host_t *vha, uint16_t addr, uint16_t *data)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2015-08-04 11:37:51 -06:00
|
|
|
if (!IS_QLA25XX(vha->hw) && !IS_QLA2031(vha->hw) &&
|
|
|
|
!IS_QLA27XX(vha->hw))
|
2013-10-30 01:38:18 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1185,
|
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_READ_SERDES;
|
|
|
|
mcp->mb[1] = addr;
|
|
|
|
mcp->mb[3] = 0;
|
|
|
|
mcp->out_mb = MBX_3|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
2015-04-09 13:00:02 -06:00
|
|
|
if (IS_QLA2031(vha->hw))
|
|
|
|
*data = mcp->mb[1] & 0xff;
|
|
|
|
else
|
|
|
|
*data = mcp->mb[1];
|
2013-10-30 01:38:18 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1186,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1187,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2014-04-11 14:54:17 -06:00
|
|
|
int
|
|
|
|
qla8044_write_serdes_word(scsi_qla_host_t *vha, uint32_t addr, uint32_t data)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
|
|
|
if (!IS_QLA8044(vha->hw))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x11a0,
|
2014-04-11 14:54:17 -06:00
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_SET_GET_ETH_SERDES_REG;
|
|
|
|
mcp->mb[1] = HCS_WRITE_SERDES;
|
|
|
|
mcp->mb[3] = LSW(addr);
|
|
|
|
mcp->mb[4] = MSW(addr);
|
|
|
|
mcp->mb[5] = LSW(data);
|
|
|
|
mcp->mb[6] = MSW(data);
|
|
|
|
mcp->out_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x11a1,
|
2014-04-11 14:54:17 -06:00
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1188,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
qla8044_read_serdes_word(scsi_qla_host_t *vha, uint32_t addr, uint32_t *data)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
|
|
|
if (!IS_QLA8044(vha->hw))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1189,
|
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_SET_GET_ETH_SERDES_REG;
|
|
|
|
mcp->mb[1] = HCS_READ_SERDES;
|
|
|
|
mcp->mb[3] = LSW(addr);
|
|
|
|
mcp->mb[4] = MSW(addr);
|
|
|
|
mcp->out_mb = MBX_4|MBX_3|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
*data = mcp->mb[2] << 16 | mcp->mb[1];
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x118a,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x118b,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2005-07-06 11:30:57 -06:00
|
|
|
/**
|
|
|
|
* qla2x00_set_serdes_params() -
|
2018-01-23 17:33:51 -07:00
|
|
|
* @vha: HA context
|
|
|
|
* @sw_em_1g:
|
|
|
|
* @sw_em_2g:
|
|
|
|
* @sw_em_4g:
|
2005-07-06 11:30:57 -06:00
|
|
|
*
|
|
|
|
* Returns
|
|
|
|
*/
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_set_serdes_params(scsi_qla_host_t *vha, uint16_t sw_em_1g,
|
2005-07-06 11:30:57 -06:00
|
|
|
uint16_t sw_em_2g, uint16_t sw_em_4g)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x109e,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_SERDES_PARAMS;
|
|
|
|
mcp->mb[1] = BIT_0;
|
2006-03-09 15:27:29 -07:00
|
|
|
mcp->mb[2] = sw_em_1g | BIT_15;
|
|
|
|
mcp->mb[3] = sw_em_2g | BIT_15;
|
|
|
|
mcp->mb[4] = sw_em_4g | BIT_15;
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2005-07-06 11:30:57 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-07-06 11:30:57 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
/*EMPTY*/
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x109f,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2005-07-06 11:30:57 -06:00
|
|
|
} else {
|
|
|
|
/*EMPTY*/
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a0,
|
|
|
|
"Done %s.\n", __func__);
|
2005-07-06 11:30:57 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2005-08-26 20:10:20 -06:00
|
|
|
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_stop_firmware(scsi_qla_host_t *vha)
|
2005-08-26 20:10:20 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
if (!IS_FWI2_CAPABLE(vha->hw))
|
2005-08-26 20:10:20 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a1,
|
|
|
|
"Entered %s.\n", __func__);
|
2005-08-26 20:10:20 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_STOP_FIRMWARE;
|
2012-02-09 12:14:06 -07:00
|
|
|
mcp->mb[1] = 0;
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
2005-08-26 20:10:20 -06:00
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = 5;
|
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2005-08-26 20:10:20 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10a2, "Failed=%x.\n", rval);
|
2009-04-06 23:33:48 -06:00
|
|
|
if (mcp->mb[0] == MBS_INVALID_COMMAND)
|
|
|
|
rval = QLA_INVALID_COMMAND;
|
2005-08-26 20:10:20 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a3,
|
|
|
|
"Done %s.\n", __func__);
|
2005-08-26 20:10:20 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2006-06-23 17:10:29 -06:00
|
|
|
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_enable_eft_trace(scsi_qla_host_t *vha, dma_addr_t eft_dma,
|
2006-06-23 17:10:29 -06:00
|
|
|
uint16_t buffers)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a4,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
if (!IS_FWI2_CAPABLE(vha->hw))
|
2006-06-23 17:10:29 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2009-12-15 22:29:46 -07:00
|
|
|
if (unlikely(pci_channel_offline(vha->hw->pdev)))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2006-06-23 17:10:29 -06:00
|
|
|
mcp->mb[0] = MBC_TRACE_CONTROL;
|
2008-01-17 10:02:16 -07:00
|
|
|
mcp->mb[1] = TC_EFT_ENABLE;
|
|
|
|
mcp->mb[2] = LSW(eft_dma);
|
|
|
|
mcp->mb[3] = MSW(eft_dma);
|
|
|
|
mcp->mb[4] = LSW(MSD(eft_dma));
|
|
|
|
mcp->mb[5] = MSW(MSD(eft_dma));
|
|
|
|
mcp->mb[6] = buffers;
|
|
|
|
mcp->mb[7] = TC_AEN_DISABLE;
|
|
|
|
mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
2006-06-23 17:10:29 -06:00
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2006-06-23 17:10:29 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2008-01-17 10:02:16 -07:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10a5,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1]);
|
2008-01-17 10:02:16 -07:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a6,
|
|
|
|
"Done %s.\n", __func__);
|
2008-01-17 10:02:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2006-06-23 17:10:29 -06:00
|
|
|
|
2008-01-17 10:02:16 -07:00
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_disable_eft_trace(scsi_qla_host_t *vha)
|
2008-01-17 10:02:16 -07:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a7,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
if (!IS_FWI2_CAPABLE(vha->hw))
|
2008-01-17 10:02:16 -07:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2009-12-15 22:29:46 -07:00
|
|
|
if (unlikely(pci_channel_offline(vha->hw->pdev)))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2008-01-17 10:02:16 -07:00
|
|
|
mcp->mb[0] = MBC_TRACE_CONTROL;
|
|
|
|
mcp->mb[1] = TC_EFT_DISABLE;
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2008-01-17 10:02:16 -07:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2006-06-23 17:10:29 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10a8,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1]);
|
2006-06-23 17:10:29 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10a9,
|
|
|
|
"Done %s.\n", __func__);
|
2006-06-23 17:10:29 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2008-01-17 10:02:17 -07:00
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_enable_fce_trace(scsi_qla_host_t *vha, dma_addr_t fce_dma,
|
2008-01-17 10:02:17 -07:00
|
|
|
uint16_t buffers, uint16_t *mb, uint32_t *dwords)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10aa,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2012-02-09 12:15:34 -07:00
|
|
|
if (!IS_QLA25XX(vha->hw) && !IS_QLA81XX(vha->hw) &&
|
2014-02-26 02:15:06 -07:00
|
|
|
!IS_QLA83XX(vha->hw) && !IS_QLA27XX(vha->hw))
|
2008-01-17 10:02:17 -07:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2009-12-15 22:29:46 -07:00
|
|
|
if (unlikely(pci_channel_offline(vha->hw->pdev)))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2008-01-17 10:02:17 -07:00
|
|
|
mcp->mb[0] = MBC_TRACE_CONTROL;
|
|
|
|
mcp->mb[1] = TC_FCE_ENABLE;
|
|
|
|
mcp->mb[2] = LSW(fce_dma);
|
|
|
|
mcp->mb[3] = MSW(fce_dma);
|
|
|
|
mcp->mb[4] = LSW(MSD(fce_dma));
|
|
|
|
mcp->mb[5] = MSW(MSD(fce_dma));
|
|
|
|
mcp->mb[6] = buffers;
|
|
|
|
mcp->mb[7] = TC_AEN_DISABLE;
|
|
|
|
mcp->mb[8] = 0;
|
|
|
|
mcp->mb[9] = TC_FCE_DEFAULT_RX_SIZE;
|
|
|
|
mcp->mb[10] = TC_FCE_DEFAULT_TX_SIZE;
|
|
|
|
mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|
|
|
|
|
MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2008-01-17 10:02:17 -07:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2008-01-17 10:02:17 -07:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10ab,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1]);
|
2008-01-17 10:02:17 -07:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ac,
|
|
|
|
"Done %s.\n", __func__);
|
2008-01-17 10:02:17 -07:00
|
|
|
|
|
|
|
if (mb)
|
|
|
|
memcpy(mb, mcp->mb, 8 * sizeof(*mb));
|
|
|
|
if (dwords)
|
2008-05-12 23:21:12 -06:00
|
|
|
*dwords = buffers;
|
2008-01-17 10:02:17 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_disable_fce_trace(scsi_qla_host_t *vha, uint64_t *wr, uint64_t *rd)
|
2008-01-17 10:02:17 -07:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ad,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
if (!IS_FWI2_CAPABLE(vha->hw))
|
2008-01-17 10:02:17 -07:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2009-12-15 22:29:46 -07:00
|
|
|
if (unlikely(pci_channel_offline(vha->hw->pdev)))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2008-01-17 10:02:17 -07:00
|
|
|
mcp->mb[0] = MBC_TRACE_CONTROL;
|
|
|
|
mcp->mb[1] = TC_FCE_DISABLE;
|
|
|
|
mcp->mb[2] = TC_FCE_DISABLE_TRACE;
|
|
|
|
mcp->out_mb = MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_9|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|
|
|
|
|
MBX_1|MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2008-01-17 10:02:17 -07:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2008-01-17 10:02:17 -07:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10ae,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1]);
|
2008-01-17 10:02:17 -07:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10af,
|
|
|
|
"Done %s.\n", __func__);
|
2008-01-17 10:02:17 -07:00
|
|
|
|
|
|
|
if (wr)
|
|
|
|
*wr = (uint64_t) mcp->mb[5] << 48 |
|
|
|
|
(uint64_t) mcp->mb[4] << 32 |
|
|
|
|
(uint64_t) mcp->mb[3] << 16 |
|
|
|
|
(uint64_t) mcp->mb[2];
|
|
|
|
if (rd)
|
|
|
|
*rd = (uint64_t) mcp->mb[9] << 48 |
|
|
|
|
(uint64_t) mcp->mb[8] << 32 |
|
|
|
|
(uint64_t) mcp->mb[7] << 16 |
|
|
|
|
(uint64_t) mcp->mb[6];
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2010-03-19 18:03:58 -06:00
|
|
|
int
|
|
|
|
qla2x00_get_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
|
|
|
|
uint16_t *port_speed, uint16_t *mb)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b0,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2010-03-19 18:03:58 -06:00
|
|
|
if (!IS_IIDMA_CAPABLE(vha->hw))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_PORT_PARAMS;
|
|
|
|
mcp->mb[1] = loop_id;
|
|
|
|
mcp->mb[2] = mcp->mb[3] = 0;
|
|
|
|
mcp->mb[9] = vha->vp_idx;
|
|
|
|
mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_3|MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
/* Return mailbox statuses. */
|
|
|
|
if (mb != NULL) {
|
|
|
|
mb[0] = mcp->mb[0];
|
|
|
|
mb[1] = mcp->mb[1];
|
|
|
|
mb[3] = mcp->mb[3];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10b1, "Failed=%x.\n", rval);
|
2010-03-19 18:03:58 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b2,
|
|
|
|
"Done %s.\n", __func__);
|
2010-03-19 18:03:58 -06:00
|
|
|
if (port_speed)
|
|
|
|
*port_speed = mcp->mb[3];
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2006-10-02 13:00:43 -06:00
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_set_idma_speed(scsi_qla_host_t *vha, uint16_t loop_id,
|
2006-10-02 13:00:43 -06:00
|
|
|
uint16_t port_speed, uint16_t *mb)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b3,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
if (!IS_IIDMA_CAPABLE(vha->hw))
|
2006-10-02 13:00:43 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_PORT_PARAMS;
|
|
|
|
mcp->mb[1] = loop_id;
|
|
|
|
mcp->mb[2] = BIT_0;
|
2012-02-09 12:15:34 -07:00
|
|
|
if (IS_CNA_CAPABLE(vha->hw))
|
2009-06-17 11:30:29 -06:00
|
|
|
mcp->mb[3] = port_speed & (BIT_5|BIT_4|BIT_3|BIT_2|BIT_1|BIT_0);
|
|
|
|
else
|
|
|
|
mcp->mb[3] = port_speed & (BIT_2|BIT_1|BIT_0);
|
|
|
|
mcp->mb[9] = vha->vp_idx;
|
|
|
|
mcp->out_mb = MBX_9|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_3|MBX_1|MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2006-10-02 13:00:43 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2006-10-02 13:00:43 -06:00
|
|
|
|
|
|
|
/* Return mailbox statuses. */
|
|
|
|
if (mb != NULL) {
|
|
|
|
mb[0] = mcp->mb[0];
|
|
|
|
mb[1] = mcp->mb[1];
|
|
|
|
mb[3] = mcp->mb[3];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10b4,
|
|
|
|
"Failed=%x.\n", rval);
|
2006-10-02 13:00:43 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b5,
|
|
|
|
"Done %s.\n", __func__);
|
2006-10-02 13:00:43 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2007-07-05 14:16:51 -06:00
|
|
|
|
|
|
|
void
|
2008-11-06 11:40:19 -07:00
|
|
|
qla24xx_report_id_acquisition(scsi_qla_host_t *vha,
|
2007-07-05 14:16:51 -06:00
|
|
|
struct vp_rpt_id_entry_24xx *rptid_entry)
|
|
|
|
{
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2017-01-19 23:28:03 -07:00
|
|
|
scsi_qla_host_t *vp = NULL;
|
2010-09-03 15:57:00 -06:00
|
|
|
unsigned long flags;
|
2013-02-07 23:57:58 -07:00
|
|
|
int found;
|
2017-03-15 10:48:54 -06:00
|
|
|
port_id_t id;
|
2017-12-28 13:33:24 -07:00
|
|
|
struct fc_port *fcport;
|
2007-07-05 14:16:51 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10b6,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2007-07-05 14:16:51 -06:00
|
|
|
if (rptid_entry->entry_status != 0)
|
|
|
|
return;
|
|
|
|
|
2017-03-15 10:48:54 -06:00
|
|
|
id.b.domain = rptid_entry->port_id[2];
|
|
|
|
id.b.area = rptid_entry->port_id[1];
|
|
|
|
id.b.al_pa = rptid_entry->port_id[0];
|
|
|
|
id.b.rsvd_1 = 0;
|
2018-03-21 00:09:34 -06:00
|
|
|
ha->flags.n2n_ae = 0;
|
2017-03-15 10:48:54 -06:00
|
|
|
|
2007-07-05 14:16:51 -06:00
|
|
|
if (rptid_entry->format == 0) {
|
2017-01-19 23:28:03 -07:00
|
|
|
/* loop */
|
2017-03-15 10:48:55 -06:00
|
|
|
ql_dbg(ql_dbg_async, vha, 0x10b7,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Format 0 : Number of VPs setup %d, number of "
|
2017-01-19 23:28:03 -07:00
|
|
|
"VPs acquired %d.\n", rptid_entry->vp_setup,
|
|
|
|
rptid_entry->vp_acquired);
|
2017-03-15 10:48:55 -06:00
|
|
|
ql_dbg(ql_dbg_async, vha, 0x10b8,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Primary port id %02x%02x%02x.\n",
|
|
|
|
rptid_entry->port_id[2], rptid_entry->port_id[1],
|
|
|
|
rptid_entry->port_id[0]);
|
2017-12-28 13:33:24 -07:00
|
|
|
ha->current_topology = ISP_CFG_NL;
|
2017-03-15 10:48:54 -06:00
|
|
|
qlt_update_host_map(vha, id);
|
2017-01-19 23:28:03 -07:00
|
|
|
|
2007-07-05 14:16:51 -06:00
|
|
|
} else if (rptid_entry->format == 1) {
|
2017-01-19 23:28:03 -07:00
|
|
|
/* fabric */
|
2017-03-15 10:48:55 -06:00
|
|
|
ql_dbg(ql_dbg_async, vha, 0x10b9,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Format 1: VP[%d] enabled - status %d - with "
|
2017-01-19 23:28:03 -07:00
|
|
|
"port id %02x%02x%02x.\n", rptid_entry->vp_idx,
|
|
|
|
rptid_entry->vp_status,
|
2007-07-05 14:16:51 -06:00
|
|
|
rptid_entry->port_id[2], rptid_entry->port_id[1],
|
2011-07-14 13:00:13 -06:00
|
|
|
rptid_entry->port_id[0]);
|
2017-10-13 10:34:06 -06:00
|
|
|
ql_dbg(ql_dbg_async, vha, 0x5075,
|
|
|
|
"Format 1: Remote WWPN %8phC.\n",
|
|
|
|
rptid_entry->u.f1.port_name);
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_async, vha, 0x5075,
|
|
|
|
"Format 1: WWPN %8phC.\n",
|
|
|
|
vha->port_name);
|
|
|
|
|
|
|
|
/* N2N. direct connect */
|
|
|
|
if (IS_QLA27XX(ha) &&
|
|
|
|
((rptid_entry->u.f1.flags>>1) & 0x7) == 2) {
|
|
|
|
/* if our portname is higher then initiate N2N login */
|
|
|
|
if (wwn_to_u64(vha->port_name) >
|
|
|
|
wwn_to_u64(rptid_entry->u.f1.port_name)) {
|
|
|
|
// ??? qlt_update_host_map(vha, id);
|
|
|
|
vha->n2n_id = 0x1;
|
|
|
|
ql_dbg(ql_dbg_async, vha, 0x5075,
|
|
|
|
"Format 1: Setting n2n_update_needed for id %d\n",
|
|
|
|
vha->n2n_id);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_async, vha, 0x5075,
|
|
|
|
"Format 1: Remote login - Waiting for WWPN %8phC.\n",
|
|
|
|
rptid_entry->u.f1.port_name);
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(vha->n2n_port_name, rptid_entry->u.f1.port_name,
|
|
|
|
WWN_SIZE);
|
|
|
|
set_bit(N2N_LOGIN_NEEDED, &vha->dpc_flags);
|
|
|
|
set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
|
|
|
|
set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
|
2018-03-21 00:09:34 -06:00
|
|
|
ha->flags.n2n_ae = 1;
|
2017-10-13 10:34:06 -06:00
|
|
|
return;
|
|
|
|
}
|
2009-10-13 16:16:51 -06:00
|
|
|
|
2017-12-28 13:33:24 -07:00
|
|
|
ha->flags.gpsc_supported = 1;
|
|
|
|
ha->current_topology = ISP_CFG_F;
|
2016-01-27 10:03:32 -07:00
|
|
|
/* buffer to buffer credit flag */
|
2017-01-19 23:28:03 -07:00
|
|
|
vha->flags.bbcr_enable = (rptid_entry->u.f1.bbcr & 0xf) != 0;
|
|
|
|
|
|
|
|
if (rptid_entry->vp_idx == 0) {
|
|
|
|
if (rptid_entry->vp_status == VP_STAT_COMPL) {
|
|
|
|
/* FA-WWN is only for physical port */
|
|
|
|
if (qla_ini_mode_enabled(vha) &&
|
|
|
|
ha->flags.fawwpn_enabled &&
|
|
|
|
(rptid_entry->u.f1.flags &
|
2017-08-23 16:05:02 -06:00
|
|
|
BIT_6)) {
|
2017-01-19 23:28:03 -07:00
|
|
|
memcpy(vha->port_name,
|
|
|
|
rptid_entry->u.f1.port_name,
|
|
|
|
WWN_SIZE);
|
|
|
|
}
|
2014-09-25 03:16:47 -06:00
|
|
|
|
2017-03-15 10:48:54 -06:00
|
|
|
qlt_update_host_map(vha, id);
|
2014-09-25 03:16:47 -06:00
|
|
|
}
|
2017-01-19 23:28:03 -07:00
|
|
|
|
|
|
|
set_bit(REGISTER_FC4_NEEDED, &vha->dpc_flags);
|
|
|
|
set_bit(REGISTER_FDMI_NEEDED, &vha->dpc_flags);
|
|
|
|
} else {
|
|
|
|
if (rptid_entry->vp_status != VP_STAT_COMPL &&
|
|
|
|
rptid_entry->vp_status != VP_STAT_ID_CHG) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10ba,
|
|
|
|
"Could not acquire ID for VP[%d].\n",
|
|
|
|
rptid_entry->vp_idx);
|
|
|
|
return;
|
2013-02-07 23:57:58 -07:00
|
|
|
}
|
2010-09-03 15:57:00 -06:00
|
|
|
|
2017-01-19 23:28:03 -07:00
|
|
|
found = 0;
|
|
|
|
spin_lock_irqsave(&ha->vport_slock, flags);
|
|
|
|
list_for_each_entry(vp, &ha->vp_list, list) {
|
|
|
|
if (rptid_entry->vp_idx == vp->vp_idx) {
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&ha->vport_slock, flags);
|
2007-07-05 14:16:51 -06:00
|
|
|
|
2017-01-19 23:28:03 -07:00
|
|
|
if (!found)
|
|
|
|
return;
|
2007-07-05 14:16:51 -06:00
|
|
|
|
2017-03-15 10:48:54 -06:00
|
|
|
qlt_update_host_map(vp, id);
|
2007-07-05 14:16:51 -06:00
|
|
|
|
2017-01-19 23:28:03 -07:00
|
|
|
/*
|
|
|
|
* Cannot configure here as we are still sitting on the
|
|
|
|
* response queue. Handle it in dpc context.
|
|
|
|
*/
|
|
|
|
set_bit(VP_IDX_ACQUIRED, &vp->vp_flags);
|
|
|
|
set_bit(REGISTER_FC4_NEEDED, &vp->dpc_flags);
|
|
|
|
set_bit(REGISTER_FDMI_NEEDED, &vp->dpc_flags);
|
|
|
|
}
|
2009-10-13 16:16:51 -06:00
|
|
|
set_bit(VP_DPC_NEEDED, &vha->dpc_flags);
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2xxx_wake_dpc(vha);
|
2017-01-19 23:28:03 -07:00
|
|
|
} else if (rptid_entry->format == 2) {
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_async, vha, 0x505f,
|
2017-01-19 23:28:03 -07:00
|
|
|
"RIDA: format 2/N2N Primary port id %02x%02x%02x.\n",
|
|
|
|
rptid_entry->port_id[2], rptid_entry->port_id[1],
|
|
|
|
rptid_entry->port_id[0]);
|
|
|
|
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_async, vha, 0x5075,
|
2017-01-19 23:28:03 -07:00
|
|
|
"N2N: Remote WWPN %8phC.\n",
|
|
|
|
rptid_entry->u.f2.port_name);
|
|
|
|
|
|
|
|
/* N2N. direct connect */
|
2017-12-28 13:33:24 -07:00
|
|
|
ha->current_topology = ISP_CFG_N;
|
|
|
|
ha->flags.rida_fmt2 = 1;
|
2017-01-19 23:28:03 -07:00
|
|
|
vha->d_id.b.domain = rptid_entry->port_id[2];
|
|
|
|
vha->d_id.b.area = rptid_entry->port_id[1];
|
|
|
|
vha->d_id.b.al_pa = rptid_entry->port_id[0];
|
|
|
|
|
2018-03-21 00:09:34 -06:00
|
|
|
ha->flags.n2n_ae = 1;
|
2017-01-19 23:28:03 -07:00
|
|
|
spin_lock_irqsave(&ha->vport_slock, flags);
|
|
|
|
qlt_update_vp_map(vha, SET_AL_PA);
|
|
|
|
spin_unlock_irqrestore(&ha->vport_slock, flags);
|
2017-12-28 13:33:24 -07:00
|
|
|
|
|
|
|
list_for_each_entry(fcport, &vha->vp_fcports, list) {
|
|
|
|
fcport->scan_state = QLA_FCPORT_SCAN;
|
|
|
|
}
|
|
|
|
|
|
|
|
fcport = qla2x00_find_fcport_by_wwpn(vha,
|
|
|
|
rptid_entry->u.f2.port_name, 1);
|
|
|
|
|
|
|
|
if (fcport) {
|
|
|
|
fcport->plogi_nack_done_deadline = jiffies + HZ;
|
|
|
|
fcport->scan_state = QLA_FCPORT_FOUND;
|
|
|
|
switch (fcport->disc_state) {
|
|
|
|
case DSC_DELETED:
|
|
|
|
ql_dbg(ql_dbg_disc, vha, 0x210d,
|
|
|
|
"%s %d %8phC login\n",
|
|
|
|
__func__, __LINE__, fcport->port_name);
|
|
|
|
qla24xx_fcport_handle_login(vha, fcport);
|
|
|
|
break;
|
|
|
|
case DSC_DELETE_PEND:
|
|
|
|
break;
|
|
|
|
default:
|
2017-12-28 13:33:43 -07:00
|
|
|
qlt_schedule_sess_for_deletion(fcport);
|
2017-12-28 13:33:24 -07:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
id.b.al_pa = rptid_entry->u.f2.remote_nport_id[0];
|
|
|
|
id.b.area = rptid_entry->u.f2.remote_nport_id[1];
|
|
|
|
id.b.domain = rptid_entry->u.f2.remote_nport_id[2];
|
|
|
|
qla24xx_post_newsess_work(vha, &id,
|
2017-12-28 13:33:26 -07:00
|
|
|
rptid_entry->u.f2.port_name,
|
|
|
|
rptid_entry->u.f2.node_name,
|
|
|
|
NULL,
|
|
|
|
FC4_TYPE_UNKNOWN);
|
2017-12-28 13:33:24 -07:00
|
|
|
}
|
2007-07-05 14:16:51 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla24xx_modify_vp_config
|
|
|
|
* Change VP configuration for vha
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* vha = adapter block pointer.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2xxx local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel context.
|
|
|
|
*/
|
|
|
|
int
|
|
|
|
qla24xx_modify_vp_config(scsi_qla_host_t *vha)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
struct vp_config_entry_24xx *vpmod;
|
|
|
|
dma_addr_t vpmod_dma;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
struct scsi_qla_host *base_vha = pci_get_drvdata(ha->pdev);
|
2007-07-05 14:16:51 -06:00
|
|
|
|
|
|
|
/* This can be called by the parent */
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10bb,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2017-09-21 00:15:26 -06:00
|
|
|
vpmod = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &vpmod_dma);
|
2007-07-05 14:16:51 -06:00
|
|
|
if (!vpmod) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0x10bc,
|
|
|
|
"Failed to allocate modify VP IOCB.\n");
|
2007-07-05 14:16:51 -06:00
|
|
|
return QLA_MEMORY_ALLOC_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
vpmod->entry_type = VP_CONFIG_IOCB_TYPE;
|
|
|
|
vpmod->entry_count = 1;
|
|
|
|
vpmod->command = VCT_COMMAND_MOD_ENABLE_VPS;
|
|
|
|
vpmod->vp_count = 1;
|
|
|
|
vpmod->vp_index1 = vha->vp_idx;
|
|
|
|
vpmod->options_idx1 = BIT_3|BIT_4|BIT_5;
|
2012-05-15 12:34:28 -06:00
|
|
|
|
|
|
|
qlt_modify_vp_config(vha, vpmod);
|
|
|
|
|
2007-07-05 14:16:51 -06:00
|
|
|
memcpy(vpmod->node_name_idx1, vha->node_name, WWN_SIZE);
|
|
|
|
memcpy(vpmod->port_name_idx1, vha->port_name, WWN_SIZE);
|
|
|
|
vpmod->entry_count = 1;
|
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_issue_iocb(base_vha, vpmod, vpmod_dma, 0);
|
2007-07-05 14:16:51 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10bd,
|
|
|
|
"Failed to issue VP config IOCB (%x).\n", rval);
|
2007-07-05 14:16:51 -06:00
|
|
|
} else if (vpmod->comp_status != 0) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10be,
|
|
|
|
"Failed to complete IOCB -- error status (%x).\n",
|
|
|
|
vpmod->comp_status);
|
2007-07-05 14:16:51 -06:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
2015-07-09 08:24:08 -06:00
|
|
|
} else if (vpmod->comp_status != cpu_to_le16(CS_COMPLETE)) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10bf,
|
|
|
|
"Failed to complete IOCB -- completion status (%x).\n",
|
|
|
|
le16_to_cpu(vpmod->comp_status));
|
2007-07-05 14:16:51 -06:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
|
|
|
} else {
|
|
|
|
/* EMPTY */
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10c0,
|
|
|
|
"Done %s.\n", __func__);
|
2007-07-05 14:16:51 -06:00
|
|
|
fc_vport_set_state(vha->fc_vport, FC_VPORT_INITIALIZING);
|
|
|
|
}
|
2008-11-06 11:40:19 -07:00
|
|
|
dma_pool_free(ha->s_dma_pool, vpmod, vpmod_dma);
|
2007-07-05 14:16:51 -06:00
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla2x00_send_change_request
|
|
|
|
* Receive or disable RSCN request from fabric controller
|
|
|
|
*
|
|
|
|
* Input:
|
|
|
|
* ha = adapter block pointer
|
|
|
|
* format = registration format:
|
|
|
|
* 0 - Reserved
|
|
|
|
* 1 - Fabric detected registration
|
|
|
|
* 2 - N_port detected registration
|
|
|
|
* 3 - Full registration
|
|
|
|
* FF - clear registration
|
|
|
|
* vp_idx = Virtual port index
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* qla2x00 local function return status code.
|
|
|
|
*
|
|
|
|
* Context:
|
|
|
|
* Kernel Context
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_send_change_request(scsi_qla_host_t *vha, uint16_t format,
|
2007-07-05 14:16:51 -06:00
|
|
|
uint16_t vp_idx)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10c7,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2007-07-05 14:16:51 -06:00
|
|
|
mcp->mb[0] = MBC_SEND_CHANGE_REQUEST;
|
|
|
|
mcp->mb[1] = format;
|
|
|
|
mcp->mb[9] = vp_idx;
|
|
|
|
mcp->out_mb = MBX_9|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0|MBX_1;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2007-07-05 14:16:51 -06:00
|
|
|
|
|
|
|
if (rval == QLA_SUCCESS) {
|
|
|
|
if (mcp->mb[0] != MBS_COMMAND_COMPLETE) {
|
|
|
|
rval = BIT_1;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
rval = BIT_1;
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2007-09-20 15:07:33 -06:00
|
|
|
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla2x00_dump_ram(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t addr,
|
2007-09-20 15:07:33 -06:00
|
|
|
uint32_t size)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1009,
|
|
|
|
"Entered %s.\n", __func__);
|
2007-09-20 15:07:33 -06:00
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
if (MSW(addr) || IS_FWI2_CAPABLE(vha->hw)) {
|
2007-09-20 15:07:33 -06:00
|
|
|
mcp->mb[0] = MBC_DUMP_RISC_RAM_EXTENDED;
|
|
|
|
mcp->mb[8] = MSW(addr);
|
|
|
|
mcp->out_mb = MBX_8|MBX_0;
|
|
|
|
} else {
|
|
|
|
mcp->mb[0] = MBC_DUMP_RISC_RAM;
|
|
|
|
mcp->out_mb = MBX_0;
|
|
|
|
}
|
|
|
|
mcp->mb[1] = LSW(addr);
|
|
|
|
mcp->mb[2] = MSW(req_dma);
|
|
|
|
mcp->mb[3] = LSW(req_dma);
|
|
|
|
mcp->mb[6] = MSW(MSD(req_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(req_dma));
|
|
|
|
mcp->out_mb |= MBX_7|MBX_6|MBX_3|MBX_2|MBX_1;
|
2008-11-06 11:40:19 -07:00
|
|
|
if (IS_FWI2_CAPABLE(vha->hw)) {
|
2007-09-20 15:07:33 -06:00
|
|
|
mcp->mb[4] = MSW(size);
|
|
|
|
mcp->mb[5] = LSW(size);
|
|
|
|
mcp->out_mb |= MBX_5|MBX_4;
|
|
|
|
} else {
|
|
|
|
mcp->mb[4] = LSW(size);
|
|
|
|
mcp->out_mb |= MBX_4;
|
|
|
|
}
|
|
|
|
|
|
|
|
mcp->in_mb = MBX_0;
|
2008-04-03 14:13:25 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2007-09-20 15:07:33 -06:00
|
|
|
mcp->flags = 0;
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2007-09-20 15:07:33 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1008,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2007-09-20 15:07:33 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1007,
|
|
|
|
"Done %s.\n", __func__);
|
2007-09-20 15:07:33 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2008-04-03 14:13:26 -06:00
|
|
|
/* 84XX Support **************************************************************/
|
|
|
|
|
|
|
|
struct cs84xx_mgmt_cmd {
|
|
|
|
union {
|
|
|
|
struct verify_chip_entry_84xx req;
|
|
|
|
struct verify_chip_rsp_84xx rsp;
|
|
|
|
} p;
|
|
|
|
};
|
|
|
|
|
|
|
|
int
|
2008-11-06 11:40:19 -07:00
|
|
|
qla84xx_verify_chip(struct scsi_qla_host *vha, uint16_t *status)
|
2008-04-03 14:13:26 -06:00
|
|
|
{
|
|
|
|
int rval, retry;
|
|
|
|
struct cs84xx_mgmt_cmd *mn;
|
|
|
|
dma_addr_t mn_dma;
|
|
|
|
uint16_t options;
|
|
|
|
unsigned long flags;
|
2008-11-06 11:40:19 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2008-04-03 14:13:26 -06:00
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10c8,
|
|
|
|
"Entered %s.\n", __func__);
|
2008-04-03 14:13:26 -06:00
|
|
|
|
|
|
|
mn = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &mn_dma);
|
|
|
|
if (mn == NULL) {
|
|
|
|
return QLA_MEMORY_ALLOC_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Force Update? */
|
|
|
|
options = ha->cs84xx->fw_update ? VCO_FORCE_UPDATE : 0;
|
|
|
|
/* Diagnostic firmware? */
|
|
|
|
/* options |= MENLO_DIAG_FW; */
|
|
|
|
/* We update the firmware with only one data sequence. */
|
|
|
|
options |= VCO_END_OF_DATA;
|
|
|
|
|
|
|
|
do {
|
2008-04-24 16:21:24 -06:00
|
|
|
retry = 0;
|
2008-04-03 14:13:26 -06:00
|
|
|
memset(mn, 0, sizeof(*mn));
|
|
|
|
mn->p.req.entry_type = VERIFY_CHIP_IOCB_TYPE;
|
|
|
|
mn->p.req.entry_count = 1;
|
|
|
|
mn->p.req.options = cpu_to_le16(options);
|
|
|
|
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111c,
|
|
|
|
"Dump of Verify Request.\n");
|
|
|
|
ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x111e,
|
|
|
|
(uint8_t *)mn, sizeof(*mn));
|
2008-04-03 14:13:26 -06:00
|
|
|
|
2008-11-06 11:40:19 -07:00
|
|
|
rval = qla2x00_issue_iocb_timeout(vha, mn, mn_dma, 0, 120);
|
2008-04-03 14:13:26 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10cb,
|
|
|
|
"Failed to issue verify IOCB (%x).\n", rval);
|
2008-04-03 14:13:26 -06:00
|
|
|
goto verify_done;
|
|
|
|
}
|
|
|
|
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1110,
|
|
|
|
"Dump of Verify Response.\n");
|
|
|
|
ql_dump_buffer(ql_dbg_mbx + ql_dbg_buffer, vha, 0x1118,
|
|
|
|
(uint8_t *)mn, sizeof(*mn));
|
2008-04-03 14:13:26 -06:00
|
|
|
|
|
|
|
status[0] = le16_to_cpu(mn->p.rsp.comp_status);
|
|
|
|
status[1] = status[0] == CS_VCS_CHIP_FAILURE ?
|
|
|
|
le16_to_cpu(mn->p.rsp.failure_code) : 0;
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ce,
|
2011-07-14 13:00:13 -06:00
|
|
|
"cs=%x fc=%x.\n", status[0], status[1]);
|
2008-04-03 14:13:26 -06:00
|
|
|
|
|
|
|
if (status[0] != CS_COMPLETE) {
|
|
|
|
rval = QLA_FUNCTION_FAILED;
|
|
|
|
if (!(options & VCO_DONT_UPDATE_FW)) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10cf,
|
|
|
|
"Firmware update failed. Retrying "
|
|
|
|
"without update firmware.\n");
|
2008-04-03 14:13:26 -06:00
|
|
|
options |= VCO_DONT_UPDATE_FW;
|
|
|
|
options &= ~VCO_FORCE_UPDATE;
|
|
|
|
retry = 1;
|
|
|
|
}
|
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d0,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Firmware updated to %x.\n",
|
|
|
|
le32_to_cpu(mn->p.rsp.fw_ver));
|
2008-04-03 14:13:26 -06:00
|
|
|
|
|
|
|
/* NOTE: we only update OP firmware. */
|
|
|
|
spin_lock_irqsave(&ha->cs84xx->access_lock, flags);
|
|
|
|
ha->cs84xx->op_fw_version =
|
|
|
|
le32_to_cpu(mn->p.rsp.fw_ver);
|
|
|
|
spin_unlock_irqrestore(&ha->cs84xx->access_lock,
|
|
|
|
flags);
|
|
|
|
}
|
|
|
|
} while (retry);
|
|
|
|
|
|
|
|
verify_done:
|
|
|
|
dma_pool_free(ha->s_dma_pool, mn, mn_dma);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10d1,
|
|
|
|
"Failed=%x.\n", rval);
|
2008-04-03 14:13:26 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d2,
|
|
|
|
"Done %s.\n", __func__);
|
2008-04-03 14:13:26 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2008-12-09 17:45:39 -07:00
|
|
|
|
|
|
|
int
|
2009-02-08 21:50:11 -07:00
|
|
|
qla25xx_init_req_que(struct scsi_qla_host *vha, struct req_que *req)
|
2008-12-09 17:45:39 -07:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
unsigned long flags;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d3,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2014-04-11 14:54:37 -06:00
|
|
|
if (IS_SHADOW_REG_CAPABLE(ha))
|
|
|
|
req->options |= BIT_13;
|
|
|
|
|
2008-12-09 17:45:39 -07:00
|
|
|
mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
|
2009-02-08 21:50:11 -07:00
|
|
|
mcp->mb[1] = req->options;
|
2008-12-09 17:45:39 -07:00
|
|
|
mcp->mb[2] = MSW(LSD(req->dma));
|
|
|
|
mcp->mb[3] = LSW(LSD(req->dma));
|
|
|
|
mcp->mb[6] = MSW(MSD(req->dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(req->dma));
|
|
|
|
mcp->mb[5] = req->length;
|
|
|
|
if (req->rsp)
|
|
|
|
mcp->mb[10] = req->rsp->id;
|
|
|
|
mcp->mb[12] = req->qos;
|
|
|
|
mcp->mb[11] = req->vp_idx;
|
|
|
|
mcp->mb[13] = req->rid;
|
2014-02-26 02:15:06 -07:00
|
|
|
if (IS_QLA83XX(ha) || IS_QLA27XX(ha))
|
2012-02-09 12:15:34 -07:00
|
|
|
mcp->mb[15] = 0;
|
2008-12-09 17:45:39 -07:00
|
|
|
|
|
|
|
mcp->mb[4] = req->id;
|
|
|
|
/* que in ptr index */
|
|
|
|
mcp->mb[8] = 0;
|
|
|
|
/* que out ptr index */
|
2014-04-11 14:54:37 -06:00
|
|
|
mcp->mb[9] = *req->out_ptr = 0;
|
2008-12-09 17:45:39 -07:00
|
|
|
mcp->out_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|MBX_7|
|
|
|
|
MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->flags = MBX_DMA_OUT;
|
2012-02-09 12:15:34 -07:00
|
|
|
mcp->tov = MBX_TOV_SECONDS * 2;
|
|
|
|
|
2014-02-26 02:15:06 -07:00
|
|
|
if (IS_QLA81XX(ha) || IS_QLA83XX(ha) || IS_QLA27XX(ha))
|
2012-02-09 12:15:34 -07:00
|
|
|
mcp->in_mb |= MBX_1;
|
2014-04-11 14:54:10 -06:00
|
|
|
if (IS_QLA83XX(ha) || IS_QLA27XX(ha)) {
|
2012-02-09 12:15:34 -07:00
|
|
|
mcp->out_mb |= MBX_15;
|
|
|
|
/* debug q create issue in SR-IOV */
|
|
|
|
mcp->in_mb |= MBX_9 | MBX_8 | MBX_7;
|
|
|
|
}
|
2008-12-09 17:45:39 -07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&ha->hardware_lock, flags);
|
2009-02-08 21:50:11 -07:00
|
|
|
if (!(req->options & BIT_0)) {
|
2013-08-26 23:37:30 -06:00
|
|
|
WRT_REG_DWORD(req->req_q_in, 0);
|
2014-04-11 14:54:09 -06:00
|
|
|
if (!IS_QLA83XX(ha) && !IS_QLA27XX(ha))
|
2013-08-26 23:37:30 -06:00
|
|
|
WRT_REG_DWORD(req->req_q_out, 0);
|
2008-12-09 17:45:39 -07:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&ha->hardware_lock, flags);
|
|
|
|
|
2008-12-18 11:06:15 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2011-07-14 13:00:13 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10d4,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d5,
|
|
|
|
"Done %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
}
|
|
|
|
|
2008-12-09 17:45:39 -07:00
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2009-02-08 21:50:11 -07:00
|
|
|
qla25xx_init_rsp_que(struct scsi_qla_host *vha, struct rsp_que *rsp)
|
2008-12-09 17:45:39 -07:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
unsigned long flags;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d6,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2014-04-11 14:54:37 -06:00
|
|
|
if (IS_SHADOW_REG_CAPABLE(ha))
|
|
|
|
rsp->options |= BIT_13;
|
|
|
|
|
2008-12-09 17:45:39 -07:00
|
|
|
mcp->mb[0] = MBC_INITIALIZE_MULTIQ;
|
2009-02-08 21:50:11 -07:00
|
|
|
mcp->mb[1] = rsp->options;
|
2008-12-09 17:45:39 -07:00
|
|
|
mcp->mb[2] = MSW(LSD(rsp->dma));
|
|
|
|
mcp->mb[3] = LSW(LSD(rsp->dma));
|
|
|
|
mcp->mb[6] = MSW(MSD(rsp->dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(rsp->dma));
|
|
|
|
mcp->mb[5] = rsp->length;
|
2009-01-05 12:18:10 -07:00
|
|
|
mcp->mb[14] = rsp->msix->entry;
|
2008-12-09 17:45:39 -07:00
|
|
|
mcp->mb[13] = rsp->rid;
|
2014-02-26 02:15:06 -07:00
|
|
|
if (IS_QLA83XX(ha) || IS_QLA27XX(ha))
|
2012-02-09 12:15:34 -07:00
|
|
|
mcp->mb[15] = 0;
|
2008-12-09 17:45:39 -07:00
|
|
|
|
|
|
|
mcp->mb[4] = rsp->id;
|
|
|
|
/* que in ptr index */
|
2014-04-11 14:54:37 -06:00
|
|
|
mcp->mb[8] = *rsp->in_ptr = 0;
|
2008-12-09 17:45:39 -07:00
|
|
|
/* que out ptr index */
|
|
|
|
mcp->mb[9] = 0;
|
2009-04-06 23:33:40 -06:00
|
|
|
mcp->out_mb = MBX_14|MBX_13|MBX_9|MBX_8|MBX_7
|
2008-12-09 17:45:39 -07:00
|
|
|
|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->flags = MBX_DMA_OUT;
|
2012-02-09 12:15:34 -07:00
|
|
|
mcp->tov = MBX_TOV_SECONDS * 2;
|
|
|
|
|
|
|
|
if (IS_QLA81XX(ha)) {
|
|
|
|
mcp->out_mb |= MBX_12|MBX_11|MBX_10;
|
|
|
|
mcp->in_mb |= MBX_1;
|
2014-02-26 02:15:06 -07:00
|
|
|
} else if (IS_QLA83XX(ha) || IS_QLA27XX(ha)) {
|
2012-02-09 12:15:34 -07:00
|
|
|
mcp->out_mb |= MBX_15|MBX_12|MBX_11|MBX_10;
|
|
|
|
mcp->in_mb |= MBX_1;
|
|
|
|
/* debug q create issue in SR-IOV */
|
|
|
|
mcp->in_mb |= MBX_9 | MBX_8 | MBX_7;
|
|
|
|
}
|
2008-12-09 17:45:39 -07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&ha->hardware_lock, flags);
|
2009-02-08 21:50:11 -07:00
|
|
|
if (!(rsp->options & BIT_0)) {
|
2013-08-26 23:37:30 -06:00
|
|
|
WRT_REG_DWORD(rsp->rsp_q_out, 0);
|
2015-06-10 09:05:18 -06:00
|
|
|
if (!IS_QLA83XX(ha) && !IS_QLA27XX(ha))
|
2013-08-26 23:37:30 -06:00
|
|
|
WRT_REG_DWORD(rsp->rsp_q_in, 0);
|
2008-12-09 17:45:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&ha->hardware_lock, flags);
|
|
|
|
|
2008-12-18 11:06:15 -07:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2011-07-14 13:00:13 -06:00
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10d7,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d8,
|
|
|
|
"Done %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
}
|
|
|
|
|
2008-12-09 17:45:39 -07:00
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2009-02-08 21:50:12 -07:00
|
|
|
int
|
|
|
|
qla81xx_idc_ack(scsi_qla_host_t *vha, uint16_t *mb)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10d9,
|
|
|
|
"Entered %s.\n", __func__);
|
2009-02-08 21:50:12 -07:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_IDC_ACK;
|
|
|
|
memcpy(&mcp->mb[1], mb, QLA_IDC_ACK_REGS * sizeof(uint16_t));
|
|
|
|
mcp->out_mb = MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10da,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2009-02-08 21:50:12 -07:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10db,
|
|
|
|
"Done %s.\n", __func__);
|
2009-02-08 21:50:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2009-03-24 10:08:06 -06:00
|
|
|
|
|
|
|
int
|
|
|
|
qla81xx_fac_get_sector_size(scsi_qla_host_t *vha, uint32_t *sector_size)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10dc,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2014-02-26 02:15:06 -07:00
|
|
|
if (!IS_QLA81XX(vha->hw) && !IS_QLA83XX(vha->hw) &&
|
|
|
|
!IS_QLA27XX(vha->hw))
|
2009-03-24 10:08:06 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
|
|
|
|
mcp->mb[1] = FAC_OPT_CMD_GET_SECTOR_SIZE;
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10dd,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1]);
|
2009-03-24 10:08:06 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10de,
|
|
|
|
"Done %s.\n", __func__);
|
2009-03-24 10:08:06 -06:00
|
|
|
*sector_size = mcp->mb[1];
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
qla81xx_fac_do_write_enable(scsi_qla_host_t *vha, int enable)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2014-02-26 02:15:06 -07:00
|
|
|
if (!IS_QLA81XX(vha->hw) && !IS_QLA83XX(vha->hw) &&
|
|
|
|
!IS_QLA27XX(vha->hw))
|
2009-03-24 10:08:06 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10df,
|
|
|
|
"Entered %s.\n", __func__);
|
2009-03-24 10:08:06 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
|
|
|
|
mcp->mb[1] = enable ? FAC_OPT_CMD_WRITE_ENABLE :
|
|
|
|
FAC_OPT_CMD_WRITE_PROTECT;
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10e0,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1]);
|
2009-03-24 10:08:06 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e1,
|
|
|
|
"Done %s.\n", __func__);
|
2009-03-24 10:08:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
qla81xx_fac_erase_sector(scsi_qla_host_t *vha, uint32_t start, uint32_t finish)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2014-02-26 02:15:06 -07:00
|
|
|
if (!IS_QLA81XX(vha->hw) && !IS_QLA83XX(vha->hw) &&
|
|
|
|
!IS_QLA27XX(vha->hw))
|
2009-03-24 10:08:06 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e2,
|
|
|
|
"Entered %s.\n", __func__);
|
2009-03-24 10:08:06 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_FLASH_ACCESS_CTRL;
|
|
|
|
mcp->mb[1] = FAC_OPT_CMD_ERASE_SECTOR;
|
|
|
|
mcp->mb[2] = LSW(start);
|
|
|
|
mcp->mb[3] = MSW(start);
|
|
|
|
mcp->mb[4] = LSW(finish);
|
|
|
|
mcp->mb[5] = MSW(finish);
|
|
|
|
mcp->out_mb = MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10e3,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
|
2009-03-24 10:08:06 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e4,
|
|
|
|
"Done %s.\n", __func__);
|
2009-03-24 10:08:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2009-03-26 09:49:17 -06:00
|
|
|
|
|
|
|
int
|
|
|
|
qla81xx_restart_mpi_firmware(scsi_qla_host_t *vha)
|
|
|
|
{
|
|
|
|
int rval = 0;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e5,
|
|
|
|
"Entered %s.\n", __func__);
|
2009-03-26 09:49:17 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_RESTART_MPI_FW;
|
|
|
|
mcp->out_mb = MBX_0;
|
|
|
|
mcp->in_mb = MBX_0|MBX_1;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10e6,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1]);
|
2009-03-26 09:49:17 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e7,
|
|
|
|
"Done %s.\n", __func__);
|
2009-03-26 09:49:17 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2009-03-24 10:08:12 -06:00
|
|
|
|
2013-08-26 23:37:35 -06:00
|
|
|
int
|
|
|
|
qla82xx_set_driver_version(scsi_qla_host_t *vha, char *version)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
int i;
|
|
|
|
int len;
|
|
|
|
uint16_t *str;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
|
|
|
if (!IS_P3P_TYPE(ha))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x117b,
|
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
str = (void *)version;
|
|
|
|
len = strlen(version);
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_SET_RNID_PARAMS;
|
|
|
|
mcp->mb[1] = RNID_TYPE_SET_VERSION << 8;
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
|
|
|
for (i = 4; i < 16 && len; i++, str++, len -= 2) {
|
|
|
|
mcp->mb[i] = cpu_to_le16p(str);
|
|
|
|
mcp->out_mb |= 1<<i;
|
|
|
|
}
|
|
|
|
for (; i < 16; i++) {
|
|
|
|
mcp->mb[i] = 0;
|
|
|
|
mcp->out_mb |= 1<<i;
|
|
|
|
}
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x117c,
|
|
|
|
"Failed=%x mb[0]=%x,%x.\n", rval, mcp->mb[0], mcp->mb[1]);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x117d,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
qla25xx_set_driver_version(scsi_qla_host_t *vha, char *version)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
int len;
|
|
|
|
uint16_t dwlen;
|
|
|
|
uint8_t *str;
|
|
|
|
dma_addr_t str_dma;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
|
|
|
if (!IS_FWI2_CAPABLE(ha) || IS_QLA24XX_TYPE(ha) || IS_QLA81XX(ha) ||
|
|
|
|
IS_P3P_TYPE(ha))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x117e,
|
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
str = dma_pool_alloc(ha->s_dma_pool, GFP_KERNEL, &str_dma);
|
|
|
|
if (!str) {
|
|
|
|
ql_log(ql_log_warn, vha, 0x117f,
|
|
|
|
"Failed to allocate driver version param.\n");
|
|
|
|
return QLA_MEMORY_ALLOC_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
memcpy(str, "\x7\x3\x11\x0", 4);
|
|
|
|
dwlen = str[0];
|
|
|
|
len = dwlen * 4 - 4;
|
|
|
|
memset(str + 4, 0, len);
|
|
|
|
if (len > strlen(version))
|
|
|
|
len = strlen(version);
|
|
|
|
memcpy(str + 4, version, len);
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_SET_RNID_PARAMS;
|
|
|
|
mcp->mb[1] = RNID_TYPE_SET_VERSION << 8 | dwlen;
|
|
|
|
mcp->mb[2] = MSW(LSD(str_dma));
|
|
|
|
mcp->mb[3] = LSW(LSD(str_dma));
|
|
|
|
mcp->mb[6] = MSW(MSD(str_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(str_dma));
|
|
|
|
mcp->out_mb = MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1180,
|
|
|
|
"Failed=%x mb[0]=%x,%x.\n", rval, mcp->mb[0], mcp->mb[1]);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1181,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
dma_pool_free(ha->s_dma_pool, str, str_dma);
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2017-10-13 10:34:06 -06:00
|
|
|
int
|
|
|
|
qla24xx_get_port_login_templ(scsi_qla_host_t *vha, dma_addr_t buf_dma,
|
|
|
|
void *buf, uint16_t bufsiz)
|
|
|
|
{
|
|
|
|
int rval, i;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
uint32_t *bp;
|
|
|
|
|
|
|
|
if (!IS_FWI2_CAPABLE(vha->hw))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1159,
|
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_RNID_PARAMS;
|
|
|
|
mcp->mb[1] = RNID_TYPE_PORT_LOGIN << 8;
|
|
|
|
mcp->mb[2] = MSW(buf_dma);
|
|
|
|
mcp->mb[3] = LSW(buf_dma);
|
|
|
|
mcp->mb[6] = MSW(MSD(buf_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(buf_dma));
|
|
|
|
mcp->mb[8] = bufsiz/4;
|
|
|
|
mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x115a,
|
|
|
|
"Failed=%x mb[0]=%x,%x.\n", rval, mcp->mb[0], mcp->mb[1]);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x115b,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
bp = (uint32_t *) buf;
|
|
|
|
for (i = 0; i < (bufsiz-4)/4; i++, bp++)
|
|
|
|
*bp = cpu_to_be32(*bp);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2013-02-07 23:58:03 -07:00
|
|
|
static int
|
|
|
|
qla2x00_read_asic_temperature(scsi_qla_host_t *vha, uint16_t *temp)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
|
|
|
if (!IS_FWI2_CAPABLE(vha->hw))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1159,
|
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_RNID_PARAMS;
|
|
|
|
mcp->mb[1] = RNID_TYPE_ASIC_TEMP << 8;
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
*temp = mcp->mb[1];
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x115a,
|
|
|
|
"Failed=%x mb[0]=%x,%x.\n", rval, mcp->mb[0], mcp->mb[1]);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x115b,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2009-03-24 10:08:12 -06:00
|
|
|
int
|
2011-05-10 12:30:15 -06:00
|
|
|
qla2x00_read_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
|
|
|
|
uint16_t dev, uint16_t off, uint16_t len, uint16_t opt)
|
2009-03-24 10:08:12 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2011-05-10 12:30:15 -06:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10e8,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2011-05-10 12:30:15 -06:00
|
|
|
if (!IS_FWI2_CAPABLE(ha))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
2009-03-24 10:08:12 -06:00
|
|
|
|
2011-05-10 12:30:15 -06:00
|
|
|
if (len == 1)
|
|
|
|
opt |= BIT_0;
|
|
|
|
|
2009-03-24 10:08:12 -06:00
|
|
|
mcp->mb[0] = MBC_READ_SFP;
|
|
|
|
mcp->mb[1] = dev;
|
|
|
|
mcp->mb[2] = MSW(sfp_dma);
|
|
|
|
mcp->mb[3] = LSW(sfp_dma);
|
|
|
|
mcp->mb[6] = MSW(MSD(sfp_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(sfp_dma));
|
|
|
|
mcp->mb[8] = len;
|
2011-05-10 12:30:15 -06:00
|
|
|
mcp->mb[9] = off;
|
2009-03-24 10:08:12 -06:00
|
|
|
mcp->mb[10] = opt;
|
|
|
|
mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
2011-05-10 12:30:11 -06:00
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
2009-03-24 10:08:12 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (opt & BIT_0)
|
2011-05-10 12:30:15 -06:00
|
|
|
*sfp = mcp->mb[1];
|
2009-03-24 10:08:12 -06:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10e9,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2017-08-23 16:05:07 -06:00
|
|
|
if (mcp->mb[0] == MBS_COMMAND_ERROR &&
|
|
|
|
mcp->mb[1] == 0x22)
|
|
|
|
/* sfp is not there */
|
|
|
|
rval = QLA_INTERFACE_ERROR;
|
2009-03-24 10:08:12 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ea,
|
|
|
|
"Done %s.\n", __func__);
|
2009-03-24 10:08:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-05-10 12:30:15 -06:00
|
|
|
qla2x00_write_sfp(scsi_qla_host_t *vha, dma_addr_t sfp_dma, uint8_t *sfp,
|
|
|
|
uint16_t dev, uint16_t off, uint16_t len, uint16_t opt)
|
2009-03-24 10:08:12 -06:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
2011-05-10 12:30:15 -06:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10eb,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2011-05-10 12:30:15 -06:00
|
|
|
if (!IS_FWI2_CAPABLE(ha))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
2009-03-24 10:08:12 -06:00
|
|
|
|
2011-05-10 12:30:15 -06:00
|
|
|
if (len == 1)
|
|
|
|
opt |= BIT_0;
|
|
|
|
|
2009-03-24 10:08:12 -06:00
|
|
|
if (opt & BIT_0)
|
2011-05-10 12:30:15 -06:00
|
|
|
len = *sfp;
|
2009-03-24 10:08:12 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_WRITE_SFP;
|
|
|
|
mcp->mb[1] = dev;
|
|
|
|
mcp->mb[2] = MSW(sfp_dma);
|
|
|
|
mcp->mb[3] = LSW(sfp_dma);
|
|
|
|
mcp->mb[6] = MSW(MSD(sfp_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(sfp_dma));
|
|
|
|
mcp->mb[8] = len;
|
2011-05-10 12:30:15 -06:00
|
|
|
mcp->mb[9] = off;
|
2009-03-24 10:08:12 -06:00
|
|
|
mcp->mb[10] = opt;
|
|
|
|
mcp->out_mb = MBX_10|MBX_9|MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
2011-05-10 12:30:15 -06:00
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
2009-03-24 10:08:12 -06:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10ec,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2009-03-24 10:08:12 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ed,
|
|
|
|
"Done %s.\n", __func__);
|
2009-03-24 10:08:12 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2009-06-03 10:55:13 -06:00
|
|
|
|
|
|
|
int
|
|
|
|
qla2x00_get_xgmac_stats(scsi_qla_host_t *vha, dma_addr_t stats_dma,
|
|
|
|
uint16_t size_in_bytes, uint16_t *actual_size)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ee,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2012-02-09 12:15:34 -07:00
|
|
|
if (!IS_CNA_CAPABLE(vha->hw))
|
2009-06-03 10:55:13 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_XGMAC_STATS;
|
|
|
|
mcp->mb[2] = MSW(stats_dma);
|
|
|
|
mcp->mb[3] = LSW(stats_dma);
|
|
|
|
mcp->mb[6] = MSW(MSD(stats_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(stats_dma));
|
|
|
|
mcp->mb[8] = size_in_bytes >> 2;
|
|
|
|
mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_0;
|
|
|
|
mcp->in_mb = MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10ef,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
|
2009-06-03 10:55:13 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f0,
|
|
|
|
"Done %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2009-06-03 10:55:13 -06:00
|
|
|
|
|
|
|
*actual_size = mcp->mb[2] << 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2009-06-03 10:55:14 -06:00
|
|
|
|
|
|
|
int
|
|
|
|
qla2x00_get_dcbx_params(scsi_qla_host_t *vha, dma_addr_t tlv_dma,
|
|
|
|
uint16_t size)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f1,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2012-02-09 12:15:34 -07:00
|
|
|
if (!IS_CNA_CAPABLE(vha->hw))
|
2009-06-03 10:55:14 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_GET_DCBX_PARAMS;
|
|
|
|
mcp->mb[1] = 0;
|
|
|
|
mcp->mb[2] = MSW(tlv_dma);
|
|
|
|
mcp->mb[3] = LSW(tlv_dma);
|
|
|
|
mcp->mb[6] = MSW(MSD(tlv_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(tlv_dma));
|
|
|
|
mcp->mb[8] = size;
|
|
|
|
mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10f2,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1], mcp->mb[2]);
|
2009-06-03 10:55:14 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f3,
|
|
|
|
"Done %s.\n", __func__);
|
2009-06-03 10:55:14 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2009-06-03 10:55:30 -06:00
|
|
|
|
|
|
|
int
|
|
|
|
qla2x00_read_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t *data)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f4,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2009-06-03 10:55:30 -06:00
|
|
|
if (!IS_FWI2_CAPABLE(vha->hw))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_READ_RAM_EXTENDED;
|
|
|
|
mcp->mb[1] = LSW(risc_addr);
|
|
|
|
mcp->mb[8] = MSW(risc_addr);
|
|
|
|
mcp->out_mb = MBX_8|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_3|MBX_2|MBX_0;
|
|
|
|
mcp->tov = 30;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10f5,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2009-06-03 10:55:30 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f6,
|
|
|
|
"Done %s.\n", __func__);
|
2009-06-03 10:55:30 -06:00
|
|
|
*data = mcp->mb[3] << 16 | mcp->mb[2];
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2010-01-12 14:02:47 -07:00
|
|
|
int
|
2010-04-12 18:59:55 -06:00
|
|
|
qla2x00_loopback_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
|
|
|
|
uint16_t *mresp)
|
2010-01-12 14:02:47 -07:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f7,
|
|
|
|
"Entered %s.\n", __func__);
|
2010-01-12 14:02:47 -07:00
|
|
|
|
|
|
|
memset(mcp->mb, 0 , sizeof(mcp->mb));
|
|
|
|
mcp->mb[0] = MBC_DIAGNOSTIC_LOOP_BACK;
|
|
|
|
mcp->mb[1] = mreq->options | BIT_6; // BIT_6 specifies 64 bit addressing
|
|
|
|
|
|
|
|
/* transfer count */
|
|
|
|
mcp->mb[10] = LSW(mreq->transfer_size);
|
|
|
|
mcp->mb[11] = MSW(mreq->transfer_size);
|
|
|
|
|
|
|
|
/* send data address */
|
|
|
|
mcp->mb[14] = LSW(mreq->send_dma);
|
|
|
|
mcp->mb[15] = MSW(mreq->send_dma);
|
|
|
|
mcp->mb[20] = LSW(MSD(mreq->send_dma));
|
|
|
|
mcp->mb[21] = MSW(MSD(mreq->send_dma));
|
|
|
|
|
2011-03-30 19:57:33 -06:00
|
|
|
/* receive data address */
|
2010-01-12 14:02:47 -07:00
|
|
|
mcp->mb[16] = LSW(mreq->rcv_dma);
|
|
|
|
mcp->mb[17] = MSW(mreq->rcv_dma);
|
|
|
|
mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
|
|
|
|
mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
|
|
|
|
|
|
|
|
/* Iteration count */
|
2013-03-28 06:21:26 -06:00
|
|
|
mcp->mb[18] = LSW(mreq->iteration_count);
|
|
|
|
mcp->mb[19] = MSW(mreq->iteration_count);
|
2010-01-12 14:02:47 -07:00
|
|
|
|
|
|
|
mcp->out_mb = MBX_21|MBX_20|MBX_19|MBX_18|MBX_17|MBX_16|MBX_15|
|
|
|
|
MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
|
2012-02-09 12:15:34 -07:00
|
|
|
if (IS_CNA_CAPABLE(vha->hw))
|
2010-01-12 14:02:47 -07:00
|
|
|
mcp->out_mb |= MBX_2;
|
|
|
|
mcp->in_mb = MBX_19|MBX_18|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
|
|
|
|
mcp->buf_size = mreq->transfer_size;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
|
|
|
|
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10f8,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x mb[3]=%x mb[18]=%x "
|
|
|
|
"mb[19]=%x.\n", rval, mcp->mb[0], mcp->mb[1], mcp->mb[2],
|
|
|
|
mcp->mb[3], mcp->mb[18], mcp->mb[19]);
|
2010-01-12 14:02:47 -07:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10f9,
|
|
|
|
"Done %s.\n", __func__);
|
2010-01-12 14:02:47 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Copy mailbox information */
|
|
|
|
memcpy( mresp, mcp->mb, 64);
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2010-04-12 18:59:55 -06:00
|
|
|
qla2x00_echo_test(scsi_qla_host_t *vha, struct msg_echo_lb *mreq,
|
|
|
|
uint16_t *mresp)
|
2010-01-12 14:02:47 -07:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10fa,
|
|
|
|
"Entered %s.\n", __func__);
|
2010-01-12 14:02:47 -07:00
|
|
|
|
|
|
|
memset(mcp->mb, 0 , sizeof(mcp->mb));
|
|
|
|
mcp->mb[0] = MBC_DIAGNOSTIC_ECHO;
|
2017-05-24 19:06:22 -06:00
|
|
|
/* BIT_6 specifies 64bit address */
|
|
|
|
mcp->mb[1] = mreq->options | BIT_15 | BIT_6;
|
2012-02-09 12:15:34 -07:00
|
|
|
if (IS_CNA_CAPABLE(ha)) {
|
2010-04-12 18:59:55 -06:00
|
|
|
mcp->mb[2] = vha->fcoe_fcf_idx;
|
|
|
|
}
|
2010-01-12 14:02:47 -07:00
|
|
|
mcp->mb[16] = LSW(mreq->rcv_dma);
|
|
|
|
mcp->mb[17] = MSW(mreq->rcv_dma);
|
|
|
|
mcp->mb[6] = LSW(MSD(mreq->rcv_dma));
|
|
|
|
mcp->mb[7] = MSW(MSD(mreq->rcv_dma));
|
|
|
|
|
|
|
|
mcp->mb[10] = LSW(mreq->transfer_size);
|
|
|
|
|
|
|
|
mcp->mb[14] = LSW(mreq->send_dma);
|
|
|
|
mcp->mb[15] = MSW(mreq->send_dma);
|
|
|
|
mcp->mb[20] = LSW(MSD(mreq->send_dma));
|
|
|
|
mcp->mb[21] = MSW(MSD(mreq->send_dma));
|
|
|
|
|
|
|
|
mcp->out_mb = MBX_21|MBX_20|MBX_17|MBX_16|MBX_15|
|
|
|
|
MBX_14|MBX_10|MBX_7|MBX_6|MBX_1|MBX_0;
|
2012-02-09 12:15:34 -07:00
|
|
|
if (IS_CNA_CAPABLE(ha))
|
2010-01-12 14:02:47 -07:00
|
|
|
mcp->out_mb |= MBX_2;
|
|
|
|
|
|
|
|
mcp->in_mb = MBX_0;
|
2012-02-09 12:15:34 -07:00
|
|
|
if (IS_QLA24XX_TYPE(ha) || IS_QLA25XX(ha) ||
|
|
|
|
IS_CNA_CAPABLE(ha) || IS_QLA2031(ha))
|
2010-01-12 14:02:47 -07:00
|
|
|
mcp->in_mb |= MBX_1;
|
2012-02-09 12:15:34 -07:00
|
|
|
if (IS_CNA_CAPABLE(ha) || IS_QLA2031(ha))
|
2010-01-12 14:02:47 -07:00
|
|
|
mcp->in_mb |= MBX_3;
|
|
|
|
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
|
|
|
|
mcp->buf_size = mreq->transfer_size;
|
|
|
|
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10fb,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1]);
|
2010-01-12 14:02:47 -07:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10fc,
|
|
|
|
"Done %s.\n", __func__);
|
2010-01-12 14:02:47 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Copy mailbox information */
|
2010-09-03 16:20:49 -06:00
|
|
|
memcpy(mresp, mcp->mb, 64);
|
2010-01-12 14:02:47 -07:00
|
|
|
return rval;
|
|
|
|
}
|
2010-09-03 16:20:49 -06:00
|
|
|
|
2010-01-12 14:02:47 -07:00
|
|
|
int
|
2011-07-14 13:00:13 -06:00
|
|
|
qla84xx_reset_chip(scsi_qla_host_t *vha, uint16_t enable_diagnostic)
|
2010-01-12 14:02:47 -07:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10fd,
|
2011-07-14 13:00:13 -06:00
|
|
|
"Entered %s enable_diag=%d.\n", __func__, enable_diagnostic);
|
2010-01-12 14:02:47 -07:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_ISP84XX_RESET;
|
|
|
|
mcp->mb[1] = enable_diagnostic;
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
|
2011-07-14 13:00:13 -06:00
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
2010-01-12 14:02:47 -07:00
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS)
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10fe, "Failed=%x.\n", rval);
|
2010-01-12 14:02:47 -07:00
|
|
|
else
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10ff,
|
|
|
|
"Done %s.\n", __func__);
|
2010-01-12 14:02:47 -07:00
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2009-06-03 10:55:30 -06:00
|
|
|
int
|
|
|
|
qla2x00_write_ram_word(scsi_qla_host_t *vha, uint32_t risc_addr, uint32_t data)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1100,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2009-06-03 10:55:30 -06:00
|
|
|
if (!IS_FWI2_CAPABLE(vha->hw))
|
2010-03-19 18:04:02 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
2009-06-03 10:55:30 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_WRITE_RAM_WORD_EXTENDED;
|
|
|
|
mcp->mb[1] = LSW(risc_addr);
|
|
|
|
mcp->mb[2] = LSW(data);
|
|
|
|
mcp->mb[3] = MSW(data);
|
|
|
|
mcp->mb[8] = MSW(risc_addr);
|
|
|
|
mcp->out_mb = MBX_8|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = 30;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1101,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2009-06-03 10:55:30 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1102,
|
|
|
|
"Done %s.\n", __func__);
|
2009-06-03 10:55:30 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2009-12-15 22:29:44 -07:00
|
|
|
|
2010-09-03 16:20:54 -06:00
|
|
|
int
|
|
|
|
qla81xx_write_mpi_register(scsi_qla_host_t *vha, uint16_t *mb)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
uint32_t stat, timer;
|
|
|
|
uint16_t mb0 = 0;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
struct device_reg_24xx __iomem *reg = &ha->iobase->isp24;
|
|
|
|
|
|
|
|
rval = QLA_SUCCESS;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1103,
|
|
|
|
"Entered %s.\n", __func__);
|
2010-09-03 16:20:54 -06:00
|
|
|
|
|
|
|
clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags);
|
|
|
|
|
|
|
|
/* Write the MBC data to the registers */
|
|
|
|
WRT_REG_WORD(®->mailbox0, MBC_WRITE_MPI_REGISTER);
|
|
|
|
WRT_REG_WORD(®->mailbox1, mb[0]);
|
|
|
|
WRT_REG_WORD(®->mailbox2, mb[1]);
|
|
|
|
WRT_REG_WORD(®->mailbox3, mb[2]);
|
|
|
|
WRT_REG_WORD(®->mailbox4, mb[3]);
|
|
|
|
|
|
|
|
WRT_REG_DWORD(®->hccr, HCCRX_SET_HOST_INT);
|
|
|
|
|
|
|
|
/* Poll for MBC interrupt */
|
|
|
|
for (timer = 6000000; timer; timer--) {
|
|
|
|
/* Check for pending interrupts. */
|
|
|
|
stat = RD_REG_DWORD(®->host_status);
|
|
|
|
if (stat & HSRX_RISC_INT) {
|
|
|
|
stat &= 0xff;
|
|
|
|
|
|
|
|
if (stat == 0x1 || stat == 0x2 ||
|
|
|
|
stat == 0x10 || stat == 0x11) {
|
|
|
|
set_bit(MBX_INTERRUPT,
|
|
|
|
&ha->mbx_cmd_flags);
|
|
|
|
mb0 = RD_REG_WORD(®->mailbox0);
|
|
|
|
WRT_REG_DWORD(®->hccr,
|
|
|
|
HCCRX_CLR_RISC_INT);
|
|
|
|
RD_REG_DWORD(®->hccr);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
udelay(5);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (test_and_clear_bit(MBX_INTERRUPT, &ha->mbx_cmd_flags))
|
|
|
|
rval = mb0 & MBS_MASK;
|
|
|
|
else
|
|
|
|
rval = QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1104,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mb[0]);
|
2010-09-03 16:20:54 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1105,
|
|
|
|
"Done %s.\n", __func__);
|
2010-09-03 16:20:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2012-02-09 12:15:34 -07:00
|
|
|
|
2009-12-15 22:29:44 -07:00
|
|
|
int
|
|
|
|
qla2x00_get_data_rate(scsi_qla_host_t *vha)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1106,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2009-12-15 22:29:44 -07:00
|
|
|
if (!IS_FWI2_CAPABLE(ha))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_DATA_RATE;
|
|
|
|
mcp->mb[1] = 0;
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_2|MBX_1|MBX_0;
|
2014-02-26 02:15:06 -07:00
|
|
|
if (IS_QLA83XX(ha) || IS_QLA27XX(ha))
|
2012-02-09 12:15:34 -07:00
|
|
|
mcp->in_mb |= MBX_3;
|
2009-12-15 22:29:44 -07:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1107,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2009-12-15 22:29:44 -07:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1108,
|
|
|
|
"Done %s.\n", __func__);
|
2009-12-15 22:29:44 -07:00
|
|
|
if (mcp->mb[1] != 0x7)
|
|
|
|
ha->link_data_rate = mcp->mb[1];
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2010-03-19 18:03:59 -06:00
|
|
|
|
2010-05-28 16:08:21 -06:00
|
|
|
int
|
|
|
|
qla81xx_get_port_config(scsi_qla_host_t *vha, uint16_t *mb)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1109,
|
|
|
|
"Entered %s.\n", __func__);
|
2010-05-28 16:08:21 -06:00
|
|
|
|
2014-02-26 02:15:06 -07:00
|
|
|
if (!IS_QLA81XX(ha) && !IS_QLA83XX(ha) && !IS_QLA8044(ha) &&
|
|
|
|
!IS_QLA27XX(ha))
|
2010-05-28 16:08:21 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
mcp->mb[0] = MBC_GET_PORT_CONFIG;
|
|
|
|
mcp->out_mb = MBX_0;
|
|
|
|
mcp->in_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x110a,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2010-05-28 16:08:21 -06:00
|
|
|
} else {
|
|
|
|
/* Copy all bits to preserve original value */
|
|
|
|
memcpy(mb, &mcp->mb[1], sizeof(uint16_t) * 4);
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x110b,
|
|
|
|
"Done %s.\n", __func__);
|
2010-05-28 16:08:21 -06:00
|
|
|
}
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
qla81xx_set_port_config(scsi_qla_host_t *vha, uint16_t *mb)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x110c,
|
|
|
|
"Entered %s.\n", __func__);
|
2010-05-28 16:08:21 -06:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_SET_PORT_CONFIG;
|
|
|
|
/* Copy all bits to preserve original setting */
|
|
|
|
memcpy(&mcp->mb[1], mb, sizeof(uint16_t) * 4);
|
|
|
|
mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x110d,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2010-05-28 16:08:21 -06:00
|
|
|
} else
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x110e,
|
|
|
|
"Done %s.\n", __func__);
|
2010-05-28 16:08:21 -06:00
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-03-19 18:03:59 -06:00
|
|
|
int
|
|
|
|
qla24xx_set_fcp_prio(scsi_qla_host_t *vha, uint16_t loop_id, uint16_t priority,
|
|
|
|
uint16_t *mb)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x110f,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2010-03-19 18:03:59 -06:00
|
|
|
if (!IS_QLA24XX_TYPE(ha) && !IS_QLA25XX(ha))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_PORT_PARAMS;
|
|
|
|
mcp->mb[1] = loop_id;
|
|
|
|
if (ha->flags.fcp_prio_enabled)
|
|
|
|
mcp->mb[2] = BIT_1;
|
|
|
|
else
|
|
|
|
mcp->mb[2] = BIT_2;
|
|
|
|
mcp->mb[4] = priority & 0xf;
|
|
|
|
mcp->mb[9] = vha->vp_idx;
|
|
|
|
mcp->out_mb = MBX_9|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_4|MBX_3|MBX_1|MBX_0;
|
|
|
|
mcp->tov = 30;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (mb != NULL) {
|
|
|
|
mb[0] = mcp->mb[0];
|
|
|
|
mb[1] = mcp->mb[1];
|
|
|
|
mb[3] = mcp->mb[3];
|
|
|
|
mb[4] = mcp->mb[4];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10cd, "Failed=%x.\n", rval);
|
2010-03-19 18:03:59 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x10cc,
|
|
|
|
"Done %s.\n", __func__);
|
2010-03-19 18:03:59 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2010-04-12 18:59:55 -06:00
|
|
|
|
2010-12-21 17:00:21 -07:00
|
|
|
int
|
2013-02-07 23:58:03 -07:00
|
|
|
qla2x00_get_thermal_temp(scsi_qla_host_t *vha, uint16_t *temp)
|
2010-12-21 17:00:21 -07:00
|
|
|
{
|
2013-02-07 23:58:03 -07:00
|
|
|
int rval = QLA_FUNCTION_FAILED;
|
2010-12-21 17:00:21 -07:00
|
|
|
struct qla_hw_data *ha = vha->hw;
|
2013-02-07 23:58:03 -07:00
|
|
|
uint8_t byte;
|
2010-12-21 17:00:21 -07:00
|
|
|
|
2013-08-26 23:37:36 -06:00
|
|
|
if (!IS_FWI2_CAPABLE(ha) || IS_QLA24XX_TYPE(ha) || IS_QLA81XX(ha)) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1150,
|
|
|
|
"Thermal not supported by this card.\n");
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (IS_QLA25XX(ha)) {
|
|
|
|
if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_QLOGIC &&
|
|
|
|
ha->pdev->subsystem_device == 0x0175) {
|
|
|
|
rval = qla2x00_read_sfp(vha, 0, &byte,
|
|
|
|
0x98, 0x1, 1, BIT_13|BIT_0);
|
|
|
|
*temp = byte;
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
if (ha->pdev->subsystem_vendor == PCI_VENDOR_ID_HP &&
|
|
|
|
ha->pdev->subsystem_device == 0x338e) {
|
|
|
|
rval = qla2x00_read_sfp(vha, 0, &byte,
|
|
|
|
0x98, 0x1, 1, BIT_15|BIT_14|BIT_0);
|
|
|
|
*temp = byte;
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x10c9,
|
|
|
|
"Thermal not supported by this card.\n");
|
|
|
|
return rval;
|
2010-12-21 17:00:21 -07:00
|
|
|
}
|
|
|
|
|
2013-08-26 23:37:36 -06:00
|
|
|
if (IS_QLA82XX(ha)) {
|
|
|
|
*temp = qla82xx_read_temperature(vha);
|
|
|
|
rval = QLA_SUCCESS;
|
|
|
|
return rval;
|
|
|
|
} else if (IS_QLA8044(ha)) {
|
|
|
|
*temp = qla8044_read_temperature(vha);
|
|
|
|
rval = QLA_SUCCESS;
|
|
|
|
return rval;
|
2010-12-21 17:00:21 -07:00
|
|
|
}
|
|
|
|
|
2013-08-26 23:37:36 -06:00
|
|
|
rval = qla2x00_read_asic_temperature(vha, temp);
|
2010-12-21 17:00:21 -07:00
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2010-04-12 18:59:55 -06:00
|
|
|
int
|
|
|
|
qla82xx_mbx_intr_enable(scsi_qla_host_t *vha)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1017,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2010-04-12 18:59:55 -06:00
|
|
|
if (!IS_FWI2_CAPABLE(ha))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
memset(mcp, 0, sizeof(mbx_cmd_t));
|
2010-07-23 04:28:34 -06:00
|
|
|
mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
|
2010-04-12 18:59:55 -06:00
|
|
|
mcp->mb[1] = 1;
|
|
|
|
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = 30;
|
|
|
|
mcp->flags = 0;
|
|
|
|
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1016,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2010-04-12 18:59:55 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x100e,
|
|
|
|
"Done %s.\n", __func__);
|
2010-04-12 18:59:55 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
qla82xx_mbx_intr_disable(scsi_qla_host_t *vha)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x100d,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-07-14 13:00:13 -06:00
|
|
|
|
2013-08-26 23:37:28 -06:00
|
|
|
if (!IS_P3P_TYPE(ha))
|
2010-04-12 18:59:55 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
memset(mcp, 0, sizeof(mbx_cmd_t));
|
2010-07-23 04:28:34 -06:00
|
|
|
mcp->mb[0] = MBC_TOGGLE_INTERRUPT;
|
2010-04-12 18:59:55 -06:00
|
|
|
mcp->mb[1] = 0;
|
|
|
|
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = 30;
|
|
|
|
mcp->flags = 0;
|
|
|
|
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2011-07-14 13:00:13 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x100c,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
2010-04-12 18:59:55 -06:00
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x100b,
|
|
|
|
"Done %s.\n", __func__);
|
2010-04-12 18:59:55 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2011-08-16 12:31:44 -06:00
|
|
|
|
|
|
|
int
|
|
|
|
qla82xx_md_get_template_size(scsi_qla_host_t *vha)
|
|
|
|
{
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
int rval = QLA_FUNCTION_FAILED;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x111f,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-08-16 12:31:44 -06:00
|
|
|
|
|
|
|
memset(mcp->mb, 0 , sizeof(mcp->mb));
|
|
|
|
mcp->mb[0] = LSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
|
|
|
|
mcp->mb[1] = MSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
|
|
|
|
mcp->mb[2] = LSW(RQST_TMPLT_SIZE);
|
|
|
|
mcp->mb[3] = MSW(RQST_TMPLT_SIZE);
|
|
|
|
|
|
|
|
mcp->out_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_14|MBX_13|MBX_12|MBX_11|MBX_10|MBX_9|MBX_8|
|
|
|
|
MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
|
|
|
|
mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
/* Always copy back return mailbox values. */
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1120,
|
|
|
|
"mailbox command FAILED=0x%x, subcode=%x.\n",
|
|
|
|
(mcp->mb[1] << 16) | mcp->mb[0],
|
|
|
|
(mcp->mb[3] << 16) | mcp->mb[2]);
|
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1121,
|
|
|
|
"Done %s.\n", __func__);
|
2011-08-16 12:31:44 -06:00
|
|
|
ha->md_template_size = ((mcp->mb[3] << 16) | mcp->mb[2]);
|
|
|
|
if (!ha->md_template_size) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1122,
|
|
|
|
"Null template size obtained.\n");
|
|
|
|
rval = QLA_FUNCTION_FAILED;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
qla82xx_md_get_template(scsi_qla_host_t *vha)
|
|
|
|
{
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
int rval = QLA_FUNCTION_FAILED;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1123,
|
|
|
|
"Entered %s.\n", __func__);
|
2011-08-16 12:31:44 -06:00
|
|
|
|
|
|
|
ha->md_tmplt_hdr = dma_alloc_coherent(&ha->pdev->dev,
|
|
|
|
ha->md_template_size, &ha->md_tmplt_hdr_dma, GFP_KERNEL);
|
|
|
|
if (!ha->md_tmplt_hdr) {
|
|
|
|
ql_log(ql_log_warn, vha, 0x1124,
|
|
|
|
"Unable to allocate memory for Minidump template.\n");
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(mcp->mb, 0 , sizeof(mcp->mb));
|
|
|
|
mcp->mb[0] = LSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
|
|
|
|
mcp->mb[1] = MSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
|
|
|
|
mcp->mb[2] = LSW(RQST_TMPLT);
|
|
|
|
mcp->mb[3] = MSW(RQST_TMPLT);
|
|
|
|
mcp->mb[4] = LSW(LSD(ha->md_tmplt_hdr_dma));
|
|
|
|
mcp->mb[5] = MSW(LSD(ha->md_tmplt_hdr_dma));
|
|
|
|
mcp->mb[6] = LSW(MSD(ha->md_tmplt_hdr_dma));
|
|
|
|
mcp->mb[7] = MSW(MSD(ha->md_tmplt_hdr_dma));
|
|
|
|
mcp->mb[8] = LSW(ha->md_template_size);
|
|
|
|
mcp->mb[9] = MSW(ha->md_template_size);
|
|
|
|
|
|
|
|
mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->out_mb = MBX_11|MBX_10|MBX_9|MBX_8|
|
|
|
|
MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1125,
|
|
|
|
"mailbox command FAILED=0x%x, subcode=%x.\n",
|
|
|
|
((mcp->mb[1] << 16) | mcp->mb[0]),
|
|
|
|
((mcp->mb[3] << 16) | mcp->mb[2]));
|
|
|
|
} else
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1126,
|
|
|
|
"Done %s.\n", __func__);
|
2011-08-16 12:31:44 -06:00
|
|
|
return rval;
|
|
|
|
}
|
2011-08-16 12:31:45 -06:00
|
|
|
|
2013-08-26 23:37:28 -06:00
|
|
|
int
|
|
|
|
qla8044_md_get_template(scsi_qla_host_t *vha)
|
|
|
|
{
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
int rval = QLA_FUNCTION_FAILED;
|
|
|
|
int offset = 0, size = MINIDUMP_SIZE_36K;
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0xb11f,
|
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
ha->md_tmplt_hdr = dma_alloc_coherent(&ha->pdev->dev,
|
|
|
|
ha->md_template_size, &ha->md_tmplt_hdr_dma, GFP_KERNEL);
|
|
|
|
if (!ha->md_tmplt_hdr) {
|
|
|
|
ql_log(ql_log_warn, vha, 0xb11b,
|
|
|
|
"Unable to allocate memory for Minidump template.\n");
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(mcp->mb, 0 , sizeof(mcp->mb));
|
|
|
|
while (offset < ha->md_template_size) {
|
|
|
|
mcp->mb[0] = LSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
|
|
|
|
mcp->mb[1] = MSW(MBC_DIAGNOSTIC_MINIDUMP_TEMPLATE);
|
|
|
|
mcp->mb[2] = LSW(RQST_TMPLT);
|
|
|
|
mcp->mb[3] = MSW(RQST_TMPLT);
|
|
|
|
mcp->mb[4] = LSW(LSD(ha->md_tmplt_hdr_dma + offset));
|
|
|
|
mcp->mb[5] = MSW(LSD(ha->md_tmplt_hdr_dma + offset));
|
|
|
|
mcp->mb[6] = LSW(MSD(ha->md_tmplt_hdr_dma + offset));
|
|
|
|
mcp->mb[7] = MSW(MSD(ha->md_tmplt_hdr_dma + offset));
|
|
|
|
mcp->mb[8] = LSW(size);
|
|
|
|
mcp->mb[9] = MSW(size);
|
|
|
|
mcp->mb[10] = offset & 0x0000FFFF;
|
|
|
|
mcp->mb[11] = offset & 0xFFFF0000;
|
|
|
|
mcp->flags = MBX_DMA_OUT|MBX_DMA_IN|IOCTL_CMD;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->out_mb = MBX_11|MBX_10|MBX_9|MBX_8|
|
|
|
|
MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0xb11c,
|
|
|
|
"mailbox command FAILED=0x%x, subcode=%x.\n",
|
|
|
|
((mcp->mb[1] << 16) | mcp->mb[0]),
|
|
|
|
((mcp->mb[3] << 16) | mcp->mb[2]));
|
|
|
|
return rval;
|
|
|
|
} else
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0xb11d,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
offset = offset + size;
|
|
|
|
}
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2012-02-09 12:15:34 -07:00
|
|
|
int
|
|
|
|
qla81xx_set_led_config(scsi_qla_host_t *vha, uint16_t *led_cfg)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
|
|
|
if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1133,
|
|
|
|
"Entered %s.\n", __func__);
|
2012-02-09 12:15:34 -07:00
|
|
|
|
|
|
|
memset(mcp, 0, sizeof(mbx_cmd_t));
|
|
|
|
mcp->mb[0] = MBC_SET_LED_CONFIG;
|
|
|
|
mcp->mb[1] = led_cfg[0];
|
|
|
|
mcp->mb[2] = led_cfg[1];
|
|
|
|
if (IS_QLA8031(ha)) {
|
|
|
|
mcp->mb[3] = led_cfg[2];
|
|
|
|
mcp->mb[4] = led_cfg[3];
|
|
|
|
mcp->mb[5] = led_cfg[4];
|
|
|
|
mcp->mb[6] = led_cfg[5];
|
|
|
|
}
|
|
|
|
|
|
|
|
mcp->out_mb = MBX_2|MBX_1|MBX_0;
|
|
|
|
if (IS_QLA8031(ha))
|
|
|
|
mcp->out_mb |= MBX_6|MBX_5|MBX_4|MBX_3;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = 30;
|
|
|
|
mcp->flags = 0;
|
|
|
|
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1134,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1135,
|
|
|
|
"Done %s.\n", __func__);
|
2012-02-09 12:15:34 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
qla81xx_get_led_config(scsi_qla_host_t *vha, uint16_t *led_cfg)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
|
|
|
if (!IS_QLA81XX(ha) && !IS_QLA8031(ha))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1136,
|
|
|
|
"Entered %s.\n", __func__);
|
2012-02-09 12:15:34 -07:00
|
|
|
|
|
|
|
memset(mcp, 0, sizeof(mbx_cmd_t));
|
|
|
|
mcp->mb[0] = MBC_GET_LED_CONFIG;
|
|
|
|
|
|
|
|
mcp->out_mb = MBX_0;
|
|
|
|
mcp->in_mb = MBX_2|MBX_1|MBX_0;
|
|
|
|
if (IS_QLA8031(ha))
|
|
|
|
mcp->in_mb |= MBX_6|MBX_5|MBX_4|MBX_3;
|
|
|
|
mcp->tov = 30;
|
|
|
|
mcp->flags = 0;
|
|
|
|
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1137,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
|
|
|
} else {
|
|
|
|
led_cfg[0] = mcp->mb[1];
|
|
|
|
led_cfg[1] = mcp->mb[2];
|
|
|
|
if (IS_QLA8031(ha)) {
|
|
|
|
led_cfg[2] = mcp->mb[3];
|
|
|
|
led_cfg[3] = mcp->mb[4];
|
|
|
|
led_cfg[4] = mcp->mb[5];
|
|
|
|
led_cfg[5] = mcp->mb[6];
|
|
|
|
}
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1138,
|
|
|
|
"Done %s.\n", __func__);
|
2012-02-09 12:15:34 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2011-08-16 12:31:45 -06:00
|
|
|
int
|
|
|
|
qla82xx_mbx_beacon_ctl(scsi_qla_host_t *vha, int enable)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2013-08-26 23:37:28 -06:00
|
|
|
if (!IS_P3P_TYPE(ha))
|
2011-08-16 12:31:45 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1127,
|
2011-08-16 12:31:45 -06:00
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
memset(mcp, 0, sizeof(mbx_cmd_t));
|
|
|
|
mcp->mb[0] = MBC_SET_LED_CONFIG;
|
|
|
|
if (enable)
|
|
|
|
mcp->mb[7] = 0xE;
|
|
|
|
else
|
|
|
|
mcp->mb[7] = 0xD;
|
|
|
|
|
|
|
|
mcp->out_mb = MBX_7|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
2012-02-09 12:15:34 -07:00
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
2011-08-16 12:31:45 -06:00
|
|
|
mcp->flags = 0;
|
|
|
|
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1128,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1129,
|
2011-08-16 12:31:45 -06:00
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2012-02-09 12:15:34 -07:00
|
|
|
|
|
|
|
int
|
2012-08-22 12:21:03 -06:00
|
|
|
qla83xx_wr_reg(scsi_qla_host_t *vha, uint32_t reg, uint32_t data)
|
2012-02-09 12:15:34 -07:00
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
2014-02-26 02:15:06 -07:00
|
|
|
if (!IS_QLA83XX(ha) && !IS_QLA27XX(ha))
|
2012-02-09 12:15:34 -07:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1130,
|
|
|
|
"Entered %s.\n", __func__);
|
2012-02-09 12:15:34 -07:00
|
|
|
|
|
|
|
mcp->mb[0] = MBC_WRITE_REMOTE_REG;
|
|
|
|
mcp->mb[1] = LSW(reg);
|
|
|
|
mcp->mb[2] = MSW(reg);
|
|
|
|
mcp->mb[3] = LSW(data);
|
|
|
|
mcp->mb[4] = MSW(data);
|
|
|
|
mcp->out_mb = MBX_4|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1131,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
|
|
|
} else {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1132,
|
2012-02-09 12:15:34 -07:00
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
2012-02-09 12:15:43 -07:00
|
|
|
|
2012-02-09 12:15:34 -07:00
|
|
|
return rval;
|
|
|
|
}
|
2012-02-09 12:15:43 -07:00
|
|
|
|
|
|
|
int
|
|
|
|
qla2x00_port_logout(scsi_qla_host_t *vha, struct fc_port *fcport)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
|
|
|
if (IS_QLA2100(ha) || IS_QLA2200(ha)) {
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x113b,
|
2012-02-09 12:15:43 -07:00
|
|
|
"Implicit LOGO Unsupported.\n");
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x113c,
|
|
|
|
"Entering %s.\n", __func__);
|
2012-02-09 12:15:43 -07:00
|
|
|
|
|
|
|
/* Perform Implicit LOGO. */
|
|
|
|
mcp->mb[0] = MBC_PORT_LOGOUT;
|
|
|
|
mcp->mb[1] = fcport->loop_id;
|
|
|
|
mcp->mb[10] = BIT_15;
|
|
|
|
mcp->out_mb = MBX_10|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval != QLA_SUCCESS)
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x113d,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
|
|
|
else
|
2012-05-15 12:34:15 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x113e,
|
|
|
|
"Done %s.\n", __func__);
|
2012-02-09 12:15:43 -07:00
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
2012-08-22 12:21:03 -06:00
|
|
|
int
|
|
|
|
qla83xx_rd_reg(scsi_qla_host_t *vha, uint32_t reg, uint32_t *data)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
unsigned long retry_max_time = jiffies + (2 * HZ);
|
|
|
|
|
2014-02-26 02:15:06 -07:00
|
|
|
if (!IS_QLA83XX(ha) && !IS_QLA27XX(ha))
|
2012-08-22 12:21:03 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x114b, "Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
retry_rd_reg:
|
|
|
|
mcp->mb[0] = MBC_READ_REMOTE_REG;
|
|
|
|
mcp->mb[1] = LSW(reg);
|
|
|
|
mcp->mb[2] = MSW(reg);
|
|
|
|
mcp->out_mb = MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_4|MBX_3|MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x114c,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1]);
|
|
|
|
} else {
|
|
|
|
*data = (mcp->mb[3] | (mcp->mb[4] << 16));
|
|
|
|
if (*data == QLA8XXX_BAD_VALUE) {
|
|
|
|
/*
|
|
|
|
* During soft-reset CAMRAM register reads might
|
|
|
|
* return 0xbad0bad0. So retry for MAX of 2 sec
|
|
|
|
* while reading camram registers.
|
|
|
|
*/
|
|
|
|
if (time_after(jiffies, retry_max_time)) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1141,
|
|
|
|
"Failure to read CAMRAM register. "
|
|
|
|
"data=0x%x.\n", *data);
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
}
|
|
|
|
msleep(100);
|
|
|
|
goto retry_rd_reg;
|
|
|
|
}
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1142, "Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
qla83xx_restart_nic_firmware(scsi_qla_host_t *vha)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
2015-06-10 09:05:18 -06:00
|
|
|
if (!IS_QLA83XX(ha) && !IS_QLA27XX(ha))
|
2012-08-22 12:21:03 -06:00
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1143, "Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_RESTART_NIC_FIRMWARE;
|
|
|
|
mcp->out_mb = MBX_0;
|
|
|
|
mcp->in_mb = MBX_1|MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1144,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1]);
|
|
|
|
ha->isp_ops->fw_dump(vha, 0);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1145, "Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
qla83xx_access_control(scsi_qla_host_t *vha, uint16_t options,
|
|
|
|
uint32_t start_addr, uint32_t end_addr, uint16_t *sector_size)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
uint8_t subcode = (uint8_t)options;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
|
|
|
|
if (!IS_QLA8031(ha))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1146, "Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_SET_ACCESS_CONTROL;
|
|
|
|
mcp->mb[1] = options;
|
|
|
|
mcp->out_mb = MBX_1|MBX_0;
|
|
|
|
if (subcode & BIT_2) {
|
|
|
|
mcp->mb[2] = LSW(start_addr);
|
|
|
|
mcp->mb[3] = MSW(start_addr);
|
|
|
|
mcp->mb[4] = LSW(end_addr);
|
|
|
|
mcp->mb[5] = MSW(end_addr);
|
|
|
|
mcp->out_mb |= MBX_5|MBX_4|MBX_3|MBX_2;
|
|
|
|
}
|
|
|
|
mcp->in_mb = MBX_2|MBX_1|MBX_0;
|
|
|
|
if (!(subcode & (BIT_2 | BIT_5)))
|
|
|
|
mcp->in_mb |= MBX_4|MBX_3;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1147,
|
|
|
|
"Failed=%x mb[0]=%x mb[1]=%x mb[2]=%x mb[3]=%x mb[4]=%x.\n",
|
|
|
|
rval, mcp->mb[0], mcp->mb[1], mcp->mb[2], mcp->mb[3],
|
|
|
|
mcp->mb[4]);
|
|
|
|
ha->isp_ops->fw_dump(vha, 0);
|
|
|
|
} else {
|
|
|
|
if (subcode & BIT_5)
|
|
|
|
*sector_size = mcp->mb[1];
|
|
|
|
else if (subcode & (BIT_6 | BIT_7)) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1148,
|
|
|
|
"Driver-lock id=%x%x", mcp->mb[4], mcp->mb[3]);
|
|
|
|
} else if (subcode & (BIT_3 | BIT_4)) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1149,
|
|
|
|
"Flash-lock id=%x%x", mcp->mb[4], mcp->mb[3]);
|
|
|
|
}
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x114a, "Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2012-08-22 12:21:04 -06:00
|
|
|
|
|
|
|
int
|
|
|
|
qla2x00_dump_mctp_data(scsi_qla_host_t *vha, dma_addr_t req_dma, uint32_t addr,
|
|
|
|
uint32_t size)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
|
|
|
if (!IS_MCTP_CAPABLE(vha->hw))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x114f,
|
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_DUMP_RISC_RAM_EXTENDED;
|
|
|
|
mcp->mb[1] = LSW(addr);
|
|
|
|
mcp->mb[2] = MSW(req_dma);
|
|
|
|
mcp->mb[3] = LSW(req_dma);
|
|
|
|
mcp->mb[4] = MSW(size);
|
|
|
|
mcp->mb[5] = LSW(size);
|
|
|
|
mcp->mb[6] = MSW(MSD(req_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(req_dma));
|
|
|
|
mcp->mb[8] = MSW(addr);
|
|
|
|
/* Setting RAM ID to valid */
|
|
|
|
mcp->mb[10] |= BIT_7;
|
|
|
|
/* For MCTP RAM ID is 0x40 */
|
|
|
|
mcp->mb[10] |= 0x40;
|
|
|
|
|
|
|
|
mcp->out_mb |= MBX_10|MBX_8|MBX_7|MBX_6|MBX_5|MBX_4|MBX_3|MBX_2|MBX_1|
|
|
|
|
MBX_0;
|
|
|
|
|
|
|
|
mcp->in_mb = MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x114e,
|
|
|
|
"Failed=%x mb[0]=%x.\n", rval, mcp->mb[0]);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x114d,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2016-07-06 09:14:26 -06:00
|
|
|
|
|
|
|
int
|
|
|
|
qla26xx_dport_diagnostics(scsi_qla_host_t *vha,
|
|
|
|
void *dd_buf, uint size, uint options)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
dma_addr_t dd_dma;
|
|
|
|
|
|
|
|
if (!IS_QLA83XX(vha->hw) && !IS_QLA27XX(vha->hw))
|
|
|
|
return QLA_FUNCTION_FAILED;
|
|
|
|
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x119f,
|
2016-07-06 09:14:26 -06:00
|
|
|
"Entered %s.\n", __func__);
|
|
|
|
|
|
|
|
dd_dma = dma_map_single(&vha->hw->pdev->dev,
|
|
|
|
dd_buf, size, DMA_FROM_DEVICE);
|
2017-08-08 07:55:30 -06:00
|
|
|
if (dma_mapping_error(&vha->hw->pdev->dev, dd_dma)) {
|
2016-07-06 09:14:26 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0x1194, "Failed to map dma buffer.\n");
|
|
|
|
return QLA_MEMORY_ALLOC_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(dd_buf, 0, size);
|
|
|
|
|
|
|
|
mcp->mb[0] = MBC_DPORT_DIAGNOSTICS;
|
|
|
|
mcp->mb[1] = options;
|
|
|
|
mcp->mb[2] = MSW(LSD(dd_dma));
|
|
|
|
mcp->mb[3] = LSW(LSD(dd_dma));
|
|
|
|
mcp->mb[6] = MSW(MSD(dd_dma));
|
|
|
|
mcp->mb[7] = LSW(MSD(dd_dma));
|
|
|
|
mcp->mb[8] = size;
|
|
|
|
mcp->out_mb = MBX_8|MBX_7|MBX_6|MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->in_mb = MBX_3|MBX_2|MBX_1|MBX_0;
|
|
|
|
mcp->buf_size = size;
|
|
|
|
mcp->flags = MBX_DMA_IN;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS * 4;
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1195, "Failed=%x.\n", rval);
|
|
|
|
} else {
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1196,
|
|
|
|
"Done %s.\n", __func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
dma_unmap_single(&vha->hw->pdev->dev, dd_dma,
|
|
|
|
size, DMA_FROM_DEVICE);
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2017-03-15 10:48:52 -06:00
|
|
|
|
|
|
|
static void qla2x00_async_mb_sp_done(void *s, int res)
|
|
|
|
{
|
|
|
|
struct srb *sp = s;
|
|
|
|
|
|
|
|
sp->u.iocb_cmd.u.mbx.rc = res;
|
|
|
|
|
|
|
|
complete(&sp->u.iocb_cmd.u.mbx.comp);
|
|
|
|
/* don't free sp here. Let the caller do the free */
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This mailbox uses the iocb interface to send MB command.
|
|
|
|
* This allows non-critial (non chip setup) command to go
|
|
|
|
* out in parrallel.
|
|
|
|
*/
|
|
|
|
int qla24xx_send_mb_cmd(struct scsi_qla_host *vha, mbx_cmd_t *mcp)
|
|
|
|
{
|
|
|
|
int rval = QLA_FUNCTION_FAILED;
|
|
|
|
srb_t *sp;
|
|
|
|
struct srb_iocb *c;
|
|
|
|
|
|
|
|
if (!vha->hw->flags.fw_started)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
sp = qla2x00_get_sp(vha, NULL, GFP_KERNEL);
|
|
|
|
if (!sp)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
sp->type = SRB_MB_IOCB;
|
|
|
|
sp->name = mb_to_str(mcp->mb[0]);
|
|
|
|
|
|
|
|
c = &sp->u.iocb_cmd;
|
|
|
|
c->timeout = qla2x00_async_iocb_timeout;
|
|
|
|
init_completion(&c->u.mbx.comp);
|
|
|
|
|
2018-03-20 15:36:14 -06:00
|
|
|
qla2x00_init_timer(sp, qla2x00_get_async_timeout(vha) + 2);
|
|
|
|
|
|
|
|
memcpy(sp->u.iocb_cmd.u.mbx.out_mb, mcp->mb, SIZEOF_IOCB_MB_REG);
|
|
|
|
|
2017-03-15 10:48:52 -06:00
|
|
|
sp->done = qla2x00_async_mb_sp_done;
|
|
|
|
|
|
|
|
rval = qla2x00_start_sp(sp);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1018,
|
2017-03-15 10:48:52 -06:00
|
|
|
"%s: %s Failed submission. %x.\n",
|
|
|
|
__func__, sp->name, rval);
|
|
|
|
goto done_free_sp;
|
|
|
|
}
|
|
|
|
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x113f, "MB:%s hndl %x submitted\n",
|
2017-03-15 10:48:52 -06:00
|
|
|
sp->name, sp->handle);
|
|
|
|
|
|
|
|
wait_for_completion(&c->u.mbx.comp);
|
|
|
|
memcpy(mcp->mb, sp->u.iocb_cmd.u.mbx.in_mb, SIZEOF_IOCB_MB_REG);
|
|
|
|
|
|
|
|
rval = c->u.mbx.rc;
|
|
|
|
switch (rval) {
|
|
|
|
case QLA_FUNCTION_TIMEOUT:
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1140, "%s: %s Timeout. %x.\n",
|
2017-03-15 10:48:52 -06:00
|
|
|
__func__, sp->name, rval);
|
|
|
|
break;
|
|
|
|
case QLA_SUCCESS:
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x119d, "%s: %s done.\n",
|
2017-03-15 10:48:52 -06:00
|
|
|
__func__, sp->name);
|
|
|
|
sp->free(sp);
|
|
|
|
break;
|
|
|
|
default:
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x119e, "%s: %s Failed. %x.\n",
|
2017-03-15 10:48:52 -06:00
|
|
|
__func__, sp->name, rval);
|
|
|
|
sp->free(sp);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
|
|
|
|
done_free_sp:
|
|
|
|
sp->free(sp);
|
|
|
|
done:
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla24xx_gpdb_wait
|
|
|
|
* NOTE: Do not call this routine from DPC thread
|
|
|
|
*/
|
|
|
|
int qla24xx_gpdb_wait(struct scsi_qla_host *vha, fc_port_t *fcport, u8 opt)
|
|
|
|
{
|
|
|
|
int rval = QLA_FUNCTION_FAILED;
|
|
|
|
dma_addr_t pd_dma;
|
|
|
|
struct port_database_24xx *pd;
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
|
|
|
|
if (!vha->hw->flags.fw_started)
|
|
|
|
goto done;
|
|
|
|
|
2017-09-21 00:15:26 -06:00
|
|
|
pd = dma_pool_zalloc(ha->s_dma_pool, GFP_KERNEL, &pd_dma);
|
2017-03-15 10:48:52 -06:00
|
|
|
if (pd == NULL) {
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_log(ql_log_warn, vha, 0xd047,
|
|
|
|
"Failed to allocate port database structure.\n");
|
2017-03-15 10:48:52 -06:00
|
|
|
goto done_free_sp;
|
|
|
|
}
|
|
|
|
|
|
|
|
memset(&mc, 0, sizeof(mc));
|
|
|
|
mc.mb[0] = MBC_GET_PORT_DATABASE;
|
|
|
|
mc.mb[1] = cpu_to_le16(fcport->loop_id);
|
|
|
|
mc.mb[2] = MSW(pd_dma);
|
|
|
|
mc.mb[3] = LSW(pd_dma);
|
|
|
|
mc.mb[6] = MSW(MSD(pd_dma));
|
|
|
|
mc.mb[7] = LSW(MSD(pd_dma));
|
|
|
|
mc.mb[9] = cpu_to_le16(vha->vp_idx);
|
|
|
|
mc.mb[10] = cpu_to_le16((uint16_t)opt);
|
|
|
|
|
|
|
|
rval = qla24xx_send_mb_cmd(vha, &mc);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1193,
|
2017-03-15 10:48:52 -06:00
|
|
|
"%s: %8phC fail\n", __func__, fcport->port_name);
|
|
|
|
goto done_free_sp;
|
|
|
|
}
|
|
|
|
|
|
|
|
rval = __qla24xx_parse_gpdb(vha, fcport, pd);
|
|
|
|
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1197, "%s: %8phC done\n",
|
2017-03-15 10:48:52 -06:00
|
|
|
__func__, fcport->port_name);
|
|
|
|
|
|
|
|
done_free_sp:
|
|
|
|
if (pd)
|
|
|
|
dma_pool_free(ha->s_dma_pool, pd, pd_dma);
|
|
|
|
done:
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int __qla24xx_parse_gpdb(struct scsi_qla_host *vha, fc_port_t *fcport,
|
|
|
|
struct port_database_24xx *pd)
|
|
|
|
{
|
|
|
|
int rval = QLA_SUCCESS;
|
|
|
|
uint64_t zero = 0;
|
2017-06-21 14:48:41 -06:00
|
|
|
u8 current_login_state, last_login_state;
|
|
|
|
|
|
|
|
if (fcport->fc4f_nvme) {
|
|
|
|
current_login_state = pd->current_login_state >> 4;
|
|
|
|
last_login_state = pd->last_login_state >> 4;
|
|
|
|
} else {
|
|
|
|
current_login_state = pd->current_login_state & 0xf;
|
|
|
|
last_login_state = pd->last_login_state & 0xf;
|
|
|
|
}
|
2017-03-15 10:48:52 -06:00
|
|
|
|
|
|
|
/* Check for logged in state. */
|
2017-12-04 15:45:08 -07:00
|
|
|
if (current_login_state != PDS_PRLI_COMPLETE) {
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x119a,
|
|
|
|
"Unable to verify login-state (%x/%x) for loop_id %x.\n",
|
2017-06-21 14:48:41 -06:00
|
|
|
current_login_state, last_login_state, fcport->loop_id);
|
2017-03-15 10:48:52 -06:00
|
|
|
rval = QLA_FUNCTION_FAILED;
|
|
|
|
goto gpd_error_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fcport->loop_id == FC_NO_LOOP_ID ||
|
|
|
|
(memcmp(fcport->port_name, (uint8_t *)&zero, 8) &&
|
|
|
|
memcmp(fcport->port_name, pd->port_name, 8))) {
|
|
|
|
/* We lost the device mid way. */
|
|
|
|
rval = QLA_NOT_LOGGED_IN;
|
|
|
|
goto gpd_error_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Names are little-endian. */
|
|
|
|
memcpy(fcport->node_name, pd->node_name, WWN_SIZE);
|
|
|
|
memcpy(fcport->port_name, pd->port_name, WWN_SIZE);
|
|
|
|
|
|
|
|
/* Get port_id of device. */
|
|
|
|
fcport->d_id.b.domain = pd->port_id[0];
|
|
|
|
fcport->d_id.b.area = pd->port_id[1];
|
|
|
|
fcport->d_id.b.al_pa = pd->port_id[2];
|
|
|
|
fcport->d_id.b.rsvd_1 = 0;
|
|
|
|
|
2017-06-21 14:48:41 -06:00
|
|
|
if (fcport->fc4f_nvme) {
|
|
|
|
fcport->nvme_prli_service_param =
|
|
|
|
pd->prli_nvme_svc_param_word_3;
|
|
|
|
fcport->port_type = FCT_NVME;
|
|
|
|
} else {
|
|
|
|
/* If not target must be initiator or unknown type. */
|
|
|
|
if ((pd->prli_svc_param_word_3[0] & BIT_4) == 0)
|
|
|
|
fcport->port_type = FCT_INITIATOR;
|
|
|
|
else
|
|
|
|
fcport->port_type = FCT_TARGET;
|
|
|
|
}
|
2017-03-15 10:48:52 -06:00
|
|
|
/* Passback COS information. */
|
|
|
|
fcport->supported_classes = (pd->flags & PDF_CLASS_2) ?
|
|
|
|
FC_COS_CLASS2 : FC_COS_CLASS3;
|
|
|
|
|
|
|
|
if (pd->prli_svc_param_word_3[0] & BIT_7) {
|
|
|
|
fcport->flags |= FCF_CONF_COMP_SUPPORTED;
|
|
|
|
fcport->conf_compl_supported = 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
gpd_error_out:
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* qla24xx_gidlist__wait
|
|
|
|
* NOTE: don't call this routine from DPC thread.
|
|
|
|
*/
|
|
|
|
int qla24xx_gidlist_wait(struct scsi_qla_host *vha,
|
|
|
|
void *id_list, dma_addr_t id_list_dma, uint16_t *entries)
|
|
|
|
{
|
|
|
|
int rval = QLA_FUNCTION_FAILED;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
|
|
|
|
if (!vha->hw->flags.fw_started)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
memset(&mc, 0, sizeof(mc));
|
|
|
|
mc.mb[0] = MBC_GET_ID_LIST;
|
|
|
|
mc.mb[2] = MSW(id_list_dma);
|
|
|
|
mc.mb[3] = LSW(id_list_dma);
|
|
|
|
mc.mb[6] = MSW(MSD(id_list_dma));
|
|
|
|
mc.mb[7] = LSW(MSD(id_list_dma));
|
|
|
|
mc.mb[8] = 0;
|
|
|
|
mc.mb[9] = cpu_to_le16(vha->vp_idx);
|
|
|
|
|
|
|
|
rval = qla24xx_send_mb_cmd(vha, &mc);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x119b,
|
|
|
|
"%s: fail\n", __func__);
|
2017-03-15 10:48:52 -06:00
|
|
|
} else {
|
|
|
|
*entries = mc.mb[1];
|
2017-06-02 10:12:01 -06:00
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x119c,
|
|
|
|
"%s: done\n", __func__);
|
2017-03-15 10:48:52 -06:00
|
|
|
}
|
|
|
|
done:
|
|
|
|
return rval;
|
|
|
|
}
|
2017-07-21 10:32:25 -06:00
|
|
|
|
|
|
|
int qla27xx_set_zio_threshold(scsi_qla_host_t *vha, uint16_t value)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1200,
|
|
|
|
"Entered %s\n", __func__);
|
|
|
|
|
|
|
|
memset(mcp->mb, 0 , sizeof(mcp->mb));
|
|
|
|
mcp->mb[0] = MBC_GET_SET_ZIO_THRESHOLD;
|
|
|
|
mcp->mb[1] = cpu_to_le16(1);
|
|
|
|
mcp->mb[2] = cpu_to_le16(value);
|
|
|
|
mcp->out_mb = MBX_2 | MBX_1 | MBX_0;
|
|
|
|
mcp->in_mb = MBX_2 | MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1201, "%s %x\n",
|
|
|
|
(rval != QLA_SUCCESS) ? "Failed" : "Done", rval);
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
int qla27xx_get_zio_threshold(scsi_qla_host_t *vha, uint16_t *value)
|
|
|
|
{
|
|
|
|
int rval;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
mbx_cmd_t *mcp = &mc;
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx + ql_dbg_verbose, vha, 0x1203,
|
|
|
|
"Entered %s\n", __func__);
|
|
|
|
|
|
|
|
memset(mcp->mb, 0, sizeof(mcp->mb));
|
|
|
|
mcp->mb[0] = MBC_GET_SET_ZIO_THRESHOLD;
|
|
|
|
mcp->mb[1] = cpu_to_le16(0);
|
|
|
|
mcp->out_mb = MBX_1 | MBX_0;
|
|
|
|
mcp->in_mb = MBX_2 | MBX_0;
|
|
|
|
mcp->tov = MBX_TOV_SECONDS;
|
|
|
|
mcp->flags = 0;
|
|
|
|
|
|
|
|
rval = qla2x00_mailbox_command(vha, mcp);
|
|
|
|
if (rval == QLA_SUCCESS)
|
|
|
|
*value = mc.mb[2];
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0x1205, "%s %x\n",
|
|
|
|
(rval != QLA_SUCCESS) ? "Failed" : "Done", rval);
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2017-08-23 16:05:07 -06:00
|
|
|
|
|
|
|
int
|
|
|
|
qla2x00_read_sfp_dev(struct scsi_qla_host *vha, char *buf, int count)
|
|
|
|
{
|
|
|
|
struct qla_hw_data *ha = vha->hw;
|
|
|
|
uint16_t iter, addr, offset;
|
|
|
|
dma_addr_t phys_addr;
|
|
|
|
int rval, c;
|
|
|
|
u8 *sfp_data;
|
|
|
|
|
|
|
|
memset(ha->sfp_data, 0, SFP_DEV_SIZE);
|
|
|
|
addr = 0xa0;
|
|
|
|
phys_addr = ha->sfp_data_dma;
|
|
|
|
sfp_data = ha->sfp_data;
|
|
|
|
offset = c = 0;
|
|
|
|
|
|
|
|
for (iter = 0; iter < SFP_DEV_SIZE / SFP_BLOCK_SIZE; iter++) {
|
|
|
|
if (iter == 4) {
|
|
|
|
/* Skip to next device address. */
|
|
|
|
addr = 0xa2;
|
|
|
|
offset = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
rval = qla2x00_read_sfp(vha, phys_addr, sfp_data,
|
|
|
|
addr, offset, SFP_BLOCK_SIZE, BIT_1);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_log(ql_log_warn, vha, 0x706d,
|
|
|
|
"Unable to read SFP data (%x/%x/%x).\n", rval,
|
|
|
|
addr, offset);
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (buf && (c < count)) {
|
|
|
|
u16 sz;
|
|
|
|
|
|
|
|
if ((count - c) >= SFP_BLOCK_SIZE)
|
|
|
|
sz = SFP_BLOCK_SIZE;
|
|
|
|
else
|
|
|
|
sz = count - c;
|
|
|
|
|
|
|
|
memcpy(buf, sfp_data, sz);
|
|
|
|
buf += SFP_BLOCK_SIZE;
|
|
|
|
c += sz;
|
|
|
|
}
|
|
|
|
phys_addr += SFP_BLOCK_SIZE;
|
|
|
|
sfp_data += SFP_BLOCK_SIZE;
|
|
|
|
offset += SFP_BLOCK_SIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return rval;
|
|
|
|
}
|
2017-12-28 13:33:23 -07:00
|
|
|
|
|
|
|
int qla24xx_res_count_wait(struct scsi_qla_host *vha,
|
|
|
|
uint16_t *out_mb, int out_mb_sz)
|
|
|
|
{
|
|
|
|
int rval = QLA_FUNCTION_FAILED;
|
|
|
|
mbx_cmd_t mc;
|
|
|
|
|
|
|
|
if (!vha->hw->flags.fw_started)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
memset(&mc, 0, sizeof(mc));
|
|
|
|
mc.mb[0] = MBC_GET_RESOURCE_COUNTS;
|
|
|
|
|
|
|
|
rval = qla24xx_send_mb_cmd(vha, &mc);
|
|
|
|
if (rval != QLA_SUCCESS) {
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0xffff,
|
|
|
|
"%s: fail\n", __func__);
|
|
|
|
} else {
|
|
|
|
if (out_mb_sz <= SIZEOF_IOCB_MB_REG)
|
|
|
|
memcpy(out_mb, mc.mb, out_mb_sz);
|
|
|
|
else
|
|
|
|
memcpy(out_mb, mc.mb, SIZEOF_IOCB_MB_REG);
|
|
|
|
|
|
|
|
ql_dbg(ql_dbg_mbx, vha, 0xffff,
|
|
|
|
"%s: done\n", __func__);
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
return rval;
|
|
|
|
}
|