Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/dev/sbus/isp_sbus.c

613 lines
17 KiB
C
Raw Normal View History

Pointy hat to me on the last delta.
2002-05-18 04:48:11 +04:00
/* $NetBSD: isp_sbus.c,v 1.53 2002/05/18 00:48:11 mjacob Exp $ */
Add a maintenance note. Add a bus specific isp_sbus_intr function- this is so we, ahem, note we're on an interrupt stack so we don't try and sleep on any mailbox commands we might want to run.
2000-08-14 11:00:08 +04:00
/*
* This driver, which is contained in NetBSD in the files:
*
* sys/dev/ic/isp.c
Fix pathnames in comment.
2000-12-23 04:37:57 +03:00
* sys/dev/ic/isp_inline.h
* sys/dev/ic/isp_netbsd.c
* sys/dev/ic/isp_netbsd.h
* sys/dev/ic/isp_target.c
* sys/dev/ic/isp_target.h
* sys/dev/ic/isp_tpublic.h
* sys/dev/ic/ispmbox.h
* sys/dev/ic/ispreg.h
* sys/dev/ic/ispvar.h
Add a maintenance note. Add a bus specific isp_sbus_intr function- this is so we, ahem, note we're on an interrupt stack so we don't try and sleep on any mailbox commands we might want to run.
2000-08-14 11:00:08 +04:00
* sys/microcode/isp/asm_sbus.h
* sys/microcode/isp/asm_1040.h
* sys/microcode/isp/asm_1080.h
* sys/microcode/isp/asm_12160.h
* sys/microcode/isp/asm_2100.h
* sys/microcode/isp/asm_2200.h
* sys/pci/isp_pci.c
* sys/sbus/isp_sbus.c
*
* Is being actively maintained by Matthew Jacob (mjacob@netbsd.org).
* This driver also is shared source with FreeBSD, OpenBSD, Linux, Solaris,
* Linux versions. This tends to be an interesting maintenance problem.
*
* Please coordinate with Matthew Jacob on changes you wish to make here.
*/
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
/*
* SBus specific probe and attach routines for Qlogic ISP SCSI adapters.
*
Implement bootverbose recognition. Move interrupt registry up a bit so we can use interrupting mailbox commands for isp_init. Set default HBA role. Rename request/response dma maps to be more consistent with PCI version. Enable bus_dmamap_sync on request queue- we already do this for response queue- better do it for the request queue as well. Checked to be working against a Sparc10.
2001-02-23 20:28:58 +03:00
* Copyright (c) 1997, 2001 by Matthew Jacob
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
* NASA AMES Research Center
* All rights reserved.
*
* 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.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 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.
*
*/
add RCSIDs
2001-11-13 09:54:32 +03:00
#include <sys/cdefs.h>
Pointy hat to me on the last delta.
2002-05-18 04:48:11 +04:00
__KERNEL_RCSID(0, "$NetBSD: isp_sbus.c,v 1.53 2002/05/18 00:48:11 mjacob Exp $");
add RCSIDs
2001-11-13 09:54:32 +03:00
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/queue.h>
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
#include <dev/ic/isp_netbsd.h>
Add a `device class' interrupt level argument (from machine/intr.h) to bus_interrupt_establish(). It's currently only used in sparc64/dev/psycho.c to assign a CPU interrupt level to devices in PCI slots.
2000-07-10 00:57:41 +04:00
#include <machine/intr.h>
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
#include <machine/autoconf.h>
Add back in inclusion of microcode and rationalize it. request/response queue indices need to be u_int16_t wide.
1999-12-04 05:56:30 +03:00
#include <dev/microcode/isp/asm_sbus.h>
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
#include <dev/sbus/sbusvar.h>
Implement bootverbose recognition. Move interrupt registry up a bit so we can use interrupting mailbox commands for isp_init. Set default HBA role. Rename request/response dma maps to be more consistent with PCI version. Enable bus_dmamap_sync on request queue- we already do this for response queue- better do it for the request queue as well. Checked to be working against a Sparc10.
2001-02-23 20:28:58 +03:00
#include <sys/reboot.h>
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
Implement F/W crashdumps for 2200 && 2300 cards (kernel compile option). Distinguish between 2312 and 2300 cards (they *are* different). Enable RIO (Reduced Interrupt Operation) for the LVD cards (hey- I've seen batched completions of the 30 commands at a time with this,....)... If we get a Port Logout on local loop topologies, we have to force the f/w to log back in. The easiest way (for us) to do this is to force a LIP. This also will wake up the disk that probably just had a f/w crash. Implement mailbox 'continuations'- this allows interrupts to re-drive a mailbox command if it's one that just essentially repeats the previous mailbox command (e.g., f/w download). This saves a boatload of sleep/wakeup twitches. If we're not a 2300 and we're about to return with a 'bogus interrupt'- check the semaphore register to be non-zero at all and outgoing mailbox 0- this seems to be where some of the lost ISP1080 commands came from.
2002-02-22 01:32:40 +03:00
static void isp_sbus_reset1(struct ispsoftc *);
ansify code
2001-03-14 09:58:25 +03:00
static int isp_sbus_intr(void *);
Add support for 2 Gigabit cards (2300/2312). This necessitated a change in how interrupts are down- the 23XX has not only a different place to check for an interrupt, but unlike all other QLogic cards, you have to read the status as a 32 bit word- not 16 bit words. Rather than have device specific functions as called from the core module (in isp_intr), it makes more sense to have the platform/bus modules do the gruntwork of splitting out the isr, semaphore register and the first outgoing mailbox register (if needed) *prior* to calling isp_intr (if calling isp_intr is necessary at all).
2001-09-01 11:12:23 +04:00
static int
isp_sbus_rd_isr(struct ispsoftc *, u_int16_t *, u_int16_t *, u_int16_t *);
ansify code
2001-03-14 09:58:25 +03:00
static u_int16_t isp_sbus_rd_reg(struct ispsoftc *, int);
static void isp_sbus_wr_reg (struct ispsoftc *, int, u_int16_t);
static int isp_sbus_mbxdma(struct ispsoftc *);
static int isp_sbus_dmasetup(struct ispsoftc *, XS_T *, ispreq_t *, u_int16_t *,
u_int16_t);
static void isp_sbus_dmateardown(struct ispsoftc *, XS_T *, u_int16_t);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
Add back in inclusion of microcode and rationalize it. request/response queue indices need to be u_int16_t wide.
1999-12-04 05:56:30 +03:00
#ifndef ISP_1000_RISC_CODE
#define ISP_1000_RISC_CODE NULL
#endif
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
static struct ispmdvec mdvec = {
Add support for 2 Gigabit cards (2300/2312). This necessitated a change in how interrupts are down- the 23XX has not only a different place to check for an interrupt, but unlike all other QLogic cards, you have to read the status as a 32 bit word- not 16 bit words. Rather than have device specific functions as called from the core module (in isp_intr), it makes more sense to have the platform/bus modules do the gruntwork of splitting out the isr, semaphore register and the first outgoing mailbox register (if needed) *prior* to calling isp_intr (if calling isp_intr is necessary at all).
2001-09-01 11:12:23 +04:00
isp_sbus_rd_isr,
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
isp_sbus_rd_reg,
isp_sbus_wr_reg,
isp_sbus_mbxdma,
isp_sbus_dmasetup,
isp_sbus_dmateardown,
NULL,
Implement F/W crashdumps for 2200 && 2300 cards (kernel compile option). Distinguish between 2312 and 2300 cards (they *are* different). Enable RIO (Reduced Interrupt Operation) for the LVD cards (hey- I've seen batched completions of the 30 commands at a time with this,....)... If we get a Port Logout on local loop topologies, we have to force the f/w to log back in. The easiest way (for us) to do this is to force a LIP. This also will wake up the disk that probably just had a f/w crash. Implement mailbox 'continuations'- this allows interrupts to re-drive a mailbox command if it's one that just essentially repeats the previous mailbox command (e.g., f/w download). This saves a boatload of sleep/wakeup twitches. If we're not a 2300 and we're about to return with a 'bogus interrupt'- check the semaphore register to be non-zero at all and outgoing mailbox 0- this seems to be where some of the lost ISP1080 commands came from.
2002-02-22 01:32:40 +03:00
isp_sbus_reset1,
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
NULL,
fix SBus bursting *correctly* this time
2000-10-22 07:04:50 +04:00
ISP_1000_RISC_CODE
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
};
struct isp_sbussoftc {
struct ispsoftc sbus_isp;
fix SBus bursting *correctly* this time
2000-10-22 07:04:50 +04:00
struct sbusdev sbus_sd;
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
sdparam sbus_dev;
bus_space_tag_t sbus_bustag;
roll internal release tag and finally use bus_space I/O
1999-01-30 10:10:38 +03:00
bus_space_handle_t sbus_reg;
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
int sbus_node;
int sbus_pri;
struct ispmdvec sbus_mdvec;
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
bus_dmamap_t *sbus_dmamap;
prototype 1080/1240 support caused register offset rewhack
1999-03-17 09:17:16 +03:00
int16_t sbus_poff[_NREG_BLKS];
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
};
ansify code
2001-03-14 09:58:25 +03:00
static int isp_match(struct device *, struct cfdata *, void *);
static void isp_sbus_attach(struct device *, struct device *, void *);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
struct cfattach isp_sbus_ca = {
sizeof (struct isp_sbussoftc), isp_match, isp_sbus_attach
};
static int
ansify code
2001-03-14 09:58:25 +03:00
isp_match(struct device *parent, struct cfdata *cf, void *aux)
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
{
int rv;
#ifdef DEBUG
static int oneshot = 1;
#endif
struct sbus_attach_args *sa = aux;
rv = (strcmp(cf->cf_driver->cd_name, sa->sa_name) == 0 ||
strcmp("PTI,ptisp", sa->sa_name) == 0 ||
strcmp("ptisp", sa->sa_name) == 0 ||
strcmp("SUNW,isp", sa->sa_name) == 0 ||
strcmp("QLGC,isp", sa->sa_name) == 0);
#ifdef DEBUG
if (rv && oneshot) {
oneshot = 0;
printf("Qlogic ISP Driver, NetBSD (sbus) Platform Version "
"%d.%d Core Version %d.%d\n",
ISP_PLATFORM_VERSION_MAJOR, ISP_PLATFORM_VERSION_MINOR,
ISP_CORE_VERSION_MAJOR, ISP_CORE_VERSION_MINOR);
}
#endif
return (rv);
}
The trigger for not downloading f/w is now a NULL f/w pointer, not a nonzero f/w length.
2000-01-09 21:55:11 +03:00
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
static void
ansify code
2001-03-14 09:58:25 +03:00
isp_sbus_attach(struct device *parent, struct device *self, void *aux)
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
{
fix SBus bursting *correctly* this time
2000-10-22 07:04:50 +04:00
int freq, ispburst, sbusburst;
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
struct sbus_attach_args *sa = aux;
struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) self;
struct ispsoftc *isp = &sbc->sbus_isp;
printf(" for %s\n", sa->sa_name);
sbc->sbus_bustag = sa->sa_bustag;
Check presence of Sbus interrupt properties before using them. Only one case is known to trigger this omission: a Sparc Classic configured as X terminal.
1999-11-21 18:01:50 +03:00
if (sa->sa_nintr != 0)
sbc->sbus_pri = sa->sa_pri;
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
sbc->sbus_mdvec = mdvec;
Fixup attachment code to use sbus_promaddr_to_handle() and not specify BUS_SPACE_MAP_LINEAR.
2002-03-21 03:16:15 +03:00
if (sa->sa_npromvaddrs) {
sbus_promaddr_to_handle(sa->sa_bustag,
sa->sa_promvaddrs[0], &sbc->sbus_reg);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
} else {
Fixup attachment code to use sbus_promaddr_to_handle() and not specify BUS_SPACE_MAP_LINEAR.
2002-03-21 03:16:15 +03:00
if (sbus_bus_map(sa->sa_bustag, sa->sa_slot, sa->sa_offset,
sa->sa_size, 0, &sbc->sbus_reg) != 0) {
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
printf("%s: cannot map registers\n", self->dv_xname);
return;
}
}
sbc->sbus_node = sa->sa_node;
getprop* -> PROM_getprop*
2001-09-27 00:53:05 +04:00
freq = PROM_getpropint(sa->sa_node, "clock-frequency", 0);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
if (freq) {
/*
* Convert from HZ to MHz, rounding up.
*/
freq = (freq + 500000)/1000000;
#if 0
printf("%s: %d MHz\n", self->dv_xname, freq);
#endif
}
sbc->sbus_mdvec.dv_clock = freq;
turn on SBUS bursts
1999-01-10 09:22:12 +03:00
/*
fix SBus bursting *correctly* this time
2000-10-22 07:04:50 +04:00
* Now figure out what the proper burst sizes, etc., to use.
* Unfortunately, there is no ddi_dma_burstsizes here which
* walks up the tree finding the limiting burst size node (if
* any).
turn on SBUS bursts
1999-01-10 09:22:12 +03:00
*/
fix SBus bursting *correctly* this time
2000-10-22 07:04:50 +04:00
sbusburst = ((struct sbus_softc *)parent)->sc_burst;
if (sbusburst == 0)
sbusburst = SBUS_BURST_32 - 1;
getprop* -> PROM_getprop*
2001-09-27 00:53:05 +04:00
ispburst = PROM_getpropint(sa->sa_node, "burst-sizes", -1);
fix SBus bursting *correctly* this time
2000-10-22 07:04:50 +04:00
if (ispburst == -1) {
ispburst = sbusburst;
}
ispburst &= sbusburst;
ispburst &= ~(1 << 7);
ispburst &= ~(1 << 6);
sbc->sbus_mdvec.dv_conf1 = 0;
if (ispburst & (1 << 5)) {
sbc->sbus_mdvec.dv_conf1 = BIU_SBUS_CONF1_FIFO_32;
} else if (ispburst & (1 << 4)) {
sbc->sbus_mdvec.dv_conf1 = BIU_SBUS_CONF1_FIFO_16;
} else if (ispburst & (1 << 3)) {
sbc->sbus_mdvec.dv_conf1 =
BIU_SBUS_CONF1_BURST8 | BIU_SBUS_CONF1_FIFO_8;
}
if (sbc->sbus_mdvec.dv_conf1) {
sbc->sbus_mdvec.dv_conf1 |= BIU_BURST_ENABLE;
}
turn on SBUS bursts
1999-01-10 09:22:12 +03:00
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
/*
* Some early versions of the PTI SBus adapter
* would fail in trying to download (via poking)
* FW. We give up on them.
*/
if (strcmp("PTI,ptisp", sa->sa_name) == 0 ||
strcmp("ptisp", sa->sa_name) == 0) {
The trigger for not downloading f/w is now a NULL f/w pointer, not a nonzero f/w length.
2000-01-09 21:55:11 +03:00
sbc->sbus_mdvec.dv_ispfw = NULL;
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
}
isp->isp_mdvec = &sbc->sbus_mdvec;
add bustype tag to softc
1998-09-08 11:36:26 +04:00
isp->isp_bustype = ISP_BT_SBUS;
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
isp->isp_type = ISP_HA_SCSI_UNKNOWN;
isp->isp_param = &sbc->sbus_dev;
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
isp->isp_dmatag = sa->sa_dmatag;
MEMZERO(isp->isp_param, sizeof (sdparam));
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
prototype 1080/1240 support caused register offset rewhack
1999-03-17 09:17:16 +03:00
sbc->sbus_poff[BIU_BLOCK >> _BLK_REG_SHFT] = BIU_REGS_OFF;
sbc->sbus_poff[MBOX_BLOCK >> _BLK_REG_SHFT] = SBUS_MBOX_REGS_OFF;
sbc->sbus_poff[SXP_BLOCK >> _BLK_REG_SHFT] = SBUS_SXP_REGS_OFF;
sbc->sbus_poff[RISC_BLOCK >> _BLK_REG_SHFT] = SBUS_RISC_REGS_OFF;
sbc->sbus_poff[DMA_BLOCK >> _BLK_REG_SHFT] = DMA_REGS_OFF;
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
Implement bootverbose recognition. Move interrupt registry up a bit so we can use interrupting mailbox commands for isp_init. Set default HBA role. Rename request/response dma maps to be more consistent with PCI version. Enable bus_dmamap_sync on request queue- we already do this for response queue- better do it for the request queue as well. Checked to be working against a Sparc10.
2001-02-23 20:28:58 +03:00
/* Establish interrupt channel */
bus_intr_establish(sbc->sbus_bustag, sbc->sbus_pri, IPL_BIO, 0,
isp_sbus_intr, sbc);
sbus_establish(&sbc->sbus_sd, &sbc->sbus_isp.isp_osinfo._dev);
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
/*
* Set up logging levels.
*/
#ifdef ISP_LOGDEFAULT
isp->isp_dblev = ISP_LOGDEFAULT;
#else
Implement bootverbose recognition. Move interrupt registry up a bit so we can use interrupting mailbox commands for isp_init. Set default HBA role. Rename request/response dma maps to be more consistent with PCI version. Enable bus_dmamap_sync on request queue- we already do this for response queue- better do it for the request queue as well. Checked to be working against a Sparc10.
2001-02-23 20:28:58 +03:00
isp->isp_dblev = ISP_LOGWARN|ISP_LOGERR;
if (bootverbose)
isp->isp_dblev |= ISP_LOGCONFIG|ISP_LOGINFO;
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
#ifdef SCSIDEBUG
isp->isp_dblev |= ISP_LOGDEBUG1|ISP_LOGDEBUG2;
#endif
#ifdef DEBUG
Implement bootverbose recognition. Move interrupt registry up a bit so we can use interrupting mailbox commands for isp_init. Set default HBA role. Rename request/response dma maps to be more consistent with PCI version. Enable bus_dmamap_sync on request queue- we already do this for response queue- better do it for the request queue as well. Checked to be working against a Sparc10.
2001-02-23 20:28:58 +03:00
isp->isp_dblev |= ISP_LOGDEBUG0;
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
#endif
#endif
Implement bootverbose recognition. Move interrupt registry up a bit so we can use interrupting mailbox commands for isp_init. Set default HBA role. Rename request/response dma maps to be more consistent with PCI version. Enable bus_dmamap_sync on request queue- we already do this for response queue- better do it for the request queue as well. Checked to be working against a Sparc10.
2001-02-23 20:28:58 +03:00
get back to looking at config flags
1999-12-20 03:49:58 +03:00
isp->isp_confopts = self->dv_cfdata->cf_flags;
Implement bootverbose recognition. Move interrupt registry up a bit so we can use interrupting mailbox commands for isp_init. Set default HBA role. Rename request/response dma maps to be more consistent with PCI version. Enable bus_dmamap_sync on request queue- we already do this for response queue- better do it for the request queue as well. Checked to be working against a Sparc10.
2001-02-23 20:28:58 +03:00
isp->isp_role = ISP_DEFAULT_ROLES;
There is no readily available tool to set NVRAM on isp's on sparc, so ignore it.
2000-01-14 11:43:17 +03:00
/*
* There's no tool on sparc to set NVRAM for ISPs, so ignore it.
*/
isp->isp_confopts |= ISP_CFG_NONVRAM;
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
ISP_LOCK(isp);
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
isp->isp_osinfo.no_mbox_ints = 1;
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
isp_reset(isp);
if (isp->isp_state != ISP_RESETSTATE) {
ISP_UNLOCK(isp);
return;
}
Implement bootverbose recognition. Move interrupt registry up a bit so we can use interrupting mailbox commands for isp_init. Set default HBA role. Rename request/response dma maps to be more consistent with PCI version. Enable bus_dmamap_sync on request queue- we already do this for response queue- better do it for the request queue as well. Checked to be working against a Sparc10.
2001-02-23 20:28:58 +03:00
ENABLE_INTS(isp);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
isp_init(isp);
if (isp->isp_state != ISP_INITSTATE) {
isp_uninit(isp);
ISP_UNLOCK(isp);
return;
}
fix SBus bursting *correctly* this time
2000-10-22 07:04:50 +04:00
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
/*
* do generic attach.
*/
Implement bootverbose recognition. Move interrupt registry up a bit so we can use interrupting mailbox commands for isp_init. Set default HBA role. Rename request/response dma maps to be more consistent with PCI version. Enable bus_dmamap_sync on request queue- we already do this for response queue- better do it for the request queue as well. Checked to be working against a Sparc10.
2001-02-23 20:28:58 +03:00
ISP_UNLOCK(isp);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
isp_attach(isp);
if (isp->isp_state != ISP_RUNSTATE) {
Implement bootverbose recognition. Move interrupt registry up a bit so we can use interrupting mailbox commands for isp_init. Set default HBA role. Rename request/response dma maps to be more consistent with PCI version. Enable bus_dmamap_sync on request queue- we already do this for response queue- better do it for the request queue as well. Checked to be working against a Sparc10.
2001-02-23 20:28:58 +03:00
ISP_LOCK(isp);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
isp_uninit(isp);
Implement bootverbose recognition. Move interrupt registry up a bit so we can use interrupting mailbox commands for isp_init. Set default HBA role. Rename request/response dma maps to be more consistent with PCI version. Enable bus_dmamap_sync on request queue- we already do this for response queue- better do it for the request queue as well. Checked to be working against a Sparc10.
2001-02-23 20:28:58 +03:00
ISP_UNLOCK(isp);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
}
}
Implement F/W crashdumps for 2200 && 2300 cards (kernel compile option). Distinguish between 2312 and 2300 cards (they *are* different). Enable RIO (Reduced Interrupt Operation) for the LVD cards (hey- I've seen batched completions of the 30 commands at a time with this,....)... If we get a Port Logout on local loop topologies, we have to force the f/w to log back in. The easiest way (for us) to do this is to force a LIP. This also will wake up the disk that probably just had a f/w crash. Implement mailbox 'continuations'- this allows interrupts to re-drive a mailbox command if it's one that just essentially repeats the previous mailbox command (e.g., f/w download). This saves a boatload of sleep/wakeup twitches. If we're not a 2300 and we're about to return with a 'bogus interrupt'- check the semaphore register to be non-zero at all and outgoing mailbox 0- this seems to be where some of the lost ISP1080 commands came from.
2002-02-22 01:32:40 +03:00
static void
isp_sbus_reset1(struct ispsoftc *isp)
{
if (isp->isp_osinfo.no_mbox_ints == 0) {
ENABLE_INTS(isp);
}
}
Add a maintenance note. Add a bus specific isp_sbus_intr function- this is so we, ahem, note we're on an interrupt stack so we don't try and sleep on any mailbox commands we might want to run.
2000-08-14 11:00:08 +04:00
static int
ansify code
2001-03-14 09:58:25 +03:00
isp_sbus_intr(void *arg)
Add a maintenance note. Add a bus specific isp_sbus_intr function- this is so we, ahem, note we're on an interrupt stack so we don't try and sleep on any mailbox commands we might want to run.
2000-08-14 11:00:08 +04:00
{
Add support for 2 Gigabit cards (2300/2312). This necessitated a change in how interrupts are down- the 23XX has not only a different place to check for an interrupt, but unlike all other QLogic cards, you have to read the status as a 32 bit word- not 16 bit words. Rather than have device specific functions as called from the core module (in isp_intr), it makes more sense to have the platform/bus modules do the gruntwork of splitting out the isr, semaphore register and the first outgoing mailbox register (if needed) *prior* to calling isp_intr (if calling isp_intr is necessary at all).
2001-09-01 11:12:23 +04:00
u_int16_t isr, sema, mbox;
struct ispsoftc *isp = arg;
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
if (ISP_READ_ISR(isp, &isr, &sema, &mbox) == 0) {
isp->isp_intbogus++;
return (0);
} else {
struct isp_sbussoftc *sbc = arg;
Add support for 2 Gigabit cards (2300/2312). This necessitated a change in how interrupts are down- the 23XX has not only a different place to check for an interrupt, but unlike all other QLogic cards, you have to read the status as a 32 bit word- not 16 bit words. Rather than have device specific functions as called from the core module (in isp_intr), it makes more sense to have the platform/bus modules do the gruntwork of splitting out the isr, semaphore register and the first outgoing mailbox register (if needed) *prior* to calling isp_intr (if calling isp_intr is necessary at all).
2001-09-01 11:12:23 +04:00
sbc->sbus_isp.isp_osinfo.onintstack = 1;
isp_intr(isp, isr, sema, mbox);
sbc->sbus_isp.isp_osinfo.onintstack = 0;
return (1);
}
}
#define IspVirt2Off(a, x) \
(((struct isp_sbussoftc *)a)->sbus_poff[((x) & _BLK_REG_MASK) >> \
_BLK_REG_SHFT] + ((x) & 0xff))
#define BXR2(sbc, off) \
bus_space_read_2(sbc->sbus_bustag, sbc->sbus_reg, off)
static int
isp_sbus_rd_isr(struct ispsoftc *isp, u_int16_t *isrp,
u_int16_t *semap, u_int16_t *mbp)
{
struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
u_int16_t isr, sema;
isr = BXR2(sbc, IspVirt2Off(isp, BIU_ISR));
sema = BXR2(sbc, IspVirt2Off(isp, BIU_SEMA));
isp_prt(isp, ISP_LOGDEBUG3, "ISR 0x%x SEMA 0x%x", isr, sema);
isr &= INT_PENDING_MASK(isp);
sema &= BIU_SEMA_LOCK;
if (isr == 0 && sema == 0) {
return (0);
}
*isrp = isr;
if ((*semap = sema) != 0) {
*mbp = BXR2(sbc, IspVirt2Off(isp, OUTMAILBOX0));
}
return (1);
Add a maintenance note. Add a bus specific isp_sbus_intr function- this is so we, ahem, note we're on an interrupt stack so we don't try and sleep on any mailbox commands we might want to run.
2000-08-14 11:00:08 +04:00
}
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
static u_int16_t
ansify code
2001-03-14 09:58:25 +03:00
isp_sbus_rd_reg(struct ispsoftc *isp, int regoff)
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
{
struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
prototype 1080/1240 support caused register offset rewhack
1999-03-17 09:17:16 +03:00
int offset = sbc->sbus_poff[(regoff & _BLK_REG_MASK) >> _BLK_REG_SHFT];
offset += (regoff & 0xff);
roll internal release tag and finally use bus_space I/O
1999-01-30 10:10:38 +03:00
return (bus_space_read_2(sbc->sbus_bustag, sbc->sbus_reg, offset));
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
}
static void
ansify code
2001-03-14 09:58:25 +03:00
isp_sbus_wr_reg(struct ispsoftc *isp, int regoff, u_int16_t val)
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
{
struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
prototype 1080/1240 support caused register offset rewhack
1999-03-17 09:17:16 +03:00
int offset = sbc->sbus_poff[(regoff & _BLK_REG_MASK) >> _BLK_REG_SHFT];
offset += (regoff & 0xff);
roll internal release tag and finally use bus_space I/O
1999-01-30 10:10:38 +03:00
bus_space_write_2(sbc->sbus_bustag, sbc->sbus_reg, offset, val);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
}
static int
ansify code
2001-03-14 09:58:25 +03:00
isp_sbus_mbxdma(struct ispsoftc *isp)
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
{
struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
bus_dma_segment_t reqseg, rspseg;
int reqrs, rsprs, i, progress;
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
size_t n;
Fix bus_size_t/size_t/int confusion.
1999-05-27 18:22:28 +04:00
bus_size_t len;
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
if (isp->isp_rquest_dma)
return (0);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
twiddle isp_xflist calculation to match more closes isp_pci.c
2001-07-06 20:09:38 +04:00
n = isp->isp_maxcmds * sizeof (XS_T *);
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
isp->isp_xflist = (XS_T **) malloc(n, M_DEVBUF, M_WAITOK);
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
if (isp->isp_xflist == NULL) {
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
isp_prt(isp, ISP_LOGERR, "cannot alloc xflist array");
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
return (1);
}
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
MEMZERO(isp->isp_xflist, n);
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
n = sizeof (bus_dmamap_t) * isp->isp_maxcmds;
sbc->sbus_dmamap = (bus_dmamap_t *) malloc(n, M_DEVBUF, M_WAITOK);
if (sbc->sbus_dmamap == NULL) {
free(isp->isp_xflist, M_DEVBUF);
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
isp->isp_xflist = NULL;
isp_prt(isp, ISP_LOGERR, "cannot alloc dmamap array");
return (1);
}
for (i = 0; i < isp->isp_maxcmds; i++) {
/* Allocate a DMA handle */
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
if (bus_dmamap_create(isp->isp_dmatag, MAXPHYS, 1, MAXPHYS, 0,
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
BUS_DMA_NOWAIT, &sbc->sbus_dmamap[i]) != 0) {
isp_prt(isp, ISP_LOGERR, "cmd DMA maps create error");
break;
}
}
if (i < isp->isp_maxcmds) {
while (--i >= 0) {
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamap_destroy(isp->isp_dmatag,
sbc->sbus_dmamap[i]);
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
}
free(isp->isp_xflist, M_DEVBUF);
free(sbc->sbus_dmamap, M_DEVBUF);
isp->isp_xflist = NULL;
sbc->sbus_dmamap = NULL;
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
return (1);
}
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
/*
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
* Allocate and map the request and response queues
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
*/
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
progress = 0;
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
len = ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp));
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
if (bus_dmamem_alloc(isp->isp_dmatag, len, 0, 0, &reqseg, 1, &reqrs,
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
BUS_DMA_NOWAIT)) {
Conform bus_dmamem_{alloc,map} usage to bus_dma(9) specs.
2000-05-10 03:16:19 +04:00
goto dmafail;
}
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
progress++;
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
if (bus_dmamem_map(isp->isp_dmatag, &reqseg, reqrs, len,
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
(caddr_t *)&isp->isp_rquest, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
Conform bus_dmamem_{alloc,map} usage to bus_dma(9) specs.
2000-05-10 03:16:19 +04:00
goto dmafail;
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
}
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
progress++;
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
if (bus_dmamap_create(isp->isp_dmatag, len, 1, len, 0, BUS_DMA_NOWAIT,
&isp->isp_rqdmap) != 0) {
Use bus_dmamap_load(), not bus_dmamap_load_raw(), and add BUS_DMA_STREAMING to data transfer map loads.
2001-03-08 05:21:44 +03:00
goto dmafail;
}
progress++;
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
if (bus_dmamap_load(isp->isp_dmatag, isp->isp_rqdmap,
Clean up bus dma code for request/response queues.
2001-04-13 01:40:56 +04:00
isp->isp_rquest, len, NULL, BUS_DMA_NOWAIT) != 0) {
Conform bus_dmamem_{alloc,map} usage to bus_dma(9) specs.
2000-05-10 03:16:19 +04:00
goto dmafail;
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
}
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
progress++;
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
isp->isp_rquest_dma = isp->isp_rqdmap->dm_segs[0].ds_addr;
Clean up bus dma code for request/response queues.
2001-04-13 01:40:56 +04:00
len = ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp));
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
if (bus_dmamem_alloc(isp->isp_dmatag, len, 0, 0, &rspseg, 1, &rsprs,
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
BUS_DMA_NOWAIT)) {
Conform bus_dmamem_{alloc,map} usage to bus_dma(9) specs.
2000-05-10 03:16:19 +04:00
goto dmafail;
}
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
progress++;
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
if (bus_dmamem_map(isp->isp_dmatag, &rspseg, rsprs, len,
Use bus_dmamap_load(), not bus_dmamap_load_raw(), and add BUS_DMA_STREAMING to data transfer map loads.
2001-03-08 05:21:44 +03:00
(caddr_t *)&isp->isp_result, BUS_DMA_NOWAIT|BUS_DMA_COHERENT)) {
Conform bus_dmamem_{alloc,map} usage to bus_dma(9) specs.
2000-05-10 03:16:19 +04:00
goto dmafail;
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
}
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
progress++;
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
if (bus_dmamap_create(isp->isp_dmatag, len, 1, len, 0, BUS_DMA_NOWAIT,
&isp->isp_rsdmap) != 0) {
Conform bus_dmamem_{alloc,map} usage to bus_dma(9) specs.
2000-05-10 03:16:19 +04:00
goto dmafail;
}
Use bus_dmamap_load(), not bus_dmamap_load_raw(), and add BUS_DMA_STREAMING to data transfer map loads.
2001-03-08 05:21:44 +03:00
progress++;
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
if (bus_dmamap_load(isp->isp_dmatag, isp->isp_rsdmap,
Clean up bus dma code for request/response queues.
2001-04-13 01:40:56 +04:00
isp->isp_result, len, NULL, BUS_DMA_NOWAIT) != 0) {
goto dmafail;
}
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
isp->isp_result_dma = isp->isp_rsdmap->dm_segs[0].ds_addr;
Clean up bus dma code for request/response queues.
2001-04-13 01:40:56 +04:00
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
return (0);
Conform bus_dmamem_{alloc,map} usage to bus_dma(9) specs.
2000-05-10 03:16:19 +04:00
dmafail:
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
isp_prt(isp, ISP_LOGERR, "Mailbox DMA Setup Failure");
if (progress >= 8) {
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamap_unload(isp->isp_dmatag, isp->isp_rsdmap);
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
}
if (progress >= 7) {
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamap_destroy(isp->isp_dmatag, isp->isp_rsdmap);
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
}
if (progress >= 6) {
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamem_unmap(isp->isp_dmatag,
Clean up bus dma code for request/response queues.
2001-04-13 01:40:56 +04:00
isp->isp_result, ISP_QUEUE_SIZE(RESULT_QUEUE_LEN(isp)));
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
}
if (progress >= 5) {
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamem_free(isp->isp_dmatag, &rspseg, rsprs);
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
}
if (progress >= 4) {
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamap_unload(isp->isp_dmatag, isp->isp_rqdmap);
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
}
if (progress >= 3) {
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamap_destroy(isp->isp_dmatag, isp->isp_rqdmap);
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
}
if (progress >= 2) {
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamem_unmap(isp->isp_dmatag,
Clean up bus dma code for request/response queues.
2001-04-13 01:40:56 +04:00
isp->isp_rquest, ISP_QUEUE_SIZE(RQUEST_QUEUE_LEN(isp)));
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
}
if (progress >= 1) {
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamem_free(isp->isp_dmatag, &reqseg, reqrs);
Oh, god, make the pain stop. "Fix" this one more time- but for the next to last time. It turns out that in fact, sparc64 was *not* working. There is a discussion within the tech-kern@netbsd.org mail list as of just prior to this date that contains the details. Suffice to say that for sparc64 we have to add back in the usage of BUS_DMA_COHERENT again to the call to bus_dmamap_load_raw. PK added the usage of bus_dmamap_load_raw- which agrees with the man page description of it- but now does not match what the original BusDma author seems to think it's supposed to do. While we're at it, do a specific set of steps for setting up and, if necessary, tearing down, mailbox dma mappings.
2001-02-28 08:46:46 +03:00
}
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
for (i = 0; i < isp->isp_maxcmds; i++) {
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamap_destroy(isp->isp_dmatag, sbc->sbus_dmamap[i]);
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
}
Conform bus_dmamem_{alloc,map} usage to bus_dma(9) specs.
2000-05-10 03:16:19 +04:00
free(sbc->sbus_dmamap, M_DEVBUF);
free(isp->isp_xflist, M_DEVBUF);
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
isp->isp_xflist = NULL;
sbc->sbus_dmamap = NULL;
Conform bus_dmamem_{alloc,map} usage to bus_dma(9) specs.
2000-05-10 03:16:19 +04:00
return (1);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
}
/*
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
* Map a DMA request.
* We're guaranteed that rq->req_handle is a value from 1 to isp->isp_maxcmds.
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
*/
static int
ansify code
2001-03-14 09:58:25 +03:00
isp_sbus_dmasetup(struct ispsoftc *isp, XS_T *xs, ispreq_t *rq,
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
u_int16_t *nxtip, u_int16_t optr)
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
{
struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
Use new isp_handle_index inline function. Change order in whch some things are done. Remember to enable interrupts after calling isp_reset but before isp_attach.
2000-07-06 02:10:56 +04:00
bus_dmamap_t dmap;
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
ispreq_t *qep;
Pointy hat to me on the last delta.
2002-05-18 04:48:11 +04:00
int error, cansleep = (xs->xs_control & XS_CTL_NOSLEEP) == 0;
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
int in = (xs->xs_control & XS_CTL_DATA_IN) != 0;
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
qep = (ispreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, isp->isp_reqidx);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
if (xs->datalen == 0) {
rq->req_seg_count = 1;
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
goto mbxsync;
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
}
Use new isp_handle_index inline function. Change order in whch some things are done. Remember to enable interrupts after calling isp_reset but before isp_attach.
2000-07-06 02:10:56 +04:00
dmap = sbc->sbus_dmamap[isp_handle_index(rq->req_handle)];
if (dmap->dm_nsegs != 0) {
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
panic("%s: dma map already allocated\n", isp->isp_name);
/* NOTREACHED */
}
Pointy hat to me on the last delta.
2002-05-18 04:48:11 +04:00
error = bus_dmamap_load(isp->isp_dmatag, dmap, xs->data, xs->datalen,
Use bus_dmamap_load(), not bus_dmamap_load_raw(), and add BUS_DMA_STREAMING to data transfer map loads.
2001-03-08 05:21:44 +03:00
NULL, (cansleep ? BUS_DMA_WAITOK : BUS_DMA_NOWAIT) |
Pointy hat to me on the last delta.
2002-05-18 04:48:11 +04:00
BUS_DMA_STREAMING);
if (error != 0) {
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
XS_SETERR(xs, HBA_BOTCH);
Replicate change that Matt Thomas made in isp_pci- if we get ENOMEM/EAGAIN in bus_dmamap_load, return CMD_EAGAIN rather than just make the command dead.
2002-05-17 23:06:24 +04:00
if (error == EAGAIN || error == ENOMEM)
return (CMD_EAGAIN);
else
return (CMD_COMPLETE);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
}
Use new isp_handle_index inline function. Change order in whch some things are done. Remember to enable interrupts after calling isp_reset but before isp_attach.
2000-07-06 02:10:56 +04:00
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamap_sync(isp->isp_dmatag, dmap, 0, xs->datalen,
Now that the underlying code for bus_dmamap_sync appears to do the right thing, don't use the illegal and "just worked by chance" addition of BUS_DMA_COHERENT to bus_dmamap_load_raw. There still is a necessity to add to the architecture to allow one to hint that this should be a cache coherent mapping. Fix offset argument to be zero for flushing data tranfers. Kudos to Izumi for spotting this.
2001-02-25 02:30:01 +03:00
in? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
Use new isp_handle_index inline function. Change order in whch some things are done. Remember to enable interrupts after calling isp_reset but before isp_attach.
2000-07-06 02:10:56 +04:00
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
if (in) {
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
rq->req_flags |= REQFLAG_DATA_IN;
} else {
rq->req_flags |= REQFLAG_DATA_OUT;
}
Handle > 12 byte CDBs.
2000-02-19 04:55:42 +03:00
Use new isp_handle_index inline function. Change order in whch some things are done. Remember to enable interrupts after calling isp_reset but before isp_attach.
2000-07-06 02:10:56 +04:00
if (XS_CDBLEN(xs) > 12) {
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
u_int16_t onxti;
ispcontreq_t local, *crq = &local, *cqe;
onxti = *nxtip;
cqe = (ispcontreq_t *) ISP_QUEUE_ENTRY(isp->isp_rquest, onxti);
*nxtip = ISP_NXT_QENTRY(onxti, RQUEST_QUEUE_LEN(isp));
if (*nxtip == optr) {
Core version 2.0 (platform version 1.0) rewrite of ISP driver. Some interace cleanups, some new common functions. The major impact that will be noticeable right away is that if you boot with not Fibre connected to the FC cards, you no longer hang indefinitely.
2000-08-02 03:55:09 +04:00
isp_prt(isp, ISP_LOGDEBUG0, "Request Queue Overflow++");
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamap_unload(isp->isp_dmatag, dmap);
Use new isp_handle_index inline function. Change order in whch some things are done. Remember to enable interrupts after calling isp_reset but before isp_attach.
2000-07-06 02:10:56 +04:00
XS_SETERR(xs, HBA_BOTCH);
return (CMD_EAGAIN);
}
Handle > 12 byte CDBs.
2000-02-19 04:55:42 +03:00
rq->req_seg_count = 2;
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
MEMZERO((void *)crq, sizeof (*crq));
Handle > 12 byte CDBs.
2000-02-19 04:55:42 +03:00
crq->req_header.rqs_entry_count = 1;
crq->req_header.rqs_entry_type = RQSTYPE_DATASEG;
crq->req_dataseg[0].ds_count = xs->datalen;
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
crq->req_dataseg[0].ds_base = dmap->dm_segs[0].ds_addr;
isp_put_cont_req(isp, crq, cqe);
MEMORYBARRIER(isp, SYNC_REQUEST, onxti, QENTRY_LEN);
Handle > 12 byte CDBs.
2000-02-19 04:55:42 +03:00
} else {
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
rq->req_seg_count = 1;
Handle > 12 byte CDBs.
2000-02-19 04:55:42 +03:00
rq->req_dataseg[0].ds_count = xs->datalen;
Use new isp_handle_index inline function. Change order in whch some things are done. Remember to enable interrupts after calling isp_reset but before isp_attach.
2000-07-06 02:10:56 +04:00
rq->req_dataseg[0].ds_base = dmap->dm_segs[0].ds_addr;
Handle > 12 byte CDBs.
2000-02-19 04:55:42 +03:00
}
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
mbxsync:
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
if (XS_CDBLEN(xs) > 12) {
isp_put_extended_request(isp,
(ispextreq_t *)rq, (ispextreq_t *) qep);
} else {
isp_put_request(isp, rq, qep);
}
Make changes as required for new return values from dma setup routine for isp. Unable to test in running kernel because they're not buildable today, but should be okay.
1998-09-18 04:26:11 +04:00
return (CMD_QUEUED);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
}
static void
ansify code
2001-03-14 09:58:25 +03:00
isp_sbus_dmateardown(struct ispsoftc *isp, XS_T *xs, u_int16_t handle)
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
{
struct isp_sbussoftc *sbc = (struct isp_sbussoftc *) isp;
Use new isp_handle_index inline function. Change order in whch some things are done. Remember to enable interrupts after calling isp_reset but before isp_attach.
2000-07-06 02:10:56 +04:00
bus_dmamap_t dmap;
dmap = sbc->sbus_dmamap[isp_handle_index(handle)];
if (dmap->dm_nsegs == 0) {
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
panic("%s: dma map not already allocated\n", isp->isp_name);
/* NOTREACHED */
}
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamap_sync(isp->isp_dmatag, dmap, 0,
We alloc xflist and dma maps in mailbox setup. We swizzle endian stuff at the end of dma setup.
1999-10-14 06:16:04 +04:00
xs->datalen, (xs->xs_control & XS_CTL_DATA_IN)?
BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
Major restructuring for swizzling to the request queue and unswizzling from the response queue. Instead of the ad hoc ISP_SWIZZLE_REQUEST, we now have a complete set of inline functions in isp_inline.h. Each platform is responsible for providing just one of a set of ISP_IOX_{GET,PUT}{8,16,32} macros. The reason this needs to be done is that we need to have a single set of functions that will work correctly on multiple architectures for both little and big endian machines. It also needs to work correctly in the case that we have the request or response queues in memory that has to be treated specially (e.g., have ddi_dma_sync called on it for Solaris after we update it or before we read from it). One thing that falls out of this is that we no longer build requests in the request queue itself. Instead, we build the request locally (e.g., on the stack) and then as part of the swizzling operation, copy it to the request queue entry we've allocated. I thought long and hard about whether this was too expensive a change to make as it in a lot of cases requires an extra copy. On balance, the flexbility is worth it. With any luck, the entry that we build locally stays in a processor writeback cache (after all, it's only 64 bytes) so that the cost of actually flushing it to the memory area that is the shared queue with the PCI device is not all that expensive. We may examine this again and try to get clever in the future to try and avoid copies. Another change that falls out of this is that MEMORYBARRIER should be taken a lot more seriously. The macro ISP_ADD_REQUEST does a MEMORYBARRIER on the entry being added. But there had been many other places this had been missing. It's now very important that it be done. For NetBSD, it does a ddi_dmamap_sync as appropriate. This gets us out of the explicit ddi_dmamap_sync on the whole response queue that we did for SBus cards at each interrupt. Set things up so that platforms that cannot have an SBus don't get a lot of the SBus code checks (dead coded out). Additional changes: Fix a longstanding buglet of sorts. When we get an entry via isp_getrqentry, the iptr value that gets returned is the value we intend to eventually plug into the ISP registers as the entry *one past* the last one we've written- *not* the current entry we're updating. All along we've been calling sync functions on the wrong index value. Argh. The 'fix' here is to rename all 'iptr' variables as 'nxti' to remember that this is the 'next' pointer- not the current pointer. Devote a single bit to mboxbsy- and set aside bits for output mbox registers that we need to pick up- we can have at least one command which does not have any defined output registers (MBOX_EXECUTE_FIRMWARE). Explicitly decode GetAllNext SNS Response back *as* a GetAllNext response. Otherwise, we won't unswizzle it correctly. Nuke some additional __P macros.
2001-12-14 03:13:44 +03:00
bus_dmamap_unload(isp->isp_dmatag, dmap);
move isp_sbus attachment into /sys/dev/sbus.
1998-08-27 15:30:45 +04:00
}