Deleted Added
sdiff udiff text old ( 238486 ) new ( 238869 )
full compact
isp.c (238486) isp.c (238869)
1/*-
2 * Copyright (c) 1997-2009 by Matthew Jacob
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *

--- 33 unchanged lines hidden (view full) ---

42 */
43#ifdef __NetBSD__
44#include <sys/cdefs.h>
45__KERNEL_RCSID(0, "$NetBSD$");
46#include <dev/ic/isp_netbsd.h>
47#endif
48#ifdef __FreeBSD__
49#include <sys/cdefs.h>
1/*-
2 * Copyright (c) 1997-2009 by Matthew Jacob
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *

--- 33 unchanged lines hidden (view full) ---

42 */
43#ifdef __NetBSD__
44#include <sys/cdefs.h>
45__KERNEL_RCSID(0, "$NetBSD$");
46#include <dev/ic/isp_netbsd.h>
47#endif
48#ifdef __FreeBSD__
49#include <sys/cdefs.h>
50__FBSDID("$FreeBSD: head/sys/dev/isp/isp.c 238486 2012-07-15 14:40:49Z brueffer $");
50__FBSDID("$FreeBSD: head/sys/dev/isp/isp.c 238869 2012-07-28 20:06:29Z mjacob $");
51#include <dev/isp/isp_freebsd.h>
52#endif
53#ifdef __OpenBSD__
54#include <dev/ic/isp_openbsd.h>
55#endif
56#ifdef __linux__
57#include "isp_linux.h"
58#endif
59#ifdef __svr4__
60#include "isp_solaris.h"
61#endif
62
63/*
64 * General defines
65 */
66#define MBOX_DELAY_COUNT 1000000 / 100
67#define ISP_MARK_PORTDB(a, b, c) \
51#include <dev/isp/isp_freebsd.h>
52#endif
53#ifdef __OpenBSD__
54#include <dev/ic/isp_openbsd.h>
55#endif
56#ifdef __linux__
57#include "isp_linux.h"
58#endif
59#ifdef __svr4__
60#include "isp_solaris.h"
61#endif
62
63/*
64 * General defines
65 */
66#define MBOX_DELAY_COUNT 1000000 / 100
67#define ISP_MARK_PORTDB(a, b, c) \
68 isp_prt(isp, ISP_LOGSANCFG, \
68 isp_prt(isp, ISP_LOG_SANCFG, \
69 "Chan %d ISP_MARK_PORTDB@LINE %d", b, __LINE__); \
70 isp_mark_portdb(a, b, c)
71
72/*
73 * Local static data
74 */
75static const char fconf[] = "Chan %d PortDB[%d] changed:\n current =(0x%x@0x%06x 0x%08x%08x 0x%08x%08x)\n database=(0x%x@0x%06x 0x%08x%08x 0x%08x%08x)";
76static const char notresp[] = "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d) nlooked %d";

--- 588 unchanged lines hidden (view full) ---

665 if (IS_2312(isp) && isp->isp_revision < 2) {
666 ISP_DELAY(100);
667 } else {
668 loops = MBOX_DELAY_COUNT;
669 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
670 ISP_DELAY(100);
671 if (--loops < 0) {
672 ISP_RESET0(isp);
69 "Chan %d ISP_MARK_PORTDB@LINE %d", b, __LINE__); \
70 isp_mark_portdb(a, b, c)
71
72/*
73 * Local static data
74 */
75static const char fconf[] = "Chan %d PortDB[%d] changed:\n current =(0x%x@0x%06x 0x%08x%08x 0x%08x%08x)\n database=(0x%x@0x%06x 0x%08x%08x 0x%08x%08x)";
76static const char notresp[] = "Not RESPONSE in RESPONSE Queue (type 0x%x) @ idx %d (next %d) nlooked %d";

--- 588 unchanged lines hidden (view full) ---

665 if (IS_2312(isp) && isp->isp_revision < 2) {
666 ISP_DELAY(100);
667 } else {
668 loops = MBOX_DELAY_COUNT;
669 while (ISP_READ(isp, OUTMAILBOX0) == MBOX_BUSY) {
670 ISP_DELAY(100);
671 if (--loops < 0) {
672 ISP_RESET0(isp);
673 isp_prt(isp, ISP_LOGERR,
674 "MBOX_BUSY never cleared on reset");
673 isp_prt(isp, ISP_LOGERR, "MBOX_BUSY never cleared on reset");
675 return;
676 }
677 }
678 }
679
680 /*
681 * Up until this point we've done everything by just reading or
682 * setting registers. From this point on we rely on at least *some*

--- 1027 unchanged lines hidden (view full) ---

1710 *
1711 * NB: for the 2300, ICBOPT_EXTENDED is required.
1712 */
1713 if (IS_2200(isp) || IS_23XX(isp)) {
1714 icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1715
1716 icbp->icb_xfwoptions = fcp->isp_xfwoptions;
1717
674 return;
675 }
676 }
677 }
678
679 /*
680 * Up until this point we've done everything by just reading or
681 * setting registers. From this point on we rely on at least *some*

--- 1027 unchanged lines hidden (view full) ---

1709 *
1710 * NB: for the 2300, ICBOPT_EXTENDED is required.
1711 */
1712 if (IS_2200(isp) || IS_23XX(isp)) {
1713 icbp->icb_fwoptions |= ICBOPT_EXTENDED;
1714
1715 icbp->icb_xfwoptions = fcp->isp_xfwoptions;
1716
1717 if (ISP_CAP_FCTAPE(isp)) {
1718 if (isp->isp_confopts & ISP_CFG_NOFCTAPE)
1719 icbp->icb_xfwoptions &= ~ICBXOPT_FCTAPE;
1720
1721 if (isp->isp_confopts & ISP_CFG_FCTAPE)
1722 icbp->icb_xfwoptions |= ICBXOPT_FCTAPE;
1723
1724 if (icbp->icb_xfwoptions & ICBXOPT_FCTAPE) {
1725 icbp->icb_fwoptions &= ~ICBOPT_FULL_LOGIN; /* per documents */
1726 icbp->icb_xfwoptions |= ICBXOPT_FCTAPE_CCQ|ICBXOPT_FCTAPE_CONFIRM;
1727 FCPARAM(isp, 0)->fctape_enabled = 1;
1728 } else {
1729 FCPARAM(isp, 0)->fctape_enabled = 0;
1730 }
1731 } else {
1732 icbp->icb_xfwoptions &= ~ICBXOPT_FCTAPE;
1733 FCPARAM(isp, 0)->fctape_enabled = 0;
1734 }
1735
1718 /*
1719 * Prefer or force Point-To-Point instead Loop?
1720 */
1721 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
1722 case ISP_CFG_NPORT:
1723 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1724 icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
1725 break;

--- 73 unchanged lines hidden (view full) ---

1799 if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1800 MBSINIT(&mbs, MBOX_SET_FIRMWARE_OPTIONS, MBLOGALL, 0);
1801 mbs.param[1] = IFCOPT1_DISF7SWTCH|IFCOPT1_LIPASYNC|IFCOPT1_LIPF8;
1802 mbs.param[2] = 0;
1803 mbs.param[3] = 0;
1804 if (ISP_FW_NEWER_THAN(isp, 3, 16, 0)) {
1805 mbs.param[1] |= IFCOPT1_EQFQASYNC|IFCOPT1_CTIO_RETRY;
1806 if (fcp->role & ISP_ROLE_TARGET) {
1736 /*
1737 * Prefer or force Point-To-Point instead Loop?
1738 */
1739 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
1740 case ISP_CFG_NPORT:
1741 icbp->icb_xfwoptions &= ~ICBXOPT_TOPO_MASK;
1742 icbp->icb_xfwoptions |= ICBXOPT_PTP_2_LOOP;
1743 break;

--- 73 unchanged lines hidden (view full) ---

1817 if (ISP_FW_NEWER_THAN(isp, 2, 26, 0)) {
1818 MBSINIT(&mbs, MBOX_SET_FIRMWARE_OPTIONS, MBLOGALL, 0);
1819 mbs.param[1] = IFCOPT1_DISF7SWTCH|IFCOPT1_LIPASYNC|IFCOPT1_LIPF8;
1820 mbs.param[2] = 0;
1821 mbs.param[3] = 0;
1822 if (ISP_FW_NEWER_THAN(isp, 3, 16, 0)) {
1823 mbs.param[1] |= IFCOPT1_EQFQASYNC|IFCOPT1_CTIO_RETRY;
1824 if (fcp->role & ISP_ROLE_TARGET) {
1825 if (ISP_FW_NEWER_THAN(isp, 3, 25, 0)) {
1826 mbs.param[1] |= IFCOPT1_ENAPURE;
1827 }
1807 mbs.param[3] = IFCOPT3_NOPRLI;
1808 }
1809 }
1810 isp_mboxcmd(isp, &mbs);
1811 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1812 return;
1813 }
1814 }
1815 icbp->icb_logintime = ICB_LOGIN_TOV;
1828 mbs.param[3] = IFCOPT3_NOPRLI;
1829 }
1830 }
1831 isp_mboxcmd(isp, &mbs);
1832 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
1833 return;
1834 }
1835 }
1836 icbp->icb_logintime = ICB_LOGIN_TOV;
1816 icbp->icb_lunetimeout = ICB_LUN_ENABLE_TOV;
1817
1837
1838#ifdef ISP_TARGET_MODE
1839 if (ISP_FW_NEWER_THAN(isp, 3, 25, 0) && (icbp->icb_fwoptions & ICBOPT_TGT_ENABLE)) {
1840 icbp->icb_lunenables = 0xffff;
1841 icbp->icb_ccnt = DFLT_CMND_CNT;
1842 icbp->icb_icnt = DFLT_INOT_CNT;
1843 icbp->icb_lunetimeout = ICB_LUN_ENABLE_TOV;
1844 }
1845#endif
1818 if (fcp->isp_wwnn && fcp->isp_wwpn && (fcp->isp_wwnn >> 60) != 2) {
1819 icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
1820 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwnn);
1821 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
1822 isp_prt(isp, ISP_LOGDEBUG1,
1823 "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1824 ((uint32_t) (fcp->isp_wwnn >> 32)),
1825 ((uint32_t) (fcp->isp_wwnn)),

--- 79 unchanged lines hidden (view full) ---

1905 */
1906 for (chan = 0; chan < isp->isp_nchan; chan++) {
1907 fcp = FCPARAM(isp, chan);
1908 if (fcp->role != ISP_ROLE_NONE) {
1909 break;
1910 }
1911 }
1912 if (chan == isp->isp_nchan) {
1846 if (fcp->isp_wwnn && fcp->isp_wwpn && (fcp->isp_wwnn >> 60) != 2) {
1847 icbp->icb_fwoptions |= ICBOPT_BOTH_WWNS;
1848 MAKE_NODE_NAME_FROM_WWN(icbp->icb_nodename, fcp->isp_wwnn);
1849 MAKE_NODE_NAME_FROM_WWN(icbp->icb_portname, fcp->isp_wwpn);
1850 isp_prt(isp, ISP_LOGDEBUG1,
1851 "Setting ICB Node 0x%08x%08x Port 0x%08x%08x",
1852 ((uint32_t) (fcp->isp_wwnn >> 32)),
1853 ((uint32_t) (fcp->isp_wwnn)),

--- 79 unchanged lines hidden (view full) ---

1933 */
1934 for (chan = 0; chan < isp->isp_nchan; chan++) {
1935 fcp = FCPARAM(isp, chan);
1936 if (fcp->role != ISP_ROLE_NONE) {
1937 break;
1938 }
1939 }
1940 if (chan == isp->isp_nchan) {
1913 isp_prt(isp, ISP_LOGDEBUG0, "all %d channels with role 'none'", chan);
1941 isp_prt(isp, ISP_LOG_WARN1, "all %d channels with role 'none'", chan);
1914 isp->isp_state = ISP_INITSTATE;
1915 return;
1916 }
1917
1918 /*
1919 * Start with channel 0.
1920 */
1921 fcp = FCPARAM(isp, 0);

--- 51 unchanged lines hidden (view full) ---

1973 icbp->icb_hardaddr = 0;
1974 ownloopid = 0;
1975 }
1976
1977 if (ownloopid)
1978 icbp->icb_fwoptions1 |= ICB2400_OPT1_HARD_ADDRESS;
1979
1980 icbp->icb_fwoptions2 = fcp->isp_xfwoptions;
1942 isp->isp_state = ISP_INITSTATE;
1943 return;
1944 }
1945
1946 /*
1947 * Start with channel 0.
1948 */
1949 fcp = FCPARAM(isp, 0);

--- 51 unchanged lines hidden (view full) ---

2001 icbp->icb_hardaddr = 0;
2002 ownloopid = 0;
2003 }
2004
2005 if (ownloopid)
2006 icbp->icb_fwoptions1 |= ICB2400_OPT1_HARD_ADDRESS;
2007
2008 icbp->icb_fwoptions2 = fcp->isp_xfwoptions;
2009 if (isp->isp_confopts & ISP_CFG_NOFCTAPE) {
2010 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_FCTAPE;
2011 }
2012 if (isp->isp_confopts & ISP_CFG_FCTAPE) {
2013 icbp->icb_fwoptions2 |= ICB2400_OPT2_FCTAPE;
2014 }
2015
2016 if (icbp->icb_fwoptions2 & ICB2400_OPT2_FCTAPE) {
2017 FCPARAM(isp, chan)->fctape_enabled = 1;
2018 } else {
2019 FCPARAM(isp, chan)->fctape_enabled = 0;
2020 }
2021
1981 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
1982 case ISP_CFG_NPORT_ONLY:
1983 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1984 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_ONLY;
1985 break;
1986 case ISP_CFG_LPORT_ONLY:
1987 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
1988 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_ONLY;

--- 342 unchanged lines hidden (view full) ---

2331 case PLOGX_IOCBERR_NOPCB:
2332 msg = "no PCB allocated";
2333 break;
2334 case PLOGX_IOCBERR_EINVAL:
2335 ISP_SNPRINTF(buf, sizeof (buf), "invalid parameter at offset 0x%x", parm1);
2336 msg = buf;
2337 break;
2338 case PLOGX_IOCBERR_PORTUSED:
2022 switch (isp->isp_confopts & ISP_CFG_PORT_PREF) {
2023 case ISP_CFG_NPORT_ONLY:
2024 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2025 icbp->icb_fwoptions2 |= ICB2400_OPT2_PTP_ONLY;
2026 break;
2027 case ISP_CFG_LPORT_ONLY:
2028 icbp->icb_fwoptions2 &= ~ICB2400_OPT2_TOPO_MASK;
2029 icbp->icb_fwoptions2 |= ICB2400_OPT2_LOOP_ONLY;

--- 342 unchanged lines hidden (view full) ---

2372 case PLOGX_IOCBERR_NOPCB:
2373 msg = "no PCB allocated";
2374 break;
2375 case PLOGX_IOCBERR_EINVAL:
2376 ISP_SNPRINTF(buf, sizeof (buf), "invalid parameter at offset 0x%x", parm1);
2377 msg = buf;
2378 break;
2379 case PLOGX_IOCBERR_PORTUSED:
2339 lev = ISP_LOGSANCFG|ISP_LOGDEBUG0;
2380 lev = ISP_LOG_SANCFG|ISP_LOG_WARN1;
2340 ISP_SNPRINTF(buf, sizeof (buf), "already logged in with N-Port handle 0x%x", parm1);
2341 msg = buf;
2342 rval = MBOX_PORT_ID_USED | (parm1 << 16);
2343 break;
2344 case PLOGX_IOCBERR_HNDLUSED:
2381 ISP_SNPRINTF(buf, sizeof (buf), "already logged in with N-Port handle 0x%x", parm1);
2382 msg = buf;
2383 rval = MBOX_PORT_ID_USED | (parm1 << 16);
2384 break;
2385 case PLOGX_IOCBERR_HNDLUSED:
2345 lev = ISP_LOGSANCFG|ISP_LOGDEBUG0;
2386 lev = ISP_LOG_SANCFG|ISP_LOG_WARN1;
2346 ISP_SNPRINTF(buf, sizeof (buf), "handle already used for PortID 0x%06x", parm1);
2347 msg = buf;
2348 rval = MBOX_LOOP_ID_USED;
2349 break;
2350 case PLOGX_IOCBERR_NOHANDLE:
2351 msg = "no handle allocated";
2352 break;
2353 case PLOGX_IOCBERR_NOFLOGI:

--- 29 unchanged lines hidden (view full) ---

2383 mbs.param[2] = portid >> 16;
2384 mbs.param[3] = portid;
2385 mbs.logval = MBLOGNONE;
2386 mbs.timeout = 500000;
2387 isp_mboxcmd(isp, &mbs);
2388
2389 switch (mbs.param[0]) {
2390 case MBOX_PORT_ID_USED:
2387 ISP_SNPRINTF(buf, sizeof (buf), "handle already used for PortID 0x%06x", parm1);
2388 msg = buf;
2389 rval = MBOX_LOOP_ID_USED;
2390 break;
2391 case PLOGX_IOCBERR_NOHANDLE:
2392 msg = "no handle allocated";
2393 break;
2394 case PLOGX_IOCBERR_NOFLOGI:

--- 29 unchanged lines hidden (view full) ---

2424 mbs.param[2] = portid >> 16;
2425 mbs.param[3] = portid;
2426 mbs.logval = MBLOGNONE;
2427 mbs.timeout = 500000;
2428 isp_mboxcmd(isp, &mbs);
2429
2430 switch (mbs.param[0]) {
2431 case MBOX_PORT_ID_USED:
2391 isp_prt(isp, ISP_LOGDEBUG0,
2392 "isp_port_login: portid 0x%06x already logged in as %u",
2393 portid, mbs.param[1]);
2432 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: portid 0x%06x already logged in as %u", portid, mbs.param[1]);
2394 return (MBOX_PORT_ID_USED | (mbs.param[1] << 16));
2395
2396 case MBOX_LOOP_ID_USED:
2433 return (MBOX_PORT_ID_USED | (mbs.param[1] << 16));
2434
2435 case MBOX_LOOP_ID_USED:
2397 isp_prt(isp, ISP_LOGDEBUG0,
2398 "isp_port_login: handle 0x%04x in use for port id 0x%02xXXXX",
2399 handle, mbs.param[1] & 0xff);
2436 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: handle 0x%04x in use for port id 0x%02xXXXX", handle, mbs.param[1] & 0xff);
2400 return (MBOX_LOOP_ID_USED);
2401
2402 case MBOX_COMMAND_COMPLETE:
2403 return (0);
2404
2405 case MBOX_COMMAND_ERROR:
2437 return (MBOX_LOOP_ID_USED);
2438
2439 case MBOX_COMMAND_COMPLETE:
2440 return (0);
2441
2442 case MBOX_COMMAND_ERROR:
2406 isp_prt(isp, ISP_LOGINFO,
2407 "isp_port_login: error 0x%x in PLOGI to port 0x%06x",
2408 mbs.param[1], portid);
2443 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: error 0x%x in PLOGI to port 0x%06x", mbs.param[1], portid);
2409 return (MBOX_COMMAND_ERROR);
2410
2411 case MBOX_ALL_IDS_USED:
2444 return (MBOX_COMMAND_ERROR);
2445
2446 case MBOX_ALL_IDS_USED:
2412 isp_prt(isp, ISP_LOGINFO,
2413 "isp_port_login: all IDs used for fabric login");
2447 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "isp_port_login: all IDs used for fabric login");
2414 return (MBOX_ALL_IDS_USED);
2415
2416 default:
2448 return (MBOX_ALL_IDS_USED);
2449
2450 default:
2417 isp_prt(isp, ISP_LOGINFO,
2418 "isp_port_login: error 0x%x on port login of 0x%06x@0x%0x",
2419 mbs.param[0], portid, handle);
2451 isp_prt(isp, ISP_LOG_SANCFG, "isp_port_login: error 0x%x on port login of 0x%06x@0x%0x", mbs.param[0], portid, handle);
2420 return (mbs.param[0]);
2421 }
2422}
2423
2424/*
2425 * Pre-24XX fabric port logout
2426 *
2427 * Note that portid is not used

--- 50 unchanged lines hidden (view full) ---

2478 if (dolock) {
2479 FC_SCRATCH_RELEASE(isp, chan);
2480 }
2481 return (mbs.param[0]);
2482 }
2483 if (IS_24XX(isp)) {
2484 isp_get_pdb_24xx(isp, fcp->isp_scratch, &un.bill);
2485 pdb->handle = un.bill.pdb_handle;
2452 return (mbs.param[0]);
2453 }
2454}
2455
2456/*
2457 * Pre-24XX fabric port logout
2458 *
2459 * Note that portid is not used

--- 50 unchanged lines hidden (view full) ---

2510 if (dolock) {
2511 FC_SCRATCH_RELEASE(isp, chan);
2512 }
2513 return (mbs.param[0]);
2514 }
2515 if (IS_24XX(isp)) {
2516 isp_get_pdb_24xx(isp, fcp->isp_scratch, &un.bill);
2517 pdb->handle = un.bill.pdb_handle;
2486 pdb->s3_role = un.bill.pdb_prli_svc3;
2518 pdb->prli_word3 = un.bill.pdb_prli_svc3;
2487 pdb->portid = BITS2WORD_24XX(un.bill.pdb_portid_bits);
2488 ISP_MEMCPY(pdb->portname, un.bill.pdb_portname, 8);
2489 ISP_MEMCPY(pdb->nodename, un.bill.pdb_nodename, 8);
2519 pdb->portid = BITS2WORD_24XX(un.bill.pdb_portid_bits);
2520 ISP_MEMCPY(pdb->portname, un.bill.pdb_portname, 8);
2521 ISP_MEMCPY(pdb->nodename, un.bill.pdb_nodename, 8);
2490 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
2491 "Chan %d Port 0x%06x flags 0x%x curstate %x",
2492 chan, pdb->portid, un.bill.pdb_flags,
2493 un.bill.pdb_curstate);
2494 if (un.bill.pdb_curstate < PDB2400_STATE_PLOGI_DONE ||
2495 un.bill.pdb_curstate > PDB2400_STATE_LOGGED_IN) {
2522 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Port 0x%06x flags 0x%x curstate %x", chan, pdb->portid, un.bill.pdb_flags, un.bill.pdb_curstate);
2523 if (un.bill.pdb_curstate < PDB2400_STATE_PLOGI_DONE || un.bill.pdb_curstate > PDB2400_STATE_LOGGED_IN) {
2496 mbs.param[0] = MBOX_NOT_LOGGED_IN;
2497 if (dolock) {
2498 FC_SCRATCH_RELEASE(isp, chan);
2499 }
2500 return (mbs.param[0]);
2501 }
2502 } else {
2503 isp_get_pdb_21xx(isp, fcp->isp_scratch, &un.fred);
2504 pdb->handle = un.fred.pdb_loopid;
2524 mbs.param[0] = MBOX_NOT_LOGGED_IN;
2525 if (dolock) {
2526 FC_SCRATCH_RELEASE(isp, chan);
2527 }
2528 return (mbs.param[0]);
2529 }
2530 } else {
2531 isp_get_pdb_21xx(isp, fcp->isp_scratch, &un.fred);
2532 pdb->handle = un.fred.pdb_loopid;
2505 pdb->s3_role = un.fred.pdb_prli_svc3;
2533 pdb->prli_word3 = un.fred.pdb_prli_svc3;
2506 pdb->portid = BITS2WORD(un.fred.pdb_portid_bits);
2507 ISP_MEMCPY(pdb->portname, un.fred.pdb_portname, 8);
2508 ISP_MEMCPY(pdb->nodename, un.fred.pdb_nodename, 8);
2509 }
2510 if (dolock) {
2511 FC_SCRATCH_RELEASE(isp, chan);
2512 }
2513 return (0);

--- 9 unchanged lines hidden (view full) ---

2523 lim = NPH_MAX_2K;
2524 } else {
2525 lim = NPH_MAX;
2526 }
2527 for (loopid = 0; loopid != lim; loopid++) {
2528 if (isp_getpdb(isp, chan, loopid, &pdb, dolock)) {
2529 continue;
2530 }
2534 pdb->portid = BITS2WORD(un.fred.pdb_portid_bits);
2535 ISP_MEMCPY(pdb->portname, un.fred.pdb_portname, 8);
2536 ISP_MEMCPY(pdb->nodename, un.fred.pdb_nodename, 8);
2537 }
2538 if (dolock) {
2539 FC_SCRATCH_RELEASE(isp, chan);
2540 }
2541 return (0);

--- 9 unchanged lines hidden (view full) ---

2551 lim = NPH_MAX_2K;
2552 } else {
2553 lim = NPH_MAX;
2554 }
2555 for (loopid = 0; loopid != lim; loopid++) {
2556 if (isp_getpdb(isp, chan, loopid, &pdb, dolock)) {
2557 continue;
2558 }
2531 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGINFO, "Chan %d Loopid 0x%04x "
2559 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGINFO, "Chan %d Loopid 0x%04x "
2532 "PortID 0x%06x WWPN 0x%02x%02x%02x%02x%02x%02x%02x%02x",
2533 chan, loopid, pdb.portid, pdb.portname[0], pdb.portname[1],
2534 pdb.portname[2], pdb.portname[3], pdb.portname[4],
2535 pdb.portname[5], pdb.portname[6], pdb.portname[7]);
2536 }
2537}
2538
2539static uint64_t

--- 61 unchanged lines hidden (view full) ---

2601 uint8_t lwfs;
2602 int loopid;
2603 fcparam *fcp;
2604 fcportdb_t *lp;
2605 isp_pdb_t pdb;
2606
2607 fcp = FCPARAM(isp, chan);
2608
2560 "PortID 0x%06x WWPN 0x%02x%02x%02x%02x%02x%02x%02x%02x",
2561 chan, loopid, pdb.portid, pdb.portname[0], pdb.portname[1],
2562 pdb.portname[2], pdb.portname[3], pdb.portname[4],
2563 pdb.portname[5], pdb.portname[6], pdb.portname[7]);
2564 }
2565}
2566
2567static uint64_t

--- 61 unchanged lines hidden (view full) ---

2629 uint8_t lwfs;
2630 int loopid;
2631 fcparam *fcp;
2632 fcportdb_t *lp;
2633 isp_pdb_t pdb;
2634
2635 fcp = FCPARAM(isp, chan);
2636
2609 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Chan %d FC Link Test Entry", chan);
2637 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC Link Test Entry", chan);
2610 ISP_MARK_PORTDB(isp, chan, 1);
2611
2612 /*
2613 * Wait up to N microseconds for F/W to go to a ready state.
2614 */
2615 lwfs = FW_CONFIG_WAIT;
2616 count = 0;
2617 while (count < usdelay) {
2618 uint64_t enano;
2619 uint32_t wrk;
2620 NANOTIME_T hra, hrb;
2621
2622 GET_NANOTIME(&hra);
2623 isp_fw_state(isp, chan);
2624 if (lwfs != fcp->isp_fwstate) {
2638 ISP_MARK_PORTDB(isp, chan, 1);
2639
2640 /*
2641 * Wait up to N microseconds for F/W to go to a ready state.
2642 */
2643 lwfs = FW_CONFIG_WAIT;
2644 count = 0;
2645 while (count < usdelay) {
2646 uint64_t enano;
2647 uint32_t wrk;
2648 NANOTIME_T hra, hrb;
2649
2650 GET_NANOTIME(&hra);
2651 isp_fw_state(isp, chan);
2652 if (lwfs != fcp->isp_fwstate) {
2625 isp_prt(isp, ISP_LOGCONFIG|ISP_LOGSANCFG, "Chan %d Firmware State <%s->%s>", chan, isp_fc_fw_statename((int)lwfs), isp_fc_fw_statename((int)fcp->isp_fwstate));
2653 isp_prt(isp, ISP_LOGCONFIG|ISP_LOG_SANCFG, "Chan %d Firmware State <%s->%s>", chan, isp_fc_fw_statename((int)lwfs), isp_fc_fw_statename((int)fcp->isp_fwstate));
2626 lwfs = fcp->isp_fwstate;
2627 }
2628 if (fcp->isp_fwstate == FW_READY) {
2629 break;
2630 }
2631 GET_NANOTIME(&hrb);
2632
2633 /*

--- 34 unchanged lines hidden (view full) ---

2668 }
2669
2670
2671
2672 /*
2673 * If we haven't gone to 'ready' state, return.
2674 */
2675 if (fcp->isp_fwstate != FW_READY) {
2654 lwfs = fcp->isp_fwstate;
2655 }
2656 if (fcp->isp_fwstate == FW_READY) {
2657 break;
2658 }
2659 GET_NANOTIME(&hrb);
2660
2661 /*

--- 34 unchanged lines hidden (view full) ---

2696 }
2697
2698
2699
2700 /*
2701 * If we haven't gone to 'ready' state, return.
2702 */
2703 if (fcp->isp_fwstate != FW_READY) {
2676 isp_prt(isp, ISP_LOGSANCFG, "%s: chan %d not at FW_READY state", __func__, chan);
2704 isp_prt(isp, ISP_LOG_SANCFG, "%s: chan %d not at FW_READY state", __func__, chan);
2677 return (-1);
2678 }
2679
2680 /*
2681 * Get our Loop ID and Port ID.
2682 */
2683 MBSINIT(&mbs, MBOX_GET_LOOP_ID, MBLOGALL, 0);
2684 mbs.param[9] = chan;

--- 48 unchanged lines hidden (view full) ---

2733 } else {
2734 int i;
2735 for (i = 0; alpa_map[i]; i++) {
2736 if (alpa_map[i] == alpa) {
2737 break;
2738 }
2739 }
2740 if (alpa_map[i] && fcp->isp_loopid != i) {
2705 return (-1);
2706 }
2707
2708 /*
2709 * Get our Loop ID and Port ID.
2710 */
2711 MBSINIT(&mbs, MBOX_GET_LOOP_ID, MBLOGALL, 0);
2712 mbs.param[9] = chan;

--- 48 unchanged lines hidden (view full) ---

2761 } else {
2762 int i;
2763 for (i = 0; alpa_map[i]; i++) {
2764 if (alpa_map[i] == alpa) {
2765 break;
2766 }
2767 }
2768 if (alpa_map[i] && fcp->isp_loopid != i) {
2741 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Chan %d deriving loopid %d from AL_PA map (AL_PA 0x%x) and ignoring returned value %d (AL_PA 0x%x)", chan, i, alpa_map[i], fcp->isp_loopid, alpa);
2769 isp_prt(isp, ISP_LOG_SANCFG,
2770 "Chan %d deriving loopid %d from AL_PA map (AL_PA 0x%x) and ignoring returned value %d (AL_PA 0x%x)",
2771 chan, i, alpa_map[i], fcp->isp_loopid, alpa);
2742 fcp->isp_loopid = i;
2743 }
2744 }
2745 }
2746
2747
2748 if (IS_24XX(isp)) { /* XXX SHOULDN'T THIS BE FOR 2K F/W? XXX */
2749 loopid = NPH_FL_ID;

--- 23 unchanged lines hidden (view full) ---

2773
2774 /*
2775 * Save the Fabric controller's port database entry.
2776 */
2777 lp = &fcp->portdb[FL_ID];
2778 lp->state = FC_PORTDB_STATE_PENDING_VALID;
2779 MAKE_WWN_FROM_NODE_NAME(lp->node_wwn, pdb.nodename);
2780 MAKE_WWN_FROM_NODE_NAME(lp->port_wwn, pdb.portname);
2772 fcp->isp_loopid = i;
2773 }
2774 }
2775 }
2776
2777
2778 if (IS_24XX(isp)) { /* XXX SHOULDN'T THIS BE FOR 2K F/W? XXX */
2779 loopid = NPH_FL_ID;

--- 23 unchanged lines hidden (view full) ---

2803
2804 /*
2805 * Save the Fabric controller's port database entry.
2806 */
2807 lp = &fcp->portdb[FL_ID];
2808 lp->state = FC_PORTDB_STATE_PENDING_VALID;
2809 MAKE_WWN_FROM_NODE_NAME(lp->node_wwn, pdb.nodename);
2810 MAKE_WWN_FROM_NODE_NAME(lp->port_wwn, pdb.portname);
2781 lp->roles = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
2811 lp->prli_word3 = pdb.prli_word3;
2782 lp->portid = pdb.portid;
2783 lp->handle = pdb.handle;
2784 lp->new_portid = lp->portid;
2812 lp->portid = pdb.portid;
2813 lp->handle = pdb.handle;
2814 lp->new_portid = lp->portid;
2785 lp->new_roles = lp->roles;
2815 lp->new_prli_word3 = lp->prli_word3;
2786 if (IS_24XX(isp)) {
2787 if (check_for_fabric) {
2788 /*
2789 * The mbs is still hanging out from the MBOX_GET_LOOP_ID above.
2790 */
2791 fcp->isp_fabric_params = mbs.param[7];
2816 if (IS_24XX(isp)) {
2817 if (check_for_fabric) {
2818 /*
2819 * The mbs is still hanging out from the MBOX_GET_LOOP_ID above.
2820 */
2821 fcp->isp_fabric_params = mbs.param[7];
2792 isp_prt(isp, ISP_LOGCONFIG, "fabric params 0x%x", mbs.param[7]);
2793 } else {
2794 fcp->isp_fabric_params = 0;
2795 }
2796 if (chan) {
2797 fcp->isp_sns_hdl = NPH_SNS_HDLBASE + chan;
2798 r = isp_plogx(isp, chan, fcp->isp_sns_hdl, SNS_PORT_ID, PLOGX_FLG_CMD_PLOGI | PLOGX_FLG_COND_PLOGI | PLOGX_FLG_SKIP_PRLI, 0);
2799 if (r) {
2800 isp_prt(isp, ISP_LOGWARN, "%s: Chan %d cannot log into SNS", __func__, chan);
2801 return (-1);
2802 }
2803 } else {
2804 fcp->isp_sns_hdl = NPH_SNS_ID;
2805 }
2806 r = isp_register_fc4_type_24xx(isp, chan);
2807 } else {
2808 fcp->isp_sns_hdl = SNS_ID;
2809 r = isp_register_fc4_type(isp, chan);
2810 }
2811 if (r) {
2822 } else {
2823 fcp->isp_fabric_params = 0;
2824 }
2825 if (chan) {
2826 fcp->isp_sns_hdl = NPH_SNS_HDLBASE + chan;
2827 r = isp_plogx(isp, chan, fcp->isp_sns_hdl, SNS_PORT_ID, PLOGX_FLG_CMD_PLOGI | PLOGX_FLG_COND_PLOGI | PLOGX_FLG_SKIP_PRLI, 0);
2828 if (r) {
2829 isp_prt(isp, ISP_LOGWARN, "%s: Chan %d cannot log into SNS", __func__, chan);
2830 return (-1);
2831 }
2832 } else {
2833 fcp->isp_sns_hdl = NPH_SNS_ID;
2834 }
2835 r = isp_register_fc4_type_24xx(isp, chan);
2836 } else {
2837 fcp->isp_sns_hdl = SNS_ID;
2838 r = isp_register_fc4_type(isp, chan);
2839 }
2840 if (r) {
2812 isp_prt(isp, ISP_LOGWARN|ISP_LOGSANCFG, "%s: register fc4 type failed", __func__);
2841 isp_prt(isp, ISP_LOGWARN|ISP_LOG_SANCFG, "%s: register fc4 type failed", __func__);
2813 return (-1);
2814 }
2815 } else {
2816not_on_fabric:
2817 fcp->portdb[FL_ID].state = FC_PORTDB_STATE_NIL;
2818 }
2819
2820 fcp->isp_gbspeed = 1;

--- 17 unchanged lines hidden (view full) ---

2838 fcp->isp_gbspeed = 1;
2839 }
2840 }
2841 }
2842
2843 /*
2844 * Announce ourselves, too.
2845 */
2842 return (-1);
2843 }
2844 } else {
2845not_on_fabric:
2846 fcp->portdb[FL_ID].state = FC_PORTDB_STATE_NIL;
2847 }
2848
2849 fcp->isp_gbspeed = 1;

--- 17 unchanged lines hidden (view full) ---

2867 fcp->isp_gbspeed = 1;
2868 }
2869 }
2870 }
2871
2872 /*
2873 * Announce ourselves, too.
2874 */
2846 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGCONFIG, topology, chan, (uint32_t) (fcp->isp_wwpn >> 32), (uint32_t) fcp->isp_wwpn, fcp->isp_portid, fcp->isp_loopid, isp_fc_toponame(fcp));
2847 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0, "Chan %d FC Link Test Complete", chan);
2875 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOGCONFIG, topology, chan, (uint32_t) (fcp->isp_wwpn >> 32), (uint32_t) fcp->isp_wwpn, fcp->isp_portid, fcp->isp_loopid, isp_fc_toponame(fcp));
2876 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC Link Test Complete", chan);
2848 return (0);
2849}
2850
2851/*
2852 * Complete the synchronization of our Port Database.
2853 *
2854 * At this point, we've scanned the local loop (if any) and the fabric
2855 * and performed fabric logins on all new devices.

--- 51 unchanged lines hidden (view full) ---

2907 if (isp_scan_fabric(isp, chan) != 0) {
2908 isp_prt(isp, ISP_LOGWARN,
2909 "isp_pdb_sync: isp_scan_fabric failed");
2910 return (-1);
2911 }
2912 }
2913 }
2914
2877 return (0);
2878}
2879
2880/*
2881 * Complete the synchronization of our Port Database.
2882 *
2883 * At this point, we've scanned the local loop (if any) and the fabric
2884 * and performed fabric logins on all new devices.

--- 51 unchanged lines hidden (view full) ---

2936 if (isp_scan_fabric(isp, chan) != 0) {
2937 isp_prt(isp, ISP_LOGWARN,
2938 "isp_pdb_sync: isp_scan_fabric failed");
2939 return (-1);
2940 }
2941 }
2942 }
2943
2915 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
2916 "Chan %d Synchronizing PDBs", chan);
2944 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Synchronizing PDBs", chan);
2917
2918 fcp->isp_loopstate = LOOP_SYNCING_PDB;
2919
2920 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
2921 lp = &fcp->portdb[dbidx];
2922
2923 if (lp->state == FC_PORTDB_STATE_NIL || lp->target_mode) {
2924 continue;

--- 20 unchanged lines hidden (view full) ---

2945 (void) isp_plogx(isp, chan, lp->handle,
2946 lp->portid,
2947 PLOGX_FLG_CMD_LOGO |
2948 PLOGX_FLG_IMPLICIT |
2949 PLOGX_FLG_FREE_NPHDL, 0);
2950 } else {
2951 lp->autologin = 0;
2952 }
2945
2946 fcp->isp_loopstate = LOOP_SYNCING_PDB;
2947
2948 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
2949 lp = &fcp->portdb[dbidx];
2950
2951 if (lp->state == FC_PORTDB_STATE_NIL || lp->target_mode) {
2952 continue;

--- 20 unchanged lines hidden (view full) ---

2973 (void) isp_plogx(isp, chan, lp->handle,
2974 lp->portid,
2975 PLOGX_FLG_CMD_LOGO |
2976 PLOGX_FLG_IMPLICIT |
2977 PLOGX_FLG_FREE_NPHDL, 0);
2978 } else {
2979 lp->autologin = 0;
2980 }
2953 lp->new_roles = 0;
2981 lp->new_prli_word3 = 0;
2954 lp->new_portid = 0;
2955 /*
2956 * Note that we might come out of this with our state
2957 * set to FC_PORTDB_STATE_ZOMBIE.
2958 */
2959 break;
2960 case FC_PORTDB_STATE_NEW:
2961 /*
2962 * It's up to the outer layers to assign a virtual
2963 * target id in isp_dev_map (if any).
2964 */
2965 lp->portid = lp->new_portid;
2982 lp->new_portid = 0;
2983 /*
2984 * Note that we might come out of this with our state
2985 * set to FC_PORTDB_STATE_ZOMBIE.
2986 */
2987 break;
2988 case FC_PORTDB_STATE_NEW:
2989 /*
2990 * It's up to the outer layers to assign a virtual
2991 * target id in isp_dev_map (if any).
2992 */
2993 lp->portid = lp->new_portid;
2966 lp->roles = lp->new_roles;
2994 lp->prli_word3 = lp->new_prli_word3;
2967 lp->state = FC_PORTDB_STATE_VALID;
2968 isp_async(isp, ISPASYNC_DEV_ARRIVED, chan, lp);
2995 lp->state = FC_PORTDB_STATE_VALID;
2996 isp_async(isp, ISPASYNC_DEV_ARRIVED, chan, lp);
2969 lp->new_roles = 0;
2997 lp->new_prli_word3 = 0;
2970 lp->new_portid = 0;
2998 lp->new_portid = 0;
2971 lp->reserved = 0;
2972 lp->new_reserved = 0;
2999 lp->announced = 0;
2973 break;
2974 case FC_PORTDB_STATE_CHANGED:
2975/*
2976 * XXXX FIX THIS
2977 */
2978 lp->state = FC_PORTDB_STATE_VALID;
2979 isp_async(isp, ISPASYNC_DEV_CHANGED, chan, lp);
3000 break;
3001 case FC_PORTDB_STATE_CHANGED:
3002/*
3003 * XXXX FIX THIS
3004 */
3005 lp->state = FC_PORTDB_STATE_VALID;
3006 isp_async(isp, ISPASYNC_DEV_CHANGED, chan, lp);
2980 lp->new_roles = 0;
3007 lp->new_prli_word3 = 0;
2981 lp->new_portid = 0;
3008 lp->new_portid = 0;
2982 lp->reserved = 0;
2983 lp->new_reserved = 0;
3009 lp->announced = 0;
2984 break;
2985 case FC_PORTDB_STATE_PENDING_VALID:
2986 lp->portid = lp->new_portid;
3010 break;
3011 case FC_PORTDB_STATE_PENDING_VALID:
3012 lp->portid = lp->new_portid;
2987 lp->roles = lp->new_roles;
3013 lp->prli_word3 = lp->new_prli_word3;
2988 if (lp->dev_map_idx) {
2989 int t = lp->dev_map_idx - 1;
2990 fcp->isp_dev_map[t] = dbidx + 1;
2991 }
2992 lp->state = FC_PORTDB_STATE_VALID;
2993 isp_async(isp, ISPASYNC_DEV_STAYED, chan, lp);
2994 if (dbidx != FL_ID) {
3014 if (lp->dev_map_idx) {
3015 int t = lp->dev_map_idx - 1;
3016 fcp->isp_dev_map[t] = dbidx + 1;
3017 }
3018 lp->state = FC_PORTDB_STATE_VALID;
3019 isp_async(isp, ISPASYNC_DEV_STAYED, chan, lp);
3020 if (dbidx != FL_ID) {
2995 lp->new_roles = 0;
3021 lp->new_prli_word3 = 0;
2996 lp->new_portid = 0;
2997 }
3022 lp->new_portid = 0;
3023 }
2998 lp->reserved = 0;
2999 lp->new_reserved = 0;
3024 lp->announced = 0;
3000 break;
3001 case FC_PORTDB_STATE_ZOMBIE:
3002 break;
3003 default:
3004 isp_prt(isp, ISP_LOGWARN,
3005 "isp_scan_loop: state %d for idx %d",
3006 lp->state, dbidx);
3007 isp_dump_portdb(isp, chan);

--- 41 unchanged lines hidden (view full) ---

3049 * If we're a N-port connection, we treat this is a short loop (0..1).
3050 */
3051 switch (fcp->isp_topo) {
3052 case TOPO_NL_PORT:
3053 lim = LOCAL_LOOP_LIM;
3054 break;
3055 case TOPO_FL_PORT:
3056 if (IS_24XX(isp) && isp->isp_nchan > 1) {
3025 break;
3026 case FC_PORTDB_STATE_ZOMBIE:
3027 break;
3028 default:
3029 isp_prt(isp, ISP_LOGWARN,
3030 "isp_scan_loop: state %d for idx %d",
3031 lp->state, dbidx);
3032 isp_dump_portdb(isp, chan);

--- 41 unchanged lines hidden (view full) ---

3074 * If we're a N-port connection, we treat this is a short loop (0..1).
3075 */
3076 switch (fcp->isp_topo) {
3077 case TOPO_NL_PORT:
3078 lim = LOCAL_LOOP_LIM;
3079 break;
3080 case TOPO_FL_PORT:
3081 if (IS_24XX(isp) && isp->isp_nchan > 1) {
3057 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3058 "Chan %d Skipping Local Loop Scan", chan);
3082 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Skipping Local Loop Scan", chan);
3059 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3060 return (0);
3061 }
3062 lim = LOCAL_LOOP_LIM;
3063 break;
3064 case TOPO_N_PORT:
3065 lim = 2;
3066 break;
3067 default:
3083 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3084 return (0);
3085 }
3086 lim = LOCAL_LOOP_LIM;
3087 break;
3088 case TOPO_N_PORT:
3089 lim = 2;
3090 break;
3091 default:
3068 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3069 "Chan %d no loop topology to scan", chan);
3092 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d no loop topology to scan", chan);
3070 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3071 return (0);
3072 }
3073
3074 fcp->isp_loopstate = LOOP_SCANNING_LOOP;
3075
3093 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3094 return (0);
3095 }
3096
3097 fcp->isp_loopstate = LOOP_SCANNING_LOOP;
3098
3076 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3077 "Chan %d FC scan loop 0..%d", chan, lim-1);
3099 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC scan loop 0..%d", chan, lim-1);
3078
3079
3080 /*
3081 * Run through the list and get the port database info for each one.
3082 */
3083 for (handle = 0; handle < lim; handle++) {
3084 int r;
3085 /*

--- 9 unchanged lines hidden (view full) ---

3095 }
3096 /*
3097 * In older cards with older f/w GET_PORT_DATABASE has been
3098 * known to hang. This trick gets around that problem.
3099 */
3100 if (IS_2100(isp) || IS_2200(isp)) {
3101 uint64_t node_wwn = isp_get_wwn(isp, chan, handle, 1);
3102 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
3100
3101
3102 /*
3103 * Run through the list and get the port database info for each one.
3104 */
3105 for (handle = 0; handle < lim; handle++) {
3106 int r;
3107 /*

--- 9 unchanged lines hidden (view full) ---

3117 }
3118 /*
3119 * In older cards with older f/w GET_PORT_DATABASE has been
3120 * known to hang. This trick gets around that problem.
3121 */
3122 if (IS_2100(isp) || IS_2200(isp)) {
3123 uint64_t node_wwn = isp_get_wwn(isp, chan, handle, 1);
3124 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
3103 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3104 "Chan %d FC scan loop DONE (bad)", chan);
3125 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC scan loop DONE (bad)", chan);
3105 return (-1);
3106 }
3107 if (node_wwn == INI_NONE) {
3108 continue;
3109 }
3110 }
3111
3112 /*
3113 * Get the port database entity for this index.
3114 */
3115 r = isp_getpdb(isp, chan, handle, &pdb, 1);
3116 if (r != 0) {
3117 isp_prt(isp, ISP_LOGDEBUG1,
3118 "Chan %d FC scan loop handle %d returned %x",
3119 chan, handle, r);
3120 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
3121 ISP_MARK_PORTDB(isp, chan, 1);
3126 return (-1);
3127 }
3128 if (node_wwn == INI_NONE) {
3129 continue;
3130 }
3131 }
3132
3133 /*
3134 * Get the port database entity for this index.
3135 */
3136 r = isp_getpdb(isp, chan, handle, &pdb, 1);
3137 if (r != 0) {
3138 isp_prt(isp, ISP_LOGDEBUG1,
3139 "Chan %d FC scan loop handle %d returned %x",
3140 chan, handle, r);
3141 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
3142 ISP_MARK_PORTDB(isp, chan, 1);
3122 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3123 "Chan %d FC scan loop DONE (bad)", chan);
3143 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC scan loop DONE (bad)", chan);
3124 return (-1);
3125 }
3126 continue;
3127 }
3128
3129 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
3130 ISP_MARK_PORTDB(isp, chan, 1);
3144 return (-1);
3145 }
3146 continue;
3147 }
3148
3149 if (fcp->isp_loopstate < LOOP_SCANNING_LOOP) {
3150 ISP_MARK_PORTDB(isp, chan, 1);
3131 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3132 "Chan %d FC scan loop DONE (bad)", chan);
3151 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC scan loop DONE (bad)", chan);
3133 return (-1);
3134 }
3135
3136 /*
3137 * On *very* old 2100 firmware we would end up sometimes
3138 * with the firmware returning the port database entry
3139 * for something else. We used to restart this, but
3140 * now we just punt.
3141 */
3142 if (IS_2100(isp) && pdb.handle != handle) {
3143 isp_prt(isp, ISP_LOGWARN,
3144 "Chan %d cannot synchronize port database", chan);
3145 ISP_MARK_PORTDB(isp, chan, 1);
3152 return (-1);
3153 }
3154
3155 /*
3156 * On *very* old 2100 firmware we would end up sometimes
3157 * with the firmware returning the port database entry
3158 * for something else. We used to restart this, but
3159 * now we just punt.
3160 */
3161 if (IS_2100(isp) && pdb.handle != handle) {
3162 isp_prt(isp, ISP_LOGWARN,
3163 "Chan %d cannot synchronize port database", chan);
3164 ISP_MARK_PORTDB(isp, chan, 1);
3146 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3147 "Chan %d FC scan loop DONE (bad)", chan);
3165 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC scan loop DONE (bad)", chan);
3148 return (-1);
3149 }
3150
3151 /*
3152 * Save the pertinent info locally.
3153 */
3154 MAKE_WWN_FROM_NODE_NAME(tmp.node_wwn, pdb.nodename);
3155 MAKE_WWN_FROM_NODE_NAME(tmp.port_wwn, pdb.portname);
3166 return (-1);
3167 }
3168
3169 /*
3170 * Save the pertinent info locally.
3171 */
3172 MAKE_WWN_FROM_NODE_NAME(tmp.node_wwn, pdb.nodename);
3173 MAKE_WWN_FROM_NODE_NAME(tmp.port_wwn, pdb.portname);
3156 tmp.roles = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
3174 tmp.prli_word3 = pdb.prli_word3;
3157 tmp.portid = pdb.portid;
3158 tmp.handle = pdb.handle;
3159
3160 /*
3161 * Check to make sure it's still a valid entry. The 24XX seems
3162 * to return a portid but not a WWPN/WWNN or role for devices
3163 * which shift on a loop.
3164 */

--- 22 unchanged lines hidden (view full) ---

3187
3188 /*
3189 * Now search the entire port database
3190 * for the same Port and Node WWN.
3191 */
3192 for (i = 0; i < MAX_FC_TARG; i++) {
3193 lp = &fcp->portdb[i];
3194
3175 tmp.portid = pdb.portid;
3176 tmp.handle = pdb.handle;
3177
3178 /*
3179 * Check to make sure it's still a valid entry. The 24XX seems
3180 * to return a portid but not a WWPN/WWNN or role for devices
3181 * which shift on a loop.
3182 */

--- 22 unchanged lines hidden (view full) ---

3205
3206 /*
3207 * Now search the entire port database
3208 * for the same Port and Node WWN.
3209 */
3210 for (i = 0; i < MAX_FC_TARG; i++) {
3211 lp = &fcp->portdb[i];
3212
3195 if (lp->state == FC_PORTDB_STATE_NIL ||
3196 lp->target_mode) {
3213 if (lp->state == FC_PORTDB_STATE_NIL || lp->target_mode) {
3197 continue;
3198 }
3199 if (lp->node_wwn != tmp.node_wwn) {
3200 continue;
3201 }
3202 if (lp->port_wwn != tmp.port_wwn) {
3203 continue;
3204 }

--- 4 unchanged lines hidden (view full) ---

3209 */
3210 if (lp->state != FC_PORTDB_STATE_PROBATIONAL &&
3211 lp->state != FC_PORTDB_STATE_ZOMBIE) {
3212 isp_prt(isp, ISP_LOGERR,
3213 "Chan %d [%d] not probational/zombie (0x%x)",
3214 chan, i, lp->state);
3215 isp_dump_portdb(isp, chan);
3216 ISP_MARK_PORTDB(isp, chan, 1);
3214 continue;
3215 }
3216 if (lp->node_wwn != tmp.node_wwn) {
3217 continue;
3218 }
3219 if (lp->port_wwn != tmp.port_wwn) {
3220 continue;
3221 }

--- 4 unchanged lines hidden (view full) ---

3226 */
3227 if (lp->state != FC_PORTDB_STATE_PROBATIONAL &&
3228 lp->state != FC_PORTDB_STATE_ZOMBIE) {
3229 isp_prt(isp, ISP_LOGERR,
3230 "Chan %d [%d] not probational/zombie (0x%x)",
3231 chan, i, lp->state);
3232 isp_dump_portdb(isp, chan);
3233 ISP_MARK_PORTDB(isp, chan, 1);
3217 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3218 "Chan %d FC scan loop DONE (bad)", chan);
3234 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC scan loop DONE (bad)", chan);
3219 return (-1);
3220 }
3221
3222 /*
3223 * Mark the device as something the f/w logs into
3224 * automatically.
3225 */
3226 lp->autologin = 1;
3227
3228 /*
3229 * Check to make see if really still the same
3230 * device. If it is, we mark it pending valid.
3231 */
3235 return (-1);
3236 }
3237
3238 /*
3239 * Mark the device as something the f/w logs into
3240 * automatically.
3241 */
3242 lp->autologin = 1;
3243
3244 /*
3245 * Check to make see if really still the same
3246 * device. If it is, we mark it pending valid.
3247 */
3232 if (lp->portid == tmp.portid &&
3233 lp->handle == tmp.handle &&
3234 lp->roles == tmp.roles) {
3248 if (lp->portid == tmp.portid && lp->handle == tmp.handle && lp->prli_word3 == tmp.prli_word3) {
3235 lp->new_portid = tmp.portid;
3249 lp->new_portid = tmp.portid;
3236 lp->new_roles = tmp.roles;
3250 lp->new_prli_word3 = tmp.prli_word3;
3237 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3251 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3238 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3239 "Chan %d Loop Port 0x%06x@0x%04x Pending "
3240 "Valid", chan, tmp.portid, tmp.handle);
3252 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Loop Port 0x%06x@0x%04x Pending Valid", chan, tmp.portid, tmp.handle);
3241 break;
3242 }
3243
3244 /*
3245 * We can wipe out the old handle value
3246 * here because it's no longer valid.
3247 */
3248 lp->handle = tmp.handle;
3249
3250 /*
3251 * Claim that this has changed and let somebody else
3252 * decide what to do.
3253 */
3253 break;
3254 }
3255
3256 /*
3257 * We can wipe out the old handle value
3258 * here because it's no longer valid.
3259 */
3260 lp->handle = tmp.handle;
3261
3262 /*
3263 * Claim that this has changed and let somebody else
3264 * decide what to do.
3265 */
3254 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3255 "Chan %d Loop Port 0x%06x@0x%04x changed",
3256 chan, tmp.portid, tmp.handle);
3266 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Loop Port 0x%06x@0x%04x changed", chan, tmp.portid, tmp.handle);
3257 lp->state = FC_PORTDB_STATE_CHANGED;
3258 lp->new_portid = tmp.portid;
3267 lp->state = FC_PORTDB_STATE_CHANGED;
3268 lp->new_portid = tmp.portid;
3259 lp->new_roles = tmp.roles;
3269 lp->new_prli_word3 = tmp.prli_word3;
3260 break;
3261 }
3262
3263 /*
3264 * Did we find and update an old entry?
3265 */
3266 if (i < MAX_FC_TARG) {
3267 continue;

--- 17 unchanged lines hidden (view full) ---

3285 continue;
3286 }
3287 lp = &fcp->portdb[i];
3288
3289 ISP_MEMZERO(lp, sizeof (fcportdb_t));
3290 lp->autologin = 1;
3291 lp->state = FC_PORTDB_STATE_NEW;
3292 lp->new_portid = tmp.portid;
3270 break;
3271 }
3272
3273 /*
3274 * Did we find and update an old entry?
3275 */
3276 if (i < MAX_FC_TARG) {
3277 continue;

--- 17 unchanged lines hidden (view full) ---

3295 continue;
3296 }
3297 lp = &fcp->portdb[i];
3298
3299 ISP_MEMZERO(lp, sizeof (fcportdb_t));
3300 lp->autologin = 1;
3301 lp->state = FC_PORTDB_STATE_NEW;
3302 lp->new_portid = tmp.portid;
3293 lp->new_roles = tmp.roles;
3303 lp->new_prli_word3 = tmp.prli_word3;
3294 lp->handle = tmp.handle;
3295 lp->port_wwn = tmp.port_wwn;
3296 lp->node_wwn = tmp.node_wwn;
3304 lp->handle = tmp.handle;
3305 lp->port_wwn = tmp.port_wwn;
3306 lp->node_wwn = tmp.node_wwn;
3297 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3298 "Chan %d Loop Port 0x%06x@0x%04x is New Entry",
3299 chan, tmp.portid, tmp.handle);
3307 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Loop Port 0x%06x@0x%04x is New Entry", chan, tmp.portid, tmp.handle);
3300 }
3301 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3308 }
3309 fcp->isp_loopstate = LOOP_LSCAN_DONE;
3302 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3303 "Chan %d FC scan loop DONE", chan);
3310 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC scan loop DONE", chan);
3304 return (0);
3305}
3306
3307/*
3308 * Scan the fabric for devices and add them to our port database.
3309 *
3310 * Use the GID_FT command to get all Port IDs for FC4 SCSI devices it knows.
3311 *

--- 26 unchanged lines hidden (view full) ---

3338 union {
3339 sns_gid_ft_req_t _x;
3340 uint8_t _y[SNS_GID_FT_REQ_SIZE];
3341 } un;
3342 fcparam *fcp = FCPARAM(isp, chan);
3343 sns_gid_ft_req_t *rq = &un._x;
3344 mbreg_t mbs;
3345
3311 return (0);
3312}
3313
3314/*
3315 * Scan the fabric for devices and add them to our port database.
3316 *
3317 * Use the GID_FT command to get all Port IDs for FC4 SCSI devices it knows.
3318 *

--- 26 unchanged lines hidden (view full) ---

3345 union {
3346 sns_gid_ft_req_t _x;
3347 uint8_t _y[SNS_GID_FT_REQ_SIZE];
3348 } un;
3349 fcparam *fcp = FCPARAM(isp, chan);
3350 sns_gid_ft_req_t *rq = &un._x;
3351 mbreg_t mbs;
3352
3346 isp_prt(isp, ISP_LOGDEBUG0,
3347 "Chan %d scanning fabric (GID_FT) via SNS", chan);
3353 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d scanning fabric (GID_FT) via SNS", chan);
3348
3349 ISP_MEMZERO(rq, SNS_GID_FT_REQ_SIZE);
3350 rq->snscb_rblen = GIDLEN >> 1;
3351 rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + IGPOFF);
3352 rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + IGPOFF);
3353 rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + IGPOFF);
3354 rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + IGPOFF);
3355 rq->snscb_sblen = 6;

--- 32 unchanged lines hidden (view full) ---

3388 ct_hdr_t clocal;
3389 uint8_t q[QENTRY_LEN];
3390 } un;
3391 isp_ct_pt_t *pt;
3392 ct_hdr_t *ct;
3393 uint32_t *rp;
3394 uint8_t *scp = fcp->isp_scratch;
3395
3354
3355 ISP_MEMZERO(rq, SNS_GID_FT_REQ_SIZE);
3356 rq->snscb_rblen = GIDLEN >> 1;
3357 rq->snscb_addr[RQRSP_ADDR0015] = DMA_WD0(fcp->isp_scdma + IGPOFF);
3358 rq->snscb_addr[RQRSP_ADDR1631] = DMA_WD1(fcp->isp_scdma + IGPOFF);
3359 rq->snscb_addr[RQRSP_ADDR3247] = DMA_WD2(fcp->isp_scdma + IGPOFF);
3360 rq->snscb_addr[RQRSP_ADDR4863] = DMA_WD3(fcp->isp_scdma + IGPOFF);
3361 rq->snscb_sblen = 6;

--- 32 unchanged lines hidden (view full) ---

3394 ct_hdr_t clocal;
3395 uint8_t q[QENTRY_LEN];
3396 } un;
3397 isp_ct_pt_t *pt;
3398 ct_hdr_t *ct;
3399 uint32_t *rp;
3400 uint8_t *scp = fcp->isp_scratch;
3401
3396 isp_prt(isp, ISP_LOGDEBUG0,
3397 "Chan %d scanning fabric (GID_FT) via CT", chan);
3402 isp_prt(isp, ISP_LOGDEBUG0, "Chan %d scanning fabric (GID_FT) via CT", chan);
3398
3399 if (!IS_24XX(isp)) {
3400 return (1);
3401 }
3402
3403 /*
3404 * Build a Passthrough IOCB in memory.
3405 */

--- 77 unchanged lines hidden (view full) ---

3483{
3484 fcparam *fcp = FCPARAM(isp, chan);
3485 uint32_t portid;
3486 uint16_t handle, oldhandle, loopid;
3487 isp_pdb_t pdb;
3488 int portidx, portlim, r;
3489 sns_gid_ft_rsp_t *rs0, *rs1;
3490
3403
3404 if (!IS_24XX(isp)) {
3405 return (1);
3406 }
3407
3408 /*
3409 * Build a Passthrough IOCB in memory.
3410 */

--- 77 unchanged lines hidden (view full) ---

3488{
3489 fcparam *fcp = FCPARAM(isp, chan);
3490 uint32_t portid;
3491 uint16_t handle, oldhandle, loopid;
3492 isp_pdb_t pdb;
3493 int portidx, portlim, r;
3494 sns_gid_ft_rsp_t *rs0, *rs1;
3495
3491 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3492 "Chan %d FC Scan Fabric", chan);
3493 if (fcp->isp_fwstate != FW_READY ||
3494 fcp->isp_loopstate < LOOP_LSCAN_DONE) {
3496 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC Scan Fabric", chan);
3497 if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate < LOOP_LSCAN_DONE) {
3495 return (-1);
3496 }
3497 if (fcp->isp_loopstate > LOOP_SCANNING_FABRIC) {
3498 return (0);
3499 }
3500 if (fcp->isp_topo != TOPO_FL_PORT && fcp->isp_topo != TOPO_F_PORT) {
3501 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3498 return (-1);
3499 }
3500 if (fcp->isp_loopstate > LOOP_SCANNING_FABRIC) {
3501 return (0);
3502 }
3503 if (fcp->isp_topo != TOPO_FL_PORT && fcp->isp_topo != TOPO_F_PORT) {
3504 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3502 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3503 "Chan %d FC Scan Fabric Done (no fabric)", chan);
3505 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC Scan Fabric Done (no fabric)", chan);
3504 return (0);
3505 }
3506
3507 fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
3508 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3509 isp_prt(isp, ISP_LOGERR, sacq);
3510 ISP_MARK_PORTDB(isp, chan, 1);
3511 return (-1);

--- 51 unchanged lines hidden (view full) ---

3563 isp_get_gid_ft_response(isp, rs0, rs1, NGENT);
3564 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC) {
3565 FC_SCRATCH_RELEASE(isp, chan);
3566 ISP_MARK_PORTDB(isp, chan, 1);
3567 return (-1);
3568 }
3569 if (rs1->snscb_cthdr.ct_cmd_resp != LS_ACC) {
3570 int level;
3506 return (0);
3507 }
3508
3509 fcp->isp_loopstate = LOOP_SCANNING_FABRIC;
3510 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
3511 isp_prt(isp, ISP_LOGERR, sacq);
3512 ISP_MARK_PORTDB(isp, chan, 1);
3513 return (-1);

--- 51 unchanged lines hidden (view full) ---

3565 isp_get_gid_ft_response(isp, rs0, rs1, NGENT);
3566 if (fcp->isp_loopstate < LOOP_SCANNING_FABRIC) {
3567 FC_SCRATCH_RELEASE(isp, chan);
3568 ISP_MARK_PORTDB(isp, chan, 1);
3569 return (-1);
3570 }
3571 if (rs1->snscb_cthdr.ct_cmd_resp != LS_ACC) {
3572 int level;
3571 if (rs1->snscb_cthdr.ct_reason == 9 &&
3572 rs1->snscb_cthdr.ct_explanation == 7) {
3573 level = ISP_LOGSANCFG|ISP_LOGDEBUG0;
3573 if (rs1->snscb_cthdr.ct_reason == 9 && rs1->snscb_cthdr.ct_explanation == 7) {
3574 level = ISP_LOG_SANCFG;
3574 } else {
3575 level = ISP_LOGWARN;
3576 }
3577 isp_prt(isp, level, "Chan %d Fabric Nameserver rejected GID_FT"
3578 " (Reason=0x%x Expl=0x%x)", chan,
3579 rs1->snscb_cthdr.ct_reason,
3580 rs1->snscb_cthdr.ct_explanation);
3581 FC_SCRATCH_RELEASE(isp, chan);

--- 27 unchanged lines hidden (view full) ---

3609 /*
3610 * If we're not at the last entry, our list wasn't big enough.
3611 */
3612 if ((rs1->snscb_ports[portidx].control & 0x80) == 0) {
3613 isp_prt(isp, ISP_LOGWARN,
3614 "fabric too big for scratch area: increase ISP_FC_SCRLEN");
3615 }
3616 portlim = portidx + 1;
3575 } else {
3576 level = ISP_LOGWARN;
3577 }
3578 isp_prt(isp, level, "Chan %d Fabric Nameserver rejected GID_FT"
3579 " (Reason=0x%x Expl=0x%x)", chan,
3580 rs1->snscb_cthdr.ct_reason,
3581 rs1->snscb_cthdr.ct_explanation);
3582 FC_SCRATCH_RELEASE(isp, chan);

--- 27 unchanged lines hidden (view full) ---

3610 /*
3611 * If we're not at the last entry, our list wasn't big enough.
3612 */
3613 if ((rs1->snscb_ports[portidx].control & 0x80) == 0) {
3614 isp_prt(isp, ISP_LOGWARN,
3615 "fabric too big for scratch area: increase ISP_FC_SCRLEN");
3616 }
3617 portlim = portidx + 1;
3617 isp_prt(isp, ISP_LOGSANCFG,
3618 isp_prt(isp, ISP_LOG_SANCFG,
3618 "Chan %d got %d ports back from name server", chan, portlim);
3619
3620 for (portidx = 0; portidx < portlim; portidx++) {
3621 int npidx;
3622
3623 portid =
3624 ((rs1->snscb_ports[portidx].portid[0]) << 16) |
3625 ((rs1->snscb_ports[portidx].portid[1]) << 8) |

--- 8 unchanged lines hidden (view full) ---

3634 break;
3635 }
3636 }
3637
3638 if (npidx < portlim) {
3639 rs1->snscb_ports[npidx].portid[0] = 0;
3640 rs1->snscb_ports[npidx].portid[1] = 0;
3641 rs1->snscb_ports[npidx].portid[2] = 0;
3619 "Chan %d got %d ports back from name server", chan, portlim);
3620
3621 for (portidx = 0; portidx < portlim; portidx++) {
3622 int npidx;
3623
3624 portid =
3625 ((rs1->snscb_ports[portidx].portid[0]) << 16) |
3626 ((rs1->snscb_ports[portidx].portid[1]) << 8) |

--- 8 unchanged lines hidden (view full) ---

3635 break;
3636 }
3637 }
3638
3639 if (npidx < portlim) {
3640 rs1->snscb_ports[npidx].portid[0] = 0;
3641 rs1->snscb_ports[npidx].portid[1] = 0;
3642 rs1->snscb_ports[npidx].portid[2] = 0;
3642 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3643 "Chan %d removing duplicate PortID 0x%06x"
3644 " entry from list", chan, portid);
3643 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d removing duplicate PortID 0x%06x entry from list", chan, portid);
3645 }
3646 }
3647
3648 /*
3649 * We now have a list of Port IDs for all FC4 SCSI devices
3650 * that the Fabric Name server knows about.
3651 *
3652 * For each entry on this list go through our port database looking

--- 13 unchanged lines hidden (view full) ---

3666 int dbidx, nr;
3667
3668 portid =
3669 ((rs1->snscb_ports[portidx].portid[0]) << 16) |
3670 ((rs1->snscb_ports[portidx].portid[1]) << 8) |
3671 ((rs1->snscb_ports[portidx].portid[2]));
3672
3673 if (portid == 0) {
3644 }
3645 }
3646
3647 /*
3648 * We now have a list of Port IDs for all FC4 SCSI devices
3649 * that the Fabric Name server knows about.
3650 *
3651 * For each entry on this list go through our port database looking

--- 13 unchanged lines hidden (view full) ---

3665 int dbidx, nr;
3666
3667 portid =
3668 ((rs1->snscb_ports[portidx].portid[0]) << 16) |
3669 ((rs1->snscb_ports[portidx].portid[1]) << 8) |
3670 ((rs1->snscb_ports[portidx].portid[2]));
3671
3672 if (portid == 0) {
3674 isp_prt(isp, ISP_LOGSANCFG,
3673 isp_prt(isp, ISP_LOG_SANCFG,
3675 "Chan %d skipping null PortID at idx %d",
3676 chan, portidx);
3677 continue;
3678 }
3679
3680 /*
3681 * Skip ourselves here and on other channels. If we're
3682 * multi-id, we can't check the portids in other FCPARAM
3683 * arenas because the resolutions here aren't synchronized.
3684 * The best way to do this is to exclude looking at portids
3685 * that have the same domain and area code as our own
3686 * portid.
3687 */
3688 if (ISP_CAP_MULTI_ID(isp)) {
3689 if ((portid >> 8) == (fcp->isp_portid >> 8)) {
3674 "Chan %d skipping null PortID at idx %d",
3675 chan, portidx);
3676 continue;
3677 }
3678
3679 /*
3680 * Skip ourselves here and on other channels. If we're
3681 * multi-id, we can't check the portids in other FCPARAM
3682 * arenas because the resolutions here aren't synchronized.
3683 * The best way to do this is to exclude looking at portids
3684 * that have the same domain and area code as our own
3685 * portid.
3686 */
3687 if (ISP_CAP_MULTI_ID(isp)) {
3688 if ((portid >> 8) == (fcp->isp_portid >> 8)) {
3690 isp_prt(isp, ISP_LOGSANCFG,
3689 isp_prt(isp, ISP_LOG_SANCFG,
3691 "Chan %d skip PortID 0x%06x",
3692 chan, portid);
3693 continue;
3694 }
3695 } else if (portid == fcp->isp_portid) {
3690 "Chan %d skip PortID 0x%06x",
3691 chan, portid);
3692 continue;
3693 }
3694 } else if (portid == fcp->isp_portid) {
3696 isp_prt(isp, ISP_LOGSANCFG,
3695 isp_prt(isp, ISP_LOG_SANCFG,
3697 "Chan %d skip ourselves on @ PortID 0x%06x",
3698 chan, portid);
3699 continue;
3700 }
3701
3696 "Chan %d skip ourselves on @ PortID 0x%06x",
3697 chan, portid);
3698 continue;
3699 }
3700
3702 isp_prt(isp, ISP_LOGSANCFG,
3701 isp_prt(isp, ISP_LOG_SANCFG,
3703 "Chan %d Checking Fabric Port 0x%06x", chan, portid);
3704
3705 /*
3706 * We now search our Port Database for any
3707 * probational entries with this PortID. We don't
3708 * look for zombies here- only probational
3709 * entries (we've already logged out of zombies).
3710 */
3711 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3712 lp = &fcp->portdb[dbidx];
3713
3702 "Chan %d Checking Fabric Port 0x%06x", chan, portid);
3703
3704 /*
3705 * We now search our Port Database for any
3706 * probational entries with this PortID. We don't
3707 * look for zombies here- only probational
3708 * entries (we've already logged out of zombies).
3709 */
3710 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3711 lp = &fcp->portdb[dbidx];
3712
3714 if (lp->state != FC_PORTDB_STATE_PROBATIONAL ||
3715 lp->target_mode) {
3713 if (lp->state != FC_PORTDB_STATE_PROBATIONAL || lp->target_mode) {
3716 continue;
3717 }
3718 if (lp->portid == portid) {
3719 break;
3720 }
3721 }
3722
3723 /*

--- 25 unchanged lines hidden (view full) ---

3749 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3750 FC_SCRATCH_RELEASE(isp, chan);
3751 ISP_MARK_PORTDB(isp, chan, 1);
3752 return (-1);
3753 }
3754 if (r != 0) {
3755 lp->new_portid = portid;
3756 lp->state = FC_PORTDB_STATE_DEAD;
3714 continue;
3715 }
3716 if (lp->portid == portid) {
3717 break;
3718 }
3719 }
3720
3721 /*

--- 25 unchanged lines hidden (view full) ---

3747 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3748 FC_SCRATCH_RELEASE(isp, chan);
3749 ISP_MARK_PORTDB(isp, chan, 1);
3750 return (-1);
3751 }
3752 if (r != 0) {
3753 lp->new_portid = portid;
3754 lp->state = FC_PORTDB_STATE_DEAD;
3757 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3758 "Chan %d Fabric Port 0x%06x is dead",
3759 chan, portid);
3755 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Fabric Port 0x%06x is dead", chan, portid);
3760 continue;
3761 }
3762
3763
3764 /*
3765 * Check to make sure that handle, portid, WWPN and
3766 * WWNN agree. If they don't, then the association
3767 * between this PortID and the stated handle has been
3768 * broken by the firmware.
3769 */
3770 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3771 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3772 if (pdb.handle != lp->handle ||
3773 pdb.portid != portid ||
3774 wwpn != lp->port_wwn ||
3775 wwnn != lp->node_wwn) {
3756 continue;
3757 }
3758
3759
3760 /*
3761 * Check to make sure that handle, portid, WWPN and
3762 * WWNN agree. If they don't, then the association
3763 * between this PortID and the stated handle has been
3764 * broken by the firmware.
3765 */
3766 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3767 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3768 if (pdb.handle != lp->handle ||
3769 pdb.portid != portid ||
3770 wwpn != lp->port_wwn ||
3771 wwnn != lp->node_wwn) {
3776 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3772 isp_prt(isp, ISP_LOG_SANCFG,
3777 fconf, chan, dbidx, pdb.handle, pdb.portid,
3778 (uint32_t) (wwnn >> 32), (uint32_t) wwnn,
3779 (uint32_t) (wwpn >> 32), (uint32_t) wwpn,
3780 lp->handle, portid,
3781 (uint32_t) (lp->node_wwn >> 32),
3782 (uint32_t) lp->node_wwn,
3783 (uint32_t) (lp->port_wwn >> 32),
3784 (uint32_t) lp->port_wwn);

--- 34 unchanged lines hidden (view full) ---

3819 lp->state = FC_PORTDB_STATE_DEAD;
3820 continue;
3821 }
3822
3823 lp->handle = pdb.handle;
3824 handle_changed++;
3825 }
3826
3773 fconf, chan, dbidx, pdb.handle, pdb.portid,
3774 (uint32_t) (wwnn >> 32), (uint32_t) wwnn,
3775 (uint32_t) (wwpn >> 32), (uint32_t) wwpn,
3776 lp->handle, portid,
3777 (uint32_t) (lp->node_wwn >> 32),
3778 (uint32_t) lp->node_wwn,
3779 (uint32_t) (lp->port_wwn >> 32),
3780 (uint32_t) lp->port_wwn);

--- 34 unchanged lines hidden (view full) ---

3815 lp->state = FC_PORTDB_STATE_DEAD;
3816 continue;
3817 }
3818
3819 lp->handle = pdb.handle;
3820 handle_changed++;
3821 }
3822
3827 nr = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
3823 nr = pdb.prli_word3;
3828
3829 /*
3830 * Check to see whether the portid and roles have
3831 * stayed the same. If they have stayed the same,
3832 * we believe that this is the same device and it
3833 * hasn't become disconnected and reconnected, so
3834 * mark it as pending valid.
3835 *
3836 * If they aren't the same, mark the device as a
3837 * changed device and save the new port id and role
3838 * and let somebody else decide.
3839 */
3840
3841 lp->new_portid = portid;
3824
3825 /*
3826 * Check to see whether the portid and roles have
3827 * stayed the same. If they have stayed the same,
3828 * we believe that this is the same device and it
3829 * hasn't become disconnected and reconnected, so
3830 * mark it as pending valid.
3831 *
3832 * If they aren't the same, mark the device as a
3833 * changed device and save the new port id and role
3834 * and let somebody else decide.
3835 */
3836
3837 lp->new_portid = portid;
3842 lp->new_roles = nr;
3843 if (pdb.portid != lp->portid || nr != lp->roles ||
3844 handle_changed) {
3845 isp_prt(isp, ISP_LOGSANCFG,
3846 "Chan %d Fabric Port 0x%06x changed",
3847 chan, portid);
3838 lp->new_prli_word3 = nr;
3839 if (pdb.portid != lp->portid || nr != lp->prli_word3 || handle_changed) {
3840 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Fabric Port 0x%06x changed", chan, portid);
3848 lp->state = FC_PORTDB_STATE_CHANGED;
3849 } else {
3841 lp->state = FC_PORTDB_STATE_CHANGED;
3842 } else {
3850 isp_prt(isp, ISP_LOGSANCFG,
3851 "Chan %d Fabric Port 0x%06x "
3852 "Now Pending Valid", chan, portid);
3843 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Fabric Port 0x%06x Now Pending Valid", chan, portid);
3853 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3854 }
3855 continue;
3856 }
3857
3858 /*
3859 * Ah- a new entry. Search the database again for all non-NIL
3860 * entries to make sure we never ever make a new database entry

--- 69 unchanged lines hidden (view full) ---

3930 ISP_MARK_PORTDB(isp, chan, 1);
3931 return (-1);
3932 }
3933 FCPARAM(isp, 0)->isp_lasthdl = oldhandle;
3934
3935 handle = pdb.handle;
3936 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3937 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3844 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3845 }
3846 continue;
3847 }
3848
3849 /*
3850 * Ah- a new entry. Search the database again for all non-NIL
3851 * entries to make sure we never ever make a new database entry

--- 69 unchanged lines hidden (view full) ---

3921 ISP_MARK_PORTDB(isp, chan, 1);
3922 return (-1);
3923 }
3924 FCPARAM(isp, 0)->isp_lasthdl = oldhandle;
3925
3926 handle = pdb.handle;
3927 MAKE_WWN_FROM_NODE_NAME(wwnn, pdb.nodename);
3928 MAKE_WWN_FROM_NODE_NAME(wwpn, pdb.portname);
3938 nr = (pdb.s3_role & SVC3_ROLE_MASK) >> SVC3_ROLE_SHIFT;
3929 nr = pdb.prli_word3;
3939
3940 /*
3941 * And go through the database *one* more time to make sure
3942 * that we do not make more than one entry that has the same
3943 * WWNN/WWPN duple
3944 */
3945 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3946 if (dbidx >= FL_ID && dbidx <= SNS_ID) {
3947 continue;
3948 }
3949 if (fcp->portdb[dbidx].target_mode) {
3950 continue;
3951 }
3930
3931 /*
3932 * And go through the database *one* more time to make sure
3933 * that we do not make more than one entry that has the same
3934 * WWNN/WWPN duple
3935 */
3936 for (dbidx = 0; dbidx < MAX_FC_TARG; dbidx++) {
3937 if (dbidx >= FL_ID && dbidx <= SNS_ID) {
3938 continue;
3939 }
3940 if (fcp->portdb[dbidx].target_mode) {
3941 continue;
3942 }
3952 if (fcp->portdb[dbidx].node_wwn == wwnn &&
3953 fcp->portdb[dbidx].port_wwn == wwpn) {
3943 if (fcp->portdb[dbidx].node_wwn == wwnn && fcp->portdb[dbidx].port_wwn == wwpn) {
3954 break;
3955 }
3956 }
3957
3958 if (dbidx == MAX_FC_TARG) {
3959 ISP_MEMZERO(lp, sizeof (fcportdb_t));
3960 lp->handle = handle;
3961 lp->node_wwn = wwnn;
3962 lp->port_wwn = wwpn;
3963 lp->new_portid = portid;
3944 break;
3945 }
3946 }
3947
3948 if (dbidx == MAX_FC_TARG) {
3949 ISP_MEMZERO(lp, sizeof (fcportdb_t));
3950 lp->handle = handle;
3951 lp->node_wwn = wwnn;
3952 lp->port_wwn = wwpn;
3953 lp->new_portid = portid;
3964 lp->new_roles = nr;
3954 lp->new_prli_word3 = nr;
3965 lp->state = FC_PORTDB_STATE_NEW;
3955 lp->state = FC_PORTDB_STATE_NEW;
3966 isp_prt(isp, ISP_LOGSANCFG,
3967 "Chan %d Fabric Port 0x%06x is a New Entry",
3968 chan, portid);
3956 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Fabric Port 0x%06x is a New Entry", chan, portid);
3969 continue;
3970 }
3971
3972 if (fcp->portdb[dbidx].state != FC_PORTDB_STATE_ZOMBIE) {
3973 isp_prt(isp, ISP_LOGWARN,
3974 "Chan %d PortID 0x%x 0x%08x%08x/0x%08x%08x %ld "
3975 "already at idx %d, state 0x%x", chan, portid,
3976 (uint32_t) (wwnn >> 32), (uint32_t) wwnn,

--- 9 unchanged lines hidden (view full) ---

3986 * are the same. For fabric devices, we
3987 * don't care that handle is different
3988 * as we assign that. If role or portid
3989 * are different, it maybe a changed device.
3990 */
3991 lp = &fcp->portdb[dbidx];
3992 lp->handle = handle;
3993 lp->new_portid = portid;
3957 continue;
3958 }
3959
3960 if (fcp->portdb[dbidx].state != FC_PORTDB_STATE_ZOMBIE) {
3961 isp_prt(isp, ISP_LOGWARN,
3962 "Chan %d PortID 0x%x 0x%08x%08x/0x%08x%08x %ld "
3963 "already at idx %d, state 0x%x", chan, portid,
3964 (uint32_t) (wwnn >> 32), (uint32_t) wwnn,

--- 9 unchanged lines hidden (view full) ---

3974 * are the same. For fabric devices, we
3975 * don't care that handle is different
3976 * as we assign that. If role or portid
3977 * are different, it maybe a changed device.
3978 */
3979 lp = &fcp->portdb[dbidx];
3980 lp->handle = handle;
3981 lp->new_portid = portid;
3994 lp->new_roles = nr;
3995 if (lp->portid != portid || lp->roles != nr) {
3996 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
3997 "Chan %d Zombie Fabric Port 0x%06x Now Changed",
3998 chan, portid);
3982 lp->new_prli_word3 = nr;
3983 if (lp->portid != portid || lp->prli_word3 != nr) {
3984 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Zombie Fabric Port 0x%06x Now Changed", chan, portid);
3999 lp->state = FC_PORTDB_STATE_CHANGED;
4000 } else {
3985 lp->state = FC_PORTDB_STATE_CHANGED;
3986 } else {
4001 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
4002 "Chan %d Zombie Fabric Port 0x%06x "
4003 "Now Pending Valid", chan, portid);
3987 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Zombie Fabric Port 0x%06x Now Pending Valid", chan, portid);
4004 lp->state = FC_PORTDB_STATE_PENDING_VALID;
4005 }
4006 }
4007
4008 FC_SCRATCH_RELEASE(isp, chan);
4009 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
4010 ISP_MARK_PORTDB(isp, chan, 1);
4011 return (-1);
4012 }
4013 fcp->isp_loopstate = LOOP_FSCAN_DONE;
3988 lp->state = FC_PORTDB_STATE_PENDING_VALID;
3989 }
3990 }
3991
3992 FC_SCRATCH_RELEASE(isp, chan);
3993 if (fcp->isp_loopstate != LOOP_SCANNING_FABRIC) {
3994 ISP_MARK_PORTDB(isp, chan, 1);
3995 return (-1);
3996 }
3997 fcp->isp_loopstate = LOOP_FSCAN_DONE;
4014 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
4015 "Chan %d FC Scan Fabric Done", chan);
3998 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d FC Scan Fabric Done", chan);
4016 return (0);
4017}
4018
4019/*
4020 * Find an unused handle and try and use to login to a port.
4021 */
4022static int
4023isp_login_device(ispsoftc_t *isp, int chan, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)

--- 232 unchanged lines hidden (view full) ---

4256 chan, pt->ctp_status);
4257 return (1);
4258 }
4259
4260 isp_get_ct_hdr(isp, (ct_hdr_t *) &scp[IGPOFF], ct);
4261 FC_SCRATCH_RELEASE(isp, chan);
4262
4263 if (ct->ct_cmd_resp == LS_RJT) {
3999 return (0);
4000}
4001
4002/*
4003 * Find an unused handle and try and use to login to a port.
4004 */
4005static int
4006isp_login_device(ispsoftc_t *isp, int chan, uint32_t portid, isp_pdb_t *p, uint16_t *ohp)

--- 232 unchanged lines hidden (view full) ---

4239 chan, pt->ctp_status);
4240 return (1);
4241 }
4242
4243 isp_get_ct_hdr(isp, (ct_hdr_t *) &scp[IGPOFF], ct);
4244 FC_SCRATCH_RELEASE(isp, chan);
4245
4246 if (ct->ct_cmd_resp == LS_RJT) {
4264 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
4265 "Chan %d Register FC4 Type rejected", chan);
4247 isp_prt(isp, ISP_LOG_SANCFG|ISP_LOG_WARN1, "Chan %d Register FC4 Type rejected", chan);
4266 return (-1);
4267 } else if (ct->ct_cmd_resp == LS_ACC) {
4248 return (-1);
4249 } else if (ct->ct_cmd_resp == LS_ACC) {
4268 isp_prt(isp, ISP_LOGSANCFG|ISP_LOGDEBUG0,
4269 "Chan %d Register FC4 Type accepted", chan);
4250 isp_prt(isp, ISP_LOG_SANCFG, "Chan %d Register FC4 Type accepted", chan);
4270 return (0);
4271 } else {
4251 return (0);
4252 } else {
4272 isp_prt(isp, ISP_LOGWARN,
4273 "Chan %d Register FC4 Type: 0x%x",
4274 chan, ct->ct_cmd_resp);
4253 isp_prt(isp, ISP_LOGWARN, "Chan %d Register FC4 Type: 0x%x", chan, ct->ct_cmd_resp);
4275 return (-1);
4276 }
4277}
4278
4279static uint16_t
4280isp_nxt_handle(ispsoftc_t *isp, int chan, uint16_t handle)
4281{
4282 int i;

--- 81 unchanged lines hidden (view full) ---

4364 * Translate the target to device handle as appropriate, checking
4365 * for correct device state as well.
4366 */
4367 target = XS_TGT(xs);
4368 if (IS_FC(isp)) {
4369 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
4370
4371 if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
4254 return (-1);
4255 }
4256}
4257
4258static uint16_t
4259isp_nxt_handle(ispsoftc_t *isp, int chan, uint16_t handle)
4260{
4261 int i;

--- 81 unchanged lines hidden (view full) ---

4343 * Translate the target to device handle as appropriate, checking
4344 * for correct device state as well.
4345 */
4346 target = XS_TGT(xs);
4347 if (IS_FC(isp)) {
4348 fcparam *fcp = FCPARAM(isp, XS_CHANNEL(xs));
4349
4350 if ((fcp->role & ISP_ROLE_INITIATOR) == 0) {
4351 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%d I am not an initiator", XS_CHANNEL(xs), target, XS_LUN(xs));
4372 XS_SETERR(xs, HBA_SELTIMEOUT);
4373 return (CMD_COMPLETE);
4374 }
4375
4376 /*
4377 * Try again later.
4378 */
4379 if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate != LOOP_READY) {
4380 return (CMD_RQLATER);
4381 }
4382
4383 if (XS_TGT(xs) >= MAX_FC_TARG) {
4352 XS_SETERR(xs, HBA_SELTIMEOUT);
4353 return (CMD_COMPLETE);
4354 }
4355
4356 /*
4357 * Try again later.
4358 */
4359 if (fcp->isp_fwstate != FW_READY || fcp->isp_loopstate != LOOP_READY) {
4360 return (CMD_RQLATER);
4361 }
4362
4363 if (XS_TGT(xs) >= MAX_FC_TARG) {
4364 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%d target too big", XS_CHANNEL(xs), target, XS_LUN(xs));
4384 XS_SETERR(xs, HBA_SELTIMEOUT);
4385 return (CMD_COMPLETE);
4386 }
4387
4388 hdlidx = fcp->isp_dev_map[XS_TGT(xs)] - 1;
4389 isp_prt(isp, ISP_LOGDEBUG2, "XS_TGT(xs)=%d- hdlidx value %d", XS_TGT(xs), hdlidx);
4390 if (hdlidx < 0 || hdlidx >= MAX_FC_TARG) {
4391 XS_SETERR(xs, HBA_SELTIMEOUT);
4392 return (CMD_COMPLETE);
4393 }
4394 if (fcp->portdb[hdlidx].state == FC_PORTDB_STATE_ZOMBIE) {
4365 XS_SETERR(xs, HBA_SELTIMEOUT);
4366 return (CMD_COMPLETE);
4367 }
4368
4369 hdlidx = fcp->isp_dev_map[XS_TGT(xs)] - 1;
4370 isp_prt(isp, ISP_LOGDEBUG2, "XS_TGT(xs)=%d- hdlidx value %d", XS_TGT(xs), hdlidx);
4371 if (hdlidx < 0 || hdlidx >= MAX_FC_TARG) {
4372 XS_SETERR(xs, HBA_SELTIMEOUT);
4373 return (CMD_COMPLETE);
4374 }
4375 if (fcp->portdb[hdlidx].state == FC_PORTDB_STATE_ZOMBIE) {
4376 isp_prt(isp, ISP_LOGDEBUG1, "%d.%d.%d target zombie", XS_CHANNEL(xs), target, XS_LUN(xs));
4395 return (CMD_RQLATER);
4396 }
4397 if (fcp->portdb[hdlidx].state != FC_PORTDB_STATE_VALID) {
4377 return (CMD_RQLATER);
4378 }
4379 if (fcp->portdb[hdlidx].state != FC_PORTDB_STATE_VALID) {
4380 isp_prt(isp, ISP_LOGDEBUG1, "%d.%d.%d bad db port state 0x%x", XS_CHANNEL(xs), target, XS_LUN(xs), fcp->portdb[hdlidx].state);
4398 XS_SETERR(xs, HBA_SELTIMEOUT);
4399 return (CMD_COMPLETE);
4400 }
4401 target = fcp->portdb[hdlidx].handle;
4402 fcp->portdb[hdlidx].dirty = 1;
4403 } else {
4404 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4405 if ((sdp->role & ISP_ROLE_INITIATOR) == 0) {
4381 XS_SETERR(xs, HBA_SELTIMEOUT);
4382 return (CMD_COMPLETE);
4383 }
4384 target = fcp->portdb[hdlidx].handle;
4385 fcp->portdb[hdlidx].dirty = 1;
4386 } else {
4387 sdparam *sdp = SDPARAM(isp, XS_CHANNEL(xs));
4388 if ((sdp->role & ISP_ROLE_INITIATOR) == 0) {
4389 isp_prt(isp, ISP_LOGDEBUG1, "%d.%d.%d I am not an initiator", XS_CHANNEL(xs), target, XS_LUN(xs));
4406 XS_SETERR(xs, HBA_SELTIMEOUT);
4407 return (CMD_COMPLETE);
4408 }
4409 if (sdp->update) {
4410 isp_spi_update(isp, XS_CHANNEL(xs));
4411 }
4412 }
4413
4414 start_again:
4415
4416 qep = isp_getrqentry(isp);
4417 if (qep == NULL) {
4390 XS_SETERR(xs, HBA_SELTIMEOUT);
4391 return (CMD_COMPLETE);
4392 }
4393 if (sdp->update) {
4394 isp_spi_update(isp, XS_CHANNEL(xs));
4395 }
4396 }
4397
4398 start_again:
4399
4400 qep = isp_getrqentry(isp);
4401 if (qep == NULL) {
4418 isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow");
4402 isp_prt(isp, ISP_LOG_WARN1, "Request Queue Overflow");
4419 XS_SETERR(xs, HBA_BOTCH);
4420 return (CMD_EAGAIN);
4421 }
4422 XS_SETERR(xs, HBA_NOERROR);
4423
4424 /*
4425 * Now see if we need to synchronize the ISP with respect to anything.
4426 * We do dual duty here (cough) for synchronizing for busses other

--- 17 unchanged lines hidden (view full) ---

4444 isp_put_marker(isp, m, qep);
4445 }
4446 ISP_SYNC_REQUEST(isp);
4447 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 0);
4448 goto start_again;
4449 }
4450
4451 reqp->req_header.rqs_entry_count = 1;
4403 XS_SETERR(xs, HBA_BOTCH);
4404 return (CMD_EAGAIN);
4405 }
4406 XS_SETERR(xs, HBA_NOERROR);
4407
4408 /*
4409 * Now see if we need to synchronize the ISP with respect to anything.
4410 * We do dual duty here (cough) for synchronizing for busses other

--- 17 unchanged lines hidden (view full) ---

4428 isp_put_marker(isp, m, qep);
4429 }
4430 ISP_SYNC_REQUEST(isp);
4431 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 0);
4432 goto start_again;
4433 }
4434
4435 reqp->req_header.rqs_entry_count = 1;
4436
4437 /*
4438 * Select and install Header Code.
4439 * Note that it might be overridden before going out
4440 * if we're on a 64 bit platform. The lower level
4441 * code (isp_send_cmd) will select the appropriate
4442 * 64 bit variant if it needs to.
4443 */
4452 if (IS_24XX(isp)) {
4453 reqp->req_header.rqs_entry_type = RQSTYPE_T7RQS;
4454 } else if (IS_FC(isp)) {
4455 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
4456 } else {
4457 if (XS_CDBLEN(xs) > 12) {
4458 reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
4459 } else {
4460 reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
4461 }
4462 }
4463
4444 if (IS_24XX(isp)) {
4445 reqp->req_header.rqs_entry_type = RQSTYPE_T7RQS;
4446 } else if (IS_FC(isp)) {
4447 reqp->req_header.rqs_entry_type = RQSTYPE_T2RQS;
4448 } else {
4449 if (XS_CDBLEN(xs) > 12) {
4450 reqp->req_header.rqs_entry_type = RQSTYPE_CMDONLY;
4451 } else {
4452 reqp->req_header.rqs_entry_type = RQSTYPE_REQUEST;
4453 }
4454 }
4455
4456 /*
4457 * Set task attributes
4458 */
4464 if (IS_24XX(isp)) {
4465 int ttype;
4466 if (XS_TAG_P(xs)) {
4467 ttype = XS_TAG_TYPE(xs);
4468 } else {
4469 if (XS_CDBP(xs)[0] == 0x3) {
4470 ttype = REQFLAG_HTAG;
4471 } else {

--- 36 unchanged lines hidden (view full) ---

4508 if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) && XS_TAG_P(xs)) {
4509 reqp->req_flags = XS_TAG_TYPE(xs);
4510 }
4511 }
4512
4513 tptr = &reqp->req_time;
4514
4515 /*
4459 if (IS_24XX(isp)) {
4460 int ttype;
4461 if (XS_TAG_P(xs)) {
4462 ttype = XS_TAG_TYPE(xs);
4463 } else {
4464 if (XS_CDBP(xs)[0] == 0x3) {
4465 ttype = REQFLAG_HTAG;
4466 } else {

--- 36 unchanged lines hidden (view full) ---

4503 if ((sdp->isp_devparam[target].actv_flags & DPARM_TQING) && XS_TAG_P(xs)) {
4504 reqp->req_flags = XS_TAG_TYPE(xs);
4505 }
4506 }
4507
4508 tptr = &reqp->req_time;
4509
4510 /*
4516 * NB: we do not support long CDBs
4511 * NB: we do not support long CDBs (yet)
4517 */
4518 cdblen = XS_CDBLEN(xs);
4519
4520 if (IS_SCSI(isp)) {
4512 */
4513 cdblen = XS_CDBLEN(xs);
4514
4515 if (IS_SCSI(isp)) {
4516 if (cdblen > sizeof (reqp->req_cdb)) {
4517 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4518 XS_SETERR(xs, HBA_BOTCH);
4519 return (CMD_COMPLETE);
4520 }
4521 reqp->req_target = target | (XS_CHANNEL(xs) << 7);
4522 reqp->req_lun_trn = XS_LUN(xs);
4521 reqp->req_target = target | (XS_CHANNEL(xs) << 7);
4522 reqp->req_lun_trn = XS_LUN(xs);
4523 cdblen = ISP_MIN(cdblen, sizeof (reqp->req_cdb));
4524 cdbp = reqp->req_cdb;
4525 reqp->req_cdblen = cdblen;
4526 } else if (IS_24XX(isp)) {
4527 ispreqt7_t *t7 = (ispreqt7_t *)local;
4528 fcportdb_t *lp;
4529
4523 cdbp = reqp->req_cdb;
4524 reqp->req_cdblen = cdblen;
4525 } else if (IS_24XX(isp)) {
4526 ispreqt7_t *t7 = (ispreqt7_t *)local;
4527 fcportdb_t *lp;
4528
4529 if (cdblen > sizeof (t7->req_cdb)) {
4530 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4531 XS_SETERR(xs, HBA_BOTCH);
4532 return (CMD_COMPLETE);
4533 }
4534
4530 lp = &FCPARAM(isp, XS_CHANNEL(xs))->portdb[hdlidx];
4531 t7->req_nphdl = target;
4532 t7->req_tidlo = lp->portid;
4533 t7->req_tidhi = lp->portid >> 16;
4534 t7->req_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(xs));
4535 if (XS_LUN(xs) > 256) {
4536 t7->req_lun[0] = XS_LUN(xs) >> 8;
4537 t7->req_lun[0] |= 0x40;
4538 }
4539 t7->req_lun[1] = XS_LUN(xs);
4535 lp = &FCPARAM(isp, XS_CHANNEL(xs))->portdb[hdlidx];
4536 t7->req_nphdl = target;
4537 t7->req_tidlo = lp->portid;
4538 t7->req_tidhi = lp->portid >> 16;
4539 t7->req_vpidx = ISP_GET_VPIDX(isp, XS_CHANNEL(xs));
4540 if (XS_LUN(xs) > 256) {
4541 t7->req_lun[0] = XS_LUN(xs) >> 8;
4542 t7->req_lun[0] |= 0x40;
4543 }
4544 t7->req_lun[1] = XS_LUN(xs);
4540 FCP_NEXT_CRN(isp, xs, t7->req_crn, XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
4545 if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
4546 if (FCP_NEXT_CRN(isp, &t7->req_crn, xs)) {
4547 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%d cannot generate next CRN", XS_CHANNEL(xs), target, XS_LUN(xs));
4548 XS_SETERR(xs, HBA_BOTCH);
4549 return (CMD_EAGAIN);
4550 }
4551 }
4541 tptr = &t7->req_time;
4542 cdbp = t7->req_cdb;
4552 tptr = &t7->req_time;
4553 cdbp = t7->req_cdb;
4543 cdblen = ISP_MIN(cdblen, sizeof (t7->req_cdb));
4544 } else if (ISP_CAP_2KLOGIN(isp)) {
4545 ispreqt2e_t *t2e = (ispreqt2e_t *)local;
4546 t2e->req_target = target;
4547 t2e->req_scclun = XS_LUN(xs);
4548 cdbp = t2e->req_cdb;
4549 cdblen = ISP_MIN(cdblen, sizeof (t2e->req_cdb));
4550 } else if (ISP_CAP_SCCFW(isp)) {
4551 ispreqt2_t *t2 = (ispreqt2_t *)local;
4552 t2->req_target = target;
4553 t2->req_scclun = XS_LUN(xs);
4554 cdbp = t2->req_cdb;
4555 cdblen = ISP_MIN(cdblen, sizeof (t2->req_cdb));
4556 } else {
4557 ispreqt2_t *t2 = (ispreqt2_t *)local;
4554 } else {
4555 ispreqt2_t *t2 = (ispreqt2_t *)local;
4558 t2->req_target = target;
4559 t2->req_lun_trn = XS_LUN(xs);
4560 cdbp = t2->req_cdb;
4561 cdblen = ISP_MIN(cdblen, sizeof (t2->req_cdb));
4556 fcportdb_t *lp;
4557
4558 if (cdblen > sizeof t2->req_cdb) {
4559 isp_prt(isp, ISP_LOGERR, "Command Length %u too long for this chip", cdblen);
4560 XS_SETERR(xs, HBA_BOTCH);
4561 return (CMD_COMPLETE);
4562 }
4563 lp = &FCPARAM(isp, XS_CHANNEL(xs))->portdb[hdlidx];
4564 if (FCPARAM(isp, XS_CHANNEL(xs))->fctape_enabled && (lp->prli_word3 & PRLI_WD3_RETRY)) {
4565 if (FCP_NEXT_CRN(isp, &t2->req_crn, xs)) {
4566 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%d cannot generate next CRN", XS_CHANNEL(xs), target, XS_LUN(xs));
4567 XS_SETERR(xs, HBA_BOTCH);
4568 return (CMD_EAGAIN);
4569 }
4570 }
4571 if (ISP_CAP_2KLOGIN(isp)) {
4572 ispreqt2e_t *t2e = (ispreqt2e_t *)local;
4573 t2e->req_target = target;
4574 t2e->req_scclun = XS_LUN(xs);
4575 cdbp = t2e->req_cdb;
4576 } else if (ISP_CAP_SCCFW(isp)) {
4577 ispreqt2_t *t2 = (ispreqt2_t *)local;
4578 t2->req_target = target;
4579 t2->req_scclun = XS_LUN(xs);
4580 cdbp = t2->req_cdb;
4581 } else {
4582 t2->req_target = target;
4583 t2->req_lun_trn = XS_LUN(xs);
4584 cdbp = t2->req_cdb;
4585 }
4562 }
4563 ISP_MEMCPY(cdbp, XS_CDBP(xs), cdblen);
4564
4565 *tptr = XS_TIME(xs) / 1000;
4566 if (*tptr == 0 && XS_TIME(xs)) {
4567 *tptr = 1;
4568 }
4569 if (IS_24XX(isp) && *tptr > 0x1999) {
4570 *tptr = 0x1999;
4571 }
4572
4573 if (isp_allocate_xs(isp, xs, &handle)) {
4586 }
4587 ISP_MEMCPY(cdbp, XS_CDBP(xs), cdblen);
4588
4589 *tptr = XS_TIME(xs) / 1000;
4590 if (*tptr == 0 && XS_TIME(xs)) {
4591 *tptr = 1;
4592 }
4593 if (IS_24XX(isp) && *tptr > 0x1999) {
4594 *tptr = 0x1999;
4595 }
4596
4597 if (isp_allocate_xs(isp, xs, &handle)) {
4574 isp_prt(isp, ISP_LOGDEBUG0, "out of xflist pointers");
4598 isp_prt(isp, ISP_LOG_WARN1, "out of xflist pointers");
4575 XS_SETERR(xs, HBA_BOTCH);
4576 return (CMD_EAGAIN);
4577 }
4578 /* Whew. Thankfully the same for type 7 requests */
4579 reqp->req_handle = handle;
4580
4581 /*
4582 * Set up DMA and/or do any platform dependent swizzling of the request entry

--- 30 unchanged lines hidden (view full) ---

4613 va_list ap;
4614
4615 switch (ctl) {
4616 case ISPCTL_RESET_BUS:
4617 /*
4618 * Issue a bus reset.
4619 */
4620 if (IS_24XX(isp)) {
4599 XS_SETERR(xs, HBA_BOTCH);
4600 return (CMD_EAGAIN);
4601 }
4602 /* Whew. Thankfully the same for type 7 requests */
4603 reqp->req_handle = handle;
4604
4605 /*
4606 * Set up DMA and/or do any platform dependent swizzling of the request entry

--- 30 unchanged lines hidden (view full) ---

4637 va_list ap;
4638
4639 switch (ctl) {
4640 case ISPCTL_RESET_BUS:
4641 /*
4642 * Issue a bus reset.
4643 */
4644 if (IS_24XX(isp)) {
4621 isp_prt(isp, ISP_LOGWARN, "RESET BUS NOT IMPLEMENTED");
4645 isp_prt(isp, ISP_LOGERR, "BUS RESET NOT IMPLEMENTED");
4622 break;
4623 } else if (IS_FC(isp)) {
4624 mbs.param[1] = 10;
4625 chan = 0;
4626 } else {
4627 va_start(ap, ctl);
4628 chan = va_arg(ap, int);
4629 va_end(ap);

--- 4 unchanged lines hidden (view full) ---

4634 mbs.param[2] = chan;
4635 }
4636 MBSINIT(&mbs, MBOX_BUS_RESET, MBLOGALL, 0);
4637 ISP_SET_SENDMARKER(isp, chan, 1);
4638 isp_mboxcmd(isp, &mbs);
4639 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4640 break;
4641 }
4646 break;
4647 } else if (IS_FC(isp)) {
4648 mbs.param[1] = 10;
4649 chan = 0;
4650 } else {
4651 va_start(ap, ctl);
4652 chan = va_arg(ap, int);
4653 va_end(ap);

--- 4 unchanged lines hidden (view full) ---

4658 mbs.param[2] = chan;
4659 }
4660 MBSINIT(&mbs, MBOX_BUS_RESET, MBLOGALL, 0);
4661 ISP_SET_SENDMARKER(isp, chan, 1);
4662 isp_mboxcmd(isp, &mbs);
4663 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4664 break;
4665 }
4642 isp_prt(isp, ISP_LOGINFO,
4643 "driver initiated bus reset of bus %d", chan);
4666 isp_prt(isp, ISP_LOGINFO, "driver initiated bus reset of bus %d", chan);
4644 return (0);
4645
4646 case ISPCTL_RESET_DEV:
4647 va_start(ap, ctl);
4648 chan = va_arg(ap, int);
4649 tgt = va_arg(ap, int);
4650 va_end(ap);
4651 if (IS_24XX(isp)) {
4652 uint8_t local[QENTRY_LEN];
4653 isp24xx_tmf_t *tmf;
4654 isp24xx_statusreq_t *sp;
4655 fcparam *fcp = FCPARAM(isp, chan);
4656 fcportdb_t *lp;
4657 int hdlidx;
4658
4659 hdlidx = fcp->isp_dev_map[tgt] - 1;
4660 if (hdlidx < 0 || hdlidx >= MAX_FC_TARG) {
4667 return (0);
4668
4669 case ISPCTL_RESET_DEV:
4670 va_start(ap, ctl);
4671 chan = va_arg(ap, int);
4672 tgt = va_arg(ap, int);
4673 va_end(ap);
4674 if (IS_24XX(isp)) {
4675 uint8_t local[QENTRY_LEN];
4676 isp24xx_tmf_t *tmf;
4677 isp24xx_statusreq_t *sp;
4678 fcparam *fcp = FCPARAM(isp, chan);
4679 fcportdb_t *lp;
4680 int hdlidx;
4681
4682 hdlidx = fcp->isp_dev_map[tgt] - 1;
4683 if (hdlidx < 0 || hdlidx >= MAX_FC_TARG) {
4661 isp_prt(isp, ISP_LOGWARN,
4662 "Chan %d bad handle %d trying to reset"
4663 "target %d", chan, hdlidx, tgt);
4684 isp_prt(isp, ISP_LOGWARN, "Chan %d bad handle %d trying to reset target %d", chan, hdlidx, tgt);
4664 break;
4665 }
4666 lp = &fcp->portdb[hdlidx];
4667 if (lp->state != FC_PORTDB_STATE_VALID) {
4685 break;
4686 }
4687 lp = &fcp->portdb[hdlidx];
4688 if (lp->state != FC_PORTDB_STATE_VALID) {
4668 isp_prt(isp, ISP_LOGWARN,
4669 "Chan %d handle %d for abort of target %d "
4670 "no longer valid", chan,
4671 hdlidx, tgt);
4689 isp_prt(isp, ISP_LOGWARN, "Chan %d handle %d for abort of target %d no longer valid", chan, hdlidx, tgt);
4672 break;
4673 }
4674
4675 tmf = (isp24xx_tmf_t *) local;
4676 ISP_MEMZERO(tmf, QENTRY_LEN);
4677 tmf->tmf_header.rqs_entry_type = RQSTYPE_TSK_MGMT;
4678 tmf->tmf_header.rqs_entry_count = 1;
4679 tmf->tmf_nphdl = lp->handle;

--- 18 unchanged lines hidden (view full) ---

4698 isp_put_24xx_tmf(isp, tmf, fcp->isp_scratch);
4699 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, QENTRY_LEN, chan);
4700 fcp->sendmarker = 1;
4701 isp_mboxcmd(isp, &mbs);
4702 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4703 FC_SCRATCH_RELEASE(isp, chan);
4704 break;
4705 }
4690 break;
4691 }
4692
4693 tmf = (isp24xx_tmf_t *) local;
4694 ISP_MEMZERO(tmf, QENTRY_LEN);
4695 tmf->tmf_header.rqs_entry_type = RQSTYPE_TSK_MGMT;
4696 tmf->tmf_header.rqs_entry_count = 1;
4697 tmf->tmf_nphdl = lp->handle;

--- 18 unchanged lines hidden (view full) ---

4716 isp_put_24xx_tmf(isp, tmf, fcp->isp_scratch);
4717 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, QENTRY_LEN, chan);
4718 fcp->sendmarker = 1;
4719 isp_mboxcmd(isp, &mbs);
4720 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4721 FC_SCRATCH_RELEASE(isp, chan);
4722 break;
4723 }
4706 MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN,
4707 QENTRY_LEN, chan);
4724 MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
4708 sp = (isp24xx_statusreq_t *) local;
4725 sp = (isp24xx_statusreq_t *) local;
4709 isp_get_24xx_response(isp,
4710 &((isp24xx_statusreq_t *)fcp->isp_scratch)[1], sp);
4726 isp_get_24xx_response(isp, &((isp24xx_statusreq_t *)fcp->isp_scratch)[1], sp);
4711 FC_SCRATCH_RELEASE(isp, chan);
4712 if (sp->req_completion_status == 0) {
4713 return (0);
4714 }
4727 FC_SCRATCH_RELEASE(isp, chan);
4728 if (sp->req_completion_status == 0) {
4729 return (0);
4730 }
4715 isp_prt(isp, ISP_LOGWARN,
4716 "Chan %d reset of target %d returned 0x%x",
4717 chan, tgt, sp->req_completion_status);
4731 isp_prt(isp, ISP_LOGWARN, "Chan %d reset of target %d returned 0x%x", chan, tgt, sp->req_completion_status);
4718 break;
4719 } else if (IS_FC(isp)) {
4720 if (ISP_CAP_2KLOGIN(isp)) {
4721 mbs.param[1] = tgt;
4722 mbs.ibits = (1 << 10);
4723 } else {
4724 mbs.param[1] = (tgt << 8);
4725 }
4726 } else {
4727 mbs.param[1] = (chan << 15) | (tgt << 8);
4728 }
4729 MBSINIT(&mbs, MBOX_ABORT_TARGET, MBLOGALL, 0);
4730 mbs.param[2] = 3; /* 'delay', in seconds */
4731 isp_mboxcmd(isp, &mbs);
4732 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4733 break;
4734 }
4732 break;
4733 } else if (IS_FC(isp)) {
4734 if (ISP_CAP_2KLOGIN(isp)) {
4735 mbs.param[1] = tgt;
4736 mbs.ibits = (1 << 10);
4737 } else {
4738 mbs.param[1] = (tgt << 8);
4739 }
4740 } else {
4741 mbs.param[1] = (chan << 15) | (tgt << 8);
4742 }
4743 MBSINIT(&mbs, MBOX_ABORT_TARGET, MBLOGALL, 0);
4744 mbs.param[2] = 3; /* 'delay', in seconds */
4745 isp_mboxcmd(isp, &mbs);
4746 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4747 break;
4748 }
4735 isp_prt(isp, ISP_LOGINFO,
4736 "Target %d on Bus %d Reset Succeeded", tgt, chan);
4749 isp_prt(isp, ISP_LOGINFO, "Target %d on Bus %d Reset Succeeded", tgt, chan);
4737 ISP_SET_SENDMARKER(isp, chan, 1);
4738 return (0);
4739
4740 case ISPCTL_ABORT_CMD:
4741 va_start(ap, ctl);
4742 xs = va_arg(ap, XS_T *);
4743 va_end(ap);
4744
4745 tgt = XS_TGT(xs);
4746 chan = XS_CHANNEL(xs);
4747
4748 handle = isp_find_handle(isp, xs);
4749 if (handle == 0) {
4750 ISP_SET_SENDMARKER(isp, chan, 1);
4751 return (0);
4752
4753 case ISPCTL_ABORT_CMD:
4754 va_start(ap, ctl);
4755 xs = va_arg(ap, XS_T *);
4756 va_end(ap);
4757
4758 tgt = XS_TGT(xs);
4759 chan = XS_CHANNEL(xs);
4760
4761 handle = isp_find_handle(isp, xs);
4762 if (handle == 0) {
4750 isp_prt(isp, ISP_LOGWARN,
4751 "cannot find handle for command to abort");
4763 isp_prt(isp, ISP_LOGWARN, "cannot find handle for command to abort");
4752 break;
4753 }
4754 if (IS_24XX(isp)) {
4755 isp24xx_abrt_t local, *ab = &local, *ab2;
4756 fcparam *fcp;
4757 fcportdb_t *lp;
4758 int hdlidx;
4759
4760 fcp = FCPARAM(isp, chan);
4761 hdlidx = fcp->isp_dev_map[tgt] - 1;
4762 if (hdlidx < 0 || hdlidx >= MAX_FC_TARG) {
4764 break;
4765 }
4766 if (IS_24XX(isp)) {
4767 isp24xx_abrt_t local, *ab = &local, *ab2;
4768 fcparam *fcp;
4769 fcportdb_t *lp;
4770 int hdlidx;
4771
4772 fcp = FCPARAM(isp, chan);
4773 hdlidx = fcp->isp_dev_map[tgt] - 1;
4774 if (hdlidx < 0 || hdlidx >= MAX_FC_TARG) {
4763 isp_prt(isp, ISP_LOGWARN,
4764 "Chan %d bad handle %d trying to abort"
4765 "target %d", chan, hdlidx, tgt);
4775 isp_prt(isp, ISP_LOGWARN, "Chan %d bad handle %d trying to abort target %d", chan, hdlidx, tgt);
4766 break;
4767 }
4768 lp = &fcp->portdb[hdlidx];
4769 if (lp->state != FC_PORTDB_STATE_VALID) {
4776 break;
4777 }
4778 lp = &fcp->portdb[hdlidx];
4779 if (lp->state != FC_PORTDB_STATE_VALID) {
4770 isp_prt(isp, ISP_LOGWARN,
4771 "Chan %d handle %d for abort of target %d "
4772 "no longer valid", chan, hdlidx, tgt);
4780 isp_prt(isp, ISP_LOGWARN, "Chan %d handle %d for abort of target %d no longer valid", chan, hdlidx, tgt);
4773 break;
4774 }
4781 break;
4782 }
4775 isp_prt(isp, ISP_LOGALL,
4776 "Chan %d Abort Cmd for N-Port 0x%04x @ Port "
4777 "0x%06x %p", chan, lp->handle, lp->portid, xs);
4783 isp_prt(isp, ISP_LOGALL, "Chan %d Abort Cmd for N-Port 0x%04x @ Port 0x%06x", chan, lp->handle, lp->portid);
4778 ISP_MEMZERO(ab, QENTRY_LEN);
4779 ab->abrt_header.rqs_entry_type = RQSTYPE_ABORT_IO;
4780 ab->abrt_header.rqs_entry_count = 1;
4781 ab->abrt_handle = lp->handle;
4782 ab->abrt_cmd_handle = handle;
4783 ab->abrt_tidlo = lp->portid;
4784 ab->abrt_tidhi = lp->portid >> 16;
4785 ab->abrt_vpidx = ISP_GET_VPIDX(isp, chan);

--- 6 unchanged lines hidden (view full) ---

4792 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
4793 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
4794
4795 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4796 isp_prt(isp, ISP_LOGERR, sacq);
4797 break;
4798 }
4799 isp_put_24xx_abrt(isp, ab, fcp->isp_scratch);
4784 ISP_MEMZERO(ab, QENTRY_LEN);
4785 ab->abrt_header.rqs_entry_type = RQSTYPE_ABORT_IO;
4786 ab->abrt_header.rqs_entry_count = 1;
4787 ab->abrt_handle = lp->handle;
4788 ab->abrt_cmd_handle = handle;
4789 ab->abrt_tidlo = lp->portid;
4790 ab->abrt_tidhi = lp->portid >> 16;
4791 ab->abrt_vpidx = ISP_GET_VPIDX(isp, chan);

--- 6 unchanged lines hidden (view full) ---

4798 mbs.param[6] = DMA_WD3(fcp->isp_scdma);
4799 mbs.param[7] = DMA_WD2(fcp->isp_scdma);
4800
4801 if (FC_SCRATCH_ACQUIRE(isp, chan)) {
4802 isp_prt(isp, ISP_LOGERR, sacq);
4803 break;
4804 }
4805 isp_put_24xx_abrt(isp, ab, fcp->isp_scratch);
4800 ab2 = (isp24xx_abrt_t *)
4801 &((uint8_t *)fcp->isp_scratch)[QENTRY_LEN];
4806 ab2 = (isp24xx_abrt_t *) &((uint8_t *)fcp->isp_scratch)[QENTRY_LEN];
4802 ab2->abrt_nphdl = 0xdeaf;
4803 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, 2 * QENTRY_LEN, chan);
4804 isp_mboxcmd(isp, &mbs);
4805 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4806 FC_SCRATCH_RELEASE(isp, chan);
4807 break;
4808 }
4807 ab2->abrt_nphdl = 0xdeaf;
4808 MEMORYBARRIER(isp, SYNC_SFORDEV, 0, 2 * QENTRY_LEN, chan);
4809 isp_mboxcmd(isp, &mbs);
4810 if (mbs.param[0] != MBOX_COMMAND_COMPLETE) {
4811 FC_SCRATCH_RELEASE(isp, chan);
4812 break;
4813 }
4809 MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN,
4810 QENTRY_LEN, chan);
4814 MEMORYBARRIER(isp, SYNC_SFORCPU, QENTRY_LEN, QENTRY_LEN, chan);
4811 isp_get_24xx_abrt(isp, ab2, ab);
4812 FC_SCRATCH_RELEASE(isp, chan);
4813 if (ab->abrt_nphdl == ISP24XX_ABRT_OKAY) {
4814 return (0);
4815 }
4815 isp_get_24xx_abrt(isp, ab2, ab);
4816 FC_SCRATCH_RELEASE(isp, chan);
4817 if (ab->abrt_nphdl == ISP24XX_ABRT_OKAY) {
4818 return (0);
4819 }
4816 isp_prt(isp, ISP_LOGWARN,
4817 "Chan %d handle %d abort returned 0x%x", chan,
4818 hdlidx, ab->abrt_nphdl);
4820 isp_prt(isp, ISP_LOGWARN, "Chan %d handle %d abort returned 0x%x", chan, hdlidx, ab->abrt_nphdl);
4819 break;
4820 } else if (IS_FC(isp)) {
4821 if (ISP_CAP_SCCFW(isp)) {
4822 if (ISP_CAP_2KLOGIN(isp)) {
4823 mbs.param[1] = tgt;
4824 } else {
4825 mbs.param[1] = tgt << 8;
4826 }

--- 171 unchanged lines hidden (view full) ---

4998#define MAX_REQUESTQ_COMPLETIONS 32
4999#endif
5000
5001void
5002isp_intr(ispsoftc_t *isp, uint32_t isr, uint16_t sema, uint16_t mbox)
5003{
5004 XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
5005 uint32_t iptr, optr, junk;
4821 break;
4822 } else if (IS_FC(isp)) {
4823 if (ISP_CAP_SCCFW(isp)) {
4824 if (ISP_CAP_2KLOGIN(isp)) {
4825 mbs.param[1] = tgt;
4826 } else {
4827 mbs.param[1] = tgt << 8;
4828 }

--- 171 unchanged lines hidden (view full) ---

5000#define MAX_REQUESTQ_COMPLETIONS 32
5001#endif
5002
5003void
5004isp_intr(ispsoftc_t *isp, uint32_t isr, uint16_t sema, uint16_t mbox)
5005{
5006 XS_T *complist[MAX_REQUESTQ_COMPLETIONS], *xs;
5007 uint32_t iptr, optr, junk;
5006 int i, nlooked = 0, ndone = 0;
5008 int i, nlooked = 0, ndone = 0, continuations_expected = 0;
5009 int etype, last_etype = 0;
5007
5008again:
5009 optr = isp->isp_residx;
5010 /*
5011 * Is this a mailbox related interrupt?
5012 * The mailbox semaphore will be nonzero if so.
5013 */
5014 if (sema) {

--- 159 unchanged lines hidden (view full) ---

5174 }
5175 }
5176 isp->isp_resodx = iptr;
5177
5178 while (optr != iptr) {
5179 uint8_t qe[QENTRY_LEN];
5180 ispstatusreq_t *sp = (ispstatusreq_t *) qe;
5181 isphdr_t *hp;
5010
5011again:
5012 optr = isp->isp_residx;
5013 /*
5014 * Is this a mailbox related interrupt?
5015 * The mailbox semaphore will be nonzero if so.
5016 */
5017 if (sema) {

--- 159 unchanged lines hidden (view full) ---

5177 }
5178 }
5179 isp->isp_resodx = iptr;
5180
5181 while (optr != iptr) {
5182 uint8_t qe[QENTRY_LEN];
5183 ispstatusreq_t *sp = (ispstatusreq_t *) qe;
5184 isphdr_t *hp;
5182 int buddaboom, etype, scsi_status, completion_status;
5185 int buddaboom, scsi_status, completion_status;
5183 int req_status_flags, req_state_flags;
5184 uint8_t *snsp, *resp;
5186 int req_status_flags, req_state_flags;
5187 uint8_t *snsp, *resp;
5185 uint32_t rlen, slen;
5188 uint32_t rlen, slen, totslen;
5186 long resid;
5187 uint16_t oop;
5188
5189 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
5190 oop = optr;
5191 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
5192 nlooked++;
5193 read_again:

--- 35 unchanged lines hidden (view full) ---

5229 }
5230 for (i = 0; i < rio->req_header.rqs_seqno; i++) {
5231 isp_fastpost_complete(isp, rio->req_handles[i]);
5232 }
5233 if (isp->isp_fpcchiwater < rio->req_header.rqs_seqno) {
5234 isp->isp_fpcchiwater = rio->req_header.rqs_seqno;
5235 }
5236 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5189 long resid;
5190 uint16_t oop;
5191
5192 hp = (isphdr_t *) ISP_QUEUE_ENTRY(isp->isp_result, optr);
5193 oop = optr;
5194 optr = ISP_NXT_QENTRY(optr, RESULT_QUEUE_LEN(isp));
5195 nlooked++;
5196 read_again:

--- 35 unchanged lines hidden (view full) ---

5232 }
5233 for (i = 0; i < rio->req_header.rqs_seqno; i++) {
5234 isp_fastpost_complete(isp, rio->req_handles[i]);
5235 }
5236 if (isp->isp_fpcchiwater < rio->req_header.rqs_seqno) {
5237 isp->isp_fpcchiwater = rio->req_header.rqs_seqno;
5238 }
5239 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5240 last_etype = etype;
5237 continue;
5238 } else if (etype == RQSTYPE_RIO2) {
5241 continue;
5242 } else if (etype == RQSTYPE_RIO2) {
5239 isp_prt(isp, ISP_LOGERR, "dropping RIO2 response\n");
5243 isp_prt(isp, ISP_LOGERR, "dropping RIO2 response");
5240 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5244 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5245 last_etype = etype;
5241 continue;
5246 continue;
5247 } else if (etype == RQSTYPE_STATUS_CONT) {
5248 isp_get_cont_response(isp, (ispstatus_cont_t *) hp, (ispstatus_cont_t *) sp);
5249 if (last_etype == RQSTYPE_RESPONSE && continuations_expected && ndone > 0 && (xs = complist[ndone-1]) != NULL) {
5250 ispstatus_cont_t *scp = (ispstatus_cont_t *) sp;
5251 XS_SENSE_APPEND(xs, scp->req_sense_data, sizeof (scp->req_sense_data));
5252 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN, "%d more Status Continuations expected", --continuations_expected);
5253 } else {
5254 isp_prt(isp, ISP_LOG_WARN1, "Ignored Continuation Response");
5255 }
5256 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5257 continue;
5242 } else {
5243 /*
5244 * Somebody reachable via isp_handle_other_response
5245 * may have updated the response queue pointers for
5246 * us, so we reload our goal index.
5247 */
5248 int r;
5249 uint32_t tsto = oop;
5250 r = isp_handle_other_response(isp, etype, hp, &tsto);
5251 if (r < 0) {
5252 goto read_again;
5253 }
5254 /*
5255 * If somebody updated the output pointer, then reset
5256 * optr to be one more than the updated amount.
5257 */
5258 while (tsto != oop) {
5258 } else {
5259 /*
5260 * Somebody reachable via isp_handle_other_response
5261 * may have updated the response queue pointers for
5262 * us, so we reload our goal index.
5263 */
5264 int r;
5265 uint32_t tsto = oop;
5266 r = isp_handle_other_response(isp, etype, hp, &tsto);
5267 if (r < 0) {
5268 goto read_again;
5269 }
5270 /*
5271 * If somebody updated the output pointer, then reset
5272 * optr to be one more than the updated amount.
5273 */
5274 while (tsto != oop) {
5259 optr = ISP_NXT_QENTRY(tsto,
5260 RESULT_QUEUE_LEN(isp));
5275 optr = ISP_NXT_QENTRY(tsto, RESULT_QUEUE_LEN(isp));
5261 }
5262 if (r > 0) {
5263 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5264 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5276 }
5277 if (r > 0) {
5278 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5279 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5280 last_etype = etype;
5265 continue;
5266 }
5267
5268 /*
5269 * After this point, we'll just look at the header as
5270 * we don't know how to deal with the rest of the
5271 * response.
5272 */
5273
5274 /*
5275 * It really has to be a bounced request just copied
5276 * from the request queue to the response queue. If
5277 * not, something bad has happened.
5278 */
5279 if (etype != RQSTYPE_REQUEST) {
5281 continue;
5282 }
5283
5284 /*
5285 * After this point, we'll just look at the header as
5286 * we don't know how to deal with the rest of the
5287 * response.
5288 */
5289
5290 /*
5291 * It really has to be a bounced request just copied
5292 * from the request queue to the response queue. If
5293 * not, something bad has happened.
5294 */
5295 if (etype != RQSTYPE_REQUEST) {
5280 isp_prt(isp, ISP_LOGERR, notresp,
5281 etype, oop, optr, nlooked);
5282 isp_print_bytes(isp,
5283 "Request Queue Entry", QENTRY_LEN, sp);
5296 isp_prt(isp, ISP_LOGERR, notresp, etype, oop, optr, nlooked);
5297 isp_print_bytes(isp, "Request Queue Entry", QENTRY_LEN, sp);
5284 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5298 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5299 last_etype = etype;
5285 continue;
5286 }
5287 buddaboom = 1;
5288 scsi_status = sp->req_scsi_status;
5289 completion_status = sp->req_completion_status;
5290 req_status_flags = sp->req_status_flags;
5291 req_state_flags = sp->req_state_flags;
5292 resid = sp->req_resid;
5293 }
5294
5295 if (sp->req_header.rqs_flags & RQSFLAG_MASK) {
5296 if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
5297 isp_print_bytes(isp, "unexpected continuation segment", QENTRY_LEN, sp);
5298 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5300 continue;
5301 }
5302 buddaboom = 1;
5303 scsi_status = sp->req_scsi_status;
5304 completion_status = sp->req_completion_status;
5305 req_status_flags = sp->req_status_flags;
5306 req_state_flags = sp->req_state_flags;
5307 resid = sp->req_resid;
5308 }
5309
5310 if (sp->req_header.rqs_flags & RQSFLAG_MASK) {
5311 if (sp->req_header.rqs_flags & RQSFLAG_CONTINUATION) {
5312 isp_print_bytes(isp, "unexpected continuation segment", QENTRY_LEN, sp);
5313 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5314 last_etype = etype;
5299 continue;
5300 }
5301 if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
5315 continue;
5316 }
5317 if (sp->req_header.rqs_flags & RQSFLAG_FULL) {
5302 isp_prt(isp, ISP_LOGDEBUG0, "internal queues full");
5318 isp_prt(isp, ISP_LOG_WARN1, "internal queues full");
5303 /*
5304 * We'll synthesize a QUEUE FULL message below.
5305 */
5306 }
5307 if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
5308 isp_print_bytes(isp, "bad header flag", QENTRY_LEN, sp);
5309 buddaboom++;
5310 }
5311 if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
5312 isp_print_bytes(isp, "bad request packet", QENTRY_LEN, sp);
5313 buddaboom++;
5314 }
5315 if (sp->req_header.rqs_flags & RQSFLAG_BADCOUNT) {
5316 isp_print_bytes(isp, "invalid entry count", QENTRY_LEN, sp);
5317 buddaboom++;
5318 }
5319 if (sp->req_header.rqs_flags & RQSFLAG_BADORDER) {
5320 isp_print_bytes(isp, "invalid IOCB ordering", QENTRY_LEN, sp);
5321 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5319 /*
5320 * We'll synthesize a QUEUE FULL message below.
5321 */
5322 }
5323 if (sp->req_header.rqs_flags & RQSFLAG_BADHEADER) {
5324 isp_print_bytes(isp, "bad header flag", QENTRY_LEN, sp);
5325 buddaboom++;
5326 }
5327 if (sp->req_header.rqs_flags & RQSFLAG_BADPACKET) {
5328 isp_print_bytes(isp, "bad request packet", QENTRY_LEN, sp);
5329 buddaboom++;
5330 }
5331 if (sp->req_header.rqs_flags & RQSFLAG_BADCOUNT) {
5332 isp_print_bytes(isp, "invalid entry count", QENTRY_LEN, sp);
5333 buddaboom++;
5334 }
5335 if (sp->req_header.rqs_flags & RQSFLAG_BADORDER) {
5336 isp_print_bytes(isp, "invalid IOCB ordering", QENTRY_LEN, sp);
5337 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5338 last_etype = etype;
5322 continue;
5323 }
5324 }
5325
5326 if (!ISP_VALID_HANDLE(isp, sp->req_handle)) {
5327 isp_prt(isp, ISP_LOGERR, "bad request handle 0x%x (iocb type 0x%x)", sp->req_handle, etype);
5328 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5329 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5339 continue;
5340 }
5341 }
5342
5343 if (!ISP_VALID_HANDLE(isp, sp->req_handle)) {
5344 isp_prt(isp, ISP_LOGERR, "bad request handle 0x%x (iocb type 0x%x)", sp->req_handle, etype);
5345 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5346 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5347 last_etype = etype;
5330 continue;
5331 }
5332 xs = isp_find_xs(isp, sp->req_handle);
5333 if (xs == NULL) {
5334 uint8_t ts = completion_status & 0xff;
5335 /*
5336 * Only whine if this isn't the expected fallout of
5337 * aborting the command or resetting the target.
5338 */
5339 if (etype != RQSTYPE_RESPONSE) {
5340 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (type 0x%x)", sp->req_handle, etype);
5341 } else if (ts != RQCS_ABORTED && ts != RQCS_RESET_OCCURRED) {
5342 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (status 0x%x)", sp->req_handle, ts);
5343 }
5344 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5345 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5348 continue;
5349 }
5350 xs = isp_find_xs(isp, sp->req_handle);
5351 if (xs == NULL) {
5352 uint8_t ts = completion_status & 0xff;
5353 /*
5354 * Only whine if this isn't the expected fallout of
5355 * aborting the command or resetting the target.
5356 */
5357 if (etype != RQSTYPE_RESPONSE) {
5358 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (type 0x%x)", sp->req_handle, etype);
5359 } else if (ts != RQCS_ABORTED && ts != RQCS_RESET_OCCURRED) {
5360 isp_prt(isp, ISP_LOGERR, "cannot find handle 0x%x (status 0x%x)", sp->req_handle, ts);
5361 }
5362 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5363 ISP_WRITE(isp, isp->isp_respoutrp, optr);
5364 last_etype = etype;
5346 continue;
5347 }
5348 if (req_status_flags & RQSTF_BUS_RESET) {
5365 continue;
5366 }
5367 if (req_status_flags & RQSTF_BUS_RESET) {
5368 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%d bus was reset", XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5349 XS_SETERR(xs, HBA_BUSRESET);
5350 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
5351 }
5352 if (buddaboom) {
5369 XS_SETERR(xs, HBA_BUSRESET);
5370 ISP_SET_SENDMARKER(isp, XS_CHANNEL(xs), 1);
5371 }
5372 if (buddaboom) {
5373 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%d buddaboom", XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs));
5353 XS_SETERR(xs, HBA_BOTCH);
5354 }
5355
5356 resp = NULL;
5357 rlen = 0;
5358 snsp = NULL;
5374 XS_SETERR(xs, HBA_BOTCH);
5375 }
5376
5377 resp = NULL;
5378 rlen = 0;
5379 snsp = NULL;
5359 slen = 0;
5380 totslen = slen = 0;
5360 if (IS_24XX(isp) && (scsi_status & (RQCS_RV|RQCS_SV)) != 0) {
5361 resp = ((isp24xx_statusreq_t *)sp)->req_rsp_sense;
5362 rlen = ((isp24xx_statusreq_t *)sp)->req_response_len;
5363 } else if (IS_FC(isp) && (scsi_status & RQCS_RV) != 0) {
5364 resp = sp->req_response;
5365 rlen = sp->req_response_len;
5366 }
5367 if (IS_FC(isp) && (scsi_status & RQCS_SV) != 0) {
5368 /*
5369 * Fibre Channel F/W doesn't say we got status
5370 * if there's Sense Data instead. I guess they
5371 * think it goes w/o saying.
5372 */
5373 req_state_flags |= RQSF_GOT_STATUS|RQSF_GOT_SENSE;
5374 if (IS_24XX(isp)) {
5375 snsp = ((isp24xx_statusreq_t *)sp)->req_rsp_sense;
5376 snsp += rlen;
5381 if (IS_24XX(isp) && (scsi_status & (RQCS_RV|RQCS_SV)) != 0) {
5382 resp = ((isp24xx_statusreq_t *)sp)->req_rsp_sense;
5383 rlen = ((isp24xx_statusreq_t *)sp)->req_response_len;
5384 } else if (IS_FC(isp) && (scsi_status & RQCS_RV) != 0) {
5385 resp = sp->req_response;
5386 rlen = sp->req_response_len;
5387 }
5388 if (IS_FC(isp) && (scsi_status & RQCS_SV) != 0) {
5389 /*
5390 * Fibre Channel F/W doesn't say we got status
5391 * if there's Sense Data instead. I guess they
5392 * think it goes w/o saying.
5393 */
5394 req_state_flags |= RQSF_GOT_STATUS|RQSF_GOT_SENSE;
5395 if (IS_24XX(isp)) {
5396 snsp = ((isp24xx_statusreq_t *)sp)->req_rsp_sense;
5397 snsp += rlen;
5377 slen = ((isp24xx_statusreq_t *)sp)->req_sense_len;
5398 totslen = ((isp24xx_statusreq_t *)sp)->req_sense_len;
5399 slen = (sizeof (((isp24xx_statusreq_t *)sp)->req_rsp_sense)) - rlen;
5400 if (totslen < slen)
5401 slen = totslen;
5378 } else {
5379 snsp = sp->req_sense_data;
5402 } else {
5403 snsp = sp->req_sense_data;
5380 slen = sp->req_sense_len;
5404 totslen = sp->req_sense_len;
5405 slen = sizeof (sp->req_sense_data);
5406 if (totslen < slen)
5407 slen = totslen;
5381 }
5382 } else if (IS_SCSI(isp) && (req_state_flags & RQSF_GOT_SENSE)) {
5383 snsp = sp->req_sense_data;
5408 }
5409 } else if (IS_SCSI(isp) && (req_state_flags & RQSF_GOT_SENSE)) {
5410 snsp = sp->req_sense_data;
5384 slen = sp->req_sense_len;
5411 totslen = sp->req_sense_len;
5412 slen = sizeof (sp->req_sense_data);
5413 if (totslen < slen)
5414 slen = totslen;
5385 }
5386 if (req_state_flags & RQSF_GOT_STATUS) {
5387 *XS_STSP(xs) = scsi_status & 0xff;
5388 }
5389
5390 switch (etype) {
5391 case RQSTYPE_RESPONSE:
5392 if (resp && rlen >= 4 && resp[FCP_RSPNS_CODE_OFFSET] != 0) {

--- 44 unchanged lines hidden (view full) ---

5437 XS_SET_RESID(xs, 0);
5438 } else if (scsi_status & RQCS_RESID) {
5439 XS_SET_RESID(xs, resid);
5440 } else {
5441 XS_SET_RESID(xs, 0);
5442 }
5443 }
5444 if (snsp && slen) {
5415 }
5416 if (req_state_flags & RQSF_GOT_STATUS) {
5417 *XS_STSP(xs) = scsi_status & 0xff;
5418 }
5419
5420 switch (etype) {
5421 case RQSTYPE_RESPONSE:
5422 if (resp && rlen >= 4 && resp[FCP_RSPNS_CODE_OFFSET] != 0) {

--- 44 unchanged lines hidden (view full) ---

5467 XS_SET_RESID(xs, 0);
5468 } else if (scsi_status & RQCS_RESID) {
5469 XS_SET_RESID(xs, resid);
5470 } else {
5471 XS_SET_RESID(xs, 0);
5472 }
5473 }
5474 if (snsp && slen) {
5445 XS_SAVE_SENSE(xs, snsp, slen);
5475 if (totslen > slen) {
5476 continuations_expected += ((totslen - slen + QENTRY_LEN - 5) / (QENTRY_LEN - 4));
5477 if (ndone > (MAX_REQUESTQ_COMPLETIONS - continuations_expected - 1)) {
5478 /* we'll lose some stats, but that's a small price to pay */
5479 for (i = 0; i < ndone; i++) {
5480 if (complist[i]) {
5481 isp->isp_rsltccmplt++;
5482 isp_done(complist[i]);
5483 }
5484 }
5485 ndone = 0;
5486 }
5487 isp_prt(isp, ISP_LOGDEBUG0|ISP_LOG_CWARN, "Expecting %d more Status Continuations for total sense length of %u",
5488 continuations_expected, totslen);
5489 }
5490 XS_SAVE_SENSE(xs, snsp, totslen, slen);
5446 } else if ((req_status_flags & RQSF_GOT_STATUS) && (scsi_status & 0xff) == SCSI_CHECK && IS_FC(isp)) {
5447 isp_prt(isp, ISP_LOGWARN, "CHECK CONDITION w/o sense data for CDB=0x%x", XS_CDBP(xs)[0] & 0xff);
5448 isp_print_bytes(isp, "CC with no Sense", QENTRY_LEN, qe);
5449 }
5450 isp_prt(isp, ISP_LOGDEBUG2, "asked for %ld got raw resid %ld settled for %ld", (long) XS_XFRLEN(xs), resid, (long) XS_GET_RESID(xs));
5451 break;
5452 case RQSTYPE_REQUEST:
5453 case RQSTYPE_A64:
5454 case RQSTYPE_T2RQS:
5455 case RQSTYPE_T3RQS:
5456 case RQSTYPE_T7RQS:
5457 if (!IS_24XX(isp) && (sp->req_header.rqs_flags & RQSFLAG_FULL)) {
5458 /*
5459 * Force Queue Full status.
5460 */
5461 *XS_STSP(xs) = SCSI_QFULL;
5462 XS_SETERR(xs, HBA_NOERROR);
5463 } else if (XS_NOERR(xs)) {
5491 } else if ((req_status_flags & RQSF_GOT_STATUS) && (scsi_status & 0xff) == SCSI_CHECK && IS_FC(isp)) {
5492 isp_prt(isp, ISP_LOGWARN, "CHECK CONDITION w/o sense data for CDB=0x%x", XS_CDBP(xs)[0] & 0xff);
5493 isp_print_bytes(isp, "CC with no Sense", QENTRY_LEN, qe);
5494 }
5495 isp_prt(isp, ISP_LOGDEBUG2, "asked for %ld got raw resid %ld settled for %ld", (long) XS_XFRLEN(xs), resid, (long) XS_GET_RESID(xs));
5496 break;
5497 case RQSTYPE_REQUEST:
5498 case RQSTYPE_A64:
5499 case RQSTYPE_T2RQS:
5500 case RQSTYPE_T3RQS:
5501 case RQSTYPE_T7RQS:
5502 if (!IS_24XX(isp) && (sp->req_header.rqs_flags & RQSFLAG_FULL)) {
5503 /*
5504 * Force Queue Full status.
5505 */
5506 *XS_STSP(xs) = SCSI_QFULL;
5507 XS_SETERR(xs, HBA_NOERROR);
5508 } else if (XS_NOERR(xs)) {
5509 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%d badness at %s:%u", XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), __func__, __LINE__);
5464 XS_SETERR(xs, HBA_BOTCH);
5465 }
5466 XS_SET_RESID(xs, XS_XFRLEN(xs));
5467 break;
5468 default:
5469 isp_print_bytes(isp, "Unhandled Response Type", QENTRY_LEN, qe);
5470 if (XS_NOERR(xs)) {
5471 XS_SETERR(xs, HBA_BOTCH);

--- 5 unchanged lines hidden (view full) ---

5477 * Free any DMA resources. As a side effect, this may
5478 * also do any cache flushing necessary for data coherence.
5479 */
5480 if (XS_XFRLEN(xs)) {
5481 ISP_DMAFREE(isp, xs, sp->req_handle);
5482 }
5483 isp_destroy_handle(isp, sp->req_handle);
5484
5510 XS_SETERR(xs, HBA_BOTCH);
5511 }
5512 XS_SET_RESID(xs, XS_XFRLEN(xs));
5513 break;
5514 default:
5515 isp_print_bytes(isp, "Unhandled Response Type", QENTRY_LEN, qe);
5516 if (XS_NOERR(xs)) {
5517 XS_SETERR(xs, HBA_BOTCH);

--- 5 unchanged lines hidden (view full) ---

5523 * Free any DMA resources. As a side effect, this may
5524 * also do any cache flushing necessary for data coherence.
5525 */
5526 if (XS_XFRLEN(xs)) {
5527 ISP_DMAFREE(isp, xs, sp->req_handle);
5528 }
5529 isp_destroy_handle(isp, sp->req_handle);
5530
5485 if (((isp->isp_dblev & (ISP_LOGDEBUG1|ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
5486 ((isp->isp_dblev & (ISP_LOGDEBUG0|ISP_LOG_CWARN) && ((!XS_NOERR(xs)) || (*XS_STSP(xs) != SCSI_GOOD))))) {
5487 isp_prt_endcmd(isp, xs);
5488 }
5489 if (isp->isp_nactive > 0) {
5490 isp->isp_nactive--;
5491 }
5492 complist[ndone++] = xs; /* defer completion call until later */
5493 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5531 if (isp->isp_nactive > 0) {
5532 isp->isp_nactive--;
5533 }
5534 complist[ndone++] = xs; /* defer completion call until later */
5535 ISP_MEMZERO(hp, QENTRY_LEN); /* PERF */
5536 last_etype = etype;
5494 if (ndone == MAX_REQUESTQ_COMPLETIONS) {
5495 break;
5496 }
5497 }
5498
5499 /*
5500 * If we looked at any commands, then it's valid to find out
5501 * what the outpointer is. It also is a trigger to update the

--- 18 unchanged lines hidden (view full) ---

5520 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
5521 ISP_WRITE(isp, BIU_SEMA, 0);
5522 }
5523
5524 isp->isp_residx = optr;
5525 for (i = 0; i < ndone; i++) {
5526 xs = complist[i];
5527 if (xs) {
5537 if (ndone == MAX_REQUESTQ_COMPLETIONS) {
5538 break;
5539 }
5540 }
5541
5542 /*
5543 * If we looked at any commands, then it's valid to find out
5544 * what the outpointer is. It also is a trigger to update the

--- 18 unchanged lines hidden (view full) ---

5563 ISP_WRITE(isp, HCCR, HCCR_CMD_CLEAR_RISC_INT);
5564 ISP_WRITE(isp, BIU_SEMA, 0);
5565 }
5566
5567 isp->isp_residx = optr;
5568 for (i = 0; i < ndone; i++) {
5569 xs = complist[i];
5570 if (xs) {
5571 if (((isp->isp_dblev & (ISP_LOGDEBUG1|ISP_LOGDEBUG2|ISP_LOGDEBUG3))) ||
5572 ((isp->isp_dblev & (ISP_LOGDEBUG0|ISP_LOG_CWARN) && ((!XS_NOERR(xs)) || (*XS_STSP(xs) != SCSI_GOOD))))) {
5573 isp_prt_endcmd(isp, xs);
5574 }
5528 isp->isp_rsltccmplt++;
5529 isp_done(xs);
5530 }
5531 }
5532}
5533
5534/*
5535 * Support routines.

--- 6 unchanged lines hidden (view full) ---

5542 int i, lim;
5543
5544 lim = XS_CDBLEN(xs) > 16? 16 : XS_CDBLEN(xs);
5545 ISP_SNPRINTF(cdbstr, sizeof (cdbstr), "0x%02x ", XS_CDBP(xs)[0]);
5546 for (i = 1; i < lim; i++) {
5547 ISP_SNPRINTF(cdbstr, sizeof (cdbstr), "%s0x%02x ", cdbstr, XS_CDBP(xs)[i]);
5548 }
5549 if (XS_SENSE_VALID(xs)) {
5575 isp->isp_rsltccmplt++;
5576 isp_done(xs);
5577 }
5578 }
5579}
5580
5581/*
5582 * Support routines.

--- 6 unchanged lines hidden (view full) ---

5589 int i, lim;
5590
5591 lim = XS_CDBLEN(xs) > 16? 16 : XS_CDBLEN(xs);
5592 ISP_SNPRINTF(cdbstr, sizeof (cdbstr), "0x%02x ", XS_CDBP(xs)[0]);
5593 for (i = 1; i < lim; i++) {
5594 ISP_SNPRINTF(cdbstr, sizeof (cdbstr), "%s0x%02x ", cdbstr, XS_CDBP(xs)[i]);
5595 }
5596 if (XS_SENSE_VALID(xs)) {
5550 isp_xs_prt(isp, xs, ISP_LOGALL, "FIN dl%d resid %ld CDB=%s KEY/ASC/ASCQ=0x%02x/0x%02x/0x%02x",
5551 XS_XFRLEN(xs), (long) XS_GET_RESID(xs), cdbstr, XS_SNSKEY(xs), XS_SNSASC(xs), XS_SNSASCQ(xs));
5597 isp_xs_prt(isp, xs, ISP_LOGALL, "FIN dl%d resid %ld CDB=%s SenseLength=%u/%u KEY/ASC/ASCQ=0x%02x/0x%02x/0x%02x",
5598 XS_XFRLEN(xs), (long) XS_GET_RESID(xs), cdbstr, XS_CUR_SNSLEN(xs), XS_TOT_SNSLEN(xs), XS_SNSKEY(xs), XS_SNSASC(xs), XS_SNSASCQ(xs));
5552 } else {
5553 isp_xs_prt(isp, xs, ISP_LOGALL, "FIN dl%d resid %ld CDB=%s STS 0x%x XS_ERR=0x%x", XS_XFRLEN(xs), (long) XS_GET_RESID(xs), cdbstr, *XS_STSP(xs), XS_ERR(xs));
5554 }
5555}
5556
5557/*
5558 * Parse an ASYNC mailbox complete
5559 *

--- 311 unchanged lines hidden (view full) ---

5871 if (ISP_H2HT(hdp->handle) != ISP_HANDLE_INITIATOR) {
5872 continue;
5873 }
5874 xs = hdp->cmd;
5875 if (XS_CHANNEL(xs) != chan) {
5876 continue;
5877 }
5878 j++;
5599 } else {
5600 isp_xs_prt(isp, xs, ISP_LOGALL, "FIN dl%d resid %ld CDB=%s STS 0x%x XS_ERR=0x%x", XS_XFRLEN(xs), (long) XS_GET_RESID(xs), cdbstr, *XS_STSP(xs), XS_ERR(xs));
5601 }
5602}
5603
5604/*
5605 * Parse an ASYNC mailbox complete
5606 *

--- 311 unchanged lines hidden (view full) ---

5918 if (ISP_H2HT(hdp->handle) != ISP_HANDLE_INITIATOR) {
5919 continue;
5920 }
5921 xs = hdp->cmd;
5922 if (XS_CHANNEL(xs) != chan) {
5923 continue;
5924 }
5925 j++;
5926 isp_prt(isp, ISP_LOG_WARN1, "%d.%d.%d bus reset set at %s:%u", XS_CHANNEL(xs), XS_TGT(xs), XS_LUN(xs), __func__, __LINE__);
5879 XS_SETERR(xs, HBA_BUSRESET);
5880 }
5881 if (j) {
5882 isp_prt(isp, ISP_LOGERR, lipd, chan, j);
5883 }
5884 }
5885 }
5886 break;

--- 210 unchanged lines hidden (view full) ---

6097 * this is not used currently.
6098 */
6099
6100static int
6101isp_handle_other_response(ispsoftc_t *isp, int type, isphdr_t *hp, uint32_t *optrp)
6102{
6103 switch (type) {
6104 case RQSTYPE_STATUS_CONT:
5927 XS_SETERR(xs, HBA_BUSRESET);
5928 }
5929 if (j) {
5930 isp_prt(isp, ISP_LOGERR, lipd, chan, j);
5931 }
5932 }
5933 }
5934 break;

--- 210 unchanged lines hidden (view full) ---

6145 * this is not used currently.
6146 */
6147
6148static int
6149isp_handle_other_response(ispsoftc_t *isp, int type, isphdr_t *hp, uint32_t *optrp)
6150{
6151 switch (type) {
6152 case RQSTYPE_STATUS_CONT:
6105 isp_prt(isp, ISP_LOGDEBUG0, "Ignored Continuation Response");
6153 isp_prt(isp, ISP_LOG_WARN1, "Ignored Continuation Response");
6106 return (1);
6107 case RQSTYPE_MARKER:
6154 return (1);
6155 case RQSTYPE_MARKER:
6108 isp_prt(isp, ISP_LOGDEBUG0, "Marker Response");
6156 isp_prt(isp, ISP_LOG_WARN1, "Marker Response");
6109 return (1);
6110 case RQSTYPE_ATIO:
6111 case RQSTYPE_CTIO:
6112 case RQSTYPE_ENABLE_LUN:
6113 case RQSTYPE_MODIFY_LUN:
6114 case RQSTYPE_NOTIFY:
6115 case RQSTYPE_NOTIFY_ACK:
6116 case RQSTYPE_CTIO1:

--- 48 unchanged lines hidden (view full) ---

6165 case RQCS_COMPLETE:
6166 if (XS_NOERR(xs)) {
6167 XS_SETERR(xs, HBA_NOERROR);
6168 }
6169 return;
6170
6171 case RQCS_INCOMPLETE:
6172 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
6157 return (1);
6158 case RQSTYPE_ATIO:
6159 case RQSTYPE_CTIO:
6160 case RQSTYPE_ENABLE_LUN:
6161 case RQSTYPE_MODIFY_LUN:
6162 case RQSTYPE_NOTIFY:
6163 case RQSTYPE_NOTIFY_ACK:
6164 case RQSTYPE_CTIO1:

--- 48 unchanged lines hidden (view full) ---

6213 case RQCS_COMPLETE:
6214 if (XS_NOERR(xs)) {
6215 XS_SETERR(xs, HBA_NOERROR);
6216 }
6217 return;
6218
6219 case RQCS_INCOMPLETE:
6220 if ((sp->req_state_flags & RQSF_GOT_TARGET) == 0) {
6173 isp_xs_prt(isp, xs, ISP_LOGDEBUG1, "Selection Timeout");
6221 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Selection Timeout @ %s:%d", __func__, __LINE__);
6174 if (XS_NOERR(xs)) {
6175 XS_SETERR(xs, HBA_SELTIMEOUT);
6176 *rp = XS_XFRLEN(xs);
6177 }
6178 return;
6179 }
6180 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Incomplete, state 0x%x", sp->req_state_flags);
6181 break;

--- 179 unchanged lines hidden (view full) ---

6361 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued cmd when queueing disabled");
6362 break;
6363
6364 case RQCS_BAD_ENTRY:
6365 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
6366 break;
6367
6368 case RQCS_QUEUE_FULL:
6222 if (XS_NOERR(xs)) {
6223 XS_SETERR(xs, HBA_SELTIMEOUT);
6224 *rp = XS_XFRLEN(xs);
6225 }
6226 return;
6227 }
6228 isp_xs_prt(isp, xs, ISP_LOGERR, "Command Incomplete, state 0x%x", sp->req_state_flags);
6229 break;

--- 179 unchanged lines hidden (view full) ---

6409 isp_xs_prt(isp, xs, ISP_LOGERR, "HBA attempted queued cmd when queueing disabled");
6410 break;
6411
6412 case RQCS_BAD_ENTRY:
6413 isp_prt(isp, ISP_LOGERR, "Invalid IOCB entry type detected");
6414 break;
6415
6416 case RQCS_QUEUE_FULL:
6369 isp_xs_prt(isp, xs, ISP_LOGDEBUG0, "internal queues full status 0x%x", *XS_STSP(xs));
6417 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "internal queues full status 0x%x", *XS_STSP(xs));
6370
6371 /*
6372 * If QFULL or some other status byte is set, then this
6373 * isn't an error, per se.
6374 *
6375 * Unfortunately, some QLogic f/w writers have, in
6376 * some cases, ommitted to *set* status to QFULL.
6418
6419 /*
6420 * If QFULL or some other status byte is set, then this
6421 * isn't an error, per se.
6422 *
6423 * Unfortunately, some QLogic f/w writers have, in
6424 * some cases, ommitted to *set* status to QFULL.
6377 *
6378
6425 */
6426#if 0
6379 if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
6380 XS_SETERR(xs, HBA_NOERROR);
6381 return;
6382 }
6383
6427 if (*XS_STSP(xs) != SCSI_GOOD && XS_NOERR(xs)) {
6428 XS_SETERR(xs, HBA_NOERROR);
6429 return;
6430 }
6431
6384 *
6385 *
6386 */
6387
6432#endif
6388 *XS_STSP(xs) = SCSI_QFULL;
6389 XS_SETERR(xs, HBA_NOERROR);
6390 return;
6391
6392 case RQCS_PHASE_SKIPPED:
6393 isp_xs_prt(isp, xs, ISP_LOGERR, "SCSI phase skipped");
6394 break;
6395

--- 45 unchanged lines hidden (view full) ---

6441 * It was there (maybe)- treat as a selection timeout.
6442 */
6443 if (sts == RQCS_PORT_UNAVAILABLE) {
6444 reason = "unavailable";
6445 } else {
6446 reason = "logout";
6447 }
6448
6433 *XS_STSP(xs) = SCSI_QFULL;
6434 XS_SETERR(xs, HBA_NOERROR);
6435 return;
6436
6437 case RQCS_PHASE_SKIPPED:
6438 isp_xs_prt(isp, xs, ISP_LOGERR, "SCSI phase skipped");
6439 break;
6440

--- 45 unchanged lines hidden (view full) ---

6486 * It was there (maybe)- treat as a selection timeout.
6487 */
6488 if (sts == RQCS_PORT_UNAVAILABLE) {
6489 reason = "unavailable";
6490 } else {
6491 reason = "logout";
6492 }
6493
6449 isp_prt(isp, ISP_LOGINFO, "port %s for target %d",
6450 reason, XS_TGT(xs));
6494 isp_prt(isp, ISP_LOGINFO, "port %s for target %d", reason, XS_TGT(xs));
6451
6452 /*
6453 * If we're on a local loop, force a LIP (which is overkill)
6454 * to force a re-login of this unit. If we're on fabric,
6455 * then we'll have to log in again as a matter of course.
6456 */
6457 if (FCPARAM(isp, 0)->isp_topo == TOPO_NL_PORT ||
6458 FCPARAM(isp, 0)->isp_topo == TOPO_FL_PORT) {

--- 5 unchanged lines hidden (view full) ---

6464 isp_mboxcmd_qnw(isp, &mbs, 1);
6465 }
6466 if (XS_NOERR(xs)) {
6467 XS_SETERR(xs, HBA_SELTIMEOUT);
6468 }
6469 return;
6470 }
6471 case RQCS_PORT_CHANGED:
6495
6496 /*
6497 * If we're on a local loop, force a LIP (which is overkill)
6498 * to force a re-login of this unit. If we're on fabric,
6499 * then we'll have to log in again as a matter of course.
6500 */
6501 if (FCPARAM(isp, 0)->isp_topo == TOPO_NL_PORT ||
6502 FCPARAM(isp, 0)->isp_topo == TOPO_FL_PORT) {

--- 5 unchanged lines hidden (view full) ---

6508 isp_mboxcmd_qnw(isp, &mbs, 1);
6509 }
6510 if (XS_NOERR(xs)) {
6511 XS_SETERR(xs, HBA_SELTIMEOUT);
6512 }
6513 return;
6514 }
6515 case RQCS_PORT_CHANGED:
6472 isp_prt(isp, ISP_LOGWARN,
6473 "port changed for target %d", XS_TGT(xs));
6516 isp_prt(isp, ISP_LOGWARN, "port changed for target %d", XS_TGT(xs));
6474 if (XS_NOERR(xs)) {
6475 XS_SETERR(xs, HBA_SELTIMEOUT);
6476 }
6477 return;
6478
6479 case RQCS_PORT_BUSY:
6517 if (XS_NOERR(xs)) {
6518 XS_SETERR(xs, HBA_SELTIMEOUT);
6519 }
6520 return;
6521
6522 case RQCS_PORT_BUSY:
6480 isp_prt(isp, ISP_LOGWARN,
6481 "port busy for target %d", XS_TGT(xs));
6523 isp_prt(isp, ISP_LOGWARN, "port busy for target %d", XS_TGT(xs));
6482 if (XS_NOERR(xs)) {
6483 XS_SETERR(xs, HBA_TGTBSY);
6484 }
6485 return;
6486
6487 default:
6524 if (XS_NOERR(xs)) {
6525 XS_SETERR(xs, HBA_TGTBSY);
6526 }
6527 return;
6528
6529 default:
6488 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x",
6489 sp->req_completion_status);
6530 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x", sp->req_completion_status);
6490 break;
6491 }
6492 if (XS_NOERR(xs)) {
6493 XS_SETERR(xs, HBA_BOTCH);
6494 }
6495}
6496
6497static void

--- 44 unchanged lines hidden (view full) ---

6542 XS_SET_RESID(xs, sp->req_resid);
6543 isp_xs_prt(isp, xs, ISP_LOGERR, "Data Overrun");
6544 if (XS_NOERR(xs)) {
6545 XS_SETERR(xs, HBA_DATAOVR);
6546 }
6547 return;
6548
6549 case RQCS_24XX_DRE: /* data reassembly error */
6531 break;
6532 }
6533 if (XS_NOERR(xs)) {
6534 XS_SETERR(xs, HBA_BOTCH);
6535 }
6536}
6537
6538static void

--- 44 unchanged lines hidden (view full) ---

6583 XS_SET_RESID(xs, sp->req_resid);
6584 isp_xs_prt(isp, xs, ISP_LOGERR, "Data Overrun");
6585 if (XS_NOERR(xs)) {
6586 XS_SETERR(xs, HBA_DATAOVR);
6587 }
6588 return;
6589
6590 case RQCS_24XX_DRE: /* data reassembly error */
6550 isp_prt(isp, ISP_LOGERR,
6551 "Chan %d data reassembly error for target %d",
6552 chan, XS_TGT(xs));
6591 isp_prt(isp, ISP_LOGERR, "Chan %d data reassembly error for target %d", chan, XS_TGT(xs));
6553 if (XS_NOERR(xs)) {
6554 XS_SETERR(xs, HBA_ABORTED);
6555 }
6556 *rp = XS_XFRLEN(xs);
6557 return;
6558
6559 case RQCS_24XX_TABORT: /* aborted by target */
6592 if (XS_NOERR(xs)) {
6593 XS_SETERR(xs, HBA_ABORTED);
6594 }
6595 *rp = XS_XFRLEN(xs);
6596 return;
6597
6598 case RQCS_24XX_TABORT: /* aborted by target */
6560 isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS",
6561 chan, XS_TGT(xs));
6599 isp_prt(isp, ISP_LOGERR, "Chan %d target %d sent ABTS", chan, XS_TGT(xs));
6562 if (XS_NOERR(xs)) {
6563 XS_SETERR(xs, HBA_ABORTED);
6564 }
6565 return;
6566
6567 case RQCS_DATA_UNDERRUN:
6568 ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
6569 /*

--- 5 unchanged lines hidden (view full) ---

6575 (sp->req_resid > XS_XFRLEN(xs))) {
6576 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6577 if (XS_NOERR(xs)) {
6578 XS_SETERR(xs, HBA_BOTCH);
6579 }
6580 return;
6581 }
6582 XS_SET_RESID(xs, sp->req_resid);
6600 if (XS_NOERR(xs)) {
6601 XS_SETERR(xs, HBA_ABORTED);
6602 }
6603 return;
6604
6605 case RQCS_DATA_UNDERRUN:
6606 ru_marked = (sp->req_scsi_status & RQCS_RU) != 0;
6607 /*

--- 5 unchanged lines hidden (view full) ---

6613 (sp->req_resid > XS_XFRLEN(xs))) {
6614 isp_xs_prt(isp, xs, ISP_LOGWARN, bun, XS_XFRLEN(xs), sp->req_resid, (ru_marked)? "marked" : "not marked");
6615 if (XS_NOERR(xs)) {
6616 XS_SETERR(xs, HBA_BOTCH);
6617 }
6618 return;
6619 }
6620 XS_SET_RESID(xs, sp->req_resid);
6583 isp_xs_prt(isp, xs, ISP_LOGDEBUG0, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
6621 isp_xs_prt(isp, xs, ISP_LOG_WARN1, "Data Underrun (%d) for command 0x%x", sp->req_resid, XS_CDBP(xs)[0] & 0xff);
6584 if (XS_NOERR(xs)) {
6585 XS_SETERR(xs, HBA_NOERROR);
6586 }
6587 return;
6588
6589 case RQCS_PORT_UNAVAILABLE:
6590 /*
6591 * No such port on the loop. Moral equivalent of SELTIMEO

--- 19 unchanged lines hidden (view full) ---

6611 * There is no MBOX_INIT_LIP for the 24XX.
6612 */
6613 if (XS_NOERR(xs)) {
6614 XS_SETERR(xs, HBA_SELTIMEOUT);
6615 }
6616 return;
6617 }
6618 case RQCS_PORT_CHANGED:
6622 if (XS_NOERR(xs)) {
6623 XS_SETERR(xs, HBA_NOERROR);
6624 }
6625 return;
6626
6627 case RQCS_PORT_UNAVAILABLE:
6628 /*
6629 * No such port on the loop. Moral equivalent of SELTIMEO

--- 19 unchanged lines hidden (view full) ---

6649 * There is no MBOX_INIT_LIP for the 24XX.
6650 */
6651 if (XS_NOERR(xs)) {
6652 XS_SETERR(xs, HBA_SELTIMEOUT);
6653 }
6654 return;
6655 }
6656 case RQCS_PORT_CHANGED:
6619 isp_prt(isp, ISP_LOGWARN,
6620 "port changed for target %d chan %d", XS_TGT(xs), chan);
6657 isp_prt(isp, ISP_LOGWARN, "port changed for target %d chan %d", XS_TGT(xs), chan);
6621 if (XS_NOERR(xs)) {
6622 XS_SETERR(xs, HBA_SELTIMEOUT);
6623 }
6624 return;
6625
6626
6627 case RQCS_24XX_ENOMEM: /* f/w resource unavailable */
6658 if (XS_NOERR(xs)) {
6659 XS_SETERR(xs, HBA_SELTIMEOUT);
6660 }
6661 return;
6662
6663
6664 case RQCS_24XX_ENOMEM: /* f/w resource unavailable */
6628 isp_prt(isp, ISP_LOGWARN,
6629 "f/w resource unavailable for target %d chan %d",
6630 XS_TGT(xs), chan);
6665 isp_prt(isp, ISP_LOGWARN, "f/w resource unavailable for target %d chan %d", XS_TGT(xs), chan);
6631 if (XS_NOERR(xs)) {
6632 *XS_STSP(xs) = SCSI_BUSY;
6633 XS_SETERR(xs, HBA_TGTBSY);
6634 }
6635 return;
6636
6637 case RQCS_24XX_TMO: /* task management overrun */
6666 if (XS_NOERR(xs)) {
6667 *XS_STSP(xs) = SCSI_BUSY;
6668 XS_SETERR(xs, HBA_TGTBSY);
6669 }
6670 return;
6671
6672 case RQCS_24XX_TMO: /* task management overrun */
6638 isp_prt(isp, ISP_LOGWARN,
6639 "command for target %d overlapped task management for "
6640 "chan %d", XS_TGT(xs), chan);
6673 isp_prt(isp, ISP_LOGWARN, "command for target %d overlapped task management for chan %d", XS_TGT(xs), chan);
6641 if (XS_NOERR(xs)) {
6642 *XS_STSP(xs) = SCSI_BUSY;
6643 XS_SETERR(xs, HBA_TGTBSY);
6644 }
6645 return;
6646
6647 default:
6674 if (XS_NOERR(xs)) {
6675 *XS_STSP(xs) = SCSI_BUSY;
6676 XS_SETERR(xs, HBA_TGTBSY);
6677 }
6678 return;
6679
6680 default:
6648 isp_prt(isp, ISP_LOGERR,
6649 "Unknown Completion Status 0x%x on chan %d",
6650 sp->req_completion_status, chan);
6681 isp_prt(isp, ISP_LOGERR, "Unknown Completion Status 0x%x on chan %d", sp->req_completion_status, chan);
6651 break;
6652 }
6653 if (XS_NOERR(xs)) {
6654 XS_SETERR(xs, HBA_BOTCH);
6655 }
6656}
6657
6658static void

--- 327 unchanged lines hidden (view full) ---

6986 ISP_FC_OPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
6987 ISP_FC_OPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
6988 ISP_FC_OPMAP(0x0f, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */
6989 ISP_FC_OPMAP(0xdf, 0x01), /* 0x03: MBOX_DUMP_RAM */
6990 ISP_FC_OPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
6991 ISP_FC_OPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
6992 ISP_FC_OPMAP_FULL(0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff), /* 0x06: MBOX_MAILBOX_REG_TEST */
6993 ISP_FC_OPMAP(0x07, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */
6682 break;
6683 }
6684 if (XS_NOERR(xs)) {
6685 XS_SETERR(xs, HBA_BOTCH);
6686 }
6687}
6688
6689static void

--- 327 unchanged lines hidden (view full) ---

7017 ISP_FC_OPMAP(0x01, 0x01), /* 0x00: MBOX_NO_OP */
7018 ISP_FC_OPMAP(0x1f, 0x01), /* 0x01: MBOX_LOAD_RAM */
7019 ISP_FC_OPMAP(0x0f, 0x01), /* 0x02: MBOX_EXEC_FIRMWARE */
7020 ISP_FC_OPMAP(0xdf, 0x01), /* 0x03: MBOX_DUMP_RAM */
7021 ISP_FC_OPMAP(0x07, 0x07), /* 0x04: MBOX_WRITE_RAM_WORD */
7022 ISP_FC_OPMAP(0x03, 0x07), /* 0x05: MBOX_READ_RAM_WORD */
7023 ISP_FC_OPMAP_FULL(0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff), /* 0x06: MBOX_MAILBOX_REG_TEST */
7024 ISP_FC_OPMAP(0x07, 0x07), /* 0x07: MBOX_VERIFY_CHECKSUM */
6994 ISP_FC_OPMAP_FULL(0x0, 0x0, 0x0, 0x01, 0x0, 0x3, 0x80, 0x4f), /* 0x08: MBOX_ABOUT_FIRMWARE */
7025 ISP_FC_OPMAP_FULL(0x0, 0x0, 0x0, 0x01, 0x0, 0x3, 0x80, 0x7f), /* 0x08: MBOX_ABOUT_FIRMWARE */
6995 ISP_FC_OPMAP(0xdf, 0x01), /* 0x09: MBOX_LOAD_RISC_RAM_2100 */
6996 ISP_FC_OPMAP(0xdf, 0x01), /* 0x0a: DUMP RAM */
6997 ISP_FC_OPMAP_HALF(0x1, 0xff, 0x0, 0x01), /* 0x0b: MBOX_LOAD_RISC_RAM */
6998 ISP_FC_OPMAP(0x00, 0x00), /* 0x0c: */
6999 ISP_FC_OPMAP_HALF(0x1, 0x0f, 0x0, 0x01), /* 0x0d: MBOX_WRITE_RAM_WORD_EXTENDED */
7000 ISP_FC_OPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
7001 ISP_FC_OPMAP_HALF(0x1, 0x03, 0x0, 0x0d), /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED */
7002 ISP_FC_OPMAP(0x1f, 0x11), /* 0x10: MBOX_INIT_REQ_QUEUE */

--- 1467 unchanged lines hidden --- 		7026 ISP_FC_OPMAP(0xdf, 0x01), /* 0x09: MBOX_LOAD_RISC_RAM_2100 */
7027 ISP_FC_OPMAP(0xdf, 0x01), /* 0x0a: DUMP RAM */
7028 ISP_FC_OPMAP_HALF(0x1, 0xff, 0x0, 0x01), /* 0x0b: MBOX_LOAD_RISC_RAM */
7029 ISP_FC_OPMAP(0x00, 0x00), /* 0x0c: */
7030 ISP_FC_OPMAP_HALF(0x1, 0x0f, 0x0, 0x01), /* 0x0d: MBOX_WRITE_RAM_WORD_EXTENDED */
7031 ISP_FC_OPMAP(0x01, 0x05), /* 0x0e: MBOX_CHECK_FIRMWARE */
7032 ISP_FC_OPMAP_HALF(0x1, 0x03, 0x0, 0x0d), /* 0x0f: MBOX_READ_RAM_WORD_EXTENDED */
7033 ISP_FC_OPMAP(0x1f, 0x11), /* 0x10: MBOX_INIT_REQ_QUEUE */

--- 1467 unchanged lines hidden ---