d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
90a5520170
freebsd-nq/sys/dev/isp/isp_target.c

1199 lines
33 KiB
C
Raw Normal View History

These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
/* $FreeBSD$ */
/*
* Machine and OS Independent Target Mode Code for the Qlogic SCSI/FC adapters.
*
Switch to using 16 bit handles instead of 32 bit handles. This is a pretty invasive change, but there are three good reasons to do this: 1. We'll never have > 16 bits of handle. 2. We can (eventually) enable the RIO (Reduced Interrupt Operation) bits which return multiple completing 16 bit handles in mailbox registers. 3. The !)$*)$*~)@$*~)$* Qlogic target mode for parallel SCSI spec changed such that at_reserved (which was 32 bits) was split into two pieces- and one of which was a 16 bit handle id that functions like the at_rxid for Fibre Channel (a tag for the f/w to correlate CTIOs with a particular command). Since we had to muck with that and this changed the whole handler architecture, we might as well... Propagate new at_handle on through int ct_fwhandle. Follow implications of changing to 16 bit handles. These above changes at least get Qlogic 1040 cards working in target mode again. 1080/12160 cards don't work yet. In isp.c: Prepare for doing all loop management in outer layers.
2001-03-02 06:28:55 +00:00
* Copyright (c) 1999, 2000, 2001 by Matthew Jacob
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
* All rights reserved.
* mjacob@feral.com
*
* 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.
some copyright cleanups
2000-09-21 20:16:04 +00:00
* 2. The name of the author may not be used to endorse or promote products
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
* derived from this software without specific prior written permission.
*
* 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.
*/
+ A variety of 23XX changes: disable MWI on 2300 based on function code, set an 'isp_port' for the 2312- it's a separate instance, but the NVRAM is shared, and the second port's NVRAM is at offset 256. + Enable RIO operation for LVD SCSI cards. This makes a *big* difference as even under reasonable load we get batched completions of about 30 commands at a time on, say, an ISP1080. + Do 'continuation' mailbox commands- this allows us to specify a work area within the softc and 'continue' repeated mailbox commands. This is more or less on an ad hoc basis and is currently only used for firmware loading (which f/w now loads substantially faster becuase the calling thread is only woken when all the f/w words are loaded- not for each one of the 40000 f/w words that gets loaded). + If we're about to return from isp_intr with a 'bogus interrupt' indication, and we're not a 23XX card, check to see whether the semaphore register is currently *2* (not *1* as it should be) and whether there's an async completion sitting in outgoing mailbox0. This seems to capture cases of lost fast posting and RIO interrupts that the 12160 && 1080 have been known to pump out under extreme load (extreme, as in > 250 active commands). + FC_SCRATCH_ACQUIRE/FC_SCRATCH_RELEASE macros. + Endian correct swizzle/unswizzle of an ATIO2 that has a WWPN in it. MFC after: 1 week
2002-02-04 21:04:25 +00:00
/*
* Bug fixes gratefully acknowledged from:
* Oded Kedem <oded@kashya.com>
*/
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
/*
* Include header file appropriate for platform we're building on.
*/
#ifdef __NetBSD__
#include <dev/ic/isp_netbsd.h>
#endif
#ifdef __FreeBSD__
#include <dev/isp/isp_freebsd.h>
#endif
#ifdef __OpenBSD__
#include <dev/ic/isp_openbsd.h>
#endif
#ifdef __linux__
#include "isp_linux.h"
#endif
#ifdef ISP_TARGET_MODE
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
static const char atiocope[] =
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
"ATIO returned for lun %d because it was in the middle of Bus Device Reset "
"on bus %d";
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
static const char atior[] =
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
"ATIO returned on for lun %d on from IID %d because a Bus Reset occurred "
"on bus %d";
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
static void isp_got_msg(struct ispsoftc *, int, in_entry_t *);
static void isp_got_msg_fc(struct ispsoftc *, int, in_fcentry_t *);
static void isp_notify_ack(struct ispsoftc *, void *);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
static void isp_handle_atio(struct ispsoftc *, at_entry_t *);
static void isp_handle_atio2(struct ispsoftc *, at2_entry_t *);
static void isp_handle_ctio(struct ispsoftc *, ct_entry_t *);
static void isp_handle_ctio2(struct ispsoftc *, ct2_entry_t *);
/*
* The Qlogic driver gets an interrupt to look at response queue entries.
* Some of these are status completions for initiatior mode commands, but
* if target mode is enabled, we get a whole wad of response queue entries
* to be handled here.
*
* Basically the split into 3 main groups: Lun Enable/Modification responses,
* SCSI Command processing, and Immediate Notification events.
*
* You start by writing a request queue entry to enable target mode (and
* establish some resource limitations which you can modify later).
* The f/w responds with a LUN ENABLE or LUN MODIFY response with
* the status of this action. If the enable was successful, you can expect...
*
* Response queue entries with SCSI commands encapsulate show up in an ATIO
* (Accept Target IO) type- sometimes with enough info to stop the command at
* this level. Ultimately the driver has to feed back to the f/w's request
* queue a sequence of CTIOs (continue target I/O) that describe data to
* be moved and/or status to be sent) and finally finishing with sending
* to the f/w's response queue an ATIO which then completes the handshake
* with the f/w for that command. There's a lot of variations on this theme,
* including flags you can set in the CTIO for the Qlogic 2X00 fibre channel
* cards that 'auto-replenish' the f/w's ATIO count, but this is the basic
* gist of it.
*
* The third group that can show up in the response queue are Immediate
* Notification events. These include things like notifications of SCSI bus
* resets, or Bus Device Reset messages or other messages received. This
Fix typo: wierd -> weird. There is no such thing as wierd in the english language.
2001-02-06 09:25:10 +00:00
* a classic oddbins area. It can get a little weird because you then turn
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
* around and acknowledge the Immediate Notify by writing an entry onto the
* request queue and then the f/w turns around and gives you an acknowledgement
* to *your* acknowledgement on the response queue (the idea being to let
* the f/w tell you when the event is *really* over I guess).
*
*/
/*
* A new response queue entry has arrived. The interrupt service code
* has already swizzled it into the platform dependent from canonical form.
*
* Because of the way this driver is designed, unfortunately most of the
* actual synchronization work has to be done in the platform specific
* code- we have no synchroniation primitives in the common code.
*/
int
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_target_notify(struct ispsoftc *isp, void *vptr, u_int16_t *optrp)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
u_int16_t status, seqid;
union {
at_entry_t *atiop;
at2_entry_t *at2iop;
ct_entry_t *ctiop;
ct2_entry_t *ct2iop;
lun_entry_t *lunenp;
in_entry_t *inotp;
in_fcentry_t *inot_fcp;
na_entry_t *nackp;
na_fcentry_t *nack_fcp;
isphdr_t *hp;
void * *vp;
#define atiop unp.atiop
#define at2iop unp.at2iop
#define ctiop unp.ctiop
#define ct2iop unp.ct2iop
#define lunenp unp.lunenp
#define inotp unp.inotp
#define inot_fcp unp.inot_fcp
#define nackp unp.nackp
#define nack_fcp unp.nack_fcp
#define hdrp unp.hp
} unp;
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
u_int8_t local[QENTRY_LEN];
int bus, type, rval = 0;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00: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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
type = isp_get_response_type(isp, (isphdr_t *)vptr);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
unp.vp = vptr;
ISP_TDQE(isp, "isp_target_notify", (int) *optrp, vptr);
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
switch(type) {
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
case RQSTYPE_ATIO:
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_get_atio(isp, atiop, (at_entry_t *) local);
isp_handle_atio(isp, (at_entry_t *) local);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case RQSTYPE_CTIO:
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_get_ctio(isp, ctiop, (ct_entry_t *) local);
isp_handle_ctio(isp, (ct_entry_t *) local);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case RQSTYPE_ATIO2:
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_get_atio2(isp, at2iop, (at2_entry_t *) local);
isp_handle_atio2(isp, (at2_entry_t *) local);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case RQSTYPE_CTIO2:
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_get_ctio2(isp, ct2iop, (ct2_entry_t *) local);
isp_handle_ctio2(isp, (ct2_entry_t *) local);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case RQSTYPE_ENABLE_LUN:
case RQSTYPE_MODIFY_LUN:
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_get_enable_lun(isp, lunenp, (lun_entry_t *) local);
(void) isp_async(isp, ISPASYNC_TARGET_ACTION, local);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case RQSTYPE_NOTIFY:
/*
* Either the ISP received a SCSI message it can't
* handle, or it's returning an Immed. Notify entry
* we sent. We can send Immed. Notify entries to
* increment the firmware's resource count for them
* (we set this initially in the Enable Lun entry).
*/
Correctly identify which bus of dual bus SCSI adapters some target mode commands (enable/disable/modify lun && immediate notify) we're talking about. Approved: jkh
2000-02-15 00:53:49 +00:00
bus = 0;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
if (IS_FC(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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_get_notify_fc(isp, inot_fcp, (in_fcentry_t *)local);
inot_fcp = (in_fcentry_t *) local;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
status = inot_fcp->in_status;
seqid = inot_fcp->in_seqid;
} 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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_get_notify(isp, inotp, (in_entry_t *)local);
inotp = (in_entry_t *) local;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
status = inotp->in_status & 0xff;
seqid = inotp->in_seqid;
Correctly identify which bus of dual bus SCSI adapters some target mode commands (enable/disable/modify lun && immediate notify) we're talking about. Approved: jkh
2000-02-15 00:53:49 +00:00
if (IS_DUALBUS(isp)) {
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
bus = GET_BUS_VAL(inotp->in_iid);
SET_BUS_VAL(inotp->in_iid, 0);
Correctly identify which bus of dual bus SCSI adapters some target mode commands (enable/disable/modify lun && immediate notify) we're talking about. Approved: jkh
2000-02-15 00:53:49 +00:00
}
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
isp_prt(isp, ISP_LOGTDEBUG0,
"Immediate Notify On Bus %d, status=0x%x seqid=0x%x",
bus, status, seqid);
/*
* ACK it right away.
*/
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_notify_ack(isp, (status == IN_RESET)? NULL : local);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
switch (status) {
case IN_RESET:
(void) isp_async(isp, ISPASYNC_BUS_RESET, &bus);
break;
case IN_MSG_RECEIVED:
case IN_IDE_RECEIVED:
if (IS_FC(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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_got_msg_fc(isp, bus, (in_fcentry_t *)local);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00: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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_got_msg(isp, bus, (in_entry_t *)local);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
break;
case IN_RSRC_UNAVAIL:
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGWARN, "Firmware out of ATIOs");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case IN_ABORT_TASK:
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGWARN,
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
"Abort Task from IID %d RX_ID 0x%x",
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
inot_fcp->in_iid, seqid);
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
(void) isp_async(isp, ISPASYNC_TARGET_ACTION, &bus);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case IN_PORT_LOGOUT:
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGWARN,
"Port Logout for Initiator %d RX_ID 0x%x",
inot_fcp->in_iid, seqid);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case IN_PORT_CHANGED:
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGWARN,
"Port Changed for Initiator %d RX_ID 0x%x",
inot_fcp->in_iid, seqid);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case IN_GLOBAL_LOGO:
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGWARN, "All ports logged out");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
default:
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"bad status (0x%x) in isp_target_notify", status);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
}
break;
case RQSTYPE_NOTIFY_ACK:
/*
* The ISP is acknowledging our acknowledgement of an
* Immediate Notify entry for some asynchronous event.
*/
if (IS_FC(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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_get_notify_ack_fc(isp, nack_fcp,
(na_fcentry_t *)local);
nack_fcp = (na_fcentry_t *)local;
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGTDEBUG1,
"Notify Ack status=0x%x seqid 0x%x",
nack_fcp->na_status, nack_fcp->na_seqid);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00: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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_get_notify_ack(isp, nackp, (na_entry_t *)local);
nackp = (na_entry_t *)local;
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGTDEBUG1,
"Notify Ack event 0x%x status=0x%x seqid 0x%x",
nackp->na_event, nackp->na_status, nackp->na_seqid);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
break;
default:
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
"Unknown entry type 0x%x in isp_target_notify", type);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
rval = -1;
break;
}
#undef atiop
#undef at2iop
#undef ctiop
#undef ct2iop
#undef lunenp
#undef inotp
#undef inot_fcp
#undef nackp
#undef nack_fcp
#undef hdrp
return (rval);
}
/*
* Toggle (on/off) target mode for bus/target/lun
*
* The caller has checked for overlap and legality.
*
* Note that not all of bus, target or lun can be paid attention to.
* Note also that this action will not be complete until the f/w writes
* response entry. The caller is responsible for synchronizing this.
*/
int
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_lun_cmd(struct ispsoftc *isp, int cmd, int bus, int tgt, int lun,
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
int cmd_cnt, int inot_cnt, u_int32_t opaque)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
lun_entry_t el;
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
u_int16_t nxti, optr;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
void *outp;
MEMZERO(&el, sizeof (el));
Correctly identify which bus of dual bus SCSI adapters some target mode commands (enable/disable/modify lun && immediate notify) we're talking about. Approved: jkh
2000-02-15 00:53:49 +00:00
if (IS_DUALBUS(isp)) {
el.le_rsvd = (bus & 0x1) << 7;
}
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
el.le_cmd_count = cmd_cnt;
el.le_in_count = inot_cnt;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
if (cmd == RQSTYPE_ENABLE_LUN) {
if (IS_SCSI(isp)) {
Remove all ISP2100_SCCLUN define based code and replace it with runtime comparisons against the tag isp_maxluns- if > 16, we're SCCLUN based. On initial regular SCSI startup, disable auto-disconnect.
2000-06-18 04:48:28 +00:00
el.le_flags = LUN_TQAE|LUN_DISAD;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
el.le_cdb6len = 12;
el.le_cdb7len = 12;
}
} else if (cmd == -RQSTYPE_ENABLE_LUN) {
cmd = RQSTYPE_ENABLE_LUN;
el.le_cmd_count = 0;
el.le_in_count = 0;
} else if (cmd == -RQSTYPE_MODIFY_LUN) {
cmd = RQSTYPE_MODIFY_LUN;
el.le_ops = LUN_CCDECR | LUN_INDECR;
} else {
el.le_ops = LUN_CCINCR | LUN_ININCR;
}
el.le_header.rqs_entry_type = cmd;
el.le_header.rqs_entry_count = 1;
el.le_reserved = opaque;
if (IS_SCSI(isp)) {
el.le_tgt = tgt;
el.le_lun = lun;
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
} else if ((FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) == 0) {
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
el.le_lun = lun;
}
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
el.le_timeout = 2;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00: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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
if (isp_getrqentry(isp, &nxti, &optr, &outp)) {
isp_prt(isp, ISP_LOGERR,
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
"Request Queue Overflow in isp_lun_cmd");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
return (-1);
}
ISP_TDQE(isp, "isp_lun_cmd", (int) optr, &el);
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_put_enable_lun(isp, &el, outp);
ISP_ADD_REQUEST(isp, nxti);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
return (0);
}
int
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_target_put_entry(struct ispsoftc *isp, void *ap)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
void *outp;
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
u_int16_t nxti, optr;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
u_int8_t etype = ((isphdr_t *) ap)->rqs_entry_type;
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
if (isp_getrqentry(isp, &nxti, &optr, &outp)) {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGWARN,
"Request Queue Overflow in isp_target_put_entry");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
return (-1);
}
switch (etype) {
case RQSTYPE_ATIO:
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_put_atio(isp, (at_entry_t *) ap, (at_entry_t *) outp);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case RQSTYPE_ATIO2:
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_put_atio2(isp, (at2_entry_t *) ap, (at2_entry_t *) outp);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case RQSTYPE_CTIO:
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_put_ctio(isp, (ct_entry_t *) ap, (ct_entry_t *) outp);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case RQSTYPE_CTIO2:
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_put_ctio2(isp, (ct2_entry_t *) ap, (ct2_entry_t *) outp);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
default:
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"Unknown type 0x%x in isp_put_entry", etype);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
return (-1);
}
ISP_TDQE(isp, "isp_target_put_entry", (int) optr, ap);;
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
ISP_ADD_REQUEST(isp, nxti);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
return (0);
}
int
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_target_put_atio(struct ispsoftc *isp, void *arg)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
union {
at_entry_t _atio;
at2_entry_t _atio2;
} atun;
MEMZERO(&atun, sizeof atun);
if (IS_FC(isp)) {
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
at2_entry_t *aep = arg;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
atun._atio2.at_header.rqs_entry_type = RQSTYPE_ATIO2;
atun._atio2.at_header.rqs_entry_count = 1;
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
atun._atio2.at_scclun = (u_int16_t) aep->at_scclun;
Remove all ISP2100_SCCLUN define based code and replace it with runtime comparisons against the tag isp_maxluns- if > 16, we're SCCLUN based. On initial regular SCSI startup, disable auto-disconnect.
2000-06-18 04:48:28 +00:00
} else {
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
atun._atio2.at_lun = (u_int8_t) aep->at_lun;
Remove all ISP2100_SCCLUN define based code and replace it with runtime comparisons against the tag isp_maxluns- if > 16, we're SCCLUN based. On initial regular SCSI startup, disable auto-disconnect.
2000-06-18 04:48:28 +00:00
}
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
atun._atio2.at_status = CT_OK;
} else {
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
at_entry_t *aep = arg;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
atun._atio.at_header.rqs_entry_type = RQSTYPE_ATIO;
atun._atio.at_header.rqs_entry_count = 1;
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
atun._atio.at_handle = aep->at_handle;
atun._atio.at_iid = aep->at_iid;
atun._atio.at_tgt = aep->at_tgt;
atun._atio.at_lun = aep->at_lun;
atun._atio.at_tag_type = aep->at_tag_type;
atun._atio.at_tag_val = aep->at_tag_val;
atun._atio.at_status = (aep->at_flags & AT_TQAE);
atun._atio.at_status |= CT_OK;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
return (isp_target_put_entry(isp, &atun));
}
/*
* Command completion- both for handling cases of no resources or
* no blackhole driver, or other cases where we have to, inline,
* finish the command sanely, or for normal command completion.
*
* The 'completion' code value has the scsi status byte in the low 8 bits.
* If status is a CHECK CONDITION and bit 8 is nonzero, then bits 12..15 have
* the sense key and bits 16..23 have the ASCQ and bits 24..31 have the ASC
* values.
*
* NB: the key, asc, ascq, cannot be used for parallel SCSI as it doesn't
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
* NB: inline SCSI sense reporting. As such, we lose this information. XXX.
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
*
* For both parallel && fibre channel, we use the feature that does
* an automatic resource autoreplenish so we don't have then later do
* put of an atio to replenish the f/w's resource count.
*/
int
Switch to using 16 bit handles instead of 32 bit handles. This is a pretty invasive change, but there are three good reasons to do this: 1. We'll never have > 16 bits of handle. 2. We can (eventually) enable the RIO (Reduced Interrupt Operation) bits which return multiple completing 16 bit handles in mailbox registers. 3. The !)$*)$*~)@$*~)$* Qlogic target mode for parallel SCSI spec changed such that at_reserved (which was 32 bits) was split into two pieces- and one of which was a 16 bit handle id that functions like the at_rxid for Fibre Channel (a tag for the f/w to correlate CTIOs with a particular command). Since we had to muck with that and this changed the whole handler architecture, we might as well... Propagate new at_handle on through int ct_fwhandle. Follow implications of changing to 16 bit handles. These above changes at least get Qlogic 1040 cards working in target mode again. 1080/12160 cards don't work yet. In isp.c: Prepare for doing all loop management in outer layers.
2001-03-02 06:28:55 +00:00
isp_endcmd(struct ispsoftc *isp, void *arg, u_int32_t code, u_int16_t hdl)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
int sts;
union {
ct_entry_t _ctio;
ct2_entry_t _ctio2;
} un;
MEMZERO(&un, sizeof un);
sts = code & 0xff;
if (IS_FC(isp)) {
at2_entry_t *aep = arg;
ct2_entry_t *cto = &un._ctio2;
cto->ct_header.rqs_entry_type = RQSTYPE_CTIO2;
cto->ct_header.rqs_entry_count = 1;
cto->ct_iid = aep->at_iid;
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
if ((FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) == 0) {
Remove all ISP2100_SCCLUN define based code and replace it with runtime comparisons against the tag isp_maxluns- if > 16, we're SCCLUN based. On initial regular SCSI startup, disable auto-disconnect.
2000-06-18 04:48:28 +00:00
cto->ct_lun = aep->at_lun;
}
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
cto->ct_rxid = aep->at_rxid;
cleanup- it was not MI code as it should have been
2000-01-15 01:49:09 +00:00
cto->rsp.m1.ct_scsi_status = sts & 0xff;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
cto->ct_flags = CT2_SENDSTATUS | CT2_NO_DATA | CT2_FLAG_MODE1;
if (hdl == 0) {
cto->ct_flags |= CT2_CCINCR;
}
if (aep->at_datalen) {
cto->ct_resid = aep->at_datalen;
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
cto->rsp.m1.ct_scsi_status |= CT2_DATA_UNDER;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
cleanup- it was not MI code as it should have been
2000-01-15 01:49:09 +00:00
if ((sts & 0xff) == SCSI_CHECK && (sts & ECMD_SVALID)) {
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
cto->rsp.m1.ct_resp[0] = 0xf0;
cto->rsp.m1.ct_resp[2] = (code >> 12) & 0xf;
cto->rsp.m1.ct_resp[7] = 8;
cto->rsp.m1.ct_resp[12] = (code >> 24) & 0xff;
cto->rsp.m1.ct_resp[13] = (code >> 16) & 0xff;
cto->rsp.m1.ct_senselen = 16;
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
cto->rsp.m1.ct_scsi_status |= CT2_SNSLEN_VALID;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
Clean up usage- ct_reserved is really ct_syshandle now.
2001-03-14 04:14:58 +00:00
cto->ct_syshandle = hdl;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
} else {
at_entry_t *aep = arg;
ct_entry_t *cto = &un._ctio;
cto->ct_header.rqs_entry_type = RQSTYPE_CTIO;
cto->ct_header.rqs_entry_count = 1;
Switch to using 16 bit handles instead of 32 bit handles. This is a pretty invasive change, but there are three good reasons to do this: 1. We'll never have > 16 bits of handle. 2. We can (eventually) enable the RIO (Reduced Interrupt Operation) bits which return multiple completing 16 bit handles in mailbox registers. 3. The !)$*)$*~)@$*~)$* Qlogic target mode for parallel SCSI spec changed such that at_reserved (which was 32 bits) was split into two pieces- and one of which was a 16 bit handle id that functions like the at_rxid for Fibre Channel (a tag for the f/w to correlate CTIOs with a particular command). Since we had to muck with that and this changed the whole handler architecture, we might as well... Propagate new at_handle on through int ct_fwhandle. Follow implications of changing to 16 bit handles. These above changes at least get Qlogic 1040 cards working in target mode again. 1080/12160 cards don't work yet. In isp.c: Prepare for doing all loop management in outer layers.
2001-03-02 06:28:55 +00:00
cto->ct_fwhandle = aep->at_handle;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
cto->ct_iid = aep->at_iid;
cto->ct_tgt = aep->at_tgt;
cto->ct_lun = aep->at_lun;
cto->ct_tag_type = aep->at_tag_type;
cto->ct_tag_val = aep->at_tag_val;
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
if (aep->at_flags & AT_TQAE) {
cto->ct_flags |= CT_TQAE;
}
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
cto->ct_flags = CT_SENDSTATUS | CT_NO_DATA;
if (hdl == 0) {
cto->ct_flags |= CT_CCINCR;
}
cto->ct_scsi_status = sts;
Clean up usage- ct_reserved is really ct_syshandle now.
2001-03-14 04:14:58 +00:00
cto->ct_syshandle = hdl;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
return (isp_target_put_entry(isp, &un));
}
void
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_target_async(struct ispsoftc *isp, int bus, int event)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
tmd_event_t evt;
tmd_msg_t msg;
switch (event) {
/*
* These three we handle here to propagate an effective bus reset
* upstream, but these do not require any immediate notify actions
* so we return when done.
*/
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
case ASYNC_LIP_F8:
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
case ASYNC_LIP_OCCURRED:
case ASYNC_LOOP_UP:
case ASYNC_LOOP_DOWN:
case ASYNC_LOOP_RESET:
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
case ASYNC_PTPMODE:
/*
* These don't require any immediate notify actions. We used
* treat them like SCSI Bus Resets, but that was just plain
* wrong. Let the normal CTIO completion report what occurred.
*/
return;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
case ASYNC_BUS_RESET:
case ASYNC_TIMEOUT_RESET:
if (IS_FC(isp)) {
return; /* we'll be getting an inotify instead */
}
evt.ev_bus = bus;
evt.ev_event = event;
(void) isp_async(isp, ISPASYNC_TARGET_EVENT, &evt);
break;
case ASYNC_DEVICE_RESET:
/*
* Bus Device Reset resets a specific target, so
* we pass this as a synthesized message.
*/
MEMZERO(&msg, sizeof msg);
if (IS_FC(isp)) {
various fixes
2000-08-27 23:38:44 +00:00
msg.nt_iid = FCPARAM(isp)->isp_loopid;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
} else {
various fixes
2000-08-27 23:38:44 +00:00
msg.nt_iid = SDPARAM(isp)->isp_initiator_id;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
msg.nt_bus = bus;
msg.nt_msg[0] = MSG_BUS_DEV_RESET;
(void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg);
break;
default:
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"isp_target_async: unknown event 0x%x", event);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
}
If debugging set, zero out an incoming response entry when we're done reading it (makes checking things easier). Before calling isp_notify_ack make sure we're at RUNSTATE- elsewise we can be responding to LIPs or SCSI bus resets before we've finished some of the wiring.
2000-07-18 07:05:37 +00:00
if (isp->isp_state == ISP_RUNSTATE)
isp_notify_ack(isp, NULL);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
/*
* Process a received message.
* The ISP firmware can handle most messages, there are only
* a few that we need to deal with:
* - abort: clean up the current command
* - abort tag and clear queue
*/
static void
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_got_msg(struct ispsoftc *isp, int bus, in_entry_t *inp)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
u_int8_t status = inp->in_status & ~QLTM_SVALID;
if (status == IN_IDE_RECEIVED || status == IN_MSG_RECEIVED) {
tmd_msg_t msg;
MEMZERO(&msg, sizeof (msg));
msg.nt_bus = bus;
msg.nt_iid = inp->in_iid;
msg.nt_tgt = inp->in_tgt;
msg.nt_lun = inp->in_lun;
msg.nt_tagtype = inp->in_tag_type;
msg.nt_tagval = inp->in_tag_val;
MEMCPY(msg.nt_msg, inp->in_msg, IN_MSGLEN);
(void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg);
} else {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"unknown immediate notify status 0x%x", inp->in_status);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
}
/*
* Synthesize a message from the task management flags in a FCP_CMND_IU.
*/
static void
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_got_msg_fc(struct ispsoftc *isp, int bus, in_fcentry_t *inp)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
int lun;
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
static const char f1[] = "%s from iid %d lun %d seq 0x%x";
static const char f2[] =
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
"unknown %s 0x%x lun %d iid %d task flags 0x%x seq 0x%x\n";
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
lun = inp->in_scclun;
} else {
lun = inp->in_lun;
}
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
if (inp->in_status != IN_MSG_RECEIVED) {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGINFO, f2, "immediate notify status",
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
inp->in_status, lun, inp->in_iid,
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
inp->in_task_flags, inp->in_seqid);
} else {
tmd_msg_t msg;
MEMZERO(&msg, sizeof (msg));
msg.nt_bus = bus;
msg.nt_iid = inp->in_iid;
msg.nt_tagval = inp->in_seqid;
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
msg.nt_lun = lun;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
if (inp->in_task_flags & TASK_FLAGS_ABORT_TASK) {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGINFO, f1, "ABORT TASK",
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
inp->in_iid, msg.nt_lun, inp->in_seqid);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
msg.nt_msg[0] = MSG_ABORT_TAG;
} else if (inp->in_task_flags & TASK_FLAGS_CLEAR_TASK_SET) {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGINFO, f1, "CLEAR TASK SET",
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
inp->in_iid, msg.nt_lun, inp->in_seqid);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
msg.nt_msg[0] = MSG_CLEAR_QUEUE;
} else if (inp->in_task_flags & TASK_FLAGS_TARGET_RESET) {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGINFO, f1, "TARGET RESET",
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
inp->in_iid, msg.nt_lun, inp->in_seqid);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
msg.nt_msg[0] = MSG_BUS_DEV_RESET;
} else if (inp->in_task_flags & TASK_FLAGS_CLEAR_ACA) {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGINFO, f1, "CLEAR ACA",
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
inp->in_iid, msg.nt_lun, inp->in_seqid);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
/* ???? */
msg.nt_msg[0] = MSG_REL_RECOVERY;
} else if (inp->in_task_flags & TASK_FLAGS_TERMINATE_TASK) {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGINFO, f1, "TERMINATE TASK",
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
inp->in_iid, msg.nt_lun, inp->in_seqid);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
msg.nt_msg[0] = MSG_TERM_IO_PROC;
} else {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGWARN, f2, "task flag",
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
inp->in_status, msg.nt_lun, inp->in_iid,
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
inp->in_task_flags, inp->in_seqid);
}
if (msg.nt_msg[0]) {
(void) isp_async(isp, ISPASYNC_TARGET_MESSAGE, &msg);
}
}
}
static void
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_notify_ack(struct ispsoftc *isp, void *arg)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
char storage[QENTRY_LEN];
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
u_int16_t nxti, optr;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
void *outp;
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
if (isp_getrqentry(isp, &nxti, &optr, &outp)) {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGWARN,
"Request Queue Overflow For isp_notify_ack");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
return;
}
cleanup- it was not MI code as it should have been
2000-01-15 01:49:09 +00:00
MEMZERO(storage, QENTRY_LEN);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
if (IS_FC(isp)) {
na_fcentry_t *na = (na_fcentry_t *) storage;
if (arg) {
in_fcentry_t *inp = arg;
cleanup- it was not MI code as it should have been
2000-01-15 01:49:09 +00:00
MEMCPY(storage, arg, sizeof (isphdr_t));
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
na->na_iid = inp->in_iid;
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
Remove all ISP2100_SCCLUN define based code and replace it with runtime comparisons against the tag isp_maxluns- if > 16, we're SCCLUN based. On initial regular SCSI startup, disable auto-disconnect.
2000-06-18 04:48:28 +00:00
na->na_lun = inp->in_scclun;
} else {
na->na_lun = inp->in_lun;
}
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
na->na_task_flags = inp->in_task_flags;
na->na_seqid = inp->in_seqid;
na->na_flags = NAFC_RCOUNT;
+ A variety of 23XX changes: disable MWI on 2300 based on function code, set an 'isp_port' for the 2312- it's a separate instance, but the NVRAM is shared, and the second port's NVRAM is at offset 256. + Enable RIO operation for LVD SCSI cards. This makes a *big* difference as even under reasonable load we get batched completions of about 30 commands at a time on, say, an ISP1080. + Do 'continuation' mailbox commands- this allows us to specify a work area within the softc and 'continue' repeated mailbox commands. This is more or less on an ad hoc basis and is currently only used for firmware loading (which f/w now loads substantially faster becuase the calling thread is only woken when all the f/w words are loaded- not for each one of the 40000 f/w words that gets loaded). + If we're about to return from isp_intr with a 'bogus interrupt' indication, and we're not a 23XX card, check to see whether the semaphore register is currently *2* (not *1* as it should be) and whether there's an async completion sitting in outgoing mailbox0. This seems to capture cases of lost fast posting and RIO interrupts that the 12160 && 1080 have been known to pump out under extreme load (extreme, as in > 250 active commands). + FC_SCRATCH_ACQUIRE/FC_SCRATCH_RELEASE macros. + Endian correct swizzle/unswizzle of an ATIO2 that has a WWPN in it. MFC after: 1 week
2002-02-04 21:04:25 +00:00
na->na_status = inp->in_status;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
if (inp->in_status == IN_RESET) {
na->na_flags |= NAFC_RST_CLRD;
}
} else {
na->na_flags = NAFC_RST_CLRD;
}
Some minor tweaklets.
2000-04-21 02:05:54 +00:00
na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
na->na_header.rqs_entry_count = 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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_put_notify_ack_fc(isp, na, (na_fcentry_t *)outp);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
} else {
na_entry_t *na = (na_entry_t *) storage;
if (arg) {
in_entry_t *inp = arg;
cleanup- it was not MI code as it should have been
2000-01-15 01:49:09 +00:00
MEMCPY(storage, arg, sizeof (isphdr_t));
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
na->na_iid = inp->in_iid;
na->na_lun = inp->in_lun;
na->na_tgt = inp->in_tgt;
na->na_seqid = inp->in_seqid;
if (inp->in_status == IN_RESET) {
Some minor tweaklets.
2000-04-21 02:05:54 +00:00
na->na_event = NA_RST_CLRD;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
} else {
Some minor tweaklets.
2000-04-21 02:05:54 +00:00
na->na_event = NA_RST_CLRD;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
Some minor tweaklets.
2000-04-21 02:05:54 +00:00
na->na_header.rqs_entry_type = RQSTYPE_NOTIFY_ACK;
na->na_header.rqs_entry_count = 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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
isp_put_notify_ack(isp, na, (na_entry_t *)outp);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
ISP_TDQE(isp, "isp_notify_ack", (int) optr, storage);
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
ISP_ADD_REQUEST(isp, nxti);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
static void
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_handle_atio(struct ispsoftc *isp, at_entry_t *aep)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
int lun;
lun = aep->at_lun;
/*
* The firmware status (except for the QLTM_SVALID bit) indicates
* why this ATIO was sent to us.
*
* If QLTM_SVALID is set, the firware has recommended Sense Data.
*
* If the DISCONNECTS DISABLED bit is set in the flags field,
* we're still connected on the SCSI bus - i.e. the initiator
* did not set DiscPriv in the identify message. We don't care
* about this so it's ignored.
*/
switch(aep->at_status & ~QLTM_SVALID) {
case AT_PATH_INVALID:
/*
* ATIO rejected by the firmware due to disabled lun.
*/
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"rejected ATIO for disabled lun %d", lun);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case AT_NOCAP:
/*
* Requested Capability not available
* We sent an ATIO that overflowed the firmware's
* command resource count.
*/
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"rejected ATIO for lun %d because of command count"
" overflow", lun);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case AT_BDR_MSG:
/*
* If we send an ATIO to the firmware to increment
* its command resource count, and the firmware is
* recovering from a Bus Device Reset, it returns
* the ATIO with this status. We set the command
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). It also has to handle the SBus cards (for platforms that have them) which, while on a Big Endian machine, do *not* require *most* of the request/response queue entry fields to be swizzled or unswizzled. 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. 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). MFC after: 2 weeks
2001-12-11 00:18:45 +00:00
* resource count in the Enable Lun entry and do
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
* not increment it. Therefore we should never get
* this status here.
*/
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
isp_prt(isp, ISP_LOGERR, atiocope, lun,
GET_BUS_VAL(aep->at_iid));
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case AT_CDB: /* Got a CDB */
case AT_PHASE_ERROR: /* Bus Phase Sequence Error */
/*
* Punt to platform specific layer.
*/
(void) isp_async(isp, ISPASYNC_TARGET_ACTION, aep);
break;
case AT_RESET:
/*
* A bus reset came along an blew away this command. Why
* they do this in addition the async event code stuff,
* I dunno.
*
* Ignore it because the async event will clear things
* up for us.
*/
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
isp_prt(isp, ISP_LOGWARN, atior, lun,
GET_IID_VAL(aep->at_iid), GET_BUS_VAL(aep->at_iid));
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
default:
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"Unknown ATIO status 0x%x from initiator %d for lun %d",
aep->at_status, aep->at_iid, lun);
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
(void) isp_target_put_atio(isp, aep);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
}
}
static void
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_handle_atio2(struct ispsoftc *isp, at2_entry_t *aep)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
int lun;
Remove all ISP2100_SCCLUN define based code and replace it with runtime comparisons against the tag isp_maxluns- if > 16, we're SCCLUN based. On initial regular SCSI startup, disable auto-disconnect.
2000-06-18 04:48:28 +00:00
Because we now store SCCLUN capabilities in firmware attributes, get rid of the silly test of isp_maxluns > 16 and use the attibutes directly. MFC after: 4 weeks
2001-09-03 03:12:10 +00:00
if (FCPARAM(isp)->isp_fwattr & ISP_FW_ATTR_SCCLUN) {
Remove all ISP2100_SCCLUN define based code and replace it with runtime comparisons against the tag isp_maxluns- if > 16, we're SCCLUN based. On initial regular SCSI startup, disable auto-disconnect.
2000-06-18 04:48:28 +00:00
lun = aep->at_scclun;
} else {
lun = aep->at_lun;
}
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
/*
* The firmware status (except for the QLTM_SVALID bit) indicates
* why this ATIO was sent to us.
*
* If QLTM_SVALID is set, the firware has recommended Sense Data.
*
* If the DISCONNECTS DISABLED bit is set in the flags field,
* we're still connected on the SCSI bus - i.e. the initiator
* did not set DiscPriv in the identify message. We don't care
* about this so it's ignored.
*/
switch(aep->at_status & ~QLTM_SVALID) {
case AT_PATH_INVALID:
/*
* ATIO rejected by the firmware due to disabled lun.
*/
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"rejected ATIO2 for disabled lun %d", lun);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case AT_NOCAP:
/*
* Requested Capability not available
* We sent an ATIO that overflowed the firmware's
* command resource count.
*/
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"rejected ATIO2 for lun %d- command count overflow", lun);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case AT_BDR_MSG:
/*
* If we send an ATIO to the firmware to increment
* its command resource count, and the firmware is
* recovering from a Bus Device Reset, it returns
* the ATIO with this status. We set the command
* resource count in the Enable Lun entry and no
* not increment it. Therefore we should never get
* this status here.
*/
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
isp_prt(isp, ISP_LOGERR, atiocope, lun, 0);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case AT_CDB: /* Got a CDB */
/*
* Punt to platform specific layer.
*/
(void) isp_async(isp, ISPASYNC_TARGET_ACTION, aep);
break;
case AT_RESET:
/*
* A bus reset came along an blew away this command. Why
* they do this in addition the async event code stuff,
* I dunno.
*
* Ignore it because the async event will clear things
* up for us.
*/
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
isp_prt(isp, ISP_LOGERR, atior, lun, aep->at_iid, 0);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
default:
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"Unknown ATIO2 status 0x%x from initiator %d for lun %d",
aep->at_status, aep->at_iid, lun);
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
(void) isp_target_put_atio(isp, aep);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
}
}
static void
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_handle_ctio(struct ispsoftc *isp, ct_entry_t *ct)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
Clean up usage- ct_reserved is really ct_syshandle now.
2001-03-14 04:14:58 +00:00
void *xs;
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
int pl = ISP_LOGTDEBUG2;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
char *fmsg = NULL;
Clean up usage- ct_reserved is really ct_syshandle now.
2001-03-14 04:14:58 +00:00
if (ct->ct_syshandle) {
xs = isp_find_xs(isp, ct->ct_syshandle);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
if (xs == NULL)
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
pl = ISP_LOGALL;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
} else {
xs = NULL;
}
switch(ct->ct_status & ~QLTM_SVALID) {
case CT_OK:
/*
* There are generally 3 possibilities as to why we'd get
* this condition:
* We disconnected after receiving a CDB.
* We sent or received data.
* We sent status & command complete.
*/
Some minor tweaklets.
2000-04-21 02:05:54 +00:00
if (ct->ct_flags & CT_SENDSTATUS) {
break;
} else if ((ct->ct_flags & CT_DATAMASK) == CT_NO_DATA) {
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
/*
* Nothing to do in this case.
*/
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, pl, "CTIO- iid %d disconnected OK",
ct->ct_iid);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
return;
}
break;
case CT_BDR_MSG:
/*
* Bus Device Reset message received or the SCSI Bus has
* been Reset; the firmware has gone to Bus Free.
*
* The firmware generates an async mailbox interupt to
* notify us of this and returns outstanding CTIOs with this
* status. These CTIOs are handled in that same way as
* CT_ABORTED ones, so just fall through here.
*/
fmsg = "Bus Device Reset";
/*FALLTHROUGH*/
case CT_RESET:
if (fmsg == NULL)
fmsg = "Bus Reset";
/*FALLTHROUGH*/
case CT_ABORTED:
/*
* When an Abort message is received the firmware goes to
* Bus Free and returns all outstanding CTIOs with the status
* set, then sends us an Immediate Notify entry.
*/
if (fmsg == NULL)
Note for ATIOs returned because of BDRs or Bus Resets for which bus this applies to. Do more bus # foo things. Acknowledge Immediate Notifies right away prior to throwing events upstream (where they're currently being ignored, *groan*) Capture ASYNC_LIP_F8 as with ASYNC_LIP_OCCURRED. Don't percolate them upstream as if they were BUS RESETS- they're not.
2001-09-04 21:48:02 +00:00
fmsg = "ABORT TAG message sent by Initiator";
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGWARN, "CTIO destroyed by %s", fmsg);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case CT_INVAL:
/*
* CTIO rejected by the firmware due to disabled lun.
* "Cannot Happen".
*/
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"Firmware rejected CTIO for disabled lun %d",
ct->ct_lun);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case CT_NOPATH:
/*
* CTIO rejected by the firmware due "no path for the
* nondisconnecting nexus specified". This means that
* we tried to access the bus while a non-disconnecting
* command is in process.
*/
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"Firmware rejected CTIO for bad nexus %d/%d/%d",
ct->ct_iid, ct->ct_tgt, ct->ct_lun);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case CT_RSELTMO:
fmsg = "Reselection";
/*FALLTHROUGH*/
case CT_TIMEOUT:
if (fmsg == NULL)
fmsg = "Command";
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR, "Firmware timed out on %s", fmsg);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
case CT_PANIC:
if (fmsg == NULL)
fmsg = "Unrecoverable Error";
/*FALLTHROUGH*/
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
case CT_ERR:
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
if (fmsg == NULL)
fmsg = "Completed with Error";
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
/*FALLTHROUGH*/
case CT_PHASE_ERROR:
if (fmsg == NULL)
fmsg = "Phase Sequence Error";
/*FALLTHROUGH*/
case CT_TERMINATED:
if (fmsg == NULL)
fmsg = "terminated by TERMINATE TRANSFER";
/*FALLTHROUGH*/
case CT_NOACK:
if (fmsg == NULL)
fmsg = "unacknowledged Immediate Notify pending";
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR, "CTIO returned by f/w- %s", fmsg);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
default:
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR, "Unknown CTIO status 0x%x",
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
ct->ct_status & ~QLTM_SVALID);
break;
}
if (xs == NULL) {
/*
* There may be more than one CTIO for a data transfer,
* or this may be a status CTIO we're not monitoring.
*
* The assumption is that they'll all be returned in the
* order we got them.
*/
Clean up usage- ct_reserved is really ct_syshandle now.
2001-03-14 04:14:58 +00:00
if (ct->ct_syshandle == 0) {
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
if ((ct->ct_flags & CT_SENDSTATUS) == 0) {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, pl,
"intermediate CTIO completed ok");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
} else {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, pl,
"unmonitored CTIO completed ok");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
} else {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, pl,
"NO xs for CTIO (handle 0x%x) status 0x%x",
Clean up usage- ct_reserved is really ct_syshandle now.
2001-03-14 04:14:58 +00:00
ct->ct_syshandle, ct->ct_status & ~QLTM_SVALID);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
} else {
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
/*
* Final CTIO completed. Release DMA resources and
* notify platform dependent layers.
*/
if ((ct->ct_flags & CT_DATAMASK) != CT_NO_DATA) {
Clean up usage- ct_reserved is really ct_syshandle now.
2001-03-14 04:14:58 +00:00
ISP_DMAFREE(isp, xs, ct->ct_syshandle);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_prt(isp, pl, "final CTIO complete");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
/*
* The platform layer will destroy the handle if appropriate.
*/
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
(void) isp_async(isp, ISPASYNC_TARGET_ACTION, ct);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
}
static void
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_handle_ctio2(struct ispsoftc *isp, ct2_entry_t *ct)
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
{
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
XS_T *xs;
int pl = ISP_LOGTDEBUG2;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
char *fmsg = NULL;
Clean up usage- ct_reserved is really ct_syshandle now.
2001-03-14 04:14:58 +00:00
if (ct->ct_syshandle) {
xs = isp_find_xs(isp, ct->ct_syshandle);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
if (xs == NULL)
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
pl = ISP_LOGALL;
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
} else {
xs = NULL;
}
switch(ct->ct_status & ~QLTM_SVALID) {
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
case CT_BUS_ERROR:
isp_prt(isp, ISP_LOGERR, "PCI DMA Bus Error");
/* FALL Through */
case CT_DATA_OVER:
case CT_DATA_UNDER:
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
case CT_OK:
/*
* There are generally 2 possibilities as to why we'd get
* this condition:
* We sent or received data.
* We sent status & command complete.
*/
break;
case CT_BDR_MSG:
/*
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
* Target Reset function received.
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
*
* The firmware generates an async mailbox interupt to
* notify us of this and returns outstanding CTIOs with this
* status. These CTIOs are handled in that same way as
* CT_ABORTED ones, so just fall through here.
*/
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
fmsg = "TARGET RESET Task Management Function Received";
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
/*FALLTHROUGH*/
case CT_RESET:
if (fmsg == NULL)
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
fmsg = "LIP Reset";
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
/*FALLTHROUGH*/
case CT_ABORTED:
/*
* When an Abort message is received the firmware goes to
* Bus Free and returns all outstanding CTIOs with the status
* set, then sends us an Immediate Notify entry.
*/
if (fmsg == NULL)
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
fmsg = "ABORT Task Management Function Received";
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR, "CTIO2 destroyed by %s", fmsg);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case CT_INVAL:
/*
cleanup- it was not MI code as it should have been
2000-01-15 01:49:09 +00:00
* CTIO rejected by the firmware - invalid data direction.
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
*/
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR, "CTIO2 had wrong data directiond");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case CT_RSELTMO:
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
fmsg = "failure to reconnect to initiator";
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
/*FALLTHROUGH*/
case CT_TIMEOUT:
if (fmsg == NULL)
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
fmsg = "command";
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR, "Firmware timed out on %s", fmsg);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case CT_ERR:
fmsg = "Completed with Error";
/*FALLTHROUGH*/
case CT_LOGOUT:
if (fmsg == NULL)
fmsg = "Port Logout";
/*FALLTHROUGH*/
case CT_PORTNOTAVAIL:
if (fmsg == NULL)
fmsg = "Port not available";
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
case CT_PORTCHANGED:
if (fmsg == NULL)
fmsg = "Port Changed";
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
case CT_NOACK:
if (fmsg == NULL)
fmsg = "unacknowledged Immediate Notify pending";
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR, "CTIO returned by f/w- %s", fmsg);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
case CT_INVRXID:
/*
* CTIO rejected by the firmware because an invalid RX_ID.
* Just print a message.
*/
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, ISP_LOGERR,
"CTIO2 completed with Invalid RX_ID 0x%x", ct->ct_rxid);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
default:
Perform some more Ansification. Remove and then replace the isp_putback_atio function- we did it a bit cleaner. We only use this if a CTIO completes with !CT_OK state. We now have managed to get away without having to poke around and trying to find the original ATIO- the csio we're using has the tag_id and lun values with it which is mostly what we need when we do the putback. Make sure we correctly propagate AT_TQAE->CT_TQAE for tags. Make sure we call ISP_DMAFREE only if we had DATA to move.
2001-04-04 21:49:51 +00:00
isp_prt(isp, ISP_LOGERR, "Unknown CTIO2 status 0x%x",
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
ct->ct_status & ~QLTM_SVALID);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
break;
}
if (xs == NULL) {
/*
* There may be more than one CTIO for a data transfer,
* or this may be a status CTIO we're not monitoring.
*
* The assumption is that they'll all be returned in the
* order we got them.
*/
Clean up usage- ct_reserved is really ct_syshandle now.
2001-03-14 04:14:58 +00:00
if (ct->ct_syshandle == 0) {
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
if ((ct->ct_flags & CT_SENDSTATUS) == 0) {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, pl,
"intermediate CTIO completed ok");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
} else {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, pl,
"unmonitored CTIO completed ok");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
} else {
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, pl,
"NO xs for CTIO (handle 0x%x) status 0x%x",
Clean up usage- ct_reserved is really ct_syshandle now.
2001-03-14 04:14:58 +00:00
ct->ct_syshandle, ct->ct_status & ~QLTM_SVALID);
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
} else {
Spring MegaChange #1. ---- Make a device for each ISP- really usable only with devfs and add an ioctl entry point (this can be used to (re)set debug levels, reset the HBA, rescan the fabric, issue lips, etc). ---- Add in a kernel thread for Fibre Channel cards. The purpose of this thread is to be woken up to clean up after Fibre Channel events block things. Basically, any FC event that casts doubt on the location or identify of FC devices blocks the queues. When, and if, we get the PORT DATABASE CHANGED or NAME SERVER DATABASE CHANGED async event, we activate the kthread which will then, in full thread context, re-evaluate the local loop and/or the fabric. When it's satisfied that things are stable, it can then release the blocked queues and let commands flow again. The prior mechanism was a lazy evaluation. That is, the next command to come down the pipe after change events would pay the full price for re-evaluation. And if this was done off of a softcall, it really could hang up the system. These changes brings the FreeBSD port more in line with the Solaris, Linux and NetBSD ports. It also, more importantly, gets us being more proactive about topology changes which could then be reflected upwards to CAM so that the periph driver can be informed sooner rather than later when things arrive or depart. --- Add in the (correct) usage of locking macros- we now have lock transition macros which allow us to transition from holding the CAM lock (Giant) and grabbing the softc lock and vice versa. Switch over to having this HBA do real locking. Some folks claim this won't be a win. They're right. But you have to start somewhere, and this will begin to teach us how to DTRT for HBAs, etc. -- Start putting in prototype 2300 support. Add back in LIP and Loop Reset as async events that each platform will handle. Add in another int_bogus instrumentation point. Do some more substantial target mode cleanups. MFC after: 8 weeks
2001-05-28 21:20:43 +00:00
if ((ct->ct_flags & CT2_DATAMASK) != CT2_NO_DATA) {
ISP_DMAFREE(isp, xs, ct->ct_syshandle);
}
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
if (ct->ct_flags & CT_SENDSTATUS) {
/*
* Sent status and command complete.
*
* We're now really done with this command, so we
* punt to the platform dependent layers because
* only there can we do the appropriate command
* complete thread synchronization.
*/
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, pl, "status CTIO complete");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
} else {
/*
* Final CTIO completed. Release DMA resources and
* notify platform dependent layers.
*/
Remove isp_tdebug. Change all PRINTF macros to the now common isp_prt logging function.
2000-08-01 06:24:01 +00:00
isp_prt(isp, pl, "data CTIO complete");
These are platform independent functions for target mode support. This is just a first pass at this and is likely to change a bit over the next month.
2000-01-04 00:00:08 +00:00
}
(void) isp_async(isp, ISPASYNC_TARGET_ACTION, ct);
/*
* The platform layer will destroy the handle if appropriate.
*/
}
}
#endif
Reference in New Issue Copy Permalink