2003-08-24 17:55:58 +00:00
|
|
|
/*-
|
2017-11-27 14:52:40 +00:00
|
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
|
|
|
*
|
2020-11-20 01:15:48 +00:00
|
|
|
* Copyright (c) 2009-2020 Alexander Motin <mav@FreeBSD.org>
|
2009-08-01 01:04:26 +00:00
|
|
|
* Copyright (c) 1997-2008 by Matthew Jacob
|
2006-01-23 06:23:37 +00:00
|
|
|
* All rights reserved.
|
1998-04-22 18:12:29 +00: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
|
|
|
|
|
* notice immediately at the beginning of the file, without modification,
|
|
|
|
|
* this list of conditions, and the following disclaimer.
|
2000-09-21 20:16:04 +00:00
|
|
|
* 2. The name of the author may not be used to endorse or promote products
|
|
|
|
|
* derived from this software without specific prior written permission.
|
1998-04-22 18:12:29 +00:00
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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.
|
|
|
|
|
*/
|
2006-07-16 20:11:50 +00:00
|
|
|
/*
|
|
|
|
|
* PCI specific probe and attach routines for Qlogic ISP SCSI adapters.
|
|
|
|
|
* FreeBSD Version.
|
|
|
|
|
*/
|
2003-08-24 17:55:58 +00:00
|
|
|
#include <sys/cdefs.h>
|
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
2000-02-11 19:45:17 +00:00
|
|
|
#include <sys/param.h>
|
|
|
|
|
#include <sys/systm.h>
|
|
|
|
|
#include <sys/kernel.h>
|
|
|
|
|
#include <sys/module.h>
|
Convert isp(4) and ispfw(4) to use firmware(9) to manage firmware
loading for the QLogic cards.
Because isp(4) exists before the root is mounted, it's not really
possible for us to use the kernel's linker to load modules directly
from disk- that's really too bad.
However, the this is still a net win in in that the firmware has
been split up on a per chip (and in some cases, functionality)
basis, so the amount of stuff loaded *can* be substantially less
than the 1.5MB of firmware images that ispfw now manages. That is,
each specific f/w set is now also built as a module. For example,
QLogic 2322 f/w is built as isp_2322.ko and Initiator/Target 1080
firmware is built as isp_1080_it.ko.
For compatibility purposes (i.e., to perturb folks the least), we
also still build all of the firmware as one ispfw.ko module.
This allows us to let 'ispfw_LOAD' keep on working in existing
loader.conf files. If you now want to strip this down to just
the firmware for your h/w, you can then change loader.conf to
load the f/w you specifically want.
We also still allow for ispfw to be statically built (e.g., for
PAE and sparc64).
Future changes will look at f/w unloading and also role switching
that then uses the kernel linker to load different ips f/w sets.
MFC after: 2 months
2006-07-09 17:50:20 +00:00
|
|
|
#include <sys/linker.h>
|
|
|
|
|
#include <sys/firmware.h>
|
2000-02-11 19:45:17 +00:00
|
|
|
#include <sys/bus.h>
|
2005-12-15 22:12:27 +00:00
|
|
|
#include <sys/stdint.h>
|
2003-08-22 06:00:27 +00:00
|
|
|
#include <dev/pci/pcireg.h>
|
|
|
|
|
#include <dev/pci/pcivar.h>
|
1998-09-15 10:06:23 +00:00
|
|
|
#include <machine/bus.h>
|
2000-02-11 19:45:17 +00:00
|
|
|
#include <machine/resource.h>
|
|
|
|
|
#include <sys/rman.h>
|
|
|
|
|
#include <sys/malloc.h>
|
2009-08-01 01:04:26 +00:00
|
|
|
#include <sys/uio.h>
|
2000-02-11 19:45:17 +00:00
|
|
|
#include <dev/isp/isp_freebsd.h>
|
1999-03-17 05:07:18 +00:00
|
|
|
|
2006-11-02 03:21:32 +00:00
|
|
|
static uint32_t isp_pci_rd_reg_2400(ispsoftc_t *, int);
|
|
|
|
|
static void isp_pci_wr_reg_2400(ispsoftc_t *, int, uint32_t);
|
2015-12-04 19:46:49 +00:00
|
|
|
static uint32_t isp_pci_rd_reg_2600(ispsoftc_t *, int);
|
|
|
|
|
static void isp_pci_wr_reg_2600(ispsoftc_t *, int, uint32_t);
|
2017-03-15 14:58:29 +00:00
|
|
|
static void isp_pci_run_isr_2400(ispsoftc_t *);
|
2006-04-21 18:30:01 +00:00
|
|
|
static int isp_pci_mbxdma(ispsoftc_t *);
|
2017-03-14 08:03:56 +00:00
|
|
|
static void isp_pci_mbxdmafree(ispsoftc_t *);
|
|
|
|
|
static int isp_pci_irqsetup(ispsoftc_t *);
|
1999-02-09 01:12:52 +00:00
|
|
|
|
2006-11-02 03:21:32 +00:00
|
|
|
static struct ispmdvec mdvec_2400 = {
|
2017-03-15 14:58:29 +00:00
|
|
|
isp_pci_run_isr_2400,
|
2006-11-02 03:21:32 +00:00
|
|
|
isp_pci_rd_reg_2400,
|
|
|
|
|
isp_pci_wr_reg_2400,
|
|
|
|
|
isp_pci_mbxdma,
|
2020-11-20 18:02:04 +00:00
|
|
|
isp_send_cmd,
|
2017-03-14 08:03:56 +00:00
|
|
|
isp_pci_irqsetup,
|
2006-11-02 03:21:32 +00:00
|
|
|
NULL
|
|
|
|
|
};
|
|
|
|
|
|
2009-08-01 01:04:26 +00:00
|
|
|
static struct ispmdvec mdvec_2500 = {
|
2017-03-15 14:58:29 +00:00
|
|
|
isp_pci_run_isr_2400,
|
2009-08-01 01:04:26 +00:00
|
|
|
isp_pci_rd_reg_2400,
|
|
|
|
|
isp_pci_wr_reg_2400,
|
|
|
|
|
isp_pci_mbxdma,
|
2020-11-20 18:02:04 +00:00
|
|
|
isp_send_cmd,
|
2017-03-14 08:03:56 +00:00
|
|
|
isp_pci_irqsetup,
|
2009-08-01 01:04:26 +00:00
|
|
|
NULL
|
|
|
|
|
};
|
|
|
|
|
|
2015-12-02 20:22:50 +00:00
|
|
|
static struct ispmdvec mdvec_2600 = {
|
2017-03-15 14:58:29 +00:00
|
|
|
isp_pci_run_isr_2400,
|
2015-12-04 19:46:49 +00:00
|
|
|
isp_pci_rd_reg_2600,
|
|
|
|
|
isp_pci_wr_reg_2600,
|
2015-12-02 20:22:50 +00:00
|
|
|
isp_pci_mbxdma,
|
2020-11-20 18:02:04 +00:00
|
|
|
isp_send_cmd,
|
2017-03-14 08:03:56 +00:00
|
|
|
isp_pci_irqsetup,
|
2015-12-02 20:22:50 +00:00
|
|
|
NULL
|
|
|
|
|
};
|
|
|
|
|
|
2018-02-28 16:24:32 +00:00
|
|
|
static struct ispmdvec mdvec_2700 = {
|
|
|
|
|
isp_pci_run_isr_2400,
|
|
|
|
|
isp_pci_rd_reg_2600,
|
|
|
|
|
isp_pci_wr_reg_2600,
|
|
|
|
|
isp_pci_mbxdma,
|
2020-11-20 18:02:04 +00:00
|
|
|
isp_send_cmd,
|
2018-02-28 16:24:32 +00:00
|
|
|
isp_pci_irqsetup,
|
|
|
|
|
NULL
|
|
|
|
|
};
|
|
|
|
|
|
1998-04-22 18:12:29 +00:00
|
|
|
#ifndef PCIM_CMD_INVEN
|
1998-09-15 10:06:23 +00:00
|
|
|
#define PCIM_CMD_INVEN 0x10
|
1998-04-22 18:12:29 +00:00
|
|
|
#endif
|
|
|
|
|
#ifndef PCIM_CMD_BUSMASTEREN
|
1998-09-15 10:06:23 +00:00
|
|
|
#define PCIM_CMD_BUSMASTEREN 0x0004
|
1998-04-22 18:12:29 +00:00
|
|
|
#endif
|
1999-02-09 01:12:52 +00:00
|
|
|
#ifndef PCIM_CMD_PERRESPEN
|
|
|
|
|
#define PCIM_CMD_PERRESPEN 0x0040
|
|
|
|
|
#endif
|
|
|
|
|
#ifndef PCIM_CMD_SEREN
|
|
|
|
|
#define PCIM_CMD_SEREN 0x0100
|
|
|
|
|
#endif
|
2006-07-03 08:24:09 +00:00
|
|
|
#ifndef PCIM_CMD_INTX_DISABLE
|
|
|
|
|
#define PCIM_CMD_INTX_DISABLE 0x0400
|
|
|
|
|
#endif
|
1999-02-09 01:12:52 +00:00
|
|
|
|
|
|
|
|
#ifndef PCIR_COMMAND
|
|
|
|
|
#define PCIR_COMMAND 0x04
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef PCIR_CACHELNSZ
|
|
|
|
|
#define PCIR_CACHELNSZ 0x0c
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#ifndef PCIR_LATTIMER
|
|
|
|
|
#define PCIR_LATTIMER 0x0d
|
|
|
|
|
#endif
|
|
|
|
|
|
1999-04-04 01:14:02 +00:00
|
|
|
#ifndef PCIR_ROMADDR
|
|
|
|
|
#define PCIR_ROMADDR 0x30
|
|
|
|
|
#endif
|
|
|
|
|
|
2000-06-18 05:18:55 +00:00
|
|
|
#define PCI_VENDOR_QLOGIC 0x1077
|
1998-04-22 18:12:29 +00:00
|
|
|
|
2006-01-26 05:04:35 +00:00
|
|
|
#define PCI_PRODUCT_QLOGIC_ISP2422 0x2422
|
2007-02-10 03:33:09 +00:00
|
|
|
#define PCI_PRODUCT_QLOGIC_ISP2432 0x2432
|
2009-08-01 01:04:26 +00:00
|
|
|
#define PCI_PRODUCT_QLOGIC_ISP2532 0x2532
|
2018-02-28 16:24:32 +00:00
|
|
|
#define PCI_PRODUCT_QLOGIC_ISP5432 0x5432
|
2015-12-02 20:22:50 +00:00
|
|
|
#define PCI_PRODUCT_QLOGIC_ISP2031 0x2031
|
2015-12-09 22:52:37 +00:00
|
|
|
#define PCI_PRODUCT_QLOGIC_ISP8031 0x8031
|
2018-02-28 16:24:32 +00:00
|
|
|
#define PCI_PRODUCT_QLOGIC_ISP2684 0x2171
|
|
|
|
|
#define PCI_PRODUCT_QLOGIC_ISP2692 0x2b61
|
|
|
|
|
#define PCI_PRODUCT_QLOGIC_ISP2714 0x2071
|
|
|
|
|
#define PCI_PRODUCT_QLOGIC_ISP2722 0x2261
|
Convert isp(4) and ispfw(4) to use firmware(9) to manage firmware
loading for the QLogic cards.
Because isp(4) exists before the root is mounted, it's not really
possible for us to use the kernel's linker to load modules directly
from disk- that's really too bad.
However, the this is still a net win in in that the firmware has
been split up on a per chip (and in some cases, functionality)
basis, so the amount of stuff loaded *can* be substantially less
than the 1.5MB of firmware images that ispfw now manages. That is,
each specific f/w set is now also built as a module. For example,
QLogic 2322 f/w is built as isp_2322.ko and Initiator/Target 1080
firmware is built as isp_1080_it.ko.
For compatibility purposes (i.e., to perturb folks the least), we
also still build all of the firmware as one ispfw.ko module.
This allows us to let 'ispfw_LOAD' keep on working in existing
loader.conf files. If you now want to strip this down to just
the firmware for your h/w, you can then change loader.conf to
load the f/w you specifically want.
We also still allow for ispfw to be statically built (e.g., for
PAE and sparc64).
Future changes will look at f/w unloading and also role switching
that then uses the kernel linker to load different ips f/w sets.
MFC after: 2 months
2006-07-09 17:50:20 +00:00
|
|
|
|
2006-01-26 06:15:58 +00:00
|
|
|
#define PCI_QLOGIC_ISP2422 \
|
|
|
|
|
((PCI_PRODUCT_QLOGIC_ISP2422 << 16) | PCI_VENDOR_QLOGIC)
|
2007-02-10 03:33:09 +00:00
|
|
|
#define PCI_QLOGIC_ISP2432 \
|
|
|
|
|
((PCI_PRODUCT_QLOGIC_ISP2432 << 16) | PCI_VENDOR_QLOGIC)
|
2009-08-01 01:04:26 +00:00
|
|
|
#define PCI_QLOGIC_ISP2532 \
|
|
|
|
|
((PCI_PRODUCT_QLOGIC_ISP2532 << 16) | PCI_VENDOR_QLOGIC)
|
2018-02-28 16:24:32 +00:00
|
|
|
#define PCI_QLOGIC_ISP5432 \
|
|
|
|
|
((PCI_PRODUCT_QLOGIC_ISP5432 << 16) | PCI_VENDOR_QLOGIC)
|
2015-12-02 20:22:50 +00:00
|
|
|
#define PCI_QLOGIC_ISP2031 \
|
|
|
|
|
((PCI_PRODUCT_QLOGIC_ISP2031 << 16) | PCI_VENDOR_QLOGIC)
|
2015-12-09 22:52:37 +00:00
|
|
|
#define PCI_QLOGIC_ISP8031 \
|
|
|
|
|
((PCI_PRODUCT_QLOGIC_ISP8031 << 16) | PCI_VENDOR_QLOGIC)
|
2018-02-28 16:24:32 +00:00
|
|
|
#define PCI_QLOGIC_ISP2684 \
|
|
|
|
|
((PCI_PRODUCT_QLOGIC_ISP2684 << 16) | PCI_VENDOR_QLOGIC)
|
|
|
|
|
#define PCI_QLOGIC_ISP2692 \
|
|
|
|
|
((PCI_PRODUCT_QLOGIC_ISP2692 << 16) | PCI_VENDOR_QLOGIC)
|
|
|
|
|
#define PCI_QLOGIC_ISP2714 \
|
|
|
|
|
((PCI_PRODUCT_QLOGIC_ISP2714 << 16) | PCI_VENDOR_QLOGIC)
|
|
|
|
|
#define PCI_QLOGIC_ISP2722 \
|
|
|
|
|
((PCI_PRODUCT_QLOGIC_ISP2722 << 16) | PCI_VENDOR_QLOGIC)
|
2015-12-09 22:52:37 +00:00
|
|
|
|
1999-02-09 01:12:52 +00:00
|
|
|
#define PCI_DFLT_LTNCY 0x40
|
|
|
|
|
#define PCI_DFLT_LNSZ 0x10
|
1998-04-22 18:12:29 +00:00
|
|
|
|
2000-02-11 19:45:17 +00:00
|
|
|
static int isp_pci_probe (device_t);
|
|
|
|
|
static int isp_pci_attach (device_t);
|
2006-11-02 03:21:32 +00:00
|
|
|
static int isp_pci_detach (device_t);
|
1998-04-22 18:12:29 +00:00
|
|
|
|
2002-04-02 23:36:14 +00:00
|
|
|
|
1998-04-22 18:12:29 +00:00
|
|
|
struct isp_pcisoftc {
|
2006-04-21 18:30:01 +00:00
|
|
|
ispsoftc_t pci_isp;
|
2011-08-13 23:34:17 +00:00
|
|
|
struct resource * regs;
|
2015-12-15 04:51:50 +00:00
|
|
|
struct resource * regs1;
|
2015-12-04 19:46:49 +00:00
|
|
|
struct resource * regs2;
|
2017-03-19 19:11:40 +00:00
|
|
|
struct {
|
|
|
|
|
int iqd;
|
|
|
|
|
struct resource * irq;
|
|
|
|
|
void * ih;
|
|
|
|
|
} irq[ISP_MAX_IRQS];
|
2011-08-13 23:34:17 +00:00
|
|
|
int rtp;
|
|
|
|
|
int rgd;
|
2015-12-15 04:51:50 +00:00
|
|
|
int rtp1;
|
|
|
|
|
int rgd1;
|
2015-12-04 19:46:49 +00:00
|
|
|
int rtp2;
|
|
|
|
|
int rgd2;
|
2002-04-02 23:36:14 +00:00
|
|
|
bus_dma_tag_t dmat;
|
2007-05-05 20:17:23 +00:00
|
|
|
int msicount;
|
1998-04-22 18:12:29 +00:00
|
|
|
};
|
|
|
|
|
|
2006-11-02 03:21:32 +00:00
|
|
|
|
2000-02-11 19:45:17 +00:00
|
|
|
static device_method_t isp_pci_methods[] = {
|
|
|
|
|
/* Device interface */
|
|
|
|
|
DEVMETHOD(device_probe, isp_pci_probe),
|
|
|
|
|
DEVMETHOD(device_attach, isp_pci_attach),
|
2006-11-02 03:21:32 +00:00
|
|
|
DEVMETHOD(device_detach, isp_pci_detach),
|
2000-02-11 19:45:17 +00:00
|
|
|
{ 0, 0 }
|
1998-04-22 18:12:29 +00:00
|
|
|
};
|
|
|
|
|
|
2000-02-11 19:45:17 +00:00
|
|
|
static driver_t isp_pci_driver = {
|
|
|
|
|
"isp", isp_pci_methods, sizeof (struct isp_pcisoftc)
|
|
|
|
|
};
|
|
|
|
|
static devclass_t isp_devclass;
|
|
|
|
|
DRIVER_MODULE(isp, pci, isp_pci_driver, isp_devclass, 0, 0);
|
2012-06-01 04:34:49 +00:00
|
|
|
MODULE_DEPEND(isp, cam, 1, 1, 1);
|
|
|
|
|
MODULE_DEPEND(isp, firmware, 1, 1, 1);
|
2012-06-24 17:30:54 +00:00
|
|
|
static int isp_nvports = 0;
|
1998-04-22 18:12:29 +00:00
|
|
|
|
2000-02-11 19:45:17 +00:00
|
|
|
static int
|
|
|
|
|
isp_pci_probe(device_t dev)
|
1999-03-17 05:07:18 +00:00
|
|
|
{
|
2009-08-01 01:04:26 +00:00
|
|
|
switch ((pci_get_device(dev) << 16) | (pci_get_vendor(dev))) {
|
2006-01-26 05:04:35 +00:00
|
|
|
case PCI_QLOGIC_ISP2422:
|
|
|
|
|
device_set_desc(dev, "Qlogic ISP 2422 PCI FC-AL Adapter");
|
|
|
|
|
break;
|
2007-02-10 03:33:09 +00:00
|
|
|
case PCI_QLOGIC_ISP2432:
|
|
|
|
|
device_set_desc(dev, "Qlogic ISP 2432 PCI FC-AL Adapter");
|
|
|
|
|
break;
|
2009-08-01 01:04:26 +00:00
|
|
|
case PCI_QLOGIC_ISP2532:
|
|
|
|
|
device_set_desc(dev, "Qlogic ISP 2532 PCI FC-AL Adapter");
|
|
|
|
|
break;
|
2011-03-10 23:53:01 +00:00
|
|
|
case PCI_QLOGIC_ISP5432:
|
|
|
|
|
device_set_desc(dev, "Qlogic ISP 5432 PCI FC-AL Adapter");
|
|
|
|
|
break;
|
2015-12-02 20:22:50 +00:00
|
|
|
case PCI_QLOGIC_ISP2031:
|
|
|
|
|
device_set_desc(dev, "Qlogic ISP 2031 PCI FC-AL Adapter");
|
|
|
|
|
break;
|
2015-12-09 22:52:37 +00:00
|
|
|
case PCI_QLOGIC_ISP8031:
|
|
|
|
|
device_set_desc(dev, "Qlogic ISP 8031 PCI FCoE Adapter");
|
|
|
|
|
break;
|
2018-02-28 16:24:32 +00:00
|
|
|
case PCI_QLOGIC_ISP2684:
|
|
|
|
|
device_set_desc(dev, "Qlogic ISP 2684 PCI FC Adapter");
|
|
|
|
|
break;
|
|
|
|
|
case PCI_QLOGIC_ISP2692:
|
|
|
|
|
device_set_desc(dev, "Qlogic ISP 2692 PCI FC Adapter");
|
|
|
|
|
break;
|
|
|
|
|
case PCI_QLOGIC_ISP2714:
|
|
|
|
|
device_set_desc(dev, "Qlogic ISP 2714 PCI FC Adapter");
|
|
|
|
|
break;
|
|
|
|
|
case PCI_QLOGIC_ISP2722:
|
|
|
|
|
device_set_desc(dev, "Qlogic ISP 2722 PCI FC Adapter");
|
|
|
|
|
break;
|
1998-04-22 18:12:29 +00:00
|
|
|
default:
|
2000-02-11 19:45:17 +00:00
|
|
|
return (ENXIO);
|
1998-04-22 18:12:29 +00:00
|
|
|
}
|
2002-07-11 03:25:04 +00:00
|
|
|
if (isp_announced == 0 && bootverbose) {
|
2000-08-01 05:16:49 +00:00
|
|
|
printf("Qlogic ISP Driver, FreeBSD Version %d.%d, "
|
1999-10-17 19:03:11 +00:00
|
|
|
"Core Version %d.%d\n",
|
1998-09-15 10:06:23 +00:00
|
|
|
ISP_PLATFORM_VERSION_MAJOR, ISP_PLATFORM_VERSION_MINOR,
|
|
|
|
|
ISP_CORE_VERSION_MAJOR, ISP_CORE_VERSION_MINOR);
|
2002-07-11 03:25:04 +00:00
|
|
|
isp_announced++;
|
1998-04-22 18:12:29 +00:00
|
|
|
}
|
2000-06-18 05:18:55 +00:00
|
|
|
/*
|
|
|
|
|
* XXXX: Here is where we might load the f/w module
|
|
|
|
|
* XXXX: (or increase a reference count to it).
|
|
|
|
|
*/
|
2005-03-05 18:17:35 +00:00
|
|
|
return (BUS_PROBE_DEFAULT);
|
1998-04-22 18:12:29 +00:00
|
|
|
}
|
|
|
|
|
|
2006-04-21 18:30:01 +00:00
|
|
|
static void
|
2012-06-24 17:30:54 +00:00
|
|
|
isp_get_generic_options(device_t dev, ispsoftc_t *isp)
|
2006-04-21 18:30:01 +00:00
|
|
|
{
|
|
|
|
|
int tval;
|
2006-11-14 08:45:48 +00:00
|
|
|
|
2006-04-21 18:30:01 +00:00
|
|
|
tval = 0;
|
2009-08-01 01:04:26 +00:00
|
|
|
if (resource_int_value(device_get_name(dev), device_get_unit(dev), "fwload_disable", &tval) == 0 && tval != 0) {
|
2006-04-21 18:30:01 +00:00
|
|
|
isp->isp_confopts |= ISP_CFG_NORELOAD;
|
|
|
|
|
}
|
|
|
|
|
tval = 0;
|
2009-08-01 01:04:26 +00:00
|
|
|
if (resource_int_value(device_get_name(dev), device_get_unit(dev), "ignore_nvram", &tval) == 0 && tval != 0) {
|
2006-04-21 18:30:01 +00:00
|
|
|
isp->isp_confopts |= ISP_CFG_NONVRAM;
|
|
|
|
|
}
|
2007-02-23 05:42:41 +00:00
|
|
|
tval = 0;
|
2009-08-01 01:04:26 +00:00
|
|
|
(void) resource_int_value(device_get_name(dev), device_get_unit(dev), "debug", &tval);
|
2007-02-23 05:42:41 +00:00
|
|
|
if (tval) {
|
|
|
|
|
isp->isp_dblev = tval;
|
|
|
|
|
} else {
|
|
|
|
|
isp->isp_dblev = ISP_LOGWARN|ISP_LOGERR;
|
|
|
|
|
}
|
|
|
|
|
if (bootverbose) {
|
|
|
|
|
isp->isp_dblev |= ISP_LOGCONFIG|ISP_LOGINFO;
|
|
|
|
|
}
|
2012-06-24 17:30:54 +00:00
|
|
|
tval = -1;
|
2009-08-01 01:04:26 +00:00
|
|
|
(void) resource_int_value(device_get_name(dev), device_get_unit(dev), "vports", &tval);
|
2015-11-21 21:44:11 +00:00
|
|
|
if (tval > 0 && tval <= 254) {
|
2012-06-24 17:30:54 +00:00
|
|
|
isp_nvports = tval;
|
2009-08-01 01:04:26 +00:00
|
|
|
}
|
|
|
|
|
tval = 7;
|
|
|
|
|
(void) resource_int_value(device_get_name(dev), device_get_unit(dev), "quickboot_time", &tval);
|
|
|
|
|
isp_quickboot_time = tval;
|
2007-02-23 05:42:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2009-08-01 01:04:26 +00:00
|
|
|
isp_get_specific_options(device_t dev, int chan, ispsoftc_t *isp)
|
2007-02-23 05:42:41 +00:00
|
|
|
{
|
|
|
|
|
const char *sptr;
|
2012-06-24 17:30:54 +00:00
|
|
|
int tval = 0;
|
2015-06-23 16:13:20 +00:00
|
|
|
char prefix[12], name[16];
|
|
|
|
|
|
|
|
|
|
if (chan == 0)
|
|
|
|
|
prefix[0] = 0;
|
|
|
|
|
else
|
|
|
|
|
snprintf(prefix, sizeof(prefix), "chan%d.", chan);
|
|
|
|
|
snprintf(name, sizeof(name), "%siid", prefix);
|
|
|
|
|
if (resource_int_value(device_get_name(dev), device_get_unit(dev),
|
|
|
|
|
name, &tval)) {
|
2020-11-20 01:15:48 +00:00
|
|
|
ISP_FC_PC(isp, chan)->default_id = 109 - chan;
|
2009-08-01 01:04:26 +00:00
|
|
|
} else {
|
2020-11-20 01:15:48 +00:00
|
|
|
ISP_FC_PC(isp, chan)->default_id = tval - chan;
|
2009-08-01 01:04:26 +00:00
|
|
|
isp->isp_confopts |= ISP_CFG_OWNLOOPID;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tval = -1;
|
2015-06-23 16:13:20 +00:00
|
|
|
snprintf(name, sizeof(name), "%srole", prefix);
|
|
|
|
|
if (resource_int_value(device_get_name(dev), device_get_unit(dev),
|
|
|
|
|
name, &tval) == 0) {
|
2009-08-01 01:04:26 +00:00
|
|
|
switch (tval) {
|
|
|
|
|
case ISP_ROLE_NONE:
|
|
|
|
|
case ISP_ROLE_INITIATOR:
|
|
|
|
|
case ISP_ROLE_TARGET:
|
2015-06-23 16:13:20 +00:00
|
|
|
case ISP_ROLE_BOTH:
|
|
|
|
|
device_printf(dev, "Chan %d setting role to 0x%x\n", chan, tval);
|
2009-08-01 01:04:26 +00:00
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
tval = -1;
|
|
|
|
|
break;
|
2007-02-23 05:42:41 +00:00
|
|
|
}
|
|
|
|
|
}
|
2009-08-01 01:04:26 +00:00
|
|
|
if (tval == -1) {
|
|
|
|
|
tval = ISP_DEFAULT_ROLES;
|
|
|
|
|
}
|
2010-03-17 02:48:14 +00:00
|
|
|
ISP_FC_PC(isp, chan)->def_role = tval;
|
2007-02-23 05:42:41 +00:00
|
|
|
|
2006-04-21 18:30:01 +00:00
|
|
|
tval = 0;
|
2015-06-23 16:13:20 +00:00
|
|
|
snprintf(name, sizeof(name), "%sfullduplex", prefix);
|
|
|
|
|
if (resource_int_value(device_get_name(dev), device_get_unit(dev),
|
|
|
|
|
name, &tval) == 0 && tval != 0) {
|
2006-04-21 18:30:01 +00:00
|
|
|
isp->isp_confopts |= ISP_CFG_FULL_DUPLEX;
|
|
|
|
|
}
|
2017-02-20 03:43:12 +00:00
|
|
|
sptr = NULL;
|
2015-06-23 16:13:20 +00:00
|
|
|
snprintf(name, sizeof(name), "%stopology", prefix);
|
|
|
|
|
if (resource_string_value(device_get_name(dev), device_get_unit(dev),
|
2017-02-20 03:43:12 +00:00
|
|
|
name, (const char **) &sptr) == 0 && sptr != NULL) {
|
2006-04-21 18:30:01 +00:00
|
|
|
if (strcmp(sptr, "lport") == 0) {
|
|
|
|
|
isp->isp_confopts |= ISP_CFG_LPORT;
|
|
|
|
|
} else if (strcmp(sptr, "nport") == 0) {
|
|
|
|
|
isp->isp_confopts |= ISP_CFG_NPORT;
|
|
|
|
|
} else if (strcmp(sptr, "lport-only") == 0) {
|
|
|
|
|
isp->isp_confopts |= ISP_CFG_LPORT_ONLY;
|
|
|
|
|
} else if (strcmp(sptr, "nport-only") == 0) {
|
|
|
|
|
isp->isp_confopts |= ISP_CFG_NPORT_ONLY;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-12-20 21:17:07 +00:00
|
|
|
#ifdef ISP_FCTAPE_OFF
|
|
|
|
|
isp->isp_confopts |= ISP_CFG_NOFCTAPE;
|
|
|
|
|
#else
|
|
|
|
|
isp->isp_confopts |= ISP_CFG_FCTAPE;
|
|
|
|
|
#endif
|
|
|
|
|
|
-----------
MISC CHANGES
Add a new async event- ISP_TARGET_NOTIFY_ACK, that will guarantee
eventual delivery of a NOTIFY ACK. This is tons better than just
ignoring the return from isp_notify_ack and hoping for the best.
Clean up the lower level lun enable code to be a bit more sensible.
Fix a botch in isp_endcmd which was messing up the sense data.
Fix notify ack for SRR to use a sensible error code in the case
of a reject.
Clean up and make clear what kind of firmware we've loaded and
what capabilities it has.
-----------
FULL (252 byte) SENSE DATA
In CTIOs for the ISP, there's only a limimted amount of space
to load SENSE DATA for associated CHECK CONDITIONS (24 or 26
bytes). This makes it difficult to send full SENSE DATA that can
be up to 252 bytes.
Implement MODE 2 responses which have us build the FCP Response
in system memory which the ISP will put onto the wire directly.
On the initiator side, the same problem occurs in that a command
status response only has a limited amount of space for SENSE DATA.
This data is supplemented by status continuation responses that
the ISP pushes onto the response queue after the status response.
We now pull them all together so that full sense data can be
returned to the periph driver.
This is supported on 23XX, 24XX and 25XX cards.
This is also preparation for doing >16 byte CDBs.
-----------
FC TAPE
Implement full FC-TAPE on both initiator and target mode side. This
capability is driven by firmware loaded, board type, board NVRAM
settings, or hint configuration options to enable or disable. This
is supported for 23XX, 24XX and 25XX cards.
On the initiator side, we pretty much just have to generate a command
reference number for each command we send out. This is FCP-4 compliant
in that we do this per ITL nexus to generate the allowed 1 thru 255
CRN.
In order to support the target side of FC-TAPE, we now pay attention
to more of the PRLI word 3 parameters which will tell us whether
an initiator wants confirmed responses. While we're at it, we'll
pay attention to the initiator view too and report it.
On sending back CTIOs, we will notice whether the initiator wants
confirmed responses and we'll set up flags to do so.
If a response or data frame is lost the initiator sends us an SRR
(Sequence Retransmit Request) ELS which shows up as an SRR notify
and all outstanding CTIOs are nuked with SRR Received status. The
SRR notify contains the offset that the initiator wants us to restart
the data transfer from or to retransmit the response frame.
If the ISP driver still has the CCB around for which the data segment
or response applies, it will retransmit.
However, we typically don't know about a lost data frame until we
send the FCP Response and the initiator totes up counters for data
moved and notices missing segments. In this case we've already
completed the data CCBs already and sent themn back up to the periph
driver. Because there's no really clean mechanism yet in CAM to
handle this, a hack has been put into place to complete the CTIO
CCB with the CAM_MESSAGE_RECV status which will have a MODIFY DATA
POINTER extended message in it. The internal ISP target groks this
and ctl(8) will be modified to deal with this as well.
At any rate, the data is retransmitted and an an FCP response is
sent. The whole point here is to successfully complete a command
so that you don't have to depend on ULP (SCSI) to have to recover,
which in the case of tape is not really possible (hence the name
FC-TAPE).
Sponsored by: Spectralogic
MFC after: 1 month
2012-07-28 20:06:29 +00:00
|
|
|
tval = 0;
|
2015-06-23 16:13:20 +00:00
|
|
|
snprintf(name, sizeof(name), "%snofctape", prefix);
|
|
|
|
|
(void) resource_int_value(device_get_name(dev), device_get_unit(dev),
|
|
|
|
|
name, &tval);
|
-----------
MISC CHANGES
Add a new async event- ISP_TARGET_NOTIFY_ACK, that will guarantee
eventual delivery of a NOTIFY ACK. This is tons better than just
ignoring the return from isp_notify_ack and hoping for the best.
Clean up the lower level lun enable code to be a bit more sensible.
Fix a botch in isp_endcmd which was messing up the sense data.
Fix notify ack for SRR to use a sensible error code in the case
of a reject.
Clean up and make clear what kind of firmware we've loaded and
what capabilities it has.
-----------
FULL (252 byte) SENSE DATA
In CTIOs for the ISP, there's only a limimted amount of space
to load SENSE DATA for associated CHECK CONDITIONS (24 or 26
bytes). This makes it difficult to send full SENSE DATA that can
be up to 252 bytes.
Implement MODE 2 responses which have us build the FCP Response
in system memory which the ISP will put onto the wire directly.
On the initiator side, the same problem occurs in that a command
status response only has a limited amount of space for SENSE DATA.
This data is supplemented by status continuation responses that
the ISP pushes onto the response queue after the status response.
We now pull them all together so that full sense data can be
returned to the periph driver.
This is supported on 23XX, 24XX and 25XX cards.
This is also preparation for doing >16 byte CDBs.
-----------
FC TAPE
Implement full FC-TAPE on both initiator and target mode side. This
capability is driven by firmware loaded, board type, board NVRAM
settings, or hint configuration options to enable or disable. This
is supported for 23XX, 24XX and 25XX cards.
On the initiator side, we pretty much just have to generate a command
reference number for each command we send out. This is FCP-4 compliant
in that we do this per ITL nexus to generate the allowed 1 thru 255
CRN.
In order to support the target side of FC-TAPE, we now pay attention
to more of the PRLI word 3 parameters which will tell us whether
an initiator wants confirmed responses. While we're at it, we'll
pay attention to the initiator view too and report it.
On sending back CTIOs, we will notice whether the initiator wants
confirmed responses and we'll set up flags to do so.
If a response or data frame is lost the initiator sends us an SRR
(Sequence Retransmit Request) ELS which shows up as an SRR notify
and all outstanding CTIOs are nuked with SRR Received status. The
SRR notify contains the offset that the initiator wants us to restart
the data transfer from or to retransmit the response frame.
If the ISP driver still has the CCB around for which the data segment
or response applies, it will retransmit.
However, we typically don't know about a lost data frame until we
send the FCP Response and the initiator totes up counters for data
moved and notices missing segments. In this case we've already
completed the data CCBs already and sent themn back up to the periph
driver. Because there's no really clean mechanism yet in CAM to
handle this, a hack has been put into place to complete the CTIO
CCB with the CAM_MESSAGE_RECV status which will have a MODIFY DATA
POINTER extended message in it. The internal ISP target groks this
and ctl(8) will be modified to deal with this as well.
At any rate, the data is retransmitted and an an FCP response is
sent. The whole point here is to successfully complete a command
so that you don't have to depend on ULP (SCSI) to have to recover,
which in the case of tape is not really possible (hence the name
FC-TAPE).
Sponsored by: Spectralogic
MFC after: 1 month
2012-07-28 20:06:29 +00:00
|
|
|
if (tval) {
|
2016-12-20 21:17:07 +00:00
|
|
|
isp->isp_confopts &= ~ISP_CFG_FCTAPE;
|
-----------
MISC CHANGES
Add a new async event- ISP_TARGET_NOTIFY_ACK, that will guarantee
eventual delivery of a NOTIFY ACK. This is tons better than just
ignoring the return from isp_notify_ack and hoping for the best.
Clean up the lower level lun enable code to be a bit more sensible.
Fix a botch in isp_endcmd which was messing up the sense data.
Fix notify ack for SRR to use a sensible error code in the case
of a reject.
Clean up and make clear what kind of firmware we've loaded and
what capabilities it has.
-----------
FULL (252 byte) SENSE DATA
In CTIOs for the ISP, there's only a limimted amount of space
to load SENSE DATA for associated CHECK CONDITIONS (24 or 26
bytes). This makes it difficult to send full SENSE DATA that can
be up to 252 bytes.
Implement MODE 2 responses which have us build the FCP Response
in system memory which the ISP will put onto the wire directly.
On the initiator side, the same problem occurs in that a command
status response only has a limited amount of space for SENSE DATA.
This data is supplemented by status continuation responses that
the ISP pushes onto the response queue after the status response.
We now pull them all together so that full sense data can be
returned to the periph driver.
This is supported on 23XX, 24XX and 25XX cards.
This is also preparation for doing >16 byte CDBs.
-----------
FC TAPE
Implement full FC-TAPE on both initiator and target mode side. This
capability is driven by firmware loaded, board type, board NVRAM
settings, or hint configuration options to enable or disable. This
is supported for 23XX, 24XX and 25XX cards.
On the initiator side, we pretty much just have to generate a command
reference number for each command we send out. This is FCP-4 compliant
in that we do this per ITL nexus to generate the allowed 1 thru 255
CRN.
In order to support the target side of FC-TAPE, we now pay attention
to more of the PRLI word 3 parameters which will tell us whether
an initiator wants confirmed responses. While we're at it, we'll
pay attention to the initiator view too and report it.
On sending back CTIOs, we will notice whether the initiator wants
confirmed responses and we'll set up flags to do so.
If a response or data frame is lost the initiator sends us an SRR
(Sequence Retransmit Request) ELS which shows up as an SRR notify
and all outstanding CTIOs are nuked with SRR Received status. The
SRR notify contains the offset that the initiator wants us to restart
the data transfer from or to retransmit the response frame.
If the ISP driver still has the CCB around for which the data segment
or response applies, it will retransmit.
However, we typically don't know about a lost data frame until we
send the FCP Response and the initiator totes up counters for data
moved and notices missing segments. In this case we've already
completed the data CCBs already and sent themn back up to the periph
driver. Because there's no really clean mechanism yet in CAM to
handle this, a hack has been put into place to complete the CTIO
CCB with the CAM_MESSAGE_RECV status which will have a MODIFY DATA
POINTER extended message in it. The internal ISP target groks this
and ctl(8) will be modified to deal with this as well.
At any rate, the data is retransmitted and an an FCP response is
sent. The whole point here is to successfully complete a command
so that you don't have to depend on ULP (SCSI) to have to recover,
which in the case of tape is not really possible (hence the name
FC-TAPE).
Sponsored by: Spectralogic
MFC after: 1 month
2012-07-28 20:06:29 +00:00
|
|
|
isp->isp_confopts |= ISP_CFG_NOFCTAPE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
tval = 0;
|
2015-06-23 16:13:20 +00:00
|
|
|
snprintf(name, sizeof(name), "%sfctape", prefix);
|
|
|
|
|
(void) resource_int_value(device_get_name(dev), device_get_unit(dev),
|
|
|
|
|
name, &tval);
|
-----------
MISC CHANGES
Add a new async event- ISP_TARGET_NOTIFY_ACK, that will guarantee
eventual delivery of a NOTIFY ACK. This is tons better than just
ignoring the return from isp_notify_ack and hoping for the best.
Clean up the lower level lun enable code to be a bit more sensible.
Fix a botch in isp_endcmd which was messing up the sense data.
Fix notify ack for SRR to use a sensible error code in the case
of a reject.
Clean up and make clear what kind of firmware we've loaded and
what capabilities it has.
-----------
FULL (252 byte) SENSE DATA
In CTIOs for the ISP, there's only a limimted amount of space
to load SENSE DATA for associated CHECK CONDITIONS (24 or 26
bytes). This makes it difficult to send full SENSE DATA that can
be up to 252 bytes.
Implement MODE 2 responses which have us build the FCP Response
in system memory which the ISP will put onto the wire directly.
On the initiator side, the same problem occurs in that a command
status response only has a limited amount of space for SENSE DATA.
This data is supplemented by status continuation responses that
the ISP pushes onto the response queue after the status response.
We now pull them all together so that full sense data can be
returned to the periph driver.
This is supported on 23XX, 24XX and 25XX cards.
This is also preparation for doing >16 byte CDBs.
-----------
FC TAPE
Implement full FC-TAPE on both initiator and target mode side. This
capability is driven by firmware loaded, board type, board NVRAM
settings, or hint configuration options to enable or disable. This
is supported for 23XX, 24XX and 25XX cards.
On the initiator side, we pretty much just have to generate a command
reference number for each command we send out. This is FCP-4 compliant
in that we do this per ITL nexus to generate the allowed 1 thru 255
CRN.
In order to support the target side of FC-TAPE, we now pay attention
to more of the PRLI word 3 parameters which will tell us whether
an initiator wants confirmed responses. While we're at it, we'll
pay attention to the initiator view too and report it.
On sending back CTIOs, we will notice whether the initiator wants
confirmed responses and we'll set up flags to do so.
If a response or data frame is lost the initiator sends us an SRR
(Sequence Retransmit Request) ELS which shows up as an SRR notify
and all outstanding CTIOs are nuked with SRR Received status. The
SRR notify contains the offset that the initiator wants us to restart
the data transfer from or to retransmit the response frame.
If the ISP driver still has the CCB around for which the data segment
or response applies, it will retransmit.
However, we typically don't know about a lost data frame until we
send the FCP Response and the initiator totes up counters for data
moved and notices missing segments. In this case we've already
completed the data CCBs already and sent themn back up to the periph
driver. Because there's no really clean mechanism yet in CAM to
handle this, a hack has been put into place to complete the CTIO
CCB with the CAM_MESSAGE_RECV status which will have a MODIFY DATA
POINTER extended message in it. The internal ISP target groks this
and ctl(8) will be modified to deal with this as well.
At any rate, the data is retransmitted and an an FCP response is
sent. The whole point here is to successfully complete a command
so that you don't have to depend on ULP (SCSI) to have to recover,
which in the case of tape is not really possible (hence the name
FC-TAPE).
Sponsored by: Spectralogic
MFC after: 1 month
2012-07-28 20:06:29 +00:00
|
|
|
if (tval) {
|
|
|
|
|
isp->isp_confopts &= ~ISP_CFG_NOFCTAPE;
|
|
|
|
|
isp->isp_confopts |= ISP_CFG_FCTAPE;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2006-04-21 18:30:01 +00:00
|
|
|
/*
|
|
|
|
|
* Because the resource_*_value functions can neither return
|
|
|
|
|
* 64 bit integer values, nor can they be directly coerced
|
|
|
|
|
* to interpret the right hand side of the assignment as
|
|
|
|
|
* you want them to interpret it, we have to force WWN
|
|
|
|
|
* hint replacement to specify WWN strings with a leading
|
|
|
|
|
* 'w' (e..g w50000000aaaa0001). Sigh.
|
|
|
|
|
*/
|
2017-02-20 03:43:12 +00:00
|
|
|
sptr = NULL;
|
2015-06-23 16:13:20 +00:00
|
|
|
snprintf(name, sizeof(name), "%sportwwn", prefix);
|
|
|
|
|
tval = resource_string_value(device_get_name(dev), device_get_unit(dev),
|
|
|
|
|
name, (const char **) &sptr);
|
2017-02-20 03:43:12 +00:00
|
|
|
if (tval == 0 && sptr != NULL && *sptr++ == 'w') {
|
|
|
|
|
char *eptr = NULL;
|
2009-08-01 01:04:26 +00:00
|
|
|
ISP_FC_PC(isp, chan)->def_wwpn = strtouq(sptr, &eptr, 16);
|
|
|
|
|
if (eptr < sptr + 16 || ISP_FC_PC(isp, chan)->def_wwpn == -1) {
|
2006-04-21 18:30:01 +00:00
|
|
|
device_printf(dev, "mangled portwwn hint '%s'\n", sptr);
|
2009-08-01 01:04:26 +00:00
|
|
|
ISP_FC_PC(isp, chan)->def_wwpn = 0;
|
2006-04-21 18:30:01 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-02-20 03:43:12 +00:00
|
|
|
sptr = NULL;
|
2015-06-23 16:13:20 +00:00
|
|
|
snprintf(name, sizeof(name), "%snodewwn", prefix);
|
|
|
|
|
tval = resource_string_value(device_get_name(dev), device_get_unit(dev),
|
|
|
|
|
name, (const char **) &sptr);
|
2017-02-20 03:43:12 +00:00
|
|
|
if (tval == 0 && sptr != NULL && *sptr++ == 'w') {
|
|
|
|
|
char *eptr = NULL;
|
2009-08-01 01:04:26 +00:00
|
|
|
ISP_FC_PC(isp, chan)->def_wwnn = strtouq(sptr, &eptr, 16);
|
|
|
|
|
if (eptr < sptr + 16 || ISP_FC_PC(isp, chan)->def_wwnn == 0) {
|
2006-04-21 18:30:01 +00:00
|
|
|
device_printf(dev, "mangled nodewwn hint '%s'\n", sptr);
|
2009-08-01 01:04:26 +00:00
|
|
|
ISP_FC_PC(isp, chan)->def_wwnn = 0;
|
2006-04-21 18:30:01 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-11-14 08:45:48 +00:00
|
|
|
tval = -1;
|
2015-06-23 16:13:20 +00:00
|
|
|
snprintf(name, sizeof(name), "%sloop_down_limit", prefix);
|
|
|
|
|
(void) resource_int_value(device_get_name(dev), device_get_unit(dev),
|
|
|
|
|
name, &tval);
|
2006-11-02 03:21:32 +00:00
|
|
|
if (tval >= 0 && tval < 0xffff) {
|
2009-08-01 01:04:26 +00:00
|
|
|
ISP_FC_PC(isp, chan)->loop_down_limit = tval;
|
2006-11-02 03:21:32 +00:00
|
|
|
} else {
|
2009-08-01 01:04:26 +00:00
|
|
|
ISP_FC_PC(isp, chan)->loop_down_limit = isp_loop_down_limit;
|
2006-11-02 03:21:32 +00:00
|
|
|
}
|
|
|
|
|
|
2006-11-14 08:45:48 +00:00
|
|
|
tval = -1;
|
2015-06-23 16:13:20 +00:00
|
|
|
snprintf(name, sizeof(name), "%sgone_device_time", prefix);
|
|
|
|
|
(void) resource_int_value(device_get_name(dev), device_get_unit(dev),
|
|
|
|
|
name, &tval);
|
2006-11-14 08:45:48 +00:00
|
|
|
if (tval >= 0 && tval < 0xffff) {
|
2009-08-01 01:04:26 +00:00
|
|
|
ISP_FC_PC(isp, chan)->gone_device_time = tval;
|
2006-11-14 08:45:48 +00:00
|
|
|
} else {
|
2009-08-01 01:04:26 +00:00
|
|
|
ISP_FC_PC(isp, chan)->gone_device_time = isp_gone_device_time;
|
2006-11-14 08:45:48 +00:00
|
|
|
}
|
2006-04-21 18:30:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
isp_pci_attach(device_t dev)
|
|
|
|
|
{
|
2017-03-14 08:03:56 +00:00
|
|
|
struct isp_pcisoftc *pcs = device_get_softc(dev);
|
|
|
|
|
ispsoftc_t *isp = &pcs->pci_isp;
|
|
|
|
|
int i;
|
2009-08-01 01:04:26 +00:00
|
|
|
uint32_t data, cmd, linesz, did;
|
|
|
|
|
size_t psize, xsize;
|
|
|
|
|
char fwname[32];
|
2006-04-21 18:30:01 +00:00
|
|
|
|
2009-08-01 01:04:26 +00:00
|
|
|
isp->isp_dev = dev;
|
|
|
|
|
isp->isp_nchan = 1;
|
2017-03-21 10:34:34 +00:00
|
|
|
mtx_init(&isp->isp_lock, "isp", NULL, MTX_DEF);
|
2006-04-21 18:30:01 +00:00
|
|
|
|
|
|
|
|
/*
|
2007-02-23 05:42:41 +00:00
|
|
|
* Get Generic Options
|
2006-04-21 18:30:01 +00:00
|
|
|
*/
|
2012-06-24 17:30:54 +00:00
|
|
|
isp_nvports = 0;
|
|
|
|
|
isp_get_generic_options(dev, isp);
|
2006-04-21 18:30:01 +00:00
|
|
|
|
1999-04-04 01:14:02 +00:00
|
|
|
linesz = PCI_DFLT_LNSZ;
|
2017-03-19 19:11:40 +00:00
|
|
|
pcs->regs = pcs->regs2 = NULL;
|
|
|
|
|
pcs->rgd = pcs->rtp = 0;
|
2000-02-11 19:45:17 +00:00
|
|
|
|
2020-11-20 01:15:48 +00:00
|
|
|
isp->isp_nchan += isp_nvports;
|
2009-08-01 01:04:26 +00:00
|
|
|
switch (pci_get_devid(dev)) {
|
|
|
|
|
case PCI_QLOGIC_ISP2422:
|
|
|
|
|
case PCI_QLOGIC_ISP2432:
|
|
|
|
|
did = 0x2400;
|
|
|
|
|
isp->isp_mdvec = &mdvec_2400;
|
|
|
|
|
isp->isp_type = ISP_HA_FC_2400;
|
|
|
|
|
break;
|
|
|
|
|
case PCI_QLOGIC_ISP2532:
|
|
|
|
|
did = 0x2500;
|
|
|
|
|
isp->isp_mdvec = &mdvec_2500;
|
|
|
|
|
isp->isp_type = ISP_HA_FC_2500;
|
|
|
|
|
break;
|
2011-03-10 23:53:01 +00:00
|
|
|
case PCI_QLOGIC_ISP5432:
|
|
|
|
|
did = 0x2500;
|
|
|
|
|
isp->isp_mdvec = &mdvec_2500;
|
|
|
|
|
isp->isp_type = ISP_HA_FC_2500;
|
|
|
|
|
break;
|
2015-12-02 20:22:50 +00:00
|
|
|
case PCI_QLOGIC_ISP2031:
|
2015-12-09 22:52:37 +00:00
|
|
|
case PCI_QLOGIC_ISP8031:
|
2015-12-02 20:22:50 +00:00
|
|
|
did = 0x2600;
|
|
|
|
|
isp->isp_mdvec = &mdvec_2600;
|
|
|
|
|
isp->isp_type = ISP_HA_FC_2600;
|
|
|
|
|
break;
|
2018-02-28 16:24:32 +00:00
|
|
|
case PCI_QLOGIC_ISP2684:
|
|
|
|
|
case PCI_QLOGIC_ISP2692:
|
|
|
|
|
case PCI_QLOGIC_ISP2714:
|
|
|
|
|
case PCI_QLOGIC_ISP2722:
|
|
|
|
|
did = 0x2700;
|
|
|
|
|
isp->isp_mdvec = &mdvec_2700;
|
|
|
|
|
isp->isp_type = ISP_HA_FC_2700;
|
|
|
|
|
break;
|
2009-08-01 01:04:26 +00:00
|
|
|
default:
|
|
|
|
|
device_printf(dev, "unknown device type\n");
|
|
|
|
|
goto bad;
|
|
|
|
|
break;
|
1998-04-22 18:12:29 +00:00
|
|
|
}
|
2009-08-01 01:04:26 +00:00
|
|
|
isp->isp_revision = pci_get_revid(dev);
|
|
|
|
|
|
2015-12-02 20:22:50 +00:00
|
|
|
if (IS_26XX(isp)) {
|
|
|
|
|
pcs->rtp = SYS_RES_MEMORY;
|
|
|
|
|
pcs->rgd = PCIR_BAR(0);
|
|
|
|
|
pcs->regs = bus_alloc_resource_any(dev, pcs->rtp, &pcs->rgd,
|
|
|
|
|
RF_ACTIVE);
|
2015-12-15 04:51:50 +00:00
|
|
|
pcs->rtp1 = SYS_RES_MEMORY;
|
|
|
|
|
pcs->rgd1 = PCIR_BAR(2);
|
|
|
|
|
pcs->regs1 = bus_alloc_resource_any(dev, pcs->rtp1, &pcs->rgd1,
|
|
|
|
|
RF_ACTIVE);
|
2015-12-04 19:46:49 +00:00
|
|
|
pcs->rtp2 = SYS_RES_MEMORY;
|
|
|
|
|
pcs->rgd2 = PCIR_BAR(4);
|
|
|
|
|
pcs->regs2 = bus_alloc_resource_any(dev, pcs->rtp2, &pcs->rgd2,
|
|
|
|
|
RF_ACTIVE);
|
2015-12-02 20:22:50 +00:00
|
|
|
} else {
|
|
|
|
|
pcs->rtp = SYS_RES_MEMORY;
|
|
|
|
|
pcs->rgd = PCIR_BAR(1);
|
|
|
|
|
pcs->regs = bus_alloc_resource_any(dev, pcs->rtp, &pcs->rgd,
|
|
|
|
|
RF_ACTIVE);
|
|
|
|
|
if (pcs->regs == NULL) {
|
|
|
|
|
pcs->rtp = SYS_RES_IOPORT;
|
|
|
|
|
pcs->rgd = PCIR_BAR(0);
|
|
|
|
|
pcs->regs = bus_alloc_resource_any(dev, pcs->rtp,
|
|
|
|
|
&pcs->rgd, RF_ACTIVE);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (pcs->regs == NULL) {
|
|
|
|
|
device_printf(dev, "Unable to map any ports\n");
|
|
|
|
|
goto bad;
|
|
|
|
|
}
|
|
|
|
|
if (bootverbose) {
|
|
|
|
|
device_printf(dev, "Using %s space register mapping\n",
|
|
|
|
|
(pcs->rtp == SYS_RES_IOPORT)? "I/O" : "Memory");
|
|
|
|
|
}
|
2015-12-04 19:46:49 +00:00
|
|
|
isp->isp_regs = pcs->regs;
|
|
|
|
|
isp->isp_regs2 = pcs->regs2;
|
2015-12-02 20:22:50 +00:00
|
|
|
|
2020-11-20 01:15:48 +00:00
|
|
|
psize = sizeof(fcparam) * isp->isp_nchan;
|
|
|
|
|
xsize = sizeof(struct isp_fc) * isp->isp_nchan;
|
2000-12-08 21:51:06 +00:00
|
|
|
isp->isp_param = malloc(psize, M_DEVBUF, M_NOWAIT | M_ZERO);
|
1999-05-11 04:53:57 +00:00
|
|
|
if (isp->isp_param == NULL) {
|
2000-02-11 19:45:17 +00:00
|
|
|
device_printf(dev, "cannot allocate parameter data\n");
|
|
|
|
|
goto bad;
|
1999-05-11 04:53:57 +00:00
|
|
|
}
|
2020-11-24 22:43:27 +00:00
|
|
|
isp->isp_osinfo.fc = malloc(xsize, M_DEVBUF, M_NOWAIT | M_ZERO);
|
|
|
|
|
if (isp->isp_osinfo.fc == NULL) {
|
2009-08-01 01:04:26 +00:00
|
|
|
device_printf(dev, "cannot allocate parameter data\n");
|
|
|
|
|
goto bad;
|
|
|
|
|
}
|
1998-04-22 18:12:29 +00:00
|
|
|
|
2007-02-23 05:42:41 +00:00
|
|
|
/*
|
|
|
|
|
* Now that we know who we are (roughly) get/set specific options
|
|
|
|
|
*/
|
2009-08-01 01:04:26 +00:00
|
|
|
for (i = 0; i < isp->isp_nchan; i++) {
|
|
|
|
|
isp_get_specific_options(dev, i, isp);
|
|
|
|
|
}
|
2007-02-23 05:42:41 +00:00
|
|
|
|
2009-08-01 01:04:26 +00:00
|
|
|
isp->isp_osinfo.fw = NULL;
|
|
|
|
|
if (isp->isp_osinfo.fw == NULL) {
|
|
|
|
|
snprintf(fwname, sizeof (fwname), "isp_%04x", did);
|
|
|
|
|
isp->isp_osinfo.fw = firmware_get(fwname);
|
|
|
|
|
}
|
|
|
|
|
if (isp->isp_osinfo.fw != NULL) {
|
2012-06-17 21:39:40 +00:00
|
|
|
isp_prt(isp, ISP_LOGCONFIG, "loaded firmware %s", fwname);
|
2009-08-01 01:04:26 +00:00
|
|
|
isp->isp_mdvec->dv_ispfw = isp->isp_osinfo.fw->data;
|
2000-06-18 05:18:55 +00:00
|
|
|
}
|
|
|
|
|
|
1999-02-09 01:12:52 +00:00
|
|
|
/*
|
2012-06-17 21:39:40 +00:00
|
|
|
* Make sure that SERR, PERR, WRITE INVALIDATE and BUSMASTER are set.
|
1999-02-09 01:12:52 +00:00
|
|
|
*/
|
2013-08-12 23:30:01 +00:00
|
|
|
cmd = pci_read_config(dev, PCIR_COMMAND, 2);
|
2012-06-24 17:30:54 +00:00
|
|
|
cmd |= PCIM_CMD_SEREN | PCIM_CMD_PERRESPEN | PCIM_CMD_BUSMASTEREN | PCIM_CMD_INVEN;
|
2020-11-20 01:15:48 +00:00
|
|
|
cmd &= ~PCIM_CMD_INTX_DISABLE;
|
2005-05-11 03:00:50 +00:00
|
|
|
pci_write_config(dev, PCIR_COMMAND, cmd, 2);
|
1999-04-04 01:14:02 +00:00
|
|
|
|
1999-02-09 01:12:52 +00:00
|
|
|
/*
|
Remove pre-CAM code. Add in getenv_int calls for variables isp_mem_map,
isp_io_map, isp_no_fwload, isp_fwload, isp_no_nvram, isp_fcduplex
which are all bitmaps of isp instances that should or shouldn't
map memory space, I/O space, not load f/w, load f/w, ignore nvram,
not ignore nvarm, set full duplex mode. Also have an isp_seed value
that we can use to generate a pseudo seed for a synthetic WWN.
Other minor cosmetic cleanup. Add in support for the Qlogic ISP
2200. Very important change where we actually check now to see
whether we were successful in mapping request and response queues
(and fibre channel scratch space).
1999-07-02 23:18:03 +00:00
|
|
|
* Make sure the Cache Line Size register is set sensibly.
|
1999-02-09 01:12:52 +00:00
|
|
|
*/
|
2000-02-11 19:45:17 +00:00
|
|
|
data = pci_read_config(dev, PCIR_CACHELNSZ, 1);
|
2007-03-13 06:46:08 +00:00
|
|
|
if (data == 0 || (linesz != PCI_DFLT_LNSZ && data != linesz)) {
|
2012-06-17 21:39:40 +00:00
|
|
|
isp_prt(isp, ISP_LOGDEBUG0, "set PCI line size to %d from %d", linesz, data);
|
2007-03-13 06:46:08 +00:00
|
|
|
data = linesz;
|
2000-02-11 19:45:17 +00:00
|
|
|
pci_write_config(dev, PCIR_CACHELNSZ, data, 1);
|
1999-02-09 01:12:52 +00:00
|
|
|
}
|
1999-04-04 01:14:02 +00:00
|
|
|
|
1999-02-09 01:12:52 +00:00
|
|
|
/*
|
|
|
|
|
* Make sure the Latency Timer is sane.
|
|
|
|
|
*/
|
2000-02-11 19:45:17 +00:00
|
|
|
data = pci_read_config(dev, PCIR_LATTIMER, 1);
|
1999-02-09 01:12:52 +00:00
|
|
|
if (data < PCI_DFLT_LTNCY) {
|
|
|
|
|
data = PCI_DFLT_LTNCY;
|
2012-06-17 21:39:40 +00:00
|
|
|
isp_prt(isp, ISP_LOGDEBUG0, "set PCI latency to %d", data);
|
2000-02-11 19:45:17 +00:00
|
|
|
pci_write_config(dev, PCIR_LATTIMER, data, 1);
|
1999-02-09 01:12:52 +00:00
|
|
|
}
|
1999-04-04 01:14:02 +00:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Make sure we've disabled the ROM.
|
|
|
|
|
*/
|
2000-02-11 19:45:17 +00:00
|
|
|
data = pci_read_config(dev, PCIR_ROMADDR, 4);
|
1999-04-04 01:14:02 +00:00
|
|
|
data &= ~1;
|
2000-02-11 19:45:17 +00:00
|
|
|
pci_write_config(dev, PCIR_ROMADDR, data, 4);
|
2009-08-01 01:04:26 +00:00
|
|
|
|
2002-02-04 21:04:25 +00:00
|
|
|
/*
|
|
|
|
|
* Last minute checks...
|
|
|
|
|
*/
|
2020-11-20 01:15:48 +00:00
|
|
|
isp->isp_port = pci_get_function(dev);
|
2002-02-04 21:04:25 +00:00
|
|
|
|
2000-07-18 06:40:22 +00:00
|
|
|
/*
|
|
|
|
|
* Make sure we're in reset state.
|
|
|
|
|
*/
|
2000-10-25 04:40:49 +00:00
|
|
|
ISP_LOCK(isp);
|
2015-10-25 10:49:05 +00:00
|
|
|
if (isp_reinit(isp, 1) != 0) {
|
2000-10-25 04:40:49 +00:00
|
|
|
ISP_UNLOCK(isp);
|
2000-02-11 19:45:17 +00:00
|
|
|
goto bad;
|
1998-04-22 18:12:29 +00:00
|
|
|
}
|
2009-08-01 01:04:26 +00:00
|
|
|
ISP_UNLOCK(isp);
|
|
|
|
|
if (isp_attach(isp)) {
|
|
|
|
|
ISP_LOCK(isp);
|
2017-03-14 08:03:56 +00:00
|
|
|
isp_shutdown(isp);
|
2001-02-11 03:53:23 +00:00
|
|
|
ISP_UNLOCK(isp);
|
|
|
|
|
goto bad;
|
1998-04-22 18:12:29 +00:00
|
|
|
}
|
2000-02-11 19:45:17 +00:00
|
|
|
return (0);
|
|
|
|
|
|
|
|
|
|
bad:
|
2019-04-28 15:08:57 +00:00
|
|
|
if (isp->isp_osinfo.fw == NULL && !IS_26XX(isp)) {
|
|
|
|
|
/*
|
|
|
|
|
* Failure to attach at boot time might have been caused
|
|
|
|
|
* by a missing ispfw(4). Except for for 16Gb adapters,
|
|
|
|
|
* there's no loadable firmware for them.
|
|
|
|
|
*/
|
|
|
|
|
isp_prt(isp, ISP_LOGWARN, "See the ispfw(4) man page on "
|
|
|
|
|
"how to load known good firmware at boot time");
|
|
|
|
|
}
|
2017-03-19 19:11:40 +00:00
|
|
|
for (i = 0; i < isp->isp_nirq; i++) {
|
|
|
|
|
(void) bus_teardown_intr(dev, pcs->irq[i].irq, pcs->irq[i].ih);
|
|
|
|
|
(void) bus_release_resource(dev, SYS_RES_IRQ, pcs->irq[i].iqd,
|
|
|
|
|
pcs->irq[0].irq);
|
2000-02-11 19:45:17 +00:00
|
|
|
}
|
2010-06-02 23:31:27 +00:00
|
|
|
if (pcs->msicount) {
|
2007-05-05 20:17:23 +00:00
|
|
|
pci_release_msi(dev);
|
|
|
|
|
}
|
2015-12-04 19:46:49 +00:00
|
|
|
if (pcs->regs)
|
2011-08-13 23:34:17 +00:00
|
|
|
(void) bus_release_resource(dev, pcs->rtp, pcs->rgd, pcs->regs);
|
2015-12-15 04:51:50 +00:00
|
|
|
if (pcs->regs1)
|
|
|
|
|
(void) bus_release_resource(dev, pcs->rtp1, pcs->rgd1, pcs->regs1);
|
2015-12-04 19:46:49 +00:00
|
|
|
if (pcs->regs2)
|
|
|
|
|
(void) bus_release_resource(dev, pcs->rtp2, pcs->rgd2, pcs->regs2);
|
2010-06-02 23:31:27 +00:00
|
|
|
if (pcs->pci_isp.isp_param) {
|
|
|
|
|
free(pcs->pci_isp.isp_param, M_DEVBUF);
|
|
|
|
|
pcs->pci_isp.isp_param = NULL;
|
|
|
|
|
}
|
2020-11-24 22:43:27 +00:00
|
|
|
if (pcs->pci_isp.isp_osinfo.fc) {
|
|
|
|
|
free(pcs->pci_isp.isp_osinfo.fc, M_DEVBUF);
|
|
|
|
|
pcs->pci_isp.isp_osinfo.fc = NULL;
|
2000-02-11 19:45:17 +00:00
|
|
|
}
|
2017-03-21 10:34:34 +00:00
|
|
|
mtx_destroy(&isp->isp_lock);
|
2000-02-11 19:45:17 +00:00
|
|
|
return (ENXIO);
|
1998-04-22 18:12:29 +00:00
|
|
|
}
|
|
|
|
|
|
2006-11-02 03:21:32 +00:00
|
|
|
static int
|
|
|
|
|
isp_pci_detach(device_t dev)
|
|
|
|
|
{
|
2017-03-14 08:03:56 +00:00
|
|
|
struct isp_pcisoftc *pcs = device_get_softc(dev);
|
|
|
|
|
ispsoftc_t *isp = &pcs->pci_isp;
|
2017-03-19 19:11:40 +00:00
|
|
|
int i, status;
|
2006-11-02 03:21:32 +00:00
|
|
|
|
2011-08-13 23:34:17 +00:00
|
|
|
status = isp_detach(isp);
|
|
|
|
|
if (status)
|
|
|
|
|
return (status);
|
|
|
|
|
ISP_LOCK(isp);
|
2017-03-14 08:03:56 +00:00
|
|
|
isp_shutdown(isp);
|
2011-08-13 23:34:17 +00:00
|
|
|
ISP_UNLOCK(isp);
|
2017-03-19 19:11:40 +00:00
|
|
|
for (i = 0; i < isp->isp_nirq; i++) {
|
|
|
|
|
(void) bus_teardown_intr(dev, pcs->irq[i].irq, pcs->irq[i].ih);
|
|
|
|
|
(void) bus_release_resource(dev, SYS_RES_IRQ, pcs->irq[i].iqd,
|
|
|
|
|
pcs->irq[i].irq);
|
|
|
|
|
}
|
2017-03-14 08:03:56 +00:00
|
|
|
if (pcs->msicount)
|
2011-08-13 23:34:17 +00:00
|
|
|
pci_release_msi(dev);
|
|
|
|
|
(void) bus_release_resource(dev, pcs->rtp, pcs->rgd, pcs->regs);
|
2015-12-15 04:51:50 +00:00
|
|
|
if (pcs->regs1)
|
|
|
|
|
(void) bus_release_resource(dev, pcs->rtp1, pcs->rgd1, pcs->regs1);
|
2015-12-04 19:46:49 +00:00
|
|
|
if (pcs->regs2)
|
|
|
|
|
(void) bus_release_resource(dev, pcs->rtp2, pcs->rgd2, pcs->regs2);
|
2017-03-14 08:03:56 +00:00
|
|
|
isp_pci_mbxdmafree(isp);
|
2011-08-13 23:34:17 +00:00
|
|
|
if (pcs->pci_isp.isp_param) {
|
|
|
|
|
free(pcs->pci_isp.isp_param, M_DEVBUF);
|
|
|
|
|
pcs->pci_isp.isp_param = NULL;
|
|
|
|
|
}
|
2020-11-24 22:43:27 +00:00
|
|
|
if (pcs->pci_isp.isp_osinfo.fc) {
|
|
|
|
|
free(pcs->pci_isp.isp_osinfo.fc, M_DEVBUF);
|
|
|
|
|
pcs->pci_isp.isp_osinfo.fc = NULL;
|
2011-08-13 23:34:17 +00:00
|
|
|
}
|
2017-03-21 10:34:34 +00:00
|
|
|
mtx_destroy(&isp->isp_lock);
|
2006-11-02 03:21:32 +00:00
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-04 19:46:49 +00:00
|
|
|
#define BXR2(isp, off) bus_read_2((isp)->isp_regs, (off))
|
|
|
|
|
#define BXW2(isp, off, v) bus_write_2((isp)->isp_regs, (off), (v))
|
|
|
|
|
#define BXR4(isp, off) bus_read_4((isp)->isp_regs, (off))
|
|
|
|
|
#define BXW4(isp, off, v) bus_write_4((isp)->isp_regs, (off), (v))
|
|
|
|
|
#define B2R4(isp, off) bus_read_4((isp)->isp_regs2, (off))
|
|
|
|
|
#define B2W4(isp, off, v) bus_write_4((isp)->isp_regs2, (off), (v))
|
2001-08-31 21:39:04 +00:00
|
|
|
|
2017-03-15 14:58:29 +00:00
|
|
|
static void
|
|
|
|
|
isp_pci_run_isr_2400(ispsoftc_t *isp)
|
2006-11-02 03:21:32 +00:00
|
|
|
{
|
|
|
|
|
uint32_t r2hisr;
|
2017-03-15 14:58:29 +00:00
|
|
|
uint16_t isr, info;
|
2006-11-02 03:21:32 +00:00
|
|
|
|
2020-11-20 01:15:48 +00:00
|
|
|
r2hisr = BXR4(isp, BIU2400_R2HSTS);
|
2006-11-02 03:21:32 +00:00
|
|
|
isp_prt(isp, ISP_LOGDEBUG3, "RISC2HOST ISR 0x%x", r2hisr);
|
2017-03-15 14:58:29 +00:00
|
|
|
if ((r2hisr & BIU_R2HST_INTR) == 0)
|
|
|
|
|
return;
|
|
|
|
|
isr = r2hisr & BIU_R2HST_ISTAT_MASK;
|
|
|
|
|
info = (r2hisr >> 16);
|
|
|
|
|
switch (isr) {
|
2015-10-23 08:26:45 +00:00
|
|
|
case ISPR2HST_ROM_MBX_OK:
|
|
|
|
|
case ISPR2HST_ROM_MBX_FAIL:
|
|
|
|
|
case ISPR2HST_MBX_OK:
|
|
|
|
|
case ISPR2HST_MBX_FAIL:
|
2017-03-15 14:58:29 +00:00
|
|
|
isp_intr_mbox(isp, info);
|
|
|
|
|
break;
|
2015-10-23 08:26:45 +00:00
|
|
|
case ISPR2HST_ASYNC_EVENT:
|
2017-03-15 14:58:29 +00:00
|
|
|
isp_intr_async(isp, info);
|
2015-10-23 08:26:45 +00:00
|
|
|
break;
|
|
|
|
|
case ISPR2HST_RSPQ_UPDATE:
|
2017-03-15 14:58:29 +00:00
|
|
|
isp_intr_respq(isp);
|
|
|
|
|
break;
|
2015-10-23 08:26:45 +00:00
|
|
|
case ISPR2HST_RSPQ_UPDATE2:
|
2017-03-15 14:58:29 +00:00
|
|
|
#ifdef ISP_TARGET_MODE
|
2015-10-23 08:26:45 +00:00
|
|
|
case ISPR2HST_ATIO_RSPQ_UPDATE:
|
2017-03-15 14:58:29 +00:00
|
|
|
#endif
|
|
|
|
|
isp_intr_respq(isp);
|
|
|
|
|
/* FALLTHROUGH */
|
|
|
|
|
#ifdef ISP_TARGET_MODE
|
|
|
|
|
case ISPR2HST_ATIO_UPDATE:
|
2015-10-23 08:26:45 +00:00
|
|
|
case ISPR2HST_ATIO_UPDATE2:
|
2017-03-15 14:58:29 +00:00
|
|
|
isp_intr_atioq(isp);
|
|
|
|
|
#endif
|
2015-10-23 08:26:45 +00:00
|
|
|
break;
|
2006-11-02 03:21:32 +00:00
|
|
|
default:
|
|
|
|
|
isp_prt(isp, ISP_LOGERR, "unknown interrupt 0x%x\n", r2hisr);
|
|
|
|
|
}
|
2017-03-15 14:58:29 +00:00
|
|
|
ISP_WRITE(isp, BIU2400_HCCR, HCCR_2400_CMD_CLEAR_RISC_INT);
|
2006-11-02 03:21:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static uint32_t
|
|
|
|
|
isp_pci_rd_reg_2400(ispsoftc_t *isp, int regoff)
|
|
|
|
|
{
|
|
|
|
|
int block = regoff & _BLK_REG_MASK;
|
|
|
|
|
|
|
|
|
|
switch (block) {
|
|
|
|
|
case BIU_BLOCK:
|
2020-11-20 01:15:48 +00:00
|
|
|
return (BXR4(isp, regoff));
|
2006-11-02 03:21:32 +00:00
|
|
|
case MBOX_BLOCK:
|
2020-11-20 01:15:48 +00:00
|
|
|
return (BXR2(isp, regoff));
|
2006-11-02 03:21:32 +00:00
|
|
|
}
|
2020-11-20 01:15:48 +00:00
|
|
|
isp_prt(isp, ISP_LOGERR, "unknown block read at 0x%x", regoff);
|
|
|
|
|
return (0xffffffff);
|
2006-11-02 03:21:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
isp_pci_wr_reg_2400(ispsoftc_t *isp, int regoff, uint32_t val)
|
|
|
|
|
{
|
|
|
|
|
int block = regoff & _BLK_REG_MASK;
|
|
|
|
|
|
|
|
|
|
switch (block) {
|
|
|
|
|
case BIU_BLOCK:
|
2020-11-20 01:15:48 +00:00
|
|
|
BXW4(isp, regoff, val);
|
2013-11-10 23:48:16 +00:00
|
|
|
#ifdef MEMORYBARRIERW
|
|
|
|
|
if (regoff == BIU2400_REQINP ||
|
|
|
|
|
regoff == BIU2400_RSPOUTP ||
|
|
|
|
|
regoff == BIU2400_PRI_REQINP ||
|
|
|
|
|
regoff == BIU2400_ATIO_RSPOUTP)
|
2020-11-20 01:15:48 +00:00
|
|
|
MEMORYBARRIERW(isp, SYNC_REG, regoff, 4, -1)
|
2013-11-10 23:48:16 +00:00
|
|
|
else
|
|
|
|
|
#endif
|
2020-11-20 01:15:48 +00:00
|
|
|
MEMORYBARRIER(isp, SYNC_REG, regoff, 4, -1);
|
|
|
|
|
return;
|
|
|
|
|
case MBOX_BLOCK:
|
|
|
|
|
BXW2(isp, regoff, val);
|
|
|
|
|
MEMORYBARRIER(isp, SYNC_REG, regoff, 2, -1);
|
|
|
|
|
return;
|
2015-12-04 19:46:49 +00:00
|
|
|
}
|
2020-11-20 01:15:48 +00:00
|
|
|
isp_prt(isp, ISP_LOGERR, "unknown block write at 0x%x", regoff);
|
2015-12-04 19:46:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static uint32_t
|
|
|
|
|
isp_pci_rd_reg_2600(ispsoftc_t *isp, int regoff)
|
|
|
|
|
{
|
|
|
|
|
uint32_t rv;
|
|
|
|
|
|
|
|
|
|
switch (regoff) {
|
|
|
|
|
case BIU2400_PRI_REQINP:
|
|
|
|
|
case BIU2400_PRI_REQOUTP:
|
|
|
|
|
isp_prt(isp, ISP_LOGERR, "unknown register read at 0x%x",
|
|
|
|
|
regoff);
|
|
|
|
|
rv = 0xffffffff;
|
|
|
|
|
break;
|
|
|
|
|
case BIU2400_REQINP:
|
|
|
|
|
rv = B2R4(isp, 0x00);
|
|
|
|
|
break;
|
|
|
|
|
case BIU2400_REQOUTP:
|
|
|
|
|
rv = B2R4(isp, 0x04);
|
|
|
|
|
break;
|
|
|
|
|
case BIU2400_RSPINP:
|
|
|
|
|
rv = B2R4(isp, 0x08);
|
|
|
|
|
break;
|
|
|
|
|
case BIU2400_RSPOUTP:
|
|
|
|
|
rv = B2R4(isp, 0x0c);
|
|
|
|
|
break;
|
|
|
|
|
case BIU2400_ATIO_RSPINP:
|
|
|
|
|
rv = B2R4(isp, 0x10);
|
|
|
|
|
break;
|
|
|
|
|
case BIU2400_ATIO_RSPOUTP:
|
|
|
|
|
rv = B2R4(isp, 0x14);
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
rv = isp_pci_rd_reg_2400(isp, regoff);
|
2006-11-02 03:21:32 +00:00
|
|
|
break;
|
1998-04-22 18:12:29 +00:00
|
|
|
}
|
2015-12-04 19:46:49 +00:00
|
|
|
return (rv);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
isp_pci_wr_reg_2600(ispsoftc_t *isp, int regoff, uint32_t val)
|
|
|
|
|
{
|
|
|
|
|
int off;
|
|
|
|
|
|
|
|
|
|
switch (regoff) {
|
|
|
|
|
case BIU2400_PRI_REQINP:
|
|
|
|
|
case BIU2400_PRI_REQOUTP:
|
|
|
|
|
isp_prt(isp, ISP_LOGERR, "unknown register write at 0x%x",
|
|
|
|
|
regoff);
|
|
|
|
|
return;
|
|
|
|
|
case BIU2400_REQINP:
|
|
|
|
|
off = 0x00;
|
|
|
|
|
break;
|
|
|
|
|
case BIU2400_REQOUTP:
|
|
|
|
|
off = 0x04;
|
|
|
|
|
break;
|
|
|
|
|
case BIU2400_RSPINP:
|
|
|
|
|
off = 0x08;
|
|
|
|
|
break;
|
|
|
|
|
case BIU2400_RSPOUTP:
|
|
|
|
|
off = 0x0c;
|
|
|
|
|
break;
|
|
|
|
|
case BIU2400_ATIO_RSPINP:
|
|
|
|
|
off = 0x10;
|
|
|
|
|
break;
|
|
|
|
|
case BIU2400_ATIO_RSPOUTP:
|
|
|
|
|
off = 0x14;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
isp_pci_wr_reg_2400(isp, regoff, val);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
B2W4(isp, off, val);
|
1998-04-22 18:12:29 +00:00
|
|
|
}
|
|
|
|
|
|
1998-09-15 10:06:23 +00:00
|
|
|
|
Remove pre-CAM code. Add in getenv_int calls for variables isp_mem_map,
isp_io_map, isp_no_fwload, isp_fwload, isp_no_nvram, isp_fcduplex
which are all bitmaps of isp instances that should or shouldn't
map memory space, I/O space, not load f/w, load f/w, ignore nvram,
not ignore nvarm, set full duplex mode. Also have an isp_seed value
that we can use to generate a pseudo seed for a synthetic WWN.
Other minor cosmetic cleanup. Add in support for the Qlogic ISP
2200. Very important change where we actually check now to see
whether we were successful in mapping request and response queues
(and fibre channel scratch space).
1999-07-02 23:18:03 +00:00
|
|
|
struct imush {
|
2015-12-27 06:16:02 +00:00
|
|
|
bus_addr_t maddr;
|
Remove pre-CAM code. Add in getenv_int calls for variables isp_mem_map,
isp_io_map, isp_no_fwload, isp_fwload, isp_no_nvram, isp_fcduplex
which are all bitmaps of isp instances that should or shouldn't
map memory space, I/O space, not load f/w, load f/w, ignore nvram,
not ignore nvarm, set full duplex mode. Also have an isp_seed value
that we can use to generate a pseudo seed for a synthetic WWN.
Other minor cosmetic cleanup. Add in support for the Qlogic ISP
2200. Very important change where we actually check now to see
whether we were successful in mapping request and response queues
(and fibre channel scratch space).
1999-07-02 23:18:03 +00:00
|
|
|
int error;
|
|
|
|
|
};
|
|
|
|
|
|
1998-09-15 10:06:23 +00:00
|
|
|
static void
|
2002-04-02 23:36:14 +00:00
|
|
|
imc(void *arg, bus_dma_segment_t *segs, int nseg, int error)
|
1998-09-15 10:06:23 +00:00
|
|
|
{
|
Remove pre-CAM code. Add in getenv_int calls for variables isp_mem_map,
isp_io_map, isp_no_fwload, isp_fwload, isp_no_nvram, isp_fcduplex
which are all bitmaps of isp instances that should or shouldn't
map memory space, I/O space, not load f/w, load f/w, ignore nvram,
not ignore nvarm, set full duplex mode. Also have an isp_seed value
that we can use to generate a pseudo seed for a synthetic WWN.
Other minor cosmetic cleanup. Add in support for the Qlogic ISP
2200. Very important change where we actually check now to see
whether we were successful in mapping request and response queues
(and fibre channel scratch space).
1999-07-02 23:18:03 +00:00
|
|
|
struct imush *imushp = (struct imush *) arg;
|
2009-08-01 01:04:26 +00:00
|
|
|
|
2015-12-27 06:16:02 +00:00
|
|
|
if (!(imushp->error = error))
|
|
|
|
|
imushp->maddr = segs[0].ds_addr;
|
1998-09-15 10:06:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
2006-04-21 18:30:01 +00:00
|
|
|
isp_pci_mbxdma(ispsoftc_t *isp)
|
1998-09-15 10:06:23 +00:00
|
|
|
{
|
2020-11-22 04:10:13 +00:00
|
|
|
bus_dma_tag_t ptag;
|
1998-09-15 10:06:23 +00:00
|
|
|
caddr_t base;
|
2020-11-20 01:15:48 +00:00
|
|
|
uint32_t len;
|
2020-11-22 04:10:13 +00:00
|
|
|
int i, error, cmap;
|
2006-02-02 21:31:34 +00:00
|
|
|
bus_size_t slim; /* segment size */
|
Remove pre-CAM code. Add in getenv_int calls for variables isp_mem_map,
isp_io_map, isp_no_fwload, isp_fwload, isp_no_nvram, isp_fcduplex
which are all bitmaps of isp instances that should or shouldn't
map memory space, I/O space, not load f/w, load f/w, ignore nvram,
not ignore nvarm, set full duplex mode. Also have an isp_seed value
that we can use to generate a pseudo seed for a synthetic WWN.
Other minor cosmetic cleanup. Add in support for the Qlogic ISP
2200. Very important change where we actually check now to see
whether we were successful in mapping request and response queues
(and fibre channel scratch space).
1999-07-02 23:18:03 +00:00
|
|
|
struct imush im;
|
2020-11-20 02:03:58 +00:00
|
|
|
#ifdef ISP_TARGET_MODE
|
2020-11-20 01:15:48 +00:00
|
|
|
isp_ecmd_t *ecmd;
|
2020-11-20 02:03:58 +00:00
|
|
|
#endif
|
Remove pre-CAM code. Add in getenv_int calls for variables isp_mem_map,
isp_io_map, isp_no_fwload, isp_fwload, isp_no_nvram, isp_fcduplex
which are all bitmaps of isp instances that should or shouldn't
map memory space, I/O space, not load f/w, load f/w, ignore nvram,
not ignore nvarm, set full duplex mode. Also have an isp_seed value
that we can use to generate a pseudo seed for a synthetic WWN.
Other minor cosmetic cleanup. Add in support for the Qlogic ISP
2200. Very important change where we actually check now to see
whether we were successful in mapping request and response queues
(and fibre channel scratch space).
1999-07-02 23:18:03 +00:00
|
|
|
|
2017-03-14 08:03:56 +00:00
|
|
|
/* Already been here? If so, leave... */
|
|
|
|
|
if (isp->isp_xflist != NULL)
|
|
|
|
|
return (0);
|
|
|
|
|
if (isp->isp_rquest != NULL && isp->isp_maxcmds == 0)
|
1999-10-17 19:03:11 +00:00
|
|
|
return (0);
|
2007-05-05 20:17:23 +00:00
|
|
|
ISP_UNLOCK(isp);
|
2006-11-02 03:21:32 +00:00
|
|
|
|
2020-11-22 04:10:13 +00:00
|
|
|
ptag = bus_get_dma_tag(isp->isp_osinfo.dev);
|
2017-03-24 14:44:03 +00:00
|
|
|
if (sizeof (bus_size_t) > 4)
|
2020-11-20 01:15:48 +00:00
|
|
|
slim = (bus_size_t) (1ULL << 32);
|
2017-03-14 08:03:56 +00:00
|
|
|
else
|
2020-11-20 01:15:48 +00:00
|
|
|
slim = (bus_size_t) (1UL << 31);
|
2020-11-22 04:10:13 +00:00
|
|
|
|
|
|
|
|
if (isp->isp_rquest != NULL)
|
|
|
|
|
goto gotmaxcmds;
|
2002-04-02 23:36:14 +00:00
|
|
|
|
1998-09-15 10:06:23 +00:00
|
|
|
/*
|
2020-11-18 03:43:03 +00:00
|
|
|
* Allocate and map the request queue.
|
1998-09-15 10:06:23 +00:00
|
|
|
*/
|
2000-08-01 05:16:49 +00:00
|
|
|
len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
|
2020-11-22 04:10:13 +00:00
|
|
|
if (bus_dma_tag_create(ptag, QENTRY_LEN, slim,
|
2020-11-20 01:15:48 +00:00
|
|
|
BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
|
2020-11-18 02:54:05 +00:00
|
|
|
len, 1, len, 0, NULL, NULL, &isp->isp_osinfo.reqdmat)) {
|
2015-12-27 06:16:02 +00:00
|
|
|
isp_prt(isp, ISP_LOGERR, "cannot create request DMA tag");
|
2017-03-14 08:03:56 +00:00
|
|
|
goto bad;
|
2015-12-27 06:16:02 +00:00
|
|
|
}
|
|
|
|
|
if (bus_dmamem_alloc(isp->isp_osinfo.reqdmat, (void **)&base,
|
|
|
|
|
BUS_DMA_COHERENT, &isp->isp_osinfo.reqmap) != 0) {
|
|
|
|
|
isp_prt(isp, ISP_LOGERR, "cannot allocate request DMA memory");
|
|
|
|
|
bus_dma_tag_destroy(isp->isp_osinfo.reqdmat);
|
2017-03-14 08:03:56 +00:00
|
|
|
goto bad;
|
2015-12-27 06:16:02 +00:00
|
|
|
}
|
|
|
|
|
isp->isp_rquest = base;
|
|
|
|
|
im.error = 0;
|
|
|
|
|
if (bus_dmamap_load(isp->isp_osinfo.reqdmat, isp->isp_osinfo.reqmap,
|
2020-11-18 02:54:05 +00:00
|
|
|
base, len, imc, &im, BUS_DMA_NOWAIT) || im.error) {
|
2015-12-27 06:16:02 +00:00
|
|
|
isp_prt(isp, ISP_LOGERR, "error loading request DMA map %d", im.error);
|
2017-03-14 08:03:56 +00:00
|
|
|
goto bad;
|
2015-12-27 06:16:02 +00:00
|
|
|
}
|
|
|
|
|
isp_prt(isp, ISP_LOGDEBUG0, "request area @ 0x%jx/0x%jx",
|
|
|
|
|
(uintmax_t)im.maddr, (uintmax_t)len);
|
|
|
|
|
isp->isp_rquest_dma = im.maddr;
|
2020-11-18 03:43:03 +00:00
|
|
|
|
|
|
|
|
#ifdef ISP_TARGET_MODE
|
|
|
|
|
/*
|
|
|
|
|
* Allocate region for external DMA addressable command/status structures.
|
|
|
|
|
*/
|
2020-11-20 01:15:48 +00:00
|
|
|
len = N_XCMDS * XCMD_SIZE;
|
2020-11-22 04:10:13 +00:00
|
|
|
if (bus_dma_tag_create(ptag, XCMD_SIZE, slim,
|
2020-11-20 01:15:48 +00:00
|
|
|
BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
|
|
|
|
|
len, 1, len, 0, NULL, NULL, &isp->isp_osinfo.ecmd_dmat)) {
|
|
|
|
|
isp_prt(isp, ISP_LOGERR, "cannot create ECMD DMA tag");
|
|
|
|
|
goto bad;
|
|
|
|
|
}
|
|
|
|
|
if (bus_dmamem_alloc(isp->isp_osinfo.ecmd_dmat, (void **)&base,
|
|
|
|
|
BUS_DMA_COHERENT, &isp->isp_osinfo.ecmd_map) != 0) {
|
|
|
|
|
isp_prt(isp, ISP_LOGERR, "cannot allocate ECMD DMA memory");
|
2020-11-22 04:10:13 +00:00
|
|
|
bus_dma_tag_destroy(isp->isp_osinfo.ecmd_dmat);
|
2020-11-20 01:15:48 +00:00
|
|
|
goto bad;
|
|
|
|
|
}
|
|
|
|
|
isp->isp_osinfo.ecmd_base = (isp_ecmd_t *)base;
|
|
|
|
|
im.error = 0;
|
|
|
|
|
if (bus_dmamap_load(isp->isp_osinfo.ecmd_dmat, isp->isp_osinfo.ecmd_map,
|
|
|
|
|
base, len, imc, &im, BUS_DMA_NOWAIT) || im.error) {
|
|
|
|
|
isp_prt(isp, ISP_LOGERR, "error loading ECMD DMA map %d", im.error);
|
|
|
|
|
goto bad;
|
|
|
|
|
}
|
|
|
|
|
isp_prt(isp, ISP_LOGDEBUG0, "ecmd area @ 0x%jx/0x%jx",
|
|
|
|
|
(uintmax_t)im.maddr, (uintmax_t)len);
|
|
|
|
|
|
|
|
|
|
isp->isp_osinfo.ecmd_dma = im.maddr;
|
|
|
|
|
isp->isp_osinfo.ecmd_free = (isp_ecmd_t *)base;
|
|
|
|
|
for (ecmd = isp->isp_osinfo.ecmd_free;
|
|
|
|
|
ecmd < &isp->isp_osinfo.ecmd_free[N_XCMDS]; ecmd++) {
|
|
|
|
|
if (ecmd == &isp->isp_osinfo.ecmd_free[N_XCMDS - 1])
|
|
|
|
|
ecmd->next = NULL;
|
|
|
|
|
else
|
|
|
|
|
ecmd->next = ecmd + 1;
|
-----------
MISC CHANGES
Add a new async event- ISP_TARGET_NOTIFY_ACK, that will guarantee
eventual delivery of a NOTIFY ACK. This is tons better than just
ignoring the return from isp_notify_ack and hoping for the best.
Clean up the lower level lun enable code to be a bit more sensible.
Fix a botch in isp_endcmd which was messing up the sense data.
Fix notify ack for SRR to use a sensible error code in the case
of a reject.
Clean up and make clear what kind of firmware we've loaded and
what capabilities it has.
-----------
FULL (252 byte) SENSE DATA
In CTIOs for the ISP, there's only a limimted amount of space
to load SENSE DATA for associated CHECK CONDITIONS (24 or 26
bytes). This makes it difficult to send full SENSE DATA that can
be up to 252 bytes.
Implement MODE 2 responses which have us build the FCP Response
in system memory which the ISP will put onto the wire directly.
On the initiator side, the same problem occurs in that a command
status response only has a limited amount of space for SENSE DATA.
This data is supplemented by status continuation responses that
the ISP pushes onto the response queue after the status response.
We now pull them all together so that full sense data can be
returned to the periph driver.
This is supported on 23XX, 24XX and 25XX cards.
This is also preparation for doing >16 byte CDBs.
-----------
FC TAPE
Implement full FC-TAPE on both initiator and target mode side. This
capability is driven by firmware loaded, board type, board NVRAM
settings, or hint configuration options to enable or disable. This
is supported for 23XX, 24XX and 25XX cards.
On the initiator side, we pretty much just have to generate a command
reference number for each command we send out. This is FCP-4 compliant
in that we do this per ITL nexus to generate the allowed 1 thru 255
CRN.
In order to support the target side of FC-TAPE, we now pay attention
to more of the PRLI word 3 parameters which will tell us whether
an initiator wants confirmed responses. While we're at it, we'll
pay attention to the initiator view too and report it.
On sending back CTIOs, we will notice whether the initiator wants
confirmed responses and we'll set up flags to do so.
If a response or data frame is lost the initiator sends us an SRR
(Sequence Retransmit Request) ELS which shows up as an SRR notify
and all outstanding CTIOs are nuked with SRR Received status. The
SRR notify contains the offset that the initiator wants us to restart
the data transfer from or to retransmit the response frame.
If the ISP driver still has the CCB around for which the data segment
or response applies, it will retransmit.
However, we typically don't know about a lost data frame until we
send the FCP Response and the initiator totes up counters for data
moved and notices missing segments. In this case we've already
completed the data CCBs already and sent themn back up to the periph
driver. Because there's no really clean mechanism yet in CAM to
handle this, a hack has been put into place to complete the CTIO
CCB with the CAM_MESSAGE_RECV status which will have a MODIFY DATA
POINTER extended message in it. The internal ISP target groks this
and ctl(8) will be modified to deal with this as well.
At any rate, the data is retransmitted and an an FCP response is
sent. The whole point here is to successfully complete a command
so that you don't have to depend on ULP (SCSI) to have to recover,
which in the case of tape is not really possible (hence the name
FC-TAPE).
Sponsored by: Spectralogic
MFC after: 1 month
2012-07-28 20:06:29 +00:00
|
|
|
}
|
2020-11-18 03:43:03 +00:00
|
|
|
#endif
|
2009-08-01 01:04:26 +00:00
|
|
|
|
2006-02-02 21:31:34 +00:00
|
|
|
/*
|
2015-12-27 06:16:02 +00:00
|
|
|
* Allocate and map the result queue.
|
2006-02-02 21:31:34 +00:00
|
|
|
*/
|
2015-12-27 06:16:02 +00:00
|
|
|
len = ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
|
2020-11-22 04:10:13 +00:00
|
|
|
if (bus_dma_tag_create(ptag, QENTRY_LEN, slim,
|
2020-11-20 01:15:48 +00:00
|
|
|
BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
|
2020-11-18 02:54:05 +00:00
|
|
|
len, 1, len, 0, NULL, NULL, &isp->isp_osinfo.respdmat)) {
|
2015-12-27 06:16:02 +00:00
|
|
|
isp_prt(isp, ISP_LOGERR, "cannot create response DMA tag");
|
2017-03-14 08:03:56 +00:00
|
|
|
goto bad;
|
2015-12-27 06:16:02 +00:00
|
|
|
}
|
|
|
|
|
if (bus_dmamem_alloc(isp->isp_osinfo.respdmat, (void **)&base,
|
|
|
|
|
BUS_DMA_COHERENT, &isp->isp_osinfo.respmap) != 0) {
|
|
|
|
|
isp_prt(isp, ISP_LOGERR, "cannot allocate response DMA memory");
|
|
|
|
|
bus_dma_tag_destroy(isp->isp_osinfo.respdmat);
|
2017-03-14 08:03:56 +00:00
|
|
|
goto bad;
|
2015-12-27 06:16:02 +00:00
|
|
|
}
|
|
|
|
|
isp->isp_result = base;
|
2009-08-01 01:04:26 +00:00
|
|
|
im.error = 0;
|
2015-12-27 06:16:02 +00:00
|
|
|
if (bus_dmamap_load(isp->isp_osinfo.respdmat, isp->isp_osinfo.respmap,
|
2020-11-18 02:54:05 +00:00
|
|
|
base, len, imc, &im, BUS_DMA_NOWAIT) || im.error) {
|
2015-12-27 06:16:02 +00:00
|
|
|
isp_prt(isp, ISP_LOGERR, "error loading response DMA map %d", im.error);
|
2017-03-14 08:03:56 +00:00
|
|
|
goto bad;
|
2015-12-27 06:16:02 +00:00
|
|
|
}
|
|
|
|
|
isp_prt(isp, ISP_LOGDEBUG0, "response area @ 0x%jx/0x%jx",
|
|
|
|
|
(uintmax_t)im.maddr, (uintmax_t)len);
|
|
|
|
|
isp->isp_result_dma = im.maddr;
|
2009-08-01 01:04:26 +00:00
|
|
|
|
2015-12-27 06:16:02 +00:00
|
|
|
#ifdef ISP_TARGET_MODE
|
|
|
|
|
/*
|
2020-11-20 19:36:34 +00:00
|
|
|
* Allocate and map ATIO queue.
|
2015-12-27 06:16:02 +00:00
|
|
|
*/
|
2020-11-20 19:36:34 +00:00
|
|
|
len = ISP_QUEUE_SIZE(ATIO_QUEUE_LEN(isp));
|
2020-11-22 04:10:13 +00:00
|
|
|
if (bus_dma_tag_create(ptag, QENTRY_LEN, slim,
|
2020-11-20 01:15:48 +00:00
|
|
|
BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
|
|
|
|
|
len, 1, len, 0, NULL, NULL, &isp->isp_osinfo.atiodmat)) {
|
|
|
|
|
isp_prt(isp, ISP_LOGERR, "cannot create ATIO DMA tag");
|
|
|
|
|
goto bad;
|
|
|
|
|
}
|
|
|
|
|
if (bus_dmamem_alloc(isp->isp_osinfo.atiodmat, (void **)&base,
|
|
|
|
|
BUS_DMA_COHERENT, &isp->isp_osinfo.atiomap) != 0) {
|
|
|
|
|
isp_prt(isp, ISP_LOGERR, "cannot allocate ATIO DMA memory");
|
|
|
|
|
bus_dma_tag_destroy(isp->isp_osinfo.atiodmat);
|
|
|
|
|
goto bad;
|
2009-08-01 01:04:26 +00:00
|
|
|
}
|
2020-11-20 01:15:48 +00:00
|
|
|
isp->isp_atioq = base;
|
|
|
|
|
im.error = 0;
|
|
|
|
|
if (bus_dmamap_load(isp->isp_osinfo.atiodmat, isp->isp_osinfo.atiomap,
|
|
|
|
|
base, len, imc, &im, BUS_DMA_NOWAIT) || im.error) {
|
|
|
|
|
isp_prt(isp, ISP_LOGERR, "error loading ATIO DMA map %d", im.error);
|
|
|
|
|
goto bad;
|
|
|
|
|
}
|
|
|
|
|
isp_prt(isp, ISP_LOGDEBUG0, "ATIO area @ 0x%jx/0x%jx",
|
|
|
|
|
(uintmax_t)im.maddr, (uintmax_t)len);
|
|
|
|
|
isp->isp_atioq_dma = im.maddr;
|
2015-12-27 06:16:02 +00:00
|
|
|
#endif
|
2009-08-01 01:04:26 +00:00
|
|
|
|
2020-11-22 04:10:13 +00:00
|
|
|
if (bus_dma_tag_create(ptag, 64, slim,
|
2020-11-20 01:15:48 +00:00
|
|
|
BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
|
|
|
|
|
2*QENTRY_LEN, 1, 2*QENTRY_LEN, 0, NULL, NULL,
|
|
|
|
|
&isp->isp_osinfo.iocbdmat)) {
|
|
|
|
|
goto bad;
|
|
|
|
|
}
|
|
|
|
|
if (bus_dmamem_alloc(isp->isp_osinfo.iocbdmat,
|
|
|
|
|
(void **)&base, BUS_DMA_COHERENT, &isp->isp_osinfo.iocbmap) != 0)
|
|
|
|
|
goto bad;
|
|
|
|
|
isp->isp_iocb = base;
|
|
|
|
|
im.error = 0;
|
|
|
|
|
if (bus_dmamap_load(isp->isp_osinfo.iocbdmat, isp->isp_osinfo.iocbmap,
|
|
|
|
|
base, 2*QENTRY_LEN, imc, &im, BUS_DMA_NOWAIT) || im.error)
|
|
|
|
|
goto bad;
|
|
|
|
|
isp->isp_iocb_dma = im.maddr;
|
|
|
|
|
|
2020-11-22 04:10:13 +00:00
|
|
|
if (bus_dma_tag_create(ptag, 64, slim,
|
2020-11-20 01:15:48 +00:00
|
|
|
BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
|
|
|
|
|
ISP_FC_SCRLEN, 1, ISP_FC_SCRLEN, 0, NULL, NULL,
|
|
|
|
|
&isp->isp_osinfo.scdmat))
|
|
|
|
|
goto bad;
|
|
|
|
|
for (cmap = 0; cmap < isp->isp_nchan; cmap++) {
|
|
|
|
|
struct isp_fc *fc = ISP_FC_PC(isp, cmap);
|
|
|
|
|
if (bus_dmamem_alloc(isp->isp_osinfo.scdmat,
|
|
|
|
|
(void **)&base, BUS_DMA_COHERENT, &fc->scmap) != 0)
|
2016-04-12 14:19:19 +00:00
|
|
|
goto bad;
|
2020-11-20 01:15:48 +00:00
|
|
|
FCPARAM(isp, cmap)->isp_scratch = base;
|
2016-04-12 14:19:19 +00:00
|
|
|
im.error = 0;
|
2020-11-20 01:15:48 +00:00
|
|
|
if (bus_dmamap_load(isp->isp_osinfo.scdmat, fc->scmap,
|
|
|
|
|
base, ISP_FC_SCRLEN, imc, &im, BUS_DMA_NOWAIT) ||
|
|
|
|
|
im.error) {
|
|
|
|
|
bus_dmamem_free(isp->isp_osinfo.scdmat,
|
|
|
|
|
base, fc->scmap);
|
|
|
|
|
FCPARAM(isp, cmap)->isp_scratch = NULL;
|
2016-04-12 14:19:19 +00:00
|
|
|
goto bad;
|
2020-11-20 01:15:48 +00:00
|
|
|
}
|
|
|
|
|
FCPARAM(isp, cmap)->isp_scdma = im.maddr;
|
|
|
|
|
for (i = 0; i < INITIAL_NEXUS_COUNT; i++) {
|
|
|
|
|
struct isp_nexus *n = malloc(sizeof (struct isp_nexus), M_DEVBUF, M_NOWAIT | M_ZERO);
|
|
|
|
|
if (n == NULL) {
|
|
|
|
|
while (fc->nexus_free_list) {
|
|
|
|
|
n = fc->nexus_free_list;
|
|
|
|
|
fc->nexus_free_list = n->next;
|
|
|
|
|
free(n, M_DEVBUF);
|
-----------
MISC CHANGES
Add a new async event- ISP_TARGET_NOTIFY_ACK, that will guarantee
eventual delivery of a NOTIFY ACK. This is tons better than just
ignoring the return from isp_notify_ack and hoping for the best.
Clean up the lower level lun enable code to be a bit more sensible.
Fix a botch in isp_endcmd which was messing up the sense data.
Fix notify ack for SRR to use a sensible error code in the case
of a reject.
Clean up and make clear what kind of firmware we've loaded and
what capabilities it has.
-----------
FULL (252 byte) SENSE DATA
In CTIOs for the ISP, there's only a limimted amount of space
to load SENSE DATA for associated CHECK CONDITIONS (24 or 26
bytes). This makes it difficult to send full SENSE DATA that can
be up to 252 bytes.
Implement MODE 2 responses which have us build the FCP Response
in system memory which the ISP will put onto the wire directly.
On the initiator side, the same problem occurs in that a command
status response only has a limited amount of space for SENSE DATA.
This data is supplemented by status continuation responses that
the ISP pushes onto the response queue after the status response.
We now pull them all together so that full sense data can be
returned to the periph driver.
This is supported on 23XX, 24XX and 25XX cards.
This is also preparation for doing >16 byte CDBs.
-----------
FC TAPE
Implement full FC-TAPE on both initiator and target mode side. This
capability is driven by firmware loaded, board type, board NVRAM
settings, or hint configuration options to enable or disable. This
is supported for 23XX, 24XX and 25XX cards.
On the initiator side, we pretty much just have to generate a command
reference number for each command we send out. This is FCP-4 compliant
in that we do this per ITL nexus to generate the allowed 1 thru 255
CRN.
In order to support the target side of FC-TAPE, we now pay attention
to more of the PRLI word 3 parameters which will tell us whether
an initiator wants confirmed responses. While we're at it, we'll
pay attention to the initiator view too and report it.
On sending back CTIOs, we will notice whether the initiator wants
confirmed responses and we'll set up flags to do so.
If a response or data frame is lost the initiator sends us an SRR
(Sequence Retransmit Request) ELS which shows up as an SRR notify
and all outstanding CTIOs are nuked with SRR Received status. The
SRR notify contains the offset that the initiator wants us to restart
the data transfer from or to retransmit the response frame.
If the ISP driver still has the CCB around for which the data segment
or response applies, it will retransmit.
However, we typically don't know about a lost data frame until we
send the FCP Response and the initiator totes up counters for data
moved and notices missing segments. In this case we've already
completed the data CCBs already and sent themn back up to the periph
driver. Because there's no really clean mechanism yet in CAM to
handle this, a hack has been put into place to complete the CTIO
CCB with the CAM_MESSAGE_RECV status which will have a MODIFY DATA
POINTER extended message in it. The internal ISP target groks this
and ctl(8) will be modified to deal with this as well.
At any rate, the data is retransmitted and an an FCP response is
sent. The whole point here is to successfully complete a command
so that you don't have to depend on ULP (SCSI) to have to recover,
which in the case of tape is not really possible (hence the name
FC-TAPE).
Sponsored by: Spectralogic
MFC after: 1 month
2012-07-28 20:06:29 +00:00
|
|
|
}
|
2020-11-20 01:15:48 +00:00
|
|
|
goto bad;
|
-----------
MISC CHANGES
Add a new async event- ISP_TARGET_NOTIFY_ACK, that will guarantee
eventual delivery of a NOTIFY ACK. This is tons better than just
ignoring the return from isp_notify_ack and hoping for the best.
Clean up the lower level lun enable code to be a bit more sensible.
Fix a botch in isp_endcmd which was messing up the sense data.
Fix notify ack for SRR to use a sensible error code in the case
of a reject.
Clean up and make clear what kind of firmware we've loaded and
what capabilities it has.
-----------
FULL (252 byte) SENSE DATA
In CTIOs for the ISP, there's only a limimted amount of space
to load SENSE DATA for associated CHECK CONDITIONS (24 or 26
bytes). This makes it difficult to send full SENSE DATA that can
be up to 252 bytes.
Implement MODE 2 responses which have us build the FCP Response
in system memory which the ISP will put onto the wire directly.
On the initiator side, the same problem occurs in that a command
status response only has a limited amount of space for SENSE DATA.
This data is supplemented by status continuation responses that
the ISP pushes onto the response queue after the status response.
We now pull them all together so that full sense data can be
returned to the periph driver.
This is supported on 23XX, 24XX and 25XX cards.
This is also preparation for doing >16 byte CDBs.
-----------
FC TAPE
Implement full FC-TAPE on both initiator and target mode side. This
capability is driven by firmware loaded, board type, board NVRAM
settings, or hint configuration options to enable or disable. This
is supported for 23XX, 24XX and 25XX cards.
On the initiator side, we pretty much just have to generate a command
reference number for each command we send out. This is FCP-4 compliant
in that we do this per ITL nexus to generate the allowed 1 thru 255
CRN.
In order to support the target side of FC-TAPE, we now pay attention
to more of the PRLI word 3 parameters which will tell us whether
an initiator wants confirmed responses. While we're at it, we'll
pay attention to the initiator view too and report it.
On sending back CTIOs, we will notice whether the initiator wants
confirmed responses and we'll set up flags to do so.
If a response or data frame is lost the initiator sends us an SRR
(Sequence Retransmit Request) ELS which shows up as an SRR notify
and all outstanding CTIOs are nuked with SRR Received status. The
SRR notify contains the offset that the initiator wants us to restart
the data transfer from or to retransmit the response frame.
If the ISP driver still has the CCB around for which the data segment
or response applies, it will retransmit.
However, we typically don't know about a lost data frame until we
send the FCP Response and the initiator totes up counters for data
moved and notices missing segments. In this case we've already
completed the data CCBs already and sent themn back up to the periph
driver. Because there's no really clean mechanism yet in CAM to
handle this, a hack has been put into place to complete the CTIO
CCB with the CAM_MESSAGE_RECV status which will have a MODIFY DATA
POINTER extended message in it. The internal ISP target groks this
and ctl(8) will be modified to deal with this as well.
At any rate, the data is retransmitted and an an FCP response is
sent. The whole point here is to successfully complete a command
so that you don't have to depend on ULP (SCSI) to have to recover,
which in the case of tape is not really possible (hence the name
FC-TAPE).
Sponsored by: Spectralogic
MFC after: 1 month
2012-07-28 20:06:29 +00:00
|
|
|
}
|
2020-11-20 01:15:48 +00:00
|
|
|
n->next = fc->nexus_free_list;
|
|
|
|
|
fc->nexus_free_list = n;
|
2009-08-01 01:04:26 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-03-14 08:03:56 +00:00
|
|
|
if (isp->isp_maxcmds == 0) {
|
|
|
|
|
ISP_LOCK(isp);
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
gotmaxcmds:
|
2020-11-22 04:10:13 +00:00
|
|
|
if (bus_dma_tag_create(ptag, 1, slim,
|
|
|
|
|
BUS_SPACE_MAXADDR, BUS_SPACE_MAXADDR, NULL, NULL,
|
|
|
|
|
(ISP_NSEG64_MAX - 1) * PAGE_SIZE, ISP_NSEG64_MAX,
|
|
|
|
|
(ISP_NSEG64_MAX - 1) * PAGE_SIZE, 0,
|
|
|
|
|
busdma_lock_mutex, &isp->isp_lock, &isp->isp_osinfo.dmat))
|
|
|
|
|
goto bad;
|
2017-03-14 08:03:56 +00:00
|
|
|
len = isp->isp_maxcmds * sizeof (struct isp_pcmd);
|
|
|
|
|
isp->isp_osinfo.pcmd_pool = (struct isp_pcmd *)
|
|
|
|
|
malloc(len, M_DEVBUF, M_WAITOK | M_ZERO);
|
1999-10-17 19:03:11 +00:00
|
|
|
for (i = 0; i < isp->isp_maxcmds; i++) {
|
2007-05-05 20:17:23 +00:00
|
|
|
struct isp_pcmd *pcmd = &isp->isp_osinfo.pcmd_pool[i];
|
|
|
|
|
error = bus_dmamap_create(isp->isp_osinfo.dmat, 0, &pcmd->dmap);
|
1998-09-15 10:06:23 +00:00
|
|
|
if (error) {
|
2009-08-01 01:04:26 +00:00
|
|
|
isp_prt(isp, ISP_LOGERR, "error %d creating per-cmd DMA maps", error);
|
2002-04-02 23:36:14 +00:00
|
|
|
while (--i >= 0) {
|
2017-03-14 08:03:56 +00:00
|
|
|
bus_dmamap_destroy(isp->isp_osinfo.dmat,
|
|
|
|
|
isp->isp_osinfo.pcmd_pool[i].dmap);
|
2002-04-02 23:36:14 +00:00
|
|
|
}
|
|
|
|
|
goto bad;
|
1998-09-15 10:06:23 +00:00
|
|
|
}
|
2017-03-21 10:34:34 +00:00
|
|
|
callout_init_mtx(&pcmd->wdog, &isp->isp_lock, 0);
|
2017-03-14 08:03:56 +00:00
|
|
|
if (i == isp->isp_maxcmds-1)
|
2007-05-05 20:17:23 +00:00
|
|
|
pcmd->next = NULL;
|
2017-03-14 08:03:56 +00:00
|
|
|
else
|
2007-05-05 20:17:23 +00:00
|
|
|
pcmd->next = &isp->isp_osinfo.pcmd_pool[i+1];
|
1998-09-15 10:06:23 +00:00
|
|
|
}
|
2007-05-05 20:17:23 +00:00
|
|
|
isp->isp_osinfo.pcmd_free = &isp->isp_osinfo.pcmd_pool[0];
|
2017-03-14 08:03:56 +00:00
|
|
|
|
2020-11-22 04:29:55 +00:00
|
|
|
len = sizeof(isp_hdl_t) * ISP_HANDLE_NUM(isp);
|
2017-03-14 08:03:56 +00:00
|
|
|
isp->isp_xflist = (isp_hdl_t *) malloc(len, M_DEVBUF, M_WAITOK | M_ZERO);
|
2020-11-22 04:29:55 +00:00
|
|
|
for (len = 0; len < ISP_HANDLE_NUM(isp) - 1; len++)
|
2017-03-14 08:03:56 +00:00
|
|
|
isp->isp_xflist[len].cmd = &isp->isp_xflist[len+1];
|
|
|
|
|
isp->isp_xffree = isp->isp_xflist;
|
|
|
|
|
|
2002-07-25 16:02:09 +00:00
|
|
|
ISP_LOCK(isp);
|
1998-09-15 10:06:23 +00:00
|
|
|
return (0);
|
2002-04-02 23:36:14 +00:00
|
|
|
|
|
|
|
|
bad:
|
2017-03-14 08:03:56 +00:00
|
|
|
isp_pci_mbxdmafree(isp);
|
|
|
|
|
ISP_LOCK(isp);
|
|
|
|
|
return (1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
isp_pci_mbxdmafree(ispsoftc_t *isp)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
if (isp->isp_xflist != NULL) {
|
|
|
|
|
free(isp->isp_xflist, M_DEVBUF);
|
|
|
|
|
isp->isp_xflist = NULL;
|
|
|
|
|
}
|
|
|
|
|
if (isp->isp_osinfo.pcmd_pool != NULL) {
|
|
|
|
|
for (i = 0; i < isp->isp_maxcmds; i++) {
|
|
|
|
|
bus_dmamap_destroy(isp->isp_osinfo.dmat,
|
|
|
|
|
isp->isp_osinfo.pcmd_pool[i].dmap);
|
|
|
|
|
}
|
|
|
|
|
free(isp->isp_osinfo.pcmd_pool, M_DEVBUF);
|
|
|
|
|
isp->isp_osinfo.pcmd_pool = NULL;
|
|
|
|
|
}
|
2020-11-22 04:10:13 +00:00
|
|
|
if (isp->isp_osinfo.dmat) {
|
|
|
|
|
bus_dma_tag_destroy(isp->isp_osinfo.dmat);
|
|
|
|
|
isp->isp_osinfo.dmat = NULL;
|
|
|
|
|
}
|
2020-11-20 01:15:48 +00:00
|
|
|
for (i = 0; i < isp->isp_nchan; i++) {
|
|
|
|
|
struct isp_fc *fc = ISP_FC_PC(isp, i);
|
|
|
|
|
if (FCPARAM(isp, i)->isp_scdma != 0) {
|
|
|
|
|
bus_dmamap_unload(isp->isp_osinfo.scdmat,
|
|
|
|
|
fc->scmap);
|
|
|
|
|
FCPARAM(isp, i)->isp_scdma = 0;
|
-----------
MISC CHANGES
Add a new async event- ISP_TARGET_NOTIFY_ACK, that will guarantee
eventual delivery of a NOTIFY ACK. This is tons better than just
ignoring the return from isp_notify_ack and hoping for the best.
Clean up the lower level lun enable code to be a bit more sensible.
Fix a botch in isp_endcmd which was messing up the sense data.
Fix notify ack for SRR to use a sensible error code in the case
of a reject.
Clean up and make clear what kind of firmware we've loaded and
what capabilities it has.
-----------
FULL (252 byte) SENSE DATA
In CTIOs for the ISP, there's only a limimted amount of space
to load SENSE DATA for associated CHECK CONDITIONS (24 or 26
bytes). This makes it difficult to send full SENSE DATA that can
be up to 252 bytes.
Implement MODE 2 responses which have us build the FCP Response
in system memory which the ISP will put onto the wire directly.
On the initiator side, the same problem occurs in that a command
status response only has a limited amount of space for SENSE DATA.
This data is supplemented by status continuation responses that
the ISP pushes onto the response queue after the status response.
We now pull them all together so that full sense data can be
returned to the periph driver.
This is supported on 23XX, 24XX and 25XX cards.
This is also preparation for doing >16 byte CDBs.
-----------
FC TAPE
Implement full FC-TAPE on both initiator and target mode side. This
capability is driven by firmware loaded, board type, board NVRAM
settings, or hint configuration options to enable or disable. This
is supported for 23XX, 24XX and 25XX cards.
On the initiator side, we pretty much just have to generate a command
reference number for each command we send out. This is FCP-4 compliant
in that we do this per ITL nexus to generate the allowed 1 thru 255
CRN.
In order to support the target side of FC-TAPE, we now pay attention
to more of the PRLI word 3 parameters which will tell us whether
an initiator wants confirmed responses. While we're at it, we'll
pay attention to the initiator view too and report it.
On sending back CTIOs, we will notice whether the initiator wants
confirmed responses and we'll set up flags to do so.
If a response or data frame is lost the initiator sends us an SRR
(Sequence Retransmit Request) ELS which shows up as an SRR notify
and all outstanding CTIOs are nuked with SRR Received status. The
SRR notify contains the offset that the initiator wants us to restart
the data transfer from or to retransmit the response frame.
If the ISP driver still has the CCB around for which the data segment
or response applies, it will retransmit.
However, we typically don't know about a lost data frame until we
send the FCP Response and the initiator totes up counters for data
moved and notices missing segments. In this case we've already
completed the data CCBs already and sent themn back up to the periph
driver. Because there's no really clean mechanism yet in CAM to
handle this, a hack has been put into place to complete the CTIO
CCB with the CAM_MESSAGE_RECV status which will have a MODIFY DATA
POINTER extended message in it. The internal ISP target groks this
and ctl(8) will be modified to deal with this as well.
At any rate, the data is retransmitted and an an FCP response is
sent. The whole point here is to successfully complete a command
so that you don't have to depend on ULP (SCSI) to have to recover,
which in the case of tape is not really possible (hence the name
FC-TAPE).
Sponsored by: Spectralogic
MFC after: 1 month
2012-07-28 20:06:29 +00:00
|
|
|
}
|
2020-11-20 01:15:48 +00:00
|
|
|
if (FCPARAM(isp, i)->isp_scratch != NULL) {
|
|
|
|
|
bus_dmamem_free(isp->isp_osinfo.scdmat,
|
|
|
|
|
FCPARAM(isp, i)->isp_scratch, fc->scmap);
|
|
|
|
|
FCPARAM(isp, i)->isp_scratch = NULL;
|
2017-03-14 08:03:56 +00:00
|
|
|
}
|
2020-11-20 01:15:48 +00:00
|
|
|
while (fc->nexus_free_list) {
|
|
|
|
|
struct isp_nexus *n = fc->nexus_free_list;
|
|
|
|
|
fc->nexus_free_list = n->next;
|
|
|
|
|
free(n, M_DEVBUF);
|
2017-03-14 08:03:56 +00:00
|
|
|
}
|
2015-12-27 06:16:02 +00:00
|
|
|
}
|
2020-11-22 04:10:13 +00:00
|
|
|
if (isp->isp_osinfo.scdmat) {
|
2020-11-20 01:15:48 +00:00
|
|
|
bus_dma_tag_destroy(isp->isp_osinfo.scdmat);
|
2020-11-22 04:10:13 +00:00
|
|
|
isp->isp_osinfo.scdmat = NULL;
|
|
|
|
|
}
|
|
|
|
|
if (isp->isp_iocb_dma != 0) {
|
2020-11-20 01:15:48 +00:00
|
|
|
bus_dmamap_unload(isp->isp_osinfo.iocbdmat,
|
|
|
|
|
isp->isp_osinfo.iocbmap);
|
|
|
|
|
isp->isp_iocb_dma = 0;
|
|
|
|
|
}
|
|
|
|
|
if (isp->isp_iocb != NULL) {
|
|
|
|
|
bus_dmamem_free(isp->isp_osinfo.iocbdmat,
|
|
|
|
|
isp->isp_iocb, isp->isp_osinfo.iocbmap);
|
|
|
|
|
bus_dma_tag_destroy(isp->isp_osinfo.iocbdmat);
|
|
|
|
|
}
|
2015-12-27 06:16:02 +00:00
|
|
|
#ifdef ISP_TARGET_MODE
|
2020-11-20 01:15:48 +00:00
|
|
|
if (isp->isp_atioq_dma != 0) {
|
|
|
|
|
bus_dmamap_unload(isp->isp_osinfo.atiodmat,
|
|
|
|
|
isp->isp_osinfo.atiomap);
|
|
|
|
|
isp->isp_atioq_dma = 0;
|
|
|
|
|
}
|
|
|
|
|
if (isp->isp_atioq != NULL) {
|
|
|
|
|
bus_dmamem_free(isp->isp_osinfo.atiodmat, isp->isp_atioq,
|
|
|
|
|
isp->isp_osinfo.atiomap);
|
|
|
|
|
bus_dma_tag_destroy(isp->isp_osinfo.atiodmat);
|
|
|
|
|
isp->isp_atioq = NULL;
|
2015-12-27 06:16:02 +00:00
|
|
|
}
|
|
|
|
|
#endif
|
2017-03-14 08:03:56 +00:00
|
|
|
if (isp->isp_result_dma != 0) {
|
|
|
|
|
bus_dmamap_unload(isp->isp_osinfo.respdmat,
|
|
|
|
|
isp->isp_osinfo.respmap);
|
|
|
|
|
isp->isp_result_dma = 0;
|
|
|
|
|
}
|
|
|
|
|
if (isp->isp_result != NULL) {
|
|
|
|
|
bus_dmamem_free(isp->isp_osinfo.respdmat, isp->isp_result,
|
|
|
|
|
isp->isp_osinfo.respmap);
|
|
|
|
|
bus_dma_tag_destroy(isp->isp_osinfo.respdmat);
|
|
|
|
|
isp->isp_result = NULL;
|
|
|
|
|
}
|
2020-11-18 03:43:03 +00:00
|
|
|
#ifdef ISP_TARGET_MODE
|
|
|
|
|
if (isp->isp_osinfo.ecmd_dma != 0) {
|
|
|
|
|
bus_dmamap_unload(isp->isp_osinfo.ecmd_dmat,
|
|
|
|
|
isp->isp_osinfo.ecmd_map);
|
|
|
|
|
isp->isp_osinfo.ecmd_dma = 0;
|
|
|
|
|
}
|
|
|
|
|
if (isp->isp_osinfo.ecmd_base != NULL) {
|
|
|
|
|
bus_dmamem_free(isp->isp_osinfo.ecmd_dmat, isp->isp_osinfo.ecmd_base,
|
|
|
|
|
isp->isp_osinfo.ecmd_map);
|
|
|
|
|
bus_dma_tag_destroy(isp->isp_osinfo.ecmd_dmat);
|
|
|
|
|
isp->isp_osinfo.ecmd_base = NULL;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
2017-03-14 08:03:56 +00:00
|
|
|
if (isp->isp_rquest_dma != 0) {
|
|
|
|
|
bus_dmamap_unload(isp->isp_osinfo.reqdmat,
|
|
|
|
|
isp->isp_osinfo.reqmap);
|
|
|
|
|
isp->isp_rquest_dma = 0;
|
|
|
|
|
}
|
|
|
|
|
if (isp->isp_rquest != NULL) {
|
|
|
|
|
bus_dmamem_free(isp->isp_osinfo.reqdmat, isp->isp_rquest,
|
|
|
|
|
isp->isp_osinfo.reqmap);
|
|
|
|
|
bus_dma_tag_destroy(isp->isp_osinfo.reqdmat);
|
|
|
|
|
isp->isp_rquest = NULL;
|
|
|
|
|
}
|
1998-09-15 10:06:23 +00:00
|
|
|
}
|
|
|
|
|
|
2017-03-14 08:03:56 +00:00
|
|
|
static int
|
|
|
|
|
isp_pci_irqsetup(ispsoftc_t *isp)
|
2006-12-16 05:54:29 +00:00
|
|
|
{
|
2017-03-19 19:11:40 +00:00
|
|
|
device_t dev = isp->isp_osinfo.dev;
|
|
|
|
|
struct isp_pcisoftc *pcs = device_get_softc(dev);
|
|
|
|
|
driver_intr_t *f;
|
|
|
|
|
int i, max_irq;
|
2006-12-16 05:54:29 +00:00
|
|
|
|
2017-03-19 19:11:40 +00:00
|
|
|
/* Allocate IRQs only once. */
|
|
|
|
|
if (isp->isp_nirq > 0)
|
|
|
|
|
return (0);
|
|
|
|
|
|
2017-03-21 08:56:13 +00:00
|
|
|
ISP_UNLOCK(isp);
|
2017-03-19 19:11:40 +00:00
|
|
|
if (ISP_CAP_MSIX(isp)) {
|
2019-02-28 21:07:16 +00:00
|
|
|
max_irq = IS_26XX(isp) ? 3 : (IS_25XX(isp) ? 2 : 0);
|
2019-02-28 15:24:00 +00:00
|
|
|
resource_int_value(device_get_name(dev),
|
|
|
|
|
device_get_unit(dev), "msix", &max_irq);
|
|
|
|
|
max_irq = imin(ISP_MAX_IRQS, max_irq);
|
2017-03-19 19:11:40 +00:00
|
|
|
pcs->msicount = imin(pci_msix_count(dev), max_irq);
|
|
|
|
|
if (pcs->msicount > 0 &&
|
|
|
|
|
pci_alloc_msix(dev, &pcs->msicount) != 0)
|
|
|
|
|
pcs->msicount = 0;
|
|
|
|
|
}
|
|
|
|
|
if (pcs->msicount == 0) {
|
2019-02-28 15:24:00 +00:00
|
|
|
max_irq = 1;
|
|
|
|
|
resource_int_value(device_get_name(dev),
|
|
|
|
|
device_get_unit(dev), "msi", &max_irq);
|
|
|
|
|
max_irq = imin(1, max_irq);
|
|
|
|
|
pcs->msicount = imin(pci_msi_count(dev), max_irq);
|
2017-03-19 19:11:40 +00:00
|
|
|
if (pcs->msicount > 0 &&
|
|
|
|
|
pci_alloc_msi(dev, &pcs->msicount) != 0)
|
|
|
|
|
pcs->msicount = 0;
|
|
|
|
|
}
|
|
|
|
|
for (i = 0; i < MAX(1, pcs->msicount); i++) {
|
|
|
|
|
pcs->irq[i].iqd = i + (pcs->msicount > 0);
|
|
|
|
|
pcs->irq[i].irq = bus_alloc_resource_any(dev, SYS_RES_IRQ,
|
|
|
|
|
&pcs->irq[i].iqd, RF_ACTIVE | RF_SHAREABLE);
|
|
|
|
|
if (pcs->irq[i].irq == NULL) {
|
|
|
|
|
device_printf(dev, "could not allocate interrupt\n");
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (i == 0)
|
|
|
|
|
f = isp_platform_intr;
|
|
|
|
|
else if (i == 1)
|
|
|
|
|
f = isp_platform_intr_resp;
|
|
|
|
|
else
|
|
|
|
|
f = isp_platform_intr_atio;
|
|
|
|
|
if (bus_setup_intr(dev, pcs->irq[i].irq, ISP_IFLAGS, NULL,
|
|
|
|
|
f, isp, &pcs->irq[i].ih)) {
|
|
|
|
|
device_printf(dev, "could not setup interrupt\n");
|
|
|
|
|
(void) bus_release_resource(dev, SYS_RES_IRQ,
|
|
|
|
|
pcs->irq[i].iqd, pcs->irq[i].irq);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (pcs->msicount > 1) {
|
|
|
|
|
bus_describe_intr(dev, pcs->irq[i].irq, pcs->irq[i].ih,
|
|
|
|
|
"%d", i);
|
|
|
|
|
}
|
|
|
|
|
isp->isp_nirq = i + 1;
|
|
|
|
|
}
|
2017-03-21 08:56:13 +00:00
|
|
|
ISP_LOCK(isp);
|
2017-03-19 19:11:40 +00:00
|
|
|
|
|
|
|
|
return (isp->isp_nirq == 0);
|
1998-04-22 18:12:29 +00:00
|
|
|
}
|
