2003-05-03 22:10:37 +04:00
|
|
|
/* $NetBSD: ispvar.h,v 1.60 2003/05/03 18:11:21 wiz Exp $ */
|
2000-08-14 11:12:15 +04:00
|
|
|
/*
|
|
|
|
* This driver, which is contained in NetBSD in the files:
|
|
|
|
*
|
|
|
|
* sys/dev/ic/isp.c
|
2000-12-23 04:37:57 +03:00
|
|
|
* sys/dev/ic/isp_inline.h
|
|
|
|
* sys/dev/ic/isp_netbsd.c
|
|
|
|
* sys/dev/ic/isp_netbsd.h
|
|
|
|
* sys/dev/ic/isp_target.c
|
|
|
|
* sys/dev/ic/isp_target.h
|
|
|
|
* sys/dev/ic/isp_tpublic.h
|
|
|
|
* sys/dev/ic/ispmbox.h
|
|
|
|
* sys/dev/ic/ispreg.h
|
|
|
|
* sys/dev/ic/ispvar.h
|
2000-08-14 11:12:15 +04:00
|
|
|
* sys/microcode/isp/asm_sbus.h
|
|
|
|
* sys/microcode/isp/asm_1040.h
|
|
|
|
* sys/microcode/isp/asm_1080.h
|
|
|
|
* sys/microcode/isp/asm_12160.h
|
|
|
|
* sys/microcode/isp/asm_2100.h
|
|
|
|
* sys/microcode/isp/asm_2200.h
|
|
|
|
* sys/pci/isp_pci.c
|
|
|
|
* sys/sbus/isp_sbus.c
|
|
|
|
*
|
|
|
|
* Is being actively maintained by Matthew Jacob (mjacob@netbsd.org).
|
|
|
|
* This driver also is shared source with FreeBSD, OpenBSD, Linux, Solaris,
|
|
|
|
* Linux versions. This tends to be an interesting maintenance problem.
|
|
|
|
*
|
|
|
|
* Please coordinate with Matthew Jacob on changes you wish to make here.
|
|
|
|
*/
|
1997-03-12 23:44:50 +03:00
|
|
|
/*
|
1999-10-14 06:21:50 +04:00
|
|
|
* Copyright (C) 1999 National Aeronautics & Space Administration
|
1997-03-12 23:44:50 +03:00
|
|
|
* All rights reserved.
|
1999-07-06 00:31:35 +04:00
|
|
|
*
|
1997-03-12 23:44:50 +03:00
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
* are met:
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
1999-07-06 00:31:35 +04:00
|
|
|
* notice, this list of conditions and the following disclaimer.
|
1997-03-12 23:44:50 +03:00
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
* 3. The name of the author may not be used to endorse or promote products
|
1999-07-06 00:31:35 +04:00
|
|
|
* derived from this software without specific prior written permission
|
1998-07-15 23:50:16 +04:00
|
|
|
*
|
1999-07-06 00:31:35 +04:00
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
1997-03-12 23:44:50 +03:00
|
|
|
*/
|
1997-03-13 00:06:41 +03:00
|
|
|
|
1999-07-06 00:31:35 +04:00
|
|
|
/*
|
|
|
|
* Soft Definitions for for Qlogic ISP SCSI adapters.
|
|
|
|
* Matthew Jacob <mjacob@nas.nasa.gov>
|
|
|
|
*/
|
1997-03-12 23:44:50 +03:00
|
|
|
#ifndef _ISPVAR_H
|
|
|
|
#define _ISPVAR_H
|
|
|
|
|
1999-03-17 09:15:47 +03:00
|
|
|
#if defined(__NetBSD__) || defined(__OpenBSD__)
|
1997-03-12 23:44:50 +03:00
|
|
|
#include <dev/ic/ispmbox.h>
|
1999-12-04 06:06:05 +03:00
|
|
|
#ifdef ISP_TARGET_MODE
|
|
|
|
#include <dev/ic/isp_target.h>
|
2000-02-12 05:29:00 +03:00
|
|
|
#include <dev/ic/isp_tpublic.h>
|
1999-12-04 06:06:05 +03:00
|
|
|
#endif
|
1998-07-15 23:50:16 +04:00
|
|
|
#endif
|
|
|
|
#ifdef __FreeBSD__
|
|
|
|
#include <dev/isp/ispmbox.h>
|
1999-12-04 06:06:05 +03:00
|
|
|
#ifdef ISP_TARGET_MODE
|
|
|
|
#include <dev/isp/isp_target.h>
|
2000-02-12 05:29:00 +03:00
|
|
|
#include <dev/isp/isp_tpublic.h>
|
1999-12-04 06:06:05 +03:00
|
|
|
#endif
|
1998-07-15 23:50:16 +04:00
|
|
|
#endif
|
|
|
|
#ifdef __linux__
|
1998-12-28 22:10:43 +03:00
|
|
|
#include "ispmbox.h"
|
1999-12-04 06:06:05 +03:00
|
|
|
#ifdef ISP_TARGET_MODE
|
|
|
|
#include "isp_target.h"
|
2000-02-12 05:29:00 +03:00
|
|
|
#include "isp_tpublic.h"
|
1999-12-04 06:06:05 +03:00
|
|
|
#endif
|
1998-07-15 23:50:16 +04:00
|
|
|
#endif
|
1997-03-12 23:44:50 +03:00
|
|
|
|
2000-08-02 03:55:09 +04:00
|
|
|
#define ISP_CORE_VERSION_MAJOR 2
|
2002-06-15 04:18:02 +04:00
|
|
|
#define ISP_CORE_VERSION_MINOR 7
|
1998-07-19 01:06:20 +04:00
|
|
|
|
1997-03-12 23:44:50 +03:00
|
|
|
/*
|
1999-01-30 10:31:50 +03:00
|
|
|
* Vector for bus specific code to provide specific services.
|
1997-03-12 23:44:50 +03:00
|
|
|
*/
|
|
|
|
struct ispsoftc;
|
|
|
|
struct ispmdvec {
|
2001-09-01 11:12:23 +04:00
|
|
|
int (*dv_rd_isr)
|
|
|
|
(struct ispsoftc *, u_int16_t *, u_int16_t *, u_int16_t *);
|
2001-03-14 08:14:36 +03:00
|
|
|
u_int16_t (*dv_rd_reg) (struct ispsoftc *, int);
|
|
|
|
void (*dv_wr_reg) (struct ispsoftc *, int, u_int16_t);
|
|
|
|
int (*dv_mbxdma) (struct ispsoftc *);
|
|
|
|
int (*dv_dmaset) (struct ispsoftc *,
|
2001-09-01 11:12:23 +04:00
|
|
|
XS_T *, ispreq_t *, u_int16_t *, u_int16_t);
|
1997-03-12 23:44:50 +03:00
|
|
|
void (*dv_dmaclr)
|
2001-09-01 11:12:23 +04:00
|
|
|
(struct ispsoftc *, XS_T *, u_int16_t);
|
2001-03-14 08:14:36 +03:00
|
|
|
void (*dv_reset0) (struct ispsoftc *);
|
|
|
|
void (*dv_reset1) (struct ispsoftc *);
|
|
|
|
void (*dv_dregs) (struct ispsoftc *, const char *);
|
2002-03-22 05:34:05 +03:00
|
|
|
u_int16_t *dv_ispfw; /* ptr to f/w */
|
1997-03-12 23:44:50 +03:00
|
|
|
u_int16_t dv_conf1;
|
1997-04-05 06:48:36 +04:00
|
|
|
u_int16_t dv_clock; /* clock frequency */
|
1997-03-12 23:44:50 +03:00
|
|
|
};
|
|
|
|
|
2000-08-02 03:55:09 +04:00
|
|
|
/*
|
|
|
|
* Overall parameters
|
|
|
|
*/
|
2001-09-01 11:12:23 +04:00
|
|
|
#define MAX_TARGETS 16
|
|
|
|
#define MAX_FC_TARG 256
|
1999-10-14 06:21:50 +04:00
|
|
|
#define ISP_MAX_TARGETS(isp) (IS_FC(isp)? MAX_FC_TARG : MAX_TARGETS)
|
2000-07-06 02:28:08 +04:00
|
|
|
#define ISP_MAX_LUNS(isp) (isp)->isp_maxluns
|
1999-10-14 06:21:50 +04:00
|
|
|
|
2001-09-01 11:12:23 +04:00
|
|
|
/*
|
|
|
|
* 'Types'
|
|
|
|
*/
|
2002-10-19 03:35:25 +04:00
|
|
|
#ifdef ISP_DAC_SUPPORTED
|
|
|
|
typedef u_int64_t isp_dma_addr_t;
|
|
|
|
#else
|
|
|
|
typedef u_int32_t isp_dma_addr_t;
|
2001-09-01 11:12:23 +04:00
|
|
|
#endif
|
1999-12-04 06:06:05 +03:00
|
|
|
|
|
|
|
/*
|
2000-08-02 03:55:09 +04:00
|
|
|
* Macros to access ISP registers through bus specific layers-
|
|
|
|
* mostly wrappers to vector through the mdvec structure.
|
1999-12-04 06:06:05 +03:00
|
|
|
*/
|
2001-09-01 11:12:23 +04:00
|
|
|
#define ISP_READ_ISR(isp, isrp, semap, mbox0p) \
|
|
|
|
(*(isp)->isp_mdvec->dv_rd_isr)(isp, isrp, semap, mbox0p)
|
1999-12-04 06:06:05 +03:00
|
|
|
|
|
|
|
#define ISP_READ(isp, reg) \
|
|
|
|
(*(isp)->isp_mdvec->dv_rd_reg)((isp), (reg))
|
|
|
|
|
|
|
|
#define ISP_WRITE(isp, reg, val) \
|
|
|
|
(*(isp)->isp_mdvec->dv_wr_reg)((isp), (reg), (val))
|
|
|
|
|
|
|
|
#define ISP_MBOXDMASETUP(isp) \
|
|
|
|
(*(isp)->isp_mdvec->dv_mbxdma)((isp))
|
|
|
|
|
|
|
|
#define ISP_DMASETUP(isp, xs, req, iptrp, optr) \
|
|
|
|
(*(isp)->isp_mdvec->dv_dmaset)((isp), (xs), (req), (iptrp), (optr))
|
|
|
|
|
|
|
|
#define ISP_DMAFREE(isp, xs, hndl) \
|
|
|
|
if ((isp)->isp_mdvec->dv_dmaclr) \
|
|
|
|
(*(isp)->isp_mdvec->dv_dmaclr)((isp), (xs), (hndl))
|
|
|
|
|
|
|
|
#define ISP_RESET0(isp) \
|
|
|
|
if ((isp)->isp_mdvec->dv_reset0) (*(isp)->isp_mdvec->dv_reset0)((isp))
|
|
|
|
#define ISP_RESET1(isp) \
|
|
|
|
if ((isp)->isp_mdvec->dv_reset1) (*(isp)->isp_mdvec->dv_reset1)((isp))
|
2000-08-02 03:55:09 +04:00
|
|
|
#define ISP_DUMPREGS(isp, m) \
|
|
|
|
if ((isp)->isp_mdvec->dv_dregs) (*(isp)->isp_mdvec->dv_dregs)((isp),(m))
|
1999-12-04 06:06:05 +03:00
|
|
|
|
|
|
|
#define ISP_SETBITS(isp, reg, val) \
|
|
|
|
(*(isp)->isp_mdvec->dv_wr_reg)((isp), (reg), ISP_READ((isp), (reg)) | (val))
|
|
|
|
|
|
|
|
#define ISP_CLRBITS(isp, reg, val) \
|
|
|
|
(*(isp)->isp_mdvec->dv_wr_reg)((isp), (reg), ISP_READ((isp), (reg)) & ~(val))
|
|
|
|
|
2000-08-02 03:55:09 +04:00
|
|
|
/*
|
|
|
|
* The MEMORYBARRIER macro is defined per platform (to provide synchronization
|
|
|
|
* on Request and Response Queues, Scratch DMA areas, and Registers)
|
|
|
|
*
|
|
|
|
* Defined Memory Barrier Synchronization Types
|
|
|
|
*/
|
|
|
|
#define SYNC_REQUEST 0 /* request queue synchronization */
|
|
|
|
#define SYNC_RESULT 1 /* result queue synchronization */
|
|
|
|
#define SYNC_SFORDEV 2 /* scratch, sync for ISP */
|
|
|
|
#define SYNC_SFORCPU 3 /* scratch, sync for CPU */
|
|
|
|
#define SYNC_REG 4 /* for registers */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Request/Response Queue defines and macros.
|
|
|
|
* The maximum is defined per platform (and can be based on board type).
|
|
|
|
*/
|
|
|
|
/* This is the size of a queue entry (request and response) */
|
1998-09-08 11:27:04 +04:00
|
|
|
#define QENTRY_LEN 64
|
2000-08-02 03:55:09 +04:00
|
|
|
/* Both request and result queue length must be a power of two */
|
|
|
|
#define RQUEST_QUEUE_LEN(x) MAXISPREQUEST(x)
|
2002-04-05 03:38:43 +04:00
|
|
|
#ifdef ISP_TARGET_MODE
|
|
|
|
#define RESULT_QUEUE_LEN(x) MAXISPREQUEST(x)
|
|
|
|
#else
|
2000-08-02 03:55:09 +04:00
|
|
|
#define RESULT_QUEUE_LEN(x) \
|
|
|
|
(((MAXISPREQUEST(x) >> 2) < 64)? 64 : MAXISPREQUEST(x) >> 2)
|
2002-04-05 03:38:43 +04:00
|
|
|
#endif
|
1998-09-08 11:27:04 +04:00
|
|
|
#define ISP_QUEUE_ENTRY(q, idx) ((q) + ((idx) * QENTRY_LEN))
|
|
|
|
#define ISP_QUEUE_SIZE(n) ((n) * QENTRY_LEN)
|
|
|
|
#define ISP_NXT_QENTRY(idx, qlen) (((idx) + 1) & ((qlen)-1))
|
2000-08-14 11:12:15 +04:00
|
|
|
#define ISP_QFREE(in, out, qlen) \
|
1998-09-18 02:52:54 +04:00
|
|
|
((in == out)? (qlen - 1) : ((in > out)? \
|
1999-10-17 05:37:34 +04:00
|
|
|
((qlen - 1) - (in - out)) : (out - in - 1)))
|
2000-08-14 11:12:15 +04:00
|
|
|
#define ISP_QAVAIL(isp) \
|
|
|
|
ISP_QFREE(isp->isp_reqidx, isp->isp_reqodx, RQUEST_QUEUE_LEN(isp))
|
1999-12-04 06:06:05 +03:00
|
|
|
|
Major restructuring for swizzling to the request queue and unswizzling from
the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have
a complete set of inline functions in isp_inline.h. Each platform is
responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32}
macros.
The reason this needs to be done is that we need to have a single set of
functions that will work correctly on multiple architectures for both little
and big endian machines. It also needs to work correctly in the case that
we have the request or response queues in memory that has to be treated
specially (e.g., have ddi_dma_sync called on it for Solaris after we update
it or before we read from it).
One thing that falls out of this is that we no longer build requests in the
request queue itself. Instead, we build the request locally (e.g., on the
stack) and then as part of the swizzling operation, copy it to the request
queue entry we've allocated. I thought long and hard about whether this was
too expensive a change to make as it in a lot of cases requires an extra
copy. On balance, the flexbility is worth it. With any luck, the entry that
we build locally stays in a processor writeback cache (after all, it's only
64 bytes) so that the cost of actually flushing it to the memory area that is
the shared queue with the PCI device is not all that expensive. We may examine
this again and try to get clever in the future to try and avoid copies.
Another change that falls out of this is that MEMORYBARRIER should be taken
a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the
entry being added. But there had been many other places this had been missing.
It's now very important that it be done.
For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of
the explicit ddi_dmamap_sync on the whole response queue that we did for SBus
cards at each interrupt.
Set things up so that platforms that cannot have an SBus don't get a lot of
the SBus code checks (dead coded out).
Additional changes:
Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry,
the iptr value that gets returned is the value we intend to eventually plug
into the ISP registers as the entry *one past* the last one we've written-
*not* the current entry we're updating. All along we've been calling sync
functions on the wrong index value. Argh. The 'fix' here is to rename all
'iptr' variables as 'nxti' to remember that this is the 'next' pointer-
not the current pointer.
Devote a single bit to mboxbsy- and set aside bits for output mbox registers
that we need to pick up- we can have at least one command which does not
have any defined output registers (MBOX_EXECUTE_FIRMWARE).
Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response.
Otherwise, we won't unswizzle it correctly.
Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
|
|
|
#define ISP_ADD_REQUEST(isp, nxti) \
|
|
|
|
MEMORYBARRIER(isp, SYNC_REQUEST, isp->isp_reqidx, QENTRY_LEN); \
|
|
|
|
WRITE_REQUEST_QUEUE_IN_POINTER(isp, nxti); \
|
|
|
|
isp->isp_reqidx = nxti
|
1999-12-04 06:06:05 +03:00
|
|
|
|
1997-08-16 04:18:36 +04:00
|
|
|
/*
|
1999-05-12 22:59:23 +04:00
|
|
|
* SCSI Specific Host Adapter Parameters- per bus, per target
|
1997-08-16 04:18:36 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
typedef struct {
|
1999-05-12 22:59:23 +04:00
|
|
|
u_int isp_gotdparms : 1,
|
1999-10-17 05:37:34 +04:00
|
|
|
isp_req_ack_active_neg : 1,
|
|
|
|
isp_data_line_active_neg: 1,
|
1997-08-16 04:18:36 +04:00
|
|
|
isp_cmd_dma_burst_enable: 1,
|
|
|
|
isp_data_dma_burst_enabl: 1,
|
1999-01-10 08:04:46 +03:00
|
|
|
isp_fifo_threshold : 3,
|
1999-01-30 10:31:50 +03:00
|
|
|
isp_ultramode : 1,
|
1997-08-16 04:18:36 +04:00
|
|
|
isp_diffmode : 1,
|
1999-03-27 01:39:44 +03:00
|
|
|
isp_lvdmode : 1,
|
2000-08-09 02:58:30 +04:00
|
|
|
isp_fast_mttr : 1, /* fast sram */
|
1997-08-16 04:18:36 +04:00
|
|
|
isp_initiator_id : 4,
|
1999-10-17 05:37:34 +04:00
|
|
|
isp_async_data_setup : 4;
|
|
|
|
u_int16_t isp_selection_timeout;
|
|
|
|
u_int16_t isp_max_queue_depth;
|
1997-08-16 04:18:36 +04:00
|
|
|
u_int8_t isp_tag_aging;
|
1999-10-17 05:37:34 +04:00
|
|
|
u_int8_t isp_bus_reset_delay;
|
|
|
|
u_int8_t isp_retry_count;
|
|
|
|
u_int8_t isp_retry_delay;
|
1997-08-16 04:18:36 +04:00
|
|
|
struct {
|
2001-09-01 11:12:23 +04:00
|
|
|
u_int32_t
|
|
|
|
exc_throttle : 8,
|
1999-05-12 22:59:23 +04:00
|
|
|
: 1,
|
2001-09-01 11:12:23 +04:00
|
|
|
dev_enable : 1, /* ignored */
|
1999-01-30 10:31:50 +03:00
|
|
|
dev_update : 1,
|
|
|
|
dev_refresh : 1,
|
2001-09-01 11:12:23 +04:00
|
|
|
actv_offset : 4,
|
|
|
|
goal_offset : 4,
|
|
|
|
nvrm_offset : 4;
|
|
|
|
u_int8_t actv_period; /* current sync period */
|
|
|
|
u_int8_t goal_period; /* goal sync period */
|
|
|
|
u_int8_t nvrm_period; /* nvram sync period */
|
|
|
|
u_int16_t actv_flags; /* current device flags */
|
|
|
|
u_int16_t goal_flags; /* goal device flags */
|
|
|
|
u_int16_t nvrm_flags; /* nvram device flags */
|
1997-08-16 04:18:36 +04:00
|
|
|
} isp_devparam[MAX_TARGETS];
|
1999-05-12 22:59:23 +04:00
|
|
|
} sdparam;
|
1997-08-16 04:18:36 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Device Flags
|
|
|
|
*/
|
1998-09-08 11:27:04 +04:00
|
|
|
#define DPARM_DISC 0x8000
|
|
|
|
#define DPARM_PARITY 0x4000
|
|
|
|
#define DPARM_WIDE 0x2000
|
|
|
|
#define DPARM_SYNC 0x1000
|
|
|
|
#define DPARM_TQING 0x0800
|
|
|
|
#define DPARM_ARQ 0x0400
|
|
|
|
#define DPARM_QFRZ 0x0200
|
|
|
|
#define DPARM_RENEG 0x0100
|
2000-08-09 02:58:30 +04:00
|
|
|
#define DPARM_NARROW 0x0080
|
|
|
|
#define DPARM_ASYNC 0x0040
|
|
|
|
#define DPARM_PPR 0x0020
|
1999-02-09 03:46:25 +03:00
|
|
|
#define DPARM_DEFAULT (0xFF00 & ~DPARM_QFRZ)
|
1998-09-08 11:27:04 +04:00
|
|
|
#define DPARM_SAFE_DFLT (DPARM_DEFAULT & ~(DPARM_WIDE|DPARM_SYNC|DPARM_TQING))
|
|
|
|
|
1997-08-16 04:18:36 +04:00
|
|
|
|
1999-03-27 01:39:44 +03:00
|
|
|
/* technically, not really correct, as they need to be rated based upon clock */
|
2000-08-09 02:58:30 +04:00
|
|
|
#define ISP_80M_SYNCPARMS 0x0c09
|
|
|
|
#define ISP_40M_SYNCPARMS 0x0c0a
|
|
|
|
#define ISP_20M_SYNCPARMS 0x0c0c
|
|
|
|
#define ISP_20M_SYNCPARMS_1040 0x080c
|
1999-10-17 05:37:34 +04:00
|
|
|
#define ISP_10M_SYNCPARMS 0x0c19
|
|
|
|
#define ISP_08M_SYNCPARMS 0x0c25
|
|
|
|
#define ISP_05M_SYNCPARMS 0x0c32
|
|
|
|
#define ISP_04M_SYNCPARMS 0x0c41
|
1997-08-16 04:18:36 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Fibre Channel Specifics
|
|
|
|
*/
|
1999-10-14 06:21:50 +04:00
|
|
|
#define FL_PORT_ID 0x7e /* FL_Port Special ID */
|
|
|
|
#define FC_PORT_ID 0x7f /* Fabric Controller Special ID */
|
|
|
|
#define FC_SNS_ID 0x80 /* SNS Server Special ID */
|
|
|
|
|
2002-04-05 03:38:43 +04:00
|
|
|
/* #define ISP_USE_GA_NXT 1 */ /* Use GA_NXT with switches */
|
|
|
|
#ifndef GA_NXT_MAX
|
|
|
|
#define GA_NXT_MAX 256
|
|
|
|
#endif
|
|
|
|
|
1997-08-16 04:18:36 +04:00
|
|
|
typedef struct {
|
1999-10-17 05:37:34 +04:00
|
|
|
u_int32_t isp_fwoptions : 16,
|
2001-10-07 00:34:49 +04:00
|
|
|
isp_gbspeed : 2,
|
2001-02-13 02:33:49 +03:00
|
|
|
isp_iid_set : 1,
|
1999-07-06 00:31:35 +04:00
|
|
|
loop_seen_once : 1,
|
2001-07-06 20:19:10 +04:00
|
|
|
isp_loopstate : 4, /* Current Loop State */
|
1999-07-06 00:31:35 +04:00
|
|
|
isp_fwstate : 3, /* ISP F/W state */
|
|
|
|
isp_gotdparms : 1,
|
2000-05-13 20:53:03 +04:00
|
|
|
isp_topo : 3,
|
1999-07-06 00:31:35 +04:00
|
|
|
isp_onfabric : 1;
|
2001-02-13 02:33:49 +03:00
|
|
|
u_int8_t isp_iid; /* 'initiator' id */
|
1998-09-08 11:27:04 +04:00
|
|
|
u_int8_t isp_loopid; /* hard loop id */
|
|
|
|
u_int8_t isp_alpa; /* ALPA */
|
1999-07-06 00:31:35 +04:00
|
|
|
u_int32_t isp_portid;
|
2001-02-13 02:33:49 +03:00
|
|
|
volatile u_int16_t isp_lipseq; /* LIP sequence # */
|
2001-09-06 02:32:38 +04:00
|
|
|
u_int16_t isp_fwattr; /* firmware attributes */
|
1998-09-08 11:27:04 +04:00
|
|
|
u_int8_t isp_execthrottle;
|
1999-10-17 05:37:34 +04:00
|
|
|
u_int8_t isp_retry_delay;
|
|
|
|
u_int8_t isp_retry_count;
|
|
|
|
u_int8_t isp_reserved;
|
1998-09-08 11:27:04 +04:00
|
|
|
u_int16_t isp_maxalloc;
|
|
|
|
u_int16_t isp_maxfrmlen;
|
1999-07-06 00:31:35 +04:00
|
|
|
u_int64_t isp_nodewwn;
|
|
|
|
u_int64_t isp_portwwn;
|
1999-03-17 09:15:47 +03:00
|
|
|
/*
|
1999-07-06 00:31:35 +04:00
|
|
|
* Port Data Base. This is indexed by 'target', which is invariate.
|
|
|
|
* However, elements within can move around due to loop changes,
|
|
|
|
* so the actual loop ID passed to the F/W is in this structure.
|
|
|
|
* The first time the loop is seen up, loopid will match the index
|
|
|
|
* (except for fabric nodes which are above mapped above FC_SNS_ID
|
|
|
|
* and are completely virtual), but subsequent LIPs can cause things
|
|
|
|
* to move around.
|
1999-03-17 09:15:47 +03:00
|
|
|
*/
|
1999-07-06 00:31:35 +04:00
|
|
|
struct lportdb {
|
2002-04-05 03:38:43 +04:00
|
|
|
u_int32_t
|
|
|
|
port_type : 8,
|
2000-05-13 20:53:03 +04:00
|
|
|
loopid : 8,
|
2002-06-15 04:18:02 +04:00
|
|
|
fc4_type : 4,
|
2002-04-05 03:38:43 +04:00
|
|
|
last_fabric_dev : 1,
|
2002-06-15 04:18:02 +04:00
|
|
|
: 2,
|
|
|
|
relogin : 1,
|
2001-07-06 20:19:10 +04:00
|
|
|
force_logout : 1,
|
2001-02-13 02:33:49 +03:00
|
|
|
was_fabric_dev : 1,
|
|
|
|
fabric_dev : 1,
|
2000-05-13 20:53:03 +04:00
|
|
|
loggedin : 1,
|
|
|
|
roles : 2,
|
|
|
|
valid : 1;
|
1999-10-17 05:37:34 +04:00
|
|
|
u_int32_t portid;
|
1999-07-06 00:31:35 +04:00
|
|
|
u_int64_t node_wwn;
|
|
|
|
u_int64_t port_wwn;
|
2001-02-13 02:33:49 +03:00
|
|
|
} portdb[MAX_FC_TARG], tport[FC_PORT_ID];
|
1999-03-17 09:15:47 +03:00
|
|
|
|
1997-08-16 04:18:36 +04:00
|
|
|
/*
|
|
|
|
* Scratch DMA mapped in area to fetch Port Database stuff, etc.
|
|
|
|
*/
|
1999-07-06 00:31:35 +04:00
|
|
|
caddr_t isp_scratch;
|
2002-10-19 03:35:25 +04:00
|
|
|
isp_dma_addr_t isp_scdma;
|
2002-02-22 01:32:40 +03:00
|
|
|
#ifdef ISP_FW_CRASH_DUMP
|
|
|
|
u_int16_t *isp_dump_data;
|
|
|
|
#endif
|
1997-08-16 04:18:36 +04:00
|
|
|
} fcparam;
|
|
|
|
|
1999-07-06 00:31:35 +04:00
|
|
|
#define FW_CONFIG_WAIT 0
|
|
|
|
#define FW_WAIT_AL_PA 1
|
|
|
|
#define FW_WAIT_LOGIN 2
|
|
|
|
#define FW_READY 3
|
|
|
|
#define FW_LOSS_OF_SYNC 4
|
|
|
|
#define FW_ERROR 5
|
|
|
|
#define FW_REINIT 6
|
|
|
|
#define FW_NON_PART 7
|
|
|
|
|
|
|
|
#define LOOP_NIL 0
|
|
|
|
#define LOOP_LIP_RCVD 1
|
|
|
|
#define LOOP_PDB_RCVD 2
|
2001-02-13 02:33:49 +03:00
|
|
|
#define LOOP_SCANNING_FABRIC 3
|
|
|
|
#define LOOP_FSCAN_DONE 4
|
|
|
|
#define LOOP_SCANNING_LOOP 5
|
2001-07-06 20:19:10 +04:00
|
|
|
#define LOOP_LSCAN_DONE 6
|
|
|
|
#define LOOP_SYNCING_PDB 7
|
|
|
|
#define LOOP_READY 8
|
1997-08-16 04:18:36 +04:00
|
|
|
|
2000-05-13 20:53:03 +04:00
|
|
|
#define TOPO_NL_PORT 0
|
|
|
|
#define TOPO_FL_PORT 1
|
|
|
|
#define TOPO_N_PORT 2
|
|
|
|
#define TOPO_F_PORT 3
|
|
|
|
#define TOPO_PTP_STUB 4
|
|
|
|
|
1997-03-12 23:44:50 +03:00
|
|
|
/*
|
|
|
|
* Soft Structure per host adapter
|
|
|
|
*/
|
2000-08-09 02:58:30 +04:00
|
|
|
typedef struct ispsoftc {
|
1998-07-15 23:50:16 +04:00
|
|
|
/*
|
|
|
|
* Platform (OS) specific data
|
|
|
|
*/
|
|
|
|
struct isposinfo isp_osinfo;
|
|
|
|
|
|
|
|
/*
|
1999-12-04 06:06:05 +03:00
|
|
|
* Pointer to bus specific functions and data
|
1998-07-15 23:50:16 +04:00
|
|
|
*/
|
1997-03-12 23:44:50 +03:00
|
|
|
struct ispmdvec * isp_mdvec;
|
1998-07-15 23:50:16 +04:00
|
|
|
|
|
|
|
/*
|
1999-12-04 06:06:05 +03:00
|
|
|
* (Mostly) nonvolatile state. Board specific parameters
|
|
|
|
* may contain some volatile state (e.g., current loop state).
|
1998-07-15 23:50:16 +04:00
|
|
|
*/
|
|
|
|
|
1999-12-04 06:06:05 +03:00
|
|
|
void * isp_param; /* type specific */
|
|
|
|
u_int16_t isp_fwrev[3]; /* Loaded F/W revision */
|
|
|
|
u_int16_t isp_romfw_rev[3]; /* PROM F/W revision */
|
|
|
|
u_int16_t isp_maxcmds; /* max possible I/O cmds */
|
|
|
|
u_int8_t isp_type; /* HBA Chip Type */
|
|
|
|
u_int8_t isp_revision; /* HBA Chip H/W Revision */
|
2000-07-06 02:28:08 +04:00
|
|
|
u_int32_t isp_maxluns; /* maximum luns supported */
|
1999-12-04 06:06:05 +03:00
|
|
|
|
2001-02-13 02:33:49 +03:00
|
|
|
u_int32_t isp_clock : 8, /* input clock */
|
2002-02-22 01:32:40 +03:00
|
|
|
: 4,
|
|
|
|
isp_port : 1, /* 23XX only */
|
Major restructuring for swizzling to the request queue and unswizzling from
the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have
a complete set of inline functions in isp_inline.h. Each platform is
responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32}
macros.
The reason this needs to be done is that we need to have a single set of
functions that will work correctly on multiple architectures for both little
and big endian machines. It also needs to work correctly in the case that
we have the request or response queues in memory that has to be treated
specially (e.g., have ddi_dma_sync called on it for Solaris after we update
it or before we read from it).
One thing that falls out of this is that we no longer build requests in the
request queue itself. Instead, we build the request locally (e.g., on the
stack) and then as part of the swizzling operation, copy it to the request
queue entry we've allocated. I thought long and hard about whether this was
too expensive a change to make as it in a lot of cases requires an extra
copy. On balance, the flexbility is worth it. With any luck, the entry that
we build locally stays in a processor writeback cache (after all, it's only
64 bytes) so that the cost of actually flushing it to the memory area that is
the shared queue with the PCI device is not all that expensive. We may examine
this again and try to get clever in the future to try and avoid copies.
Another change that falls out of this is that MEMORYBARRIER should be taken
a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the
entry being added. But there had been many other places this had been missing.
It's now very important that it be done.
For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of
the explicit ddi_dmamap_sync on the whole response queue that we did for SBus
cards at each interrupt.
Set things up so that platforms that cannot have an SBus don't get a lot of
the SBus code checks (dead coded out).
Additional changes:
Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry,
the iptr value that gets returned is the value we intend to eventually plug
into the ISP registers as the entry *one past* the last one we've written-
*not* the current entry we're updating. All along we've been calling sync
functions on the wrong index value. Argh. The 'fix' here is to rename all
'iptr' variables as 'nxti' to remember that this is the 'next' pointer-
not the current pointer.
Devote a single bit to mboxbsy- and set aside bits for output mbox registers
that we need to pick up- we can have at least one command which does not
have any defined output registers (MBOX_EXECUTE_FIRMWARE).
Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response.
Otherwise, we won't unswizzle it correctly.
Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
|
|
|
isp_failed : 1, /* board failed */
|
|
|
|
isp_open : 1, /* opened (ioctl) */
|
2001-02-13 02:33:49 +03:00
|
|
|
isp_touched : 1, /* board ever seen? */
|
2000-08-09 02:58:30 +04:00
|
|
|
isp_bustype : 1, /* SBus or PCI */
|
|
|
|
isp_loaded_fw : 1, /* loaded firmware */
|
Major restructuring for swizzling to the request queue and unswizzling from
the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have
a complete set of inline functions in isp_inline.h. Each platform is
responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32}
macros.
The reason this needs to be done is that we need to have a single set of
functions that will work correctly on multiple architectures for both little
and big endian machines. It also needs to work correctly in the case that
we have the request or response queues in memory that has to be treated
specially (e.g., have ddi_dma_sync called on it for Solaris after we update
it or before we read from it).
One thing that falls out of this is that we no longer build requests in the
request queue itself. Instead, we build the request locally (e.g., on the
stack) and then as part of the swizzling operation, copy it to the request
queue entry we've allocated. I thought long and hard about whether this was
too expensive a change to make as it in a lot of cases requires an extra
copy. On balance, the flexbility is worth it. With any luck, the entry that
we build locally stays in a processor writeback cache (after all, it's only
64 bytes) so that the cost of actually flushing it to the memory area that is
the shared queue with the PCI device is not all that expensive. We may examine
this again and try to get clever in the future to try and avoid copies.
Another change that falls out of this is that MEMORYBARRIER should be taken
a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the
entry being added. But there had been many other places this had been missing.
It's now very important that it be done.
For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of
the explicit ddi_dmamap_sync on the whole response queue that we did for SBus
cards at each interrupt.
Set things up so that platforms that cannot have an SBus don't get a lot of
the SBus code checks (dead coded out).
Additional changes:
Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry,
the iptr value that gets returned is the value we intend to eventually plug
into the ISP registers as the entry *one past* the last one we've written-
*not* the current entry we're updating. All along we've been calling sync
functions on the wrong index value. Argh. The 'fix' here is to rename all
'iptr' variables as 'nxti' to remember that this is the 'next' pointer-
not the current pointer.
Devote a single bit to mboxbsy- and set aside bits for output mbox registers
that we need to pick up- we can have at least one command which does not
have any defined output registers (MBOX_EXECUTE_FIRMWARE).
Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response.
Otherwise, we won't unswizzle it correctly.
Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
|
|
|
isp_role : 2, /* roles supported */
|
2001-02-13 02:33:49 +03:00
|
|
|
isp_dblev : 12; /* debug log mask */
|
|
|
|
|
|
|
|
u_int32_t isp_confopts; /* config options */
|
|
|
|
|
2001-09-01 11:12:23 +04:00
|
|
|
u_int16_t isp_rqstinrp; /* register for REQINP */
|
|
|
|
u_int16_t isp_rqstoutrp; /* register for REQOUTP */
|
|
|
|
u_int16_t isp_respinrp; /* register for RESINP */
|
|
|
|
u_int16_t isp_respoutrp; /* register for RESOUTP */
|
|
|
|
|
2000-12-09 11:06:31 +03:00
|
|
|
/*
|
|
|
|
* Instrumentation
|
|
|
|
*/
|
|
|
|
u_int64_t isp_intcnt; /* total int count */
|
|
|
|
u_int64_t isp_intbogus; /* spurious int count */
|
2002-01-04 00:45:06 +03:00
|
|
|
u_int64_t isp_intmboxc; /* mbox completions */
|
|
|
|
u_int64_t isp_intoasync; /* other async */
|
|
|
|
u_int64_t isp_rsltccmplt; /* CMDs on result q */
|
|
|
|
u_int64_t isp_fphccmplt; /* CMDs via fastpost */
|
|
|
|
u_int16_t isp_rscchiwater;
|
|
|
|
u_int16_t isp_fpcchiwater;
|
1997-08-16 04:18:36 +04:00
|
|
|
|
1997-03-12 23:44:50 +03:00
|
|
|
/*
|
1998-09-08 11:27:04 +04:00
|
|
|
* Volatile state
|
1997-03-12 23:44:50 +03:00
|
|
|
*/
|
1998-09-08 11:27:04 +04:00
|
|
|
|
2000-07-06 02:28:08 +04:00
|
|
|
volatile u_int32_t
|
Major restructuring for swizzling to the request queue and unswizzling from
the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have
a complete set of inline functions in isp_inline.h. Each platform is
responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32}
macros.
The reason this needs to be done is that we need to have a single set of
functions that will work correctly on multiple architectures for both little
and big endian machines. It also needs to work correctly in the case that
we have the request or response queues in memory that has to be treated
specially (e.g., have ddi_dma_sync called on it for Solaris after we update
it or before we read from it).
One thing that falls out of this is that we no longer build requests in the
request queue itself. Instead, we build the request locally (e.g., on the
stack) and then as part of the swizzling operation, copy it to the request
queue entry we've allocated. I thought long and hard about whether this was
too expensive a change to make as it in a lot of cases requires an extra
copy. On balance, the flexbility is worth it. With any luck, the entry that
we build locally stays in a processor writeback cache (after all, it's only
64 bytes) so that the cost of actually flushing it to the memory area that is
the shared queue with the PCI device is not all that expensive. We may examine
this again and try to get clever in the future to try and avoid copies.
Another change that falls out of this is that MEMORYBARRIER should be taken
a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the
entry being added. But there had been many other places this had been missing.
It's now very important that it be done.
For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of
the explicit ddi_dmamap_sync on the whole response queue that we did for SBus
cards at each interrupt.
Set things up so that platforms that cannot have an SBus don't get a lot of
the SBus code checks (dead coded out).
Additional changes:
Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry,
the iptr value that gets returned is the value we intend to eventually plug
into the ISP registers as the entry *one past* the last one we've written-
*not* the current entry we're updating. All along we've been calling sync
functions on the wrong index value. Argh. The 'fix' here is to rename all
'iptr' variables as 'nxti' to remember that this is the 'next' pointer-
not the current pointer.
Devote a single bit to mboxbsy- and set aside bits for output mbox registers
that we need to pick up- we can have at least one command which does not
have any defined output registers (MBOX_EXECUTE_FIRMWARE).
Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response.
Otherwise, we won't unswizzle it correctly.
Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
|
|
|
isp_obits : 8, /* mailbox command output */
|
|
|
|
isp_mboxbsy : 1, /* mailbox command active */
|
1998-09-08 11:27:04 +04:00
|
|
|
isp_state : 3,
|
1999-05-12 22:59:23 +04:00
|
|
|
isp_sendmarker : 2, /* send a marker entry */
|
|
|
|
isp_update : 2, /* update parameters */
|
1999-10-14 06:21:50 +04:00
|
|
|
isp_nactive : 16; /* how many commands active */
|
|
|
|
volatile u_int16_t isp_reqodx; /* index of last ISP pickup */
|
|
|
|
volatile u_int16_t isp_reqidx; /* index of next request */
|
|
|
|
volatile u_int16_t isp_residx; /* index of next result */
|
2002-03-22 05:34:05 +03:00
|
|
|
volatile u_int16_t isp_resodx; /* index of next result */
|
|
|
|
volatile u_int16_t isp_rspbsy;
|
1999-10-14 06:21:50 +04:00
|
|
|
volatile u_int16_t isp_lasthdls; /* last handle seed */
|
2000-07-06 02:28:08 +04:00
|
|
|
volatile u_int16_t isp_mboxtmp[MAX_MAILBOX];
|
2001-02-13 02:33:49 +03:00
|
|
|
volatile u_int16_t isp_lastmbxcmd; /* last mbox command sent */
|
2002-02-22 01:32:40 +03:00
|
|
|
volatile u_int16_t isp_mbxwrk0;
|
|
|
|
volatile u_int16_t isp_mbxwrk1;
|
|
|
|
volatile u_int16_t isp_mbxwrk2;
|
|
|
|
void * isp_mbxworkp;
|
1997-08-16 04:18:36 +04:00
|
|
|
|
1997-03-12 23:44:50 +03:00
|
|
|
/*
|
1999-12-04 06:06:05 +03:00
|
|
|
* Active commands are stored here, indexed by handle functions.
|
1997-03-12 23:44:50 +03:00
|
|
|
*/
|
2000-08-02 03:55:09 +04:00
|
|
|
XS_T **isp_xflist;
|
1997-08-16 04:18:36 +04:00
|
|
|
|
1997-03-12 23:44:50 +03:00
|
|
|
/*
|
2003-05-03 22:10:37 +04:00
|
|
|
* request/result queue pointers and DMA handles for them.
|
1997-03-12 23:44:50 +03:00
|
|
|
*/
|
1999-07-06 00:31:35 +04:00
|
|
|
caddr_t isp_rquest;
|
|
|
|
caddr_t isp_result;
|
2002-10-19 03:35:25 +04:00
|
|
|
isp_dma_addr_t isp_rquest_dma;
|
|
|
|
isp_dma_addr_t isp_result_dma;
|
2000-08-09 02:58:30 +04:00
|
|
|
} ispsoftc_t;
|
1997-03-12 23:44:50 +03:00
|
|
|
|
1999-10-14 06:21:50 +04:00
|
|
|
#define SDPARAM(isp) ((sdparam *) (isp)->isp_param)
|
|
|
|
#define FCPARAM(isp) ((fcparam *) (isp)->isp_param)
|
|
|
|
|
1997-08-16 04:18:36 +04:00
|
|
|
/*
|
2000-08-02 03:55:09 +04:00
|
|
|
* ISP Driver Run States
|
1998-07-15 23:50:16 +04:00
|
|
|
*/
|
|
|
|
#define ISP_NILSTATE 0
|
|
|
|
#define ISP_RESETSTATE 1
|
|
|
|
#define ISP_INITSTATE 2
|
|
|
|
#define ISP_RUNSTATE 3
|
|
|
|
|
|
|
|
/*
|
|
|
|
* ISP Configuration Options
|
|
|
|
*/
|
|
|
|
#define ISP_CFG_NORELOAD 0x80 /* don't download f/w */
|
1999-02-09 03:46:25 +03:00
|
|
|
#define ISP_CFG_NONVRAM 0x40 /* ignore NVRAM */
|
2001-10-07 00:34:49 +04:00
|
|
|
#define ISP_CFG_TWOGB 0x20 /* force 2GB connection (23XX only) */
|
|
|
|
#define ISP_CFG_ONEGB 0x10 /* force 1GB connection (23XX only) */
|
1999-12-04 06:06:05 +03:00
|
|
|
#define ISP_CFG_FULL_DUPLEX 0x01 /* Full Duplex (Fibre Channel only) */
|
2000-12-09 11:06:31 +03:00
|
|
|
#define ISP_CFG_PORT_PREF 0x0C /* Mask for Port Prefs (2200 only) */
|
|
|
|
#define ISP_CFG_LPORT 0x00 /* prefer {N/F}L-Port connection */
|
|
|
|
#define ISP_CFG_NPORT 0x04 /* prefer {N/F}-Port connection */
|
|
|
|
#define ISP_CFG_NPORT_ONLY 0x08 /* insist on {N/F}-Port connection */
|
|
|
|
#define ISP_CFG_LPORT_ONLY 0x0C /* insist on {N/F}L-Port connection */
|
2002-02-22 01:32:40 +03:00
|
|
|
#define ISP_CFG_OWNWWPN 0x100 /* override NVRAM wwpn */
|
|
|
|
#define ISP_CFG_OWNWWNN 0x200 /* override NVRAM wwnn */
|
2002-06-15 04:18:02 +04:00
|
|
|
#define ISP_CFG_OWNFSZ 0x400 /* override NVRAM frame size */
|
|
|
|
#define ISP_CFG_OWNLOOPID 0x800 /* override NVRAM loopid */
|
|
|
|
#define ISP_CFG_OWNEXCTHROTTLE 0x1000 /* override NVRAM execution throttle */
|
1998-07-15 23:50:16 +04:00
|
|
|
|
2001-02-13 02:33:49 +03:00
|
|
|
/*
|
|
|
|
* Prior to calling isp_reset for the first time, the outer layer
|
|
|
|
* should set isp_role to one of NONE, INITIATOR, TARGET, BOTH.
|
|
|
|
*
|
|
|
|
* If you set ISP_ROLE_NONE, the cards will be reset, new firmware loaded,
|
|
|
|
* NVRAM read, and defaults set, but any further initialization (e.g.
|
|
|
|
* INITIALIZE CONTROL BLOCK commands for 2X00 cards) won't be done.
|
|
|
|
*
|
|
|
|
* If INITIATOR MODE isn't set, attempts to run commands will be stopped
|
|
|
|
* at isp_start and completed with the moral equivalent of SELECTION TIMEOUT.
|
|
|
|
*
|
|
|
|
* If TARGET MODE is set, it doesn't mean that the rest of target mode support
|
|
|
|
* needs to be enabled, or will even work. What happens with the 2X00 cards
|
|
|
|
* here is that if you have enabled it with TARGET MODE as part of the ICB
|
|
|
|
* options, but you haven't given the f/w any ram resources for ATIOs or
|
|
|
|
* Immediate Notifies, the f/w just handles what it can and you never see
|
|
|
|
* anything. Basically, it sends a single byte of data (the first byte,
|
|
|
|
* which you can set as part of the INITIALIZE CONTROL BLOCK command) for
|
|
|
|
* INQUIRY, and sends back QUEUE FULL status for any other command.
|
2001-07-06 20:19:10 +04:00
|
|
|
*
|
2001-02-13 02:33:49 +03:00
|
|
|
*/
|
|
|
|
#define ISP_ROLE_NONE 0x0
|
|
|
|
#define ISP_ROLE_INITIATOR 0x1
|
|
|
|
#define ISP_ROLE_TARGET 0x2
|
|
|
|
#define ISP_ROLE_BOTH (ISP_ROLE_TARGET|ISP_ROLE_INITIATOR)
|
|
|
|
#define ISP_ROLE_EITHER ISP_ROLE_BOTH
|
|
|
|
#ifndef ISP_DEFAULT_ROLES
|
|
|
|
#define ISP_DEFAULT_ROLES ISP_ROLE_INITIATOR
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2000-08-02 03:55:09 +04:00
|
|
|
/*
|
|
|
|
* Firmware related defines
|
|
|
|
*/
|
2001-02-13 02:33:49 +03:00
|
|
|
#define ISP_CODE_ORG 0x1000 /* default f/w code start */
|
2001-09-01 11:12:23 +04:00
|
|
|
#define ISP_CODE_ORG_2300 0x0800 /* ..except for 2300s */
|
1999-04-04 05:27:06 +04:00
|
|
|
#define ISP_FW_REV(maj, min, mic) ((maj << 24) | (min << 16) | mic)
|
2001-09-06 02:32:38 +04:00
|
|
|
#define ISP_FW_MAJOR(code) ((code >> 24) & 0xff)
|
|
|
|
#define ISP_FW_MINOR(code) ((code >> 16) & 0xff)
|
|
|
|
#define ISP_FW_MICRO(code) ((code >> 8) & 0xff)
|
2001-02-13 02:33:49 +03:00
|
|
|
#define ISP_FW_REVX(xp) ((xp[0]<<24) | (xp[1] << 16) | xp[2])
|
2001-09-06 02:32:38 +04:00
|
|
|
#define ISP_FW_MAJORX(xp) (xp[0])
|
|
|
|
#define ISP_FW_MINORX(xp) (xp[1])
|
|
|
|
#define ISP_FW_MICROX(xp) (xp[2])
|
2002-08-17 01:43:14 +04:00
|
|
|
#define ISP_FW_NEWER_THAN(i, major, minor, micro) \
|
|
|
|
(ISP_FW_REVX((i)->isp_fwrev) > ISP_FW_REV(major, minor, micro))
|
1998-09-08 11:27:04 +04:00
|
|
|
|
1998-07-15 23:50:16 +04:00
|
|
|
/*
|
1998-09-08 11:27:04 +04:00
|
|
|
* Bus (implementation) types
|
|
|
|
*/
|
|
|
|
#define ISP_BT_PCI 0 /* PCI Implementations */
|
|
|
|
#define ISP_BT_SBUS 1 /* SBus Implementations */
|
|
|
|
|
Major restructuring for swizzling to the request queue and unswizzling from
the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have
a complete set of inline functions in isp_inline.h. Each platform is
responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32}
macros.
The reason this needs to be done is that we need to have a single set of
functions that will work correctly on multiple architectures for both little
and big endian machines. It also needs to work correctly in the case that
we have the request or response queues in memory that has to be treated
specially (e.g., have ddi_dma_sync called on it for Solaris after we update
it or before we read from it).
One thing that falls out of this is that we no longer build requests in the
request queue itself. Instead, we build the request locally (e.g., on the
stack) and then as part of the swizzling operation, copy it to the request
queue entry we've allocated. I thought long and hard about whether this was
too expensive a change to make as it in a lot of cases requires an extra
copy. On balance, the flexbility is worth it. With any luck, the entry that
we build locally stays in a processor writeback cache (after all, it's only
64 bytes) so that the cost of actually flushing it to the memory area that is
the shared queue with the PCI device is not all that expensive. We may examine
this again and try to get clever in the future to try and avoid copies.
Another change that falls out of this is that MEMORYBARRIER should be taken
a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the
entry being added. But there had been many other places this had been missing.
It's now very important that it be done.
For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of
the explicit ddi_dmamap_sync on the whole response queue that we did for SBus
cards at each interrupt.
Set things up so that platforms that cannot have an SBus don't get a lot of
the SBus code checks (dead coded out).
Additional changes:
Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry,
the iptr value that gets returned is the value we intend to eventually plug
into the ISP registers as the entry *one past* the last one we've written-
*not* the current entry we're updating. All along we've been calling sync
functions on the wrong index value. Argh. The 'fix' here is to rename all
'iptr' variables as 'nxti' to remember that this is the 'next' pointer-
not the current pointer.
Devote a single bit to mboxbsy- and set aside bits for output mbox registers
that we need to pick up- we can have at least one command which does not
have any defined output registers (MBOX_EXECUTE_FIRMWARE).
Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response.
Otherwise, we won't unswizzle it correctly.
Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
|
|
|
/*
|
|
|
|
* If we have not otherwise defined SBus support away make sure
|
|
|
|
* it is defined here such that the code is included as default
|
|
|
|
*/
|
|
|
|
#ifndef ISP_SBUS_SUPPORTED
|
|
|
|
#define ISP_SBUS_SUPPORTED 1
|
|
|
|
#endif
|
|
|
|
|
1998-09-08 11:27:04 +04:00
|
|
|
/*
|
|
|
|
* Chip Types
|
1997-08-16 04:18:36 +04:00
|
|
|
*/
|
|
|
|
#define ISP_HA_SCSI 0xf
|
1998-09-08 11:27:04 +04:00
|
|
|
#define ISP_HA_SCSI_UNKNOWN 0x1
|
|
|
|
#define ISP_HA_SCSI_1020 0x2
|
|
|
|
#define ISP_HA_SCSI_1020A 0x3
|
|
|
|
#define ISP_HA_SCSI_1040 0x4
|
|
|
|
#define ISP_HA_SCSI_1040A 0x5
|
|
|
|
#define ISP_HA_SCSI_1040B 0x6
|
1999-04-04 05:27:06 +04:00
|
|
|
#define ISP_HA_SCSI_1040C 0x7
|
1999-12-16 08:35:42 +03:00
|
|
|
#define ISP_HA_SCSI_1240 0x8
|
|
|
|
#define ISP_HA_SCSI_1080 0x9
|
|
|
|
#define ISP_HA_SCSI_1280 0xa
|
2002-10-19 03:35:25 +04:00
|
|
|
#define ISP_HA_SCSI_10160 0xb
|
|
|
|
#define ISP_HA_SCSI_12160 0xc
|
1997-08-16 04:18:36 +04:00
|
|
|
#define ISP_HA_FC 0xf0
|
|
|
|
#define ISP_HA_FC_2100 0x10
|
1999-07-06 00:31:35 +04:00
|
|
|
#define ISP_HA_FC_2200 0x20
|
2001-05-16 07:58:34 +04:00
|
|
|
#define ISP_HA_FC_2300 0x30
|
2002-01-04 00:45:06 +03:00
|
|
|
#define ISP_HA_FC_2312 0x40
|
1997-08-16 04:18:36 +04:00
|
|
|
|
1999-03-17 09:15:47 +03:00
|
|
|
#define IS_SCSI(isp) (isp->isp_type & ISP_HA_SCSI)
|
1999-12-16 08:35:42 +03:00
|
|
|
#define IS_1240(isp) (isp->isp_type == ISP_HA_SCSI_1240)
|
1999-03-17 09:15:47 +03:00
|
|
|
#define IS_1080(isp) (isp->isp_type == ISP_HA_SCSI_1080)
|
1999-12-16 08:35:42 +03:00
|
|
|
#define IS_1280(isp) (isp->isp_type == ISP_HA_SCSI_1280)
|
2002-10-19 03:35:25 +04:00
|
|
|
#define IS_10160(isp) (isp->isp_type == ISP_HA_SCSI_10160)
|
2000-02-12 05:29:00 +03:00
|
|
|
#define IS_12160(isp) (isp->isp_type == ISP_HA_SCSI_12160)
|
|
|
|
|
|
|
|
#define IS_12X0(isp) (IS_1240(isp) || IS_1280(isp))
|
2002-10-19 03:35:25 +04:00
|
|
|
#define IS_1X160(isp) (IS_10160(isp) || IS_12160(isp))
|
2000-02-12 05:29:00 +03:00
|
|
|
#define IS_DUALBUS(isp) (IS_12X0(isp) || IS_12160(isp))
|
2002-10-19 03:35:25 +04:00
|
|
|
#define IS_ULTRA2(isp) (IS_1080(isp) || IS_1280(isp) || IS_1X160(isp))
|
|
|
|
#define IS_ULTRA3(isp) (IS_1X160(isp))
|
2000-02-12 05:29:00 +03:00
|
|
|
|
2001-05-16 07:58:34 +04:00
|
|
|
#define IS_FC(isp) ((isp)->isp_type & ISP_HA_FC)
|
|
|
|
#define IS_2100(isp) ((isp)->isp_type == ISP_HA_FC_2100)
|
|
|
|
#define IS_2200(isp) ((isp)->isp_type == ISP_HA_FC_2200)
|
2002-01-04 00:45:06 +03:00
|
|
|
#define IS_23XX(isp) ((isp)->isp_type >= ISP_HA_FC_2300)
|
|
|
|
#define IS_2300(isp) ((isp)->isp_type == ISP_HA_FC_2300)
|
|
|
|
#define IS_2312(isp) ((isp)->isp_type == ISP_HA_FC_2312)
|
2000-02-12 05:29:00 +03:00
|
|
|
|
2000-08-02 03:55:09 +04:00
|
|
|
/*
|
|
|
|
* DMA cookie macros
|
|
|
|
*/
|
2002-10-19 03:35:25 +04:00
|
|
|
#ifdef ISP_DAC_SUPPORTRED
|
|
|
|
#define DMA_WD3(x) (((x) >> 48) & 0xffff)
|
|
|
|
#define DMA_WD2(x) (((x) >> 32) & 0xffff)
|
|
|
|
#else
|
2001-09-01 11:12:23 +04:00
|
|
|
#define DMA_WD3(x) 0
|
|
|
|
#define DMA_WD2(x) 0
|
2002-10-19 03:35:25 +04:00
|
|
|
#endif
|
2001-09-01 11:12:23 +04:00
|
|
|
#define DMA_WD1(x) (((x) >> 16) & 0xffff)
|
|
|
|
#define DMA_WD0(x) (((x) & 0xffff))
|
1999-03-17 09:15:47 +03:00
|
|
|
|
1997-03-12 23:44:50 +03:00
|
|
|
/*
|
2000-08-02 03:55:09 +04:00
|
|
|
* Core System Function Prototypes
|
1997-03-12 23:44:50 +03:00
|
|
|
*/
|
1998-07-15 23:50:16 +04:00
|
|
|
|
1997-03-12 23:44:50 +03:00
|
|
|
/*
|
1998-07-15 23:50:16 +04:00
|
|
|
* Reset Hardware. Totally. Assumes that you'll follow this with
|
|
|
|
* a call to isp_init.
|
1997-03-12 23:44:50 +03:00
|
|
|
*/
|
2001-03-14 08:14:36 +03:00
|
|
|
void isp_reset(struct ispsoftc *);
|
1997-03-12 23:44:50 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialize Hardware to known state
|
|
|
|
*/
|
2001-03-14 08:14:36 +03:00
|
|
|
void isp_init(struct ispsoftc *);
|
1997-03-12 23:44:50 +03:00
|
|
|
|
1998-07-19 01:06:20 +04:00
|
|
|
/*
|
|
|
|
* Reset the ISP and call completion for any orphaned commands.
|
|
|
|
*/
|
2001-03-14 08:14:36 +03:00
|
|
|
void isp_reinit(struct ispsoftc *);
|
1998-07-19 01:06:20 +04:00
|
|
|
|
2002-02-22 01:32:40 +03:00
|
|
|
#ifdef ISP_FW_CRASH_DUMP
|
|
|
|
/*
|
|
|
|
* Dump firmware entry point.
|
|
|
|
*/
|
|
|
|
void isp_fw_dump(struct ispsoftc *isp);
|
|
|
|
#endif
|
|
|
|
|
1997-03-12 23:44:50 +03:00
|
|
|
/*
|
2001-09-01 11:12:23 +04:00
|
|
|
* Internal Interrupt Service Routine
|
|
|
|
*
|
|
|
|
* The outer layers do the spade work to get the appropriate status register,
|
|
|
|
* semaphore register and first mailbox register (if appropriate). This also
|
|
|
|
* means that most spurious/bogus interrupts not for us can be filtered first.
|
1997-03-12 23:44:50 +03:00
|
|
|
*/
|
2001-09-01 11:12:23 +04:00
|
|
|
void isp_intr(struct ispsoftc *, u_int16_t, u_int16_t, u_int16_t);
|
|
|
|
|
1997-03-12 23:44:50 +03:00
|
|
|
|
1998-07-15 23:50:16 +04:00
|
|
|
/*
|
2000-08-02 03:55:09 +04:00
|
|
|
* Command Entry Point- Platform Dependent layers call into this
|
|
|
|
*/
|
2001-03-14 08:14:36 +03:00
|
|
|
int isp_start(XS_T *);
|
2000-08-02 03:55:09 +04:00
|
|
|
/* these values are what isp_start returns */
|
|
|
|
#define CMD_COMPLETE 101 /* command completed */
|
|
|
|
#define CMD_EAGAIN 102 /* busy- maybe retry later */
|
|
|
|
#define CMD_QUEUED 103 /* command has been queued for execution */
|
|
|
|
#define CMD_RQLATER 104 /* requeue this command later */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Command Completion Point- Core layers call out from this with completed cmds
|
1998-07-15 23:50:16 +04:00
|
|
|
*/
|
2001-03-14 08:14:36 +03:00
|
|
|
void isp_done(XS_T *);
|
1997-03-12 23:44:50 +03:00
|
|
|
|
1998-07-15 23:50:16 +04:00
|
|
|
/*
|
1999-01-30 10:31:50 +03:00
|
|
|
* Platform Dependent to External to Internal Control Function
|
1998-07-15 23:50:16 +04:00
|
|
|
*
|
2001-02-13 02:33:49 +03:00
|
|
|
* Assumes locks are held on entry. You should note that with many of
|
|
|
|
* these commands and locks may be released while this is occurring.
|
|
|
|
*
|
|
|
|
* A few notes about some of these functions:
|
|
|
|
*
|
|
|
|
* ISPCTL_FCLINK_TEST tests to make sure we have good fibre channel link.
|
|
|
|
* The argument is a pointer to an integer which is the time, in microseconds,
|
|
|
|
* we should wait to see whether we have good link. This test, if successful,
|
|
|
|
* lets us know our connection topology and our Loop ID/AL_PA and so on.
|
|
|
|
* You can't get anywhere without this.
|
|
|
|
*
|
|
|
|
* ISPCTL_SCAN_FABRIC queries the name server (if we're on a fabric) for
|
|
|
|
* all entities using the FC Generic Services subcommand GET ALL NEXT.
|
|
|
|
* For each found entity, an ISPASYNC_FABRICDEV event is generated (see
|
|
|
|
* below).
|
|
|
|
*
|
|
|
|
* ISPCTL_SCAN_LOOP does a local loop scan. This is only done if the connection
|
|
|
|
* topology is NL or FL port (private or public loop). Since the Qlogic f/w
|
|
|
|
* 'automatically' manages local loop connections, this function essentially
|
|
|
|
* notes the arrival, departure, and possible shuffling around of local loop
|
|
|
|
* entities. Thus for each arrival and departure this generates an isp_async
|
|
|
|
* event of ISPASYNC_PROMENADE (see below).
|
1998-07-15 23:50:16 +04:00
|
|
|
*
|
2001-02-13 02:33:49 +03:00
|
|
|
* ISPCTL_PDB_SYNC is somewhat misnamed. It actually is the final step, in
|
|
|
|
* order, of ISPCTL_FCLINK_TEST, ISPCTL_SCAN_FABRIC, and ISPCTL_SCAN_LOOP.
|
|
|
|
* The main purpose of ISPCTL_PDB_SYNC is to complete management of logging
|
|
|
|
* and logging out of fabric devices (if one is on a fabric) and then marking
|
|
|
|
* the 'loop state' as being ready to now be used for sending commands to
|
|
|
|
* devices. Originally fabric name server and local loop scanning were
|
2001-07-22 17:33:58 +04:00
|
|
|
* part of this function. It's now been separated to allow for finer control.
|
1998-07-15 23:50:16 +04:00
|
|
|
*/
|
|
|
|
typedef enum {
|
1999-07-06 00:31:35 +04:00
|
|
|
ISPCTL_RESET_BUS, /* Reset Bus */
|
|
|
|
ISPCTL_RESET_DEV, /* Reset Device */
|
|
|
|
ISPCTL_ABORT_CMD, /* Abort Command */
|
2001-02-13 02:33:49 +03:00
|
|
|
ISPCTL_UPDATE_PARAMS, /* Update Operating Parameters (SCSI) */
|
2000-01-06 06:00:11 +03:00
|
|
|
ISPCTL_FCLINK_TEST, /* Test FC Link Status */
|
2001-02-13 02:33:49 +03:00
|
|
|
ISPCTL_SCAN_FABRIC, /* (Re)scan Fabric Name Server */
|
|
|
|
ISPCTL_SCAN_LOOP, /* (Re)scan Local Loop */
|
2000-01-06 06:00:11 +03:00
|
|
|
ISPCTL_PDB_SYNC, /* Synchronize Port Database */
|
2001-02-13 02:33:49 +03:00
|
|
|
ISPCTL_SEND_LIP, /* Send a LIP */
|
|
|
|
ISPCTL_GET_POSMAP, /* Get FC-AL position map */
|
2001-02-20 04:11:35 +03:00
|
|
|
ISPCTL_RUN_MBOXCMD, /* run a mailbox command */
|
2000-01-06 06:00:11 +03:00
|
|
|
ISPCTL_TOGGLE_TMODE /* toggle target mode */
|
1998-07-15 23:50:16 +04:00
|
|
|
} ispctl_t;
|
2001-03-14 08:14:36 +03:00
|
|
|
int isp_control(struct ispsoftc *, ispctl_t, void *);
|
1997-03-12 23:44:50 +03:00
|
|
|
|
1999-01-30 10:31:50 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Platform Dependent to Internal to External Control Function
|
|
|
|
* (each platform must provide such a function)
|
|
|
|
*
|
2001-02-13 02:33:49 +03:00
|
|
|
* Assumes locks are held.
|
|
|
|
*
|
|
|
|
* A few notes about some of these functions:
|
|
|
|
*
|
|
|
|
* ISPASYNC_CHANGE_NOTIFY notifies the outer layer that a change has
|
|
|
|
* occurred that invalidates the list of fabric devices known and/or
|
|
|
|
* the list of known loop devices. The argument passed is a pointer
|
|
|
|
* whose values are defined below (local loop change, name server
|
|
|
|
* change, other). 'Other' may simply be a LIP, or a change in
|
|
|
|
* connection topology.
|
|
|
|
*
|
|
|
|
* ISPASYNC_FABRIC_DEV announces the next element in a list of
|
|
|
|
* fabric device names we're getting out of the name server. The
|
|
|
|
* argument points to a GET ALL NEXT response structure. The list
|
|
|
|
* is known to terminate with an entry that refers to ourselves.
|
|
|
|
* One of the main purposes of this function is to allow outer
|
|
|
|
* layers, which are OS dependent, to set policy as to which fabric
|
|
|
|
* devices might actually be logged into (and made visible) later
|
|
|
|
* at ISPCTL_PDB_SYNC time. Since there's a finite number of fabric
|
|
|
|
* devices that we can log into (256 less 3 'reserved' for F-port
|
|
|
|
* topologies), and fabrics can grow up to 8 million or so entries
|
|
|
|
* (24 bits of Port Address, less a wad of reserved spaces), clearly
|
|
|
|
* we had better let the OS determine login policy.
|
|
|
|
*
|
|
|
|
* ISPASYNC_PROMENADE has an argument that is a pointer to an integer which
|
2002-10-19 03:35:25 +04:00
|
|
|
* is an index into the portdb in the softc ('target'). Whether that entry's
|
2001-02-13 02:33:49 +03:00
|
|
|
* valid tag is set or not says whether something has arrived or departed.
|
|
|
|
* The name refers to a favorite pastime of many city dwellers- watching
|
|
|
|
* people come and go, talking of Michaelangelo, and so on..
|
2001-02-20 04:11:35 +03:00
|
|
|
*
|
|
|
|
* ISPASYNC_UNHANDLED_RESPONSE gives outer layers a chance to parse a
|
|
|
|
* response queue entry not otherwise handled. The outer layer should
|
Major restructuring for swizzling to the request queue and unswizzling from
the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have
a complete set of inline functions in isp_inline.h. Each platform is
responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32}
macros.
The reason this needs to be done is that we need to have a single set of
functions that will work correctly on multiple architectures for both little
and big endian machines. It also needs to work correctly in the case that
we have the request or response queues in memory that has to be treated
specially (e.g., have ddi_dma_sync called on it for Solaris after we update
it or before we read from it).
One thing that falls out of this is that we no longer build requests in the
request queue itself. Instead, we build the request locally (e.g., on the
stack) and then as part of the swizzling operation, copy it to the request
queue entry we've allocated. I thought long and hard about whether this was
too expensive a change to make as it in a lot of cases requires an extra
copy. On balance, the flexbility is worth it. With any luck, the entry that
we build locally stays in a processor writeback cache (after all, it's only
64 bytes) so that the cost of actually flushing it to the memory area that is
the shared queue with the PCI device is not all that expensive. We may examine
this again and try to get clever in the future to try and avoid copies.
Another change that falls out of this is that MEMORYBARRIER should be taken
a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the
entry being added. But there had been many other places this had been missing.
It's now very important that it be done.
For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of
the explicit ddi_dmamap_sync on the whole response queue that we did for SBus
cards at each interrupt.
Set things up so that platforms that cannot have an SBus don't get a lot of
the SBus code checks (dead coded out).
Additional changes:
Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry,
the iptr value that gets returned is the value we intend to eventually plug
into the ISP registers as the entry *one past* the last one we've written-
*not* the current entry we're updating. All along we've been calling sync
functions on the wrong index value. Argh. The 'fix' here is to rename all
'iptr' variables as 'nxti' to remember that this is the 'next' pointer-
not the current pointer.
Devote a single bit to mboxbsy- and set aside bits for output mbox registers
that we need to pick up- we can have at least one command which does not
have any defined output registers (MBOX_EXECUTE_FIRMWARE).
Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response.
Otherwise, we won't unswizzle it correctly.
Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
|
|
|
* return non-zero if it handled it. The 'arg' points to an unmassaged
|
|
|
|
* response queue entry.
|
1999-01-30 10:31:50 +03:00
|
|
|
*/
|
|
|
|
|
|
|
|
typedef enum {
|
2001-02-13 02:33:49 +03:00
|
|
|
ISPASYNC_NEW_TGT_PARAMS, /* New Target Parameters Negotiated */
|
1999-07-06 00:31:35 +04:00
|
|
|
ISPASYNC_BUS_RESET, /* Bus Was Reset */
|
|
|
|
ISPASYNC_LOOP_DOWN, /* FC Loop Down */
|
|
|
|
ISPASYNC_LOOP_UP, /* FC Loop Up */
|
2001-05-22 23:32:41 +04:00
|
|
|
ISPASYNC_LIP, /* LIP Received */
|
|
|
|
ISPASYNC_LOOP_RESET, /* Loop Reset Received */
|
2001-02-13 02:33:49 +03:00
|
|
|
ISPASYNC_CHANGE_NOTIFY, /* FC Change Notification */
|
|
|
|
ISPASYNC_FABRIC_DEV, /* FC Fabric Device Arrival */
|
|
|
|
ISPASYNC_PROMENADE, /* FC Objects coming && going */
|
2000-01-06 06:00:11 +03:00
|
|
|
ISPASYNC_TARGET_MESSAGE, /* target message */
|
|
|
|
ISPASYNC_TARGET_EVENT, /* target asynchronous event */
|
2001-02-13 02:33:49 +03:00
|
|
|
ISPASYNC_TARGET_ACTION, /* other target command action */
|
2001-02-20 04:11:35 +03:00
|
|
|
ISPASYNC_CONF_CHANGE, /* Platform Configuration Change */
|
2001-07-06 20:19:10 +04:00
|
|
|
ISPASYNC_UNHANDLED_RESPONSE, /* Unhandled Response Entry */
|
2002-06-15 04:18:02 +04:00
|
|
|
ISPASYNC_FW_CRASH, /* Firmware has crashed */
|
2002-08-13 01:33:39 +04:00
|
|
|
ISPASYNC_FW_DUMPED, /* Firmware crashdump taken */
|
2002-06-15 04:18:02 +04:00
|
|
|
ISPASYNC_FW_RESTARTED /* Firmware has been restarted */
|
1999-01-30 10:31:50 +03:00
|
|
|
} ispasync_t;
|
2001-03-14 08:14:36 +03:00
|
|
|
int isp_async(struct ispsoftc *, ispasync_t, void *);
|
1999-01-30 10:31:50 +03:00
|
|
|
|
2001-02-13 02:33:49 +03:00
|
|
|
#define ISPASYNC_CHANGE_PDB ((void *) 0)
|
|
|
|
#define ISPASYNC_CHANGE_SNS ((void *) 1)
|
|
|
|
#define ISPASYNC_CHANGE_OTHER ((void *) 2)
|
|
|
|
|
1998-07-15 23:50:16 +04:00
|
|
|
/*
|
2000-08-02 03:55:09 +04:00
|
|
|
* Platform Dependent Error and Debug Printout
|
1998-07-15 23:50:16 +04:00
|
|
|
*/
|
2000-12-29 01:27:46 +03:00
|
|
|
#ifdef __GNUC__
|
2001-03-14 08:14:36 +03:00
|
|
|
void isp_prt(struct ispsoftc *, int level, const char *, ...)
|
2000-12-29 01:27:46 +03:00
|
|
|
__attribute__((__format__(__printf__,3,4)));
|
|
|
|
#else
|
2001-03-14 08:14:36 +03:00
|
|
|
void isp_prt(struct ispsoftc *, int level, const char *, ...);
|
2000-12-29 01:27:46 +03:00
|
|
|
#endif
|
|
|
|
|
2000-08-02 03:55:09 +04:00
|
|
|
#define ISP_LOGALL 0x0 /* log always */
|
|
|
|
#define ISP_LOGCONFIG 0x1 /* log configuration messages */
|
|
|
|
#define ISP_LOGINFO 0x2 /* log informational messages */
|
|
|
|
#define ISP_LOGWARN 0x4 /* log warning messages */
|
|
|
|
#define ISP_LOGERR 0x8 /* log error messages */
|
|
|
|
#define ISP_LOGDEBUG0 0x10 /* log simple debug messages */
|
|
|
|
#define ISP_LOGDEBUG1 0x20 /* log intermediate debug messages */
|
|
|
|
#define ISP_LOGDEBUG2 0x40 /* log most debug messages */
|
2001-07-06 20:19:10 +04:00
|
|
|
#define ISP_LOGDEBUG3 0x80 /* log high frequency debug messages */
|
|
|
|
#define ISP_LOGDEBUG4 0x100 /* log high frequency debug messages */
|
2000-08-02 03:55:09 +04:00
|
|
|
#define ISP_LOGTDEBUG0 0x200 /* log simple debug messages (target mode) */
|
|
|
|
#define ISP_LOGTDEBUG1 0x400 /* log intermediate debug messages (target) */
|
|
|
|
#define ISP_LOGTDEBUG2 0x800 /* log all debug messages (target) */
|
1998-09-08 11:27:04 +04:00
|
|
|
|
2000-08-02 03:55:09 +04:00
|
|
|
/*
|
|
|
|
* Each Platform provides it's own isposinfo substructure of the ispsoftc
|
|
|
|
* defined above.
|
|
|
|
*
|
|
|
|
* Each platform must also provide the following macros/defines:
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* INLINE - platform specific define for 'inline' functions
|
|
|
|
*
|
2002-10-19 03:35:25 +04:00
|
|
|
* ISP_DAC_SUPPORTED - Is DAC (Dual Address Cycle) is supported?
|
|
|
|
* Basically means whether or not DMA for PCI
|
|
|
|
* PCI cards (Ultra2 or better or FC) works
|
|
|
|
* above 4GB.
|
2001-09-01 11:12:23 +04:00
|
|
|
*
|
2000-08-02 03:55:09 +04:00
|
|
|
* ISP2100_SCRLEN - length for the Fibre Channel scratch DMA area
|
|
|
|
*
|
|
|
|
* MEMZERO(dst, src) platform zeroing function
|
|
|
|
* MEMCPY(dst, src, count) platform copying function
|
|
|
|
* SNPRINTF(buf, bufsize, fmt, ...) snprintf
|
|
|
|
* USEC_DELAY(usecs) microsecond spindelay function
|
2000-12-09 11:06:31 +03:00
|
|
|
* USEC_SLEEP(isp, usecs) microsecond sleep function
|
2000-08-02 03:55:09 +04:00
|
|
|
*
|
|
|
|
* NANOTIME_T nanosecond time type
|
|
|
|
*
|
|
|
|
* GET_NANOTIME(NANOTIME_T *) get current nanotime.
|
|
|
|
*
|
|
|
|
* GET_NANOSEC(NANOTIME_T *) get u_int64_t from NANOTIME_T
|
|
|
|
*
|
|
|
|
* NANOTIME_SUB(NANOTIME_T *, NANOTIME_T *)
|
|
|
|
* subtract two NANOTIME_T values
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* MAXISPREQUEST(struct ispsoftc *) maximum request queue size
|
|
|
|
* for this particular board type
|
|
|
|
*
|
|
|
|
* MEMORYBARRIER(struct ispsoftc *, barrier_type, offset, size)
|
|
|
|
*
|
|
|
|
* Function/Macro the provides memory synchronization on
|
|
|
|
* various objects so that the ISP's and the system's view
|
|
|
|
* of the same object is consistent.
|
|
|
|
*
|
|
|
|
* MBOX_ACQUIRE(struct ispsoftc *) acquire lock on mailbox regs
|
|
|
|
* MBOX_WAIT_COMPLETE(struct ispsoftc *) wait for mailbox cmd to be done
|
|
|
|
* MBOX_NOTIFY_COMPLETE(struct ispsoftc *) notification of mbox cmd donee
|
|
|
|
* MBOX_RELEASE(struct ispsoftc *) release lock on mailbox regs
|
2001-02-13 02:33:49 +03:00
|
|
|
*
|
2002-02-22 01:32:40 +03:00
|
|
|
* FC_SCRATCH_ACQUIRE(struct ispsoftc *) acquire lock on FC scratch area
|
|
|
|
* FC_SCRATCH_RELEASE(struct ispsoftc *) acquire lock on FC scratch area
|
2000-08-02 03:55:09 +04:00
|
|
|
*
|
|
|
|
* SCSI_GOOD SCSI 'Good' Status
|
|
|
|
* SCSI_CHECK SCSI 'Check Condition' Status
|
|
|
|
* SCSI_BUSY SCSI 'Busy' Status
|
|
|
|
* SCSI_QFULL SCSI 'Queue Full' Status
|
|
|
|
*
|
|
|
|
* XS_T Platform SCSI transaction type (i.e., command for HBA)
|
|
|
|
* XS_ISP(xs) gets an instance out of an XS_T
|
|
|
|
* XS_CHANNEL(xs) gets the channel (bus # for DUALBUS cards) ""
|
|
|
|
* XS_TGT(xs) gets the target ""
|
|
|
|
* XS_LUN(xs) gets the lun ""
|
|
|
|
* XS_CDBP(xs) gets a pointer to the scsi CDB ""
|
|
|
|
* XS_CDBLEN(xs) gets the CDB's length ""
|
|
|
|
* XS_XFRLEN(xs) gets the associated data transfer length ""
|
|
|
|
* XS_TIME(xs) gets the time (in milliseconds) for this command
|
|
|
|
* XS_RESID(xs) gets the current residual count
|
|
|
|
* XS_STSP(xs) gets a pointer to the SCSI status byte ""
|
|
|
|
* XS_SNSP(xs) gets a pointer to the associate sense data
|
|
|
|
* XS_SNSLEN(xs) gets the length of sense data storage
|
|
|
|
* XS_SNSKEY(xs) dereferences XS_SNSP to get the current stored Sense Key
|
|
|
|
* XS_TAG_P(xs) predicate of whether this command should be tagged
|
|
|
|
* XS_TAG_TYPE(xs) which type of tag to use
|
|
|
|
* XS_SETERR(xs) set error state
|
|
|
|
*
|
|
|
|
* HBA_NOERROR command has no erros
|
|
|
|
* HBA_BOTCH hba botched something
|
|
|
|
* HBA_CMDTIMEOUT command timed out
|
|
|
|
* HBA_SELTIMEOUT selection timed out (also port logouts for FC)
|
|
|
|
* HBA_TGTBSY target returned a BUSY status
|
|
|
|
* HBA_BUSRESET bus reset destroyed command
|
|
|
|
* HBA_ABORTED command was aborted (by request)
|
|
|
|
* HBA_DATAOVR a data overrun was detected
|
|
|
|
* HBA_ARQFAIL Automatic Request Sense failed
|
|
|
|
*
|
|
|
|
* XS_ERR(xs) return current error state
|
|
|
|
* XS_NOERR(xs) there is no error currently set
|
|
|
|
* XS_INITERR(xs) initialize error state
|
|
|
|
*
|
|
|
|
* XS_SAVE_SENSE(xs, sp) save sense data
|
|
|
|
*
|
|
|
|
* XS_SET_STATE_STAT(isp, sp, xs) platform dependent interpreter of
|
|
|
|
* response queue entry status bits
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* DEFAULT_IID(struct ispsoftc *) Default SCSI initiator ID
|
|
|
|
* DEFAULT_LOOPID(struct ispsoftc *) Default FC Loop ID
|
2000-10-16 09:16:56 +04:00
|
|
|
* DEFAULT_NODEWWN(struct ispsoftc *) Default Node WWN
|
|
|
|
* DEFAULT_PORTWWN(struct ispsoftc *) Default Port WWN
|
2002-06-15 04:18:02 +04:00
|
|
|
* DEFAULT_FRAMESIZE(struct ispsoftc *) Default Frame Size
|
|
|
|
* DEFAULT_EXEC_THROTTLE(struct ispsoftc *) Default Execution Throttle
|
2000-10-16 09:16:56 +04:00
|
|
|
* These establish reasonable defaults for each platform.
|
|
|
|
* These must be available independent of card NVRAM and are
|
|
|
|
* to be used should NVRAM not be readable.
|
|
|
|
*
|
|
|
|
* ISP_NODEWWN(struct ispsoftc *) FC Node WWN to use
|
|
|
|
* ISP_PORTWWN(struct ispsoftc *) FC Port WWN to use
|
|
|
|
*
|
|
|
|
* These are to be used after NVRAM is read. The tags
|
|
|
|
* in fcparam.isp_{node,port}wwn reflect the values
|
|
|
|
* read from NVRAM (possibly corrected for card botches).
|
|
|
|
* Each platform can take that information and override
|
|
|
|
* it or ignore and return the Node and Port WWNs to be
|
|
|
|
* used when sending the Qlogic f/w the Initialization Control
|
|
|
|
* Block.
|
2000-08-02 03:55:09 +04:00
|
|
|
*
|
|
|
|
* (XXX these do endian specific transformations- in transition XXX)
|
Major restructuring for swizzling to the request queue and unswizzling from
the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have
a complete set of inline functions in isp_inline.h. Each platform is
responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32}
macros.
The reason this needs to be done is that we need to have a single set of
functions that will work correctly on multiple architectures for both little
and big endian machines. It also needs to work correctly in the case that
we have the request or response queues in memory that has to be treated
specially (e.g., have ddi_dma_sync called on it for Solaris after we update
it or before we read from it).
One thing that falls out of this is that we no longer build requests in the
request queue itself. Instead, we build the request locally (e.g., on the
stack) and then as part of the swizzling operation, copy it to the request
queue entry we've allocated. I thought long and hard about whether this was
too expensive a change to make as it in a lot of cases requires an extra
copy. On balance, the flexbility is worth it. With any luck, the entry that
we build locally stays in a processor writeback cache (after all, it's only
64 bytes) so that the cost of actually flushing it to the memory area that is
the shared queue with the PCI device is not all that expensive. We may examine
this again and try to get clever in the future to try and avoid copies.
Another change that falls out of this is that MEMORYBARRIER should be taken
a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the
entry being added. But there had been many other places this had been missing.
It's now very important that it be done.
For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of
the explicit ddi_dmamap_sync on the whole response queue that we did for SBus
cards at each interrupt.
Set things up so that platforms that cannot have an SBus don't get a lot of
the SBus code checks (dead coded out).
Additional changes:
Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry,
the iptr value that gets returned is the value we intend to eventually plug
into the ISP registers as the entry *one past* the last one we've written-
*not* the current entry we're updating. All along we've been calling sync
functions on the wrong index value. Argh. The 'fix' here is to rename all
'iptr' variables as 'nxti' to remember that this is the 'next' pointer-
not the current pointer.
Devote a single bit to mboxbsy- and set aside bits for output mbox registers
that we need to pick up- we can have at least one command which does not
have any defined output registers (MBOX_EXECUTE_FIRMWARE).
Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response.
Otherwise, we won't unswizzle it correctly.
Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
|
|
|
*
|
|
|
|
* ISP_IOXPUT_8(struct ispsoftc *, u_int8_t srcval, u_int8_t *dstptr)
|
|
|
|
* ISP_IOXPUT_16(struct ispsoftc *, u_int16_t srcval, u_int16_t *dstptr)
|
|
|
|
* ISP_IOXPUT_32(struct ispsoftc *, u_int32_t srcval, u_int32_t *dstptr)
|
|
|
|
*
|
|
|
|
* ISP_IOXGET_8(struct ispsoftc *, u_int8_t *srcptr, u_int8_t dstrval)
|
|
|
|
* ISP_IOXGET_16(struct ispsoftc *, u_int16_t *srcptr, u_int16_t dstrval)
|
|
|
|
* ISP_IOXGET_32(struct ispsoftc *, u_int32_t *srcptr, u_int32_t dstrval)
|
|
|
|
*
|
|
|
|
* ISP_SWIZZLE_NVRAM_WORD(struct ispsoftc *, u_int16_t *)
|
2000-08-02 03:55:09 +04:00
|
|
|
*/
|
2001-05-16 07:58:34 +04:00
|
|
|
|
1997-03-12 23:44:50 +03:00
|
|
|
#endif /* _ISPVAR_H */
|