diff options
Diffstat (limited to 'sys/dev/asr/asr.c')
| -rw-r--r-- | sys/dev/asr/asr.c | 7958 |
1 files changed, 3979 insertions, 3979 deletions
diff --git a/sys/dev/asr/asr.c b/sys/dev/asr/asr.c index a3c8d1d..16aaabb 100644 --- a/sys/dev/asr/asr.c +++ b/sys/dev/asr/asr.c @@ -22,121 +22,121 @@ * * SCSI I2O host adapter driver * - * V1.08 2001/08/21 Mark_Salyzyn@adaptec.com - * - The 2000S and 2005S do not initialize on some machines, + * V1.08 2001/08/21 Mark_Salyzyn@adaptec.com + * - The 2000S and 2005S do not initialize on some machines, * increased timeout to 255ms from 50ms for the StatusGet * command. - * V1.07 2001/05/22 Mark_Salyzyn@adaptec.com - * - I knew this one was too good to be true. The error return - * on ioctl commands needs to be compared to CAM_REQ_CMP, not - * to the bit masked status. - * V1.06 2001/05/08 Mark_Salyzyn@adaptec.com - * - The 2005S that was supported is affectionately called the - * Conjoined BAR Firmware. In order to support RAID-5 in a - * 16MB low-cost configuration, Firmware was forced to go - * to a Split BAR Firmware. This requires a separate IOP and - * Messaging base address. - * V1.05 2001/04/25 Mark_Salyzyn@adaptec.com - * - Handle support for 2005S Zero Channel RAID solution. - * - System locked up if the Adapter locked up. Do not try - * to send other commands if the resetIOP command fails. The - * fail outstanding command discovery loop was flawed as the - * removal of the command from the list prevented discovering - * all the commands. - * - Comment changes to clarify driver. - * - SysInfo searched for an EATA SmartROM, not an I2O SmartROM. - * - We do not use the AC_FOUND_DEV event because of I2O. - * Removed asr_async. - * V1.04 2000/09/22 Mark_Salyzyn@adaptec.com, msmith@freebsd.org, - * lampa@fee.vutbr.cz and Scott_Long@adaptec.com. - * - Removed support for PM1554, PM2554 and PM2654 in Mode-0 - * mode as this is confused with competitor adapters in run - * mode. - * - critical locking needed in ASR_ccbAdd and ASR_ccbRemove - * to prevent operating system panic. - * - moved default major number to 154 from 97. - * V1.03 2000/07/12 Mark_Salyzyn@adaptec.com - * - The controller is not actually an ASR (Adaptec SCSI RAID) - * series that is visible, it's more of an internal code name. - * remove any visible references within reason for now. - * - bus_ptr->LUN was not correctly zeroed when initially - * allocated causing a possible panic of the operating system - * during boot. - * V1.02 2000/06/26 Mark_Salyzyn@adaptec.com - * - Code always fails for ASR_getTid affecting performance. - * - initiated a set of changes that resulted from a formal - * code inspection by Mark_Salyzyn@adaptec.com, - * George_Dake@adaptec.com, Jeff_Zeak@adaptec.com, - * Martin_Wilson@adaptec.com and Vincent_Trandoan@adaptec.com. - * Their findings were focussed on the LCT & TID handler, and - * all resulting changes were to improve code readability, - * consistency or have a positive effect on performance. - * V1.01 2000/06/14 Mark_Salyzyn@adaptec.com - * - Passthrough returned an incorrect error. - * - Passthrough did not migrate the intrinsic scsi layer wakeup - * on command completion. - * - generate control device nodes using make_dev and delete_dev. - * - Performance affected by TID caching reallocing. - * - Made suggested changes by Justin_Gibbs@adaptec.com - * - use splcam instead of splbio. - * - use cam_imask instead of bio_imask. - * - use u_int8_t instead of u_char. - * - use u_int16_t instead of u_short. - * - use u_int32_t instead of u_long where appropriate. - * - use 64 bit context handler instead of 32 bit. - * - create_ccb should only allocate the worst case - * requirements for the driver since CAM may evolve - * making union ccb much larger than needed here. - * renamed create_ccb to asr_alloc_ccb. - * - go nutz justifying all debug prints as macros - * defined at the top and remove unsightly ifdefs. - * - INLINE STATIC viewed as confusing. Historically - * utilized to affect code performance and debug - * issues in OS, Compiler or OEM specific situations. - * V1.00 2000/05/31 Mark_Salyzyn@adaptec.com - * - Ported from FreeBSD 2.2.X DPT I2O driver. - * changed struct scsi_xfer to union ccb/struct ccb_hdr - * changed variable name xs to ccb - * changed struct scsi_link to struct cam_path - * changed struct scsibus_data to struct cam_sim - * stopped using fordriver for holding on to the TID - * use proprietary packet creation instead of scsi_inquire - * CAM layer sends synchronize commands. + * V1.07 2001/05/22 Mark_Salyzyn@adaptec.com + * - I knew this one was too good to be true. The error return + * on ioctl commands needs to be compared to CAM_REQ_CMP, not + * to the bit masked status. + * V1.06 2001/05/08 Mark_Salyzyn@adaptec.com + * - The 2005S that was supported is affectionately called the + * Conjoined BAR Firmware. In order to support RAID-5 in a + * 16MB low-cost configuration, Firmware was forced to go + * to a Split BAR Firmware. This requires a separate IOP and + * Messaging base address. + * V1.05 2001/04/25 Mark_Salyzyn@adaptec.com + * - Handle support for 2005S Zero Channel RAID solution. + * - System locked up if the Adapter locked up. Do not try + * to send other commands if the resetIOP command fails. The + * fail outstanding command discovery loop was flawed as the + * removal of the command from the list prevented discovering + * all the commands. + * - Comment changes to clarify driver. + * - SysInfo searched for an EATA SmartROM, not an I2O SmartROM. + * - We do not use the AC_FOUND_DEV event because of I2O. + * Removed asr_async. + * V1.04 2000/09/22 Mark_Salyzyn@adaptec.com, msmith@freebsd.org, + * lampa@fee.vutbr.cz and Scott_Long@adaptec.com. + * - Removed support for PM1554, PM2554 and PM2654 in Mode-0 + * mode as this is confused with competitor adapters in run + * mode. + * - critical locking needed in ASR_ccbAdd and ASR_ccbRemove + * to prevent operating system panic. + * - moved default major number to 154 from 97. + * V1.03 2000/07/12 Mark_Salyzyn@adaptec.com + * - The controller is not actually an ASR (Adaptec SCSI RAID) + * series that is visible, it's more of an internal code name. + * remove any visible references within reason for now. + * - bus_ptr->LUN was not correctly zeroed when initially + * allocated causing a possible panic of the operating system + * during boot. + * V1.02 2000/06/26 Mark_Salyzyn@adaptec.com + * - Code always fails for ASR_getTid affecting performance. + * - initiated a set of changes that resulted from a formal + * code inspection by Mark_Salyzyn@adaptec.com, + * George_Dake@adaptec.com, Jeff_Zeak@adaptec.com, + * Martin_Wilson@adaptec.com and Vincent_Trandoan@adaptec.com. + * Their findings were focussed on the LCT & TID handler, and + * all resulting changes were to improve code readability, + * consistency or have a positive effect on performance. + * V1.01 2000/06/14 Mark_Salyzyn@adaptec.com + * - Passthrough returned an incorrect error. + * - Passthrough did not migrate the intrinsic scsi layer wakeup + * on command completion. + * - generate control device nodes using make_dev and delete_dev. + * - Performance affected by TID caching reallocing. + * - Made suggested changes by Justin_Gibbs@adaptec.com + * - use splcam instead of splbio. + * - use cam_imask instead of bio_imask. + * - use u_int8_t instead of u_char. + * - use u_int16_t instead of u_short. + * - use u_int32_t instead of u_long where appropriate. + * - use 64 bit context handler instead of 32 bit. + * - create_ccb should only allocate the worst case + * requirements for the driver since CAM may evolve + * making union ccb much larger than needed here. + * renamed create_ccb to asr_alloc_ccb. + * - go nutz justifying all debug prints as macros + * defined at the top and remove unsightly ifdefs. + * - INLINE STATIC viewed as confusing. Historically + * utilized to affect code performance and debug + * issues in OS, Compiler or OEM specific situations. + * V1.00 2000/05/31 Mark_Salyzyn@adaptec.com + * - Ported from FreeBSD 2.2.X DPT I2O driver. + * changed struct scsi_xfer to union ccb/struct ccb_hdr + * changed variable name xs to ccb + * changed struct scsi_link to struct cam_path + * changed struct scsibus_data to struct cam_sim + * stopped using fordriver for holding on to the TID + * use proprietary packet creation instead of scsi_inquire + * CAM layer sends synchronize commands. * * $FreeBSD$ */ -#define ASR_VERSION 1 -#define ASR_REVISION '0' -#define ASR_SUBREVISION '8' -#define ASR_MONTH 8 -#define ASR_DAY 21 -#define ASR_YEAR 2001 - 1980 +#define ASR_VERSION 1 +#define ASR_REVISION '0' +#define ASR_SUBREVISION '8' +#define ASR_MONTH 8 +#define ASR_DAY 21 +#define ASR_YEAR 2001 - 1980 /* - * Debug macros to reduce the unsightly ifdefs + * Debug macros to reduce the unsightly ifdefs */ #if (defined(DEBUG_ASR) || defined(DEBUG_ASR_USR_CMD) || defined(DEBUG_ASR_CMD)) -# define debug_asr_message(message) \ - { \ - u_int32_t * pointer = (u_int32_t *)message; \ - u_int32_t length = I2O_MESSAGE_FRAME_getMessageSize(message);\ - u_int32_t counter = 0; \ - \ - while (length--) { \ - printf ("%08lx%c", (u_long)*(pointer++), \ - (((++counter & 7) == 0) || (length == 0)) \ - ? '\n' \ - : ' '); \ - } \ - } +# define debug_asr_message(message) \ + { \ + u_int32_t * pointer = (u_int32_t *)message; \ + u_int32_t length = I2O_MESSAGE_FRAME_getMessageSize(message);\ + u_int32_t counter = 0; \ + \ + while (length--) { \ + printf ("%08lx%c", (u_long)*(pointer++), \ + (((++counter & 7) == 0) || (length == 0)) \ + ? '\n' \ + : ' '); \ + } \ + } #endif /* DEBUG_ASR || DEBUG_ASR_USR_CMD || DEBUG_ASR_CMD */ #if (defined(DEBUG_ASR)) /* Breaks on none STDC based compilers :-( */ -# define debug_asr_printf(fmt,args...) printf(fmt, ##args) +# define debug_asr_printf(fmt,args...) printf(fmt, ##args) # define debug_asr_dump_message(message) debug_asr_message(message) -# define debug_asr_print_path(ccb) xpt_print_path(ccb->ccb_h.path); +# define debug_asr_print_path(ccb) xpt_print_path(ccb->ccb_h.path); /* None fatal version of the ASSERT macro */ # if (defined(__STDC__)) # define ASSERT(phrase) if(!(phrase))printf(#phrase " at line %d file %s\n",__LINE__,__FILE__) @@ -151,30 +151,30 @@ #endif /* DEBUG_ASR */ /* - * If DEBUG_ASR_CMD is defined: - * 0 - Display incoming SCSI commands - * 1 - add in a quick character before queueing. - * 2 - add in outgoing message frames. + * If DEBUG_ASR_CMD is defined: + * 0 - Display incoming SCSI commands + * 1 - add in a quick character before queueing. + * 2 - add in outgoing message frames. */ #if (defined(DEBUG_ASR_CMD)) # define debug_asr_cmd_printf(fmt,args...) printf(fmt,##args) -# define debug_asr_dump_ccb(ccb) \ - { \ - u_int8_t * cp = (unsigned char *)&(ccb->csio.cdb_io); \ - int len = ccb->csio.cdb_len; \ - \ - while (len) { \ - debug_asr_cmd_printf (" %02x", *(cp++)); \ - --len; \ - } \ - } +# define debug_asr_dump_ccb(ccb) \ + { \ + u_int8_t * cp = (unsigned char *)&(ccb->csio.cdb_io); \ + int len = ccb->csio.cdb_len; \ + \ + while (len) { \ + debug_asr_cmd_printf (" %02x", *(cp++)); \ + --len; \ + } \ + } # if (DEBUG_ASR_CMD > 0) -# define debug_asr_cmd1_printf debug_asr_cmd_printf +# define debug_asr_cmd1_printf debug_asr_cmd_printf # else # define debug_asr_cmd1_printf(fmt,args...) # endif # if (DEBUG_ASR_CMD > 1) -# define debug_asr_cmd2_printf debug_asr_cmd_printf +# define debug_asr_cmd2_printf debug_asr_cmd_printf # define debug_asr_cmd2_dump_message(message) debug_asr_message(message) # else # define debug_asr_cmd2_printf(fmt,args...) @@ -196,22 +196,22 @@ # define debug_usr_cmd_dump_message(message) #endif /* DEBUG_ASR_USR_CMD */ -#define dsDescription_size 46 /* Snug as a bug in a rug */ +#define dsDescription_size 46 /* Snug as a bug in a rug */ #include "dev/asr/dptsig.h" static dpt_sig_S ASR_sig = { - { 'd', 'P', 't', 'S', 'i', 'G'}, SIG_VERSION, PROC_INTEL, - PROC_386 | PROC_486 | PROC_PENTIUM | PROC_SEXIUM, FT_HBADRVR, 0, - OEM_DPT, OS_FREE_BSD, CAP_ABOVE16MB, DEV_ALL, - ADF_ALL_SC5, - 0, 0, ASR_VERSION, ASR_REVISION, ASR_SUBREVISION, - ASR_MONTH, ASR_DAY, ASR_YEAR, -/* 01234567890123456789012345678901234567890123456789 < 50 chars */ - "Adaptec FreeBSD 4.0.0 Unix SCSI I2O HBA Driver" - /* ^^^^^ asr_attach alters these to match OS */ + { 'd', 'P', 't', 'S', 'i', 'G'}, SIG_VERSION, PROC_INTEL, + PROC_386 | PROC_486 | PROC_PENTIUM | PROC_SEXIUM, FT_HBADRVR, 0, + OEM_DPT, OS_FREE_BSD, CAP_ABOVE16MB, DEV_ALL, + ADF_ALL_SC5, + 0, 0, ASR_VERSION, ASR_REVISION, ASR_SUBREVISION, + ASR_MONTH, ASR_DAY, ASR_YEAR, +/* 01234567890123456789012345678901234567890123456789 < 50 chars */ + "Adaptec FreeBSD 4.0.0 Unix SCSI I2O HBA Driver" + /* ^^^^^ asr_attach alters these to match OS */ }; -#include <sys/param.h> /* TRUE=1 and FALSE=0 defined here */ +#include <sys/param.h> /* TRUE=1 and FALSE=0 defined here */ #include <sys/kernel.h> #include <sys/systm.h> #include <sys/malloc.h> @@ -246,8 +246,8 @@ static dpt_sig_S ASR_sig = { #include <pci/pcivar.h> #include <pci/pcireg.h> -#define STATIC static -#define INLINE +#define STATIC static +#define INLINE #if (defined(DEBUG_ASR) && (DEBUG_ASR > 0)) # undef STATIC @@ -255,33 +255,33 @@ static dpt_sig_S ASR_sig = { # undef INLINE # define INLINE #endif -#define IN -#define OUT -#define INOUT +#define IN +#define OUT +#define INOUT -#define osdSwap4(x) ((u_long)ntohl((u_long)(x))) -#define KVTOPHYS(x) vtophys(x) -#include "dev/asr/dptalign.h" -#include "dev/asr/i2oexec.h" -#include "dev/asr/i2obscsi.h" -#include "dev/asr/i2odpt.h" -#include "dev/asr/i2oadptr.h" -#include "opt_asr.h" +#define osdSwap4(x) ((u_long)ntohl((u_long)(x))) +#define KVTOPHYS(x) vtophys(x) +#include "dev/asr/dptalign.h" +#include "dev/asr/i2oexec.h" +#include "dev/asr/i2obscsi.h" +#include "dev/asr/i2odpt.h" +#include "dev/asr/i2oadptr.h" +#include "opt_asr.h" -#include "dev/asr/sys_info.h" +#include "dev/asr/sys_info.h" /* Configuration Definitions */ -#define SG_SIZE 58 /* Scatter Gather list Size */ -#define MAX_TARGET_ID 126 /* Maximum Target ID supported */ -#define MAX_LUN 255 /* Maximum LUN Supported */ -#define MAX_CHANNEL 7 /* Maximum Channel # Supported by driver */ -#define MAX_INBOUND 2000 /* Max CCBs, Also Max Queue Size */ -#define MAX_OUTBOUND 256 /* Maximum outbound frames/adapter */ -#define MAX_INBOUND_SIZE 512 /* Maximum inbound frame size */ -#define MAX_MAP 4194304L /* Maximum mapping size of IOP */ - /* Also serves as the minimum map for */ - /* the 2005S zero channel RAID product */ +#define SG_SIZE 58 /* Scatter Gather list Size */ +#define MAX_TARGET_ID 126 /* Maximum Target ID supported */ +#define MAX_LUN 255 /* Maximum LUN Supported */ +#define MAX_CHANNEL 7 /* Maximum Channel # Supported by driver */ +#define MAX_INBOUND 2000 /* Max CCBs, Also Max Queue Size */ +#define MAX_OUTBOUND 256 /* Maximum outbound frames/adapter */ +#define MAX_INBOUND_SIZE 512 /* Maximum inbound frame size */ +#define MAX_MAP 4194304L /* Maximum mapping size of IOP */ + /* Also serves as the minimum map for */ + /* the 2005S zero channel RAID product */ /************************************************************************** ** ASR Host Adapter structure - One Structure For Each Host Adapter That ** @@ -291,13 +291,13 @@ static dpt_sig_S ASR_sig = { /* I2O register set */ typedef struct { - U8 Address[0x30]; - volatile U32 Status; - volatile U32 Mask; -# define Mask_InterruptsDisabled 0x08 - U32 x[2]; - volatile U32 ToFIFO; /* In Bound FIFO */ - volatile U32 FromFIFO; /* Out Bound FIFO */ + U8 Address[0x30]; + volatile U32 Status; + volatile U32 Mask; +# define Mask_InterruptsDisabled 0x08 + U32 x[2]; + volatile U32 ToFIFO; /* In Bound FIFO */ + volatile U32 FromFIFO; /* Out Bound FIFO */ } i2oRegs_t; /* @@ -306,141 +306,141 @@ typedef struct { typedef u_int16_t tid_t; typedef struct { - u_int32_t size; /* up to MAX_LUN */ - tid_t TID[1]; + u_int32_t size; /* up to MAX_LUN */ + tid_t TID[1]; } lun2tid_t; typedef struct { - u_int32_t size; /* up to MAX_TARGET */ - lun2tid_t * LUN[1]; + u_int32_t size; /* up to MAX_TARGET */ + lun2tid_t * LUN[1]; } target2lun_t; /* - * To ensure that we only allocate and use the worst case ccb here, lets - * make our own local ccb union. If asr_alloc_ccb is utilized for another - * ccb type, ensure that you add the additional structures into our local - * ccb union. To ensure strict type checking, we will utilize the local - * ccb definition wherever possible. + * To ensure that we only allocate and use the worst case ccb here, lets + * make our own local ccb union. If asr_alloc_ccb is utilized for another + * ccb type, ensure that you add the additional structures into our local + * ccb union. To ensure strict type checking, we will utilize the local + * ccb definition wherever possible. */ union asr_ccb { - struct ccb_hdr ccb_h; /* For convenience */ - struct ccb_scsiio csio; - struct ccb_setasync csa; + struct ccb_hdr ccb_h; /* For convenience */ + struct ccb_scsiio csio; + struct ccb_setasync csa; }; typedef struct Asr_softc { - u_int16_t ha_irq; - void * ha_Base; /* base port for each board */ - u_int8_t * volatile ha_blinkLED; - i2oRegs_t * ha_Virt; /* Base address of IOP */ - U8 * ha_Fvirt; /* Base address of Frames */ - I2O_IOP_ENTRY ha_SystemTable; - LIST_HEAD(,ccb_hdr) ha_ccb; /* ccbs in use */ - struct cam_path * ha_path[MAX_CHANNEL+1]; - struct cam_sim * ha_sim[MAX_CHANNEL+1]; + u_int16_t ha_irq; + void * ha_Base; /* base port for each board */ + u_int8_t * volatile ha_blinkLED; + i2oRegs_t * ha_Virt; /* Base address of IOP */ + U8 * ha_Fvirt; /* Base address of Frames */ + I2O_IOP_ENTRY ha_SystemTable; + LIST_HEAD(,ccb_hdr) ha_ccb; /* ccbs in use */ + struct cam_path * ha_path[MAX_CHANNEL+1]; + struct cam_sim * ha_sim[MAX_CHANNEL+1]; #if __FreeBSD_version >= 400000 - struct resource * ha_mem_res; - struct resource * ha_mes_res; - struct resource * ha_irq_res; - void * ha_intr; + struct resource * ha_mem_res; + struct resource * ha_mes_res; + struct resource * ha_irq_res; + void * ha_intr; #endif - PI2O_LCT ha_LCT; /* Complete list of devices */ -# define le_type IdentityTag[0] -# define I2O_BSA 0x20 -# define I2O_FCA 0x40 -# define I2O_SCSI 0x00 -# define I2O_PORT 0x80 -# define I2O_UNKNOWN 0x7F -# define le_bus IdentityTag[1] -# define le_target IdentityTag[2] -# define le_lun IdentityTag[3] - target2lun_t * ha_targets[MAX_CHANNEL+1]; - PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME ha_Msgs; - u_long ha_Msgs_Phys; - - u_int8_t ha_in_reset; -# define HA_OPERATIONAL 0 -# define HA_IN_RESET 1 -# define HA_OFF_LINE 2 -# define HA_OFF_LINE_RECOVERY 3 - /* Configuration information */ - /* The target id maximums we take */ - u_int8_t ha_MaxBus; /* Maximum bus */ - u_int8_t ha_MaxId; /* Maximum target ID */ - u_int8_t ha_MaxLun; /* Maximum target LUN */ - u_int8_t ha_SgSize; /* Max SG elements */ - u_int8_t ha_pciBusNum; - u_int8_t ha_pciDeviceNum; - u_int8_t ha_adapter_target[MAX_CHANNEL+1]; - u_int16_t ha_QueueSize; /* Max outstanding commands */ - u_int16_t ha_Msgs_Count; - - /* Links into other parents and HBAs */ - struct Asr_softc * ha_next; /* HBA list */ + PI2O_LCT ha_LCT; /* Complete list of devices */ +# define le_type IdentityTag[0] +# define I2O_BSA 0x20 +# define I2O_FCA 0x40 +# define I2O_SCSI 0x00 +# define I2O_PORT 0x80 +# define I2O_UNKNOWN 0x7F +# define le_bus IdentityTag[1] +# define le_target IdentityTag[2] +# define le_lun IdentityTag[3] + target2lun_t * ha_targets[MAX_CHANNEL+1]; + PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME ha_Msgs; + u_long ha_Msgs_Phys; + + u_int8_t ha_in_reset; +# define HA_OPERATIONAL 0 +# define HA_IN_RESET 1 +# define HA_OFF_LINE 2 +# define HA_OFF_LINE_RECOVERY 3 + /* Configuration information */ + /* The target id maximums we take */ + u_int8_t ha_MaxBus; /* Maximum bus */ + u_int8_t ha_MaxId; /* Maximum target ID */ + u_int8_t ha_MaxLun; /* Maximum target LUN */ + u_int8_t ha_SgSize; /* Max SG elements */ + u_int8_t ha_pciBusNum; + u_int8_t ha_pciDeviceNum; + u_int8_t ha_adapter_target[MAX_CHANNEL+1]; + u_int16_t ha_QueueSize; /* Max outstanding commands */ + u_int16_t ha_Msgs_Count; + + /* Links into other parents and HBAs */ + struct Asr_softc * ha_next; /* HBA list */ #ifdef ASR_MEASURE_PERFORMANCE -#define MAX_TIMEQ_SIZE 256 /* assumes MAX 256 scsi commands sent */ - asr_perf_t ha_performance; - u_int32_t ha_submitted_ccbs_count; - - /* Queueing macros for a circular queue */ -#define TIMEQ_FREE_LIST_EMPTY(head, tail) (-1 == (head) && -1 == (tail)) -#define TIMEQ_FREE_LIST_FULL(head, tail) ((((tail) + 1) % MAX_TIMEQ_SIZE) == (head)) -#define ENQ_TIMEQ_FREE_LIST(item, Q, head, tail) \ - if (!TIMEQ_FREE_LIST_FULL((head), (tail))) { \ - if TIMEQ_FREE_LIST_EMPTY((head),(tail)) { \ - (head) = (tail) = 0; \ - } \ - else (tail) = ((tail) + 1) % MAX_TIMEQ_SIZE; \ - Q[(tail)] = (item); \ - } \ - else { \ - debug_asr_printf("asr: Enqueueing when TimeQ Free List is full... This should not happen!\n"); \ - } -#define DEQ_TIMEQ_FREE_LIST(item, Q, head, tail) \ - if (!TIMEQ_FREE_LIST_EMPTY((head), (tail))) { \ - item = Q[(head)]; \ - if ((head) == (tail)) { (head) = (tail) = -1; } \ - else (head) = ((head) + 1) % MAX_TIMEQ_SIZE; \ - } \ - else { \ - (item) = -1; \ - debug_asr_printf("asr: Dequeueing when TimeQ Free List is empty... This should not happen!\n"); \ - } - - /* Circular queue of time stamps */ - struct timeval ha_timeQ[MAX_TIMEQ_SIZE]; - u_int32_t ha_timeQFreeList[MAX_TIMEQ_SIZE]; - int ha_timeQFreeHead; - int ha_timeQFreeTail; +#define MAX_TIMEQ_SIZE 256 /* assumes MAX 256 scsi commands sent */ + asr_perf_t ha_performance; + u_int32_t ha_submitted_ccbs_count; + + /* Queueing macros for a circular queue */ +#define TIMEQ_FREE_LIST_EMPTY(head, tail) (-1 == (head) && -1 == (tail)) +#define TIMEQ_FREE_LIST_FULL(head, tail) ((((tail) + 1) % MAX_TIMEQ_SIZE) == (head)) +#define ENQ_TIMEQ_FREE_LIST(item, Q, head, tail) \ + if (!TIMEQ_FREE_LIST_FULL((head), (tail))) { \ + if TIMEQ_FREE_LIST_EMPTY((head),(tail)) { \ + (head) = (tail) = 0; \ + } \ + else (tail) = ((tail) + 1) % MAX_TIMEQ_SIZE; \ + Q[(tail)] = (item); \ + } \ + else { \ + debug_asr_printf("asr: Enqueueing when TimeQ Free List is full... This should not happen!\n"); \ + } +#define DEQ_TIMEQ_FREE_LIST(item, Q, head, tail) \ + if (!TIMEQ_FREE_LIST_EMPTY((head), (tail))) { \ + item = Q[(head)]; \ + if ((head) == (tail)) { (head) = (tail) = -1; } \ + else (head) = ((head) + 1) % MAX_TIMEQ_SIZE; \ + } \ + else { \ + (item) = -1; \ + debug_asr_printf("asr: Dequeueing when TimeQ Free List is empty... This should not happen!\n"); \ + } + + /* Circular queue of time stamps */ + struct timeval ha_timeQ[MAX_TIMEQ_SIZE]; + u_int32_t ha_timeQFreeList[MAX_TIMEQ_SIZE]; + int ha_timeQFreeHead; + int ha_timeQFreeTail; #endif } Asr_softc_t; STATIC Asr_softc_t * Asr_softc; /* - * Prototypes of the routines we have in this object. + * Prototypes of the routines we have in this object. */ /* Externally callable routines */ #if __FreeBSD_version >= 400000 -#define PROBE_ARGS IN device_t tag -#define PROBE_RET int -#define PROBE_SET() u_int32_t id = (pci_get_device(tag)<<16)|pci_get_vendor(tag) -#define PROBE_RETURN(retval) if(retval){device_set_desc(tag,retval);return(0);}else{return(ENXIO);} -#define ATTACH_ARGS IN device_t tag -#define ATTACH_RET int -#define ATTACH_SET() int unit = device_get_unit(tag) -#define ATTACH_RETURN(retval) return(retval) +#define PROBE_ARGS IN device_t tag +#define PROBE_RET int +#define PROBE_SET() u_int32_t id = (pci_get_device(tag)<<16)|pci_get_vendor(tag) +#define PROBE_RETURN(retval) if(retval){device_set_desc(tag,retval);return(0);}else{return(ENXIO);} +#define ATTACH_ARGS IN device_t tag +#define ATTACH_RET int +#define ATTACH_SET() int unit = device_get_unit(tag) +#define ATTACH_RETURN(retval) return(retval) #else -#define PROBE_ARGS IN pcici_t tag, IN pcidi_t id -#define PROBE_RET const char * -#define PROBE_SET() -#define PROBE_RETURN(retval) return(retval) -#define ATTACH_ARGS IN pcici_t tag, IN int unit -#define ATTACH_RET void -#define ATTACH_SET() -#define ATTACH_RETURN(retval) return +#define PROBE_ARGS IN pcici_t tag, IN pcidi_t id +#define PROBE_RET const char * +#define PROBE_SET() +#define PROBE_RETURN(retval) return(retval) +#define ATTACH_ARGS IN pcici_t tag, IN int unit +#define ATTACH_RET void +#define ATTACH_SET() +#define ATTACH_RETURN(retval) return #endif /* I2O HDM interface */ STATIC PROBE_RET asr_probe(PROBE_ARGS); @@ -453,54 +453,54 @@ STATIC PROBE_RET mode0_probe(PROBE_ARGS); STATIC ATTACH_RET mode0_attach(ATTACH_ARGS); STATIC Asr_softc_t * ASR_get_sc( - IN dev_t dev); -STATIC int asr_ioctl( - IN dev_t dev, - IN u_long cmd, - INOUT caddr_t data, - int flag, - struct thread * td); -STATIC int asr_open( - IN dev_t dev, - int32_t flags, - int32_t ifmt, - IN struct thread * td); -STATIC int asr_close( - dev_t dev, - int flags, - int ifmt, - struct thread * td); -STATIC int asr_intr( - IN Asr_softc_t * sc); -STATIC void asr_timeout( - INOUT void * arg); -STATIC int ASR_init( - IN Asr_softc_t * sc); + IN dev_t dev); +STATIC int asr_ioctl( + IN dev_t dev, + IN u_long cmd, + INOUT caddr_t data, + int flag, + struct thread * td); +STATIC int asr_open( + IN dev_t dev, + int32_t flags, + int32_t ifmt, + IN struct thread * td); +STATIC int asr_close( + dev_t dev, + int flags, + int ifmt, + struct thread * td); +STATIC int asr_intr( + IN Asr_softc_t * sc); +STATIC void asr_timeout( + INOUT void * arg); +STATIC int ASR_init( + IN Asr_softc_t * sc); STATIC INLINE int ASR_acquireLct( - INOUT Asr_softc_t * sc); + INOUT Asr_softc_t * sc); STATIC INLINE int ASR_acquireHrt( - INOUT Asr_softc_t * sc); -STATIC void asr_action( - IN struct cam_sim * sim, - IN union ccb * ccb); -STATIC void asr_poll( - IN struct cam_sim * sim); + INOUT Asr_softc_t * sc); +STATIC void asr_action( + IN struct cam_sim * sim, + IN union ccb * ccb); +STATIC void asr_poll( + IN struct cam_sim * sim); /* - * Here is the auto-probe structure used to nest our tests appropriately - * during the startup phase of the operating system. + * Here is the auto-probe structure used to nest our tests appropriately + * during the startup phase of the operating system. */ #if __FreeBSD_version >= 400000 STATIC device_method_t asr_methods[] = { - DEVMETHOD(device_probe, asr_probe), - DEVMETHOD(device_attach, asr_attach), - { 0, 0 } + DEVMETHOD(device_probe, asr_probe), + DEVMETHOD(device_attach, asr_attach), + { 0, 0 } }; STATIC driver_t asr_driver = { - "asr", - asr_methods, - sizeof(Asr_softc_t) + "asr", + asr_methods, + sizeof(Asr_softc_t) }; STATIC devclass_t asr_devclass; @@ -508,15 +508,15 @@ STATIC devclass_t asr_devclass; DRIVER_MODULE(asr, pci, asr_driver, asr_devclass, 0, 0); STATIC device_method_t domino_methods[] = { - DEVMETHOD(device_probe, domino_probe), - DEVMETHOD(device_attach, domino_attach), - { 0, 0 } + DEVMETHOD(device_probe, domino_probe), + DEVMETHOD(device_attach, domino_attach), + { 0, 0 } }; STATIC driver_t domino_driver = { - "domino", - domino_methods, - 0 + "domino", + domino_methods, + 0 }; STATIC devclass_t domino_devclass; @@ -524,15 +524,15 @@ STATIC devclass_t domino_devclass; DRIVER_MODULE(domino, pci, domino_driver, domino_devclass, 0, 0); STATIC device_method_t mode0_methods[] = { - DEVMETHOD(device_probe, mode0_probe), - DEVMETHOD(device_attach, mode0_attach), - { 0, 0 } + DEVMETHOD(device_probe, mode0_probe), + DEVMETHOD(device_attach, mode0_attach), + { 0, 0 } }; STATIC driver_t mode0_driver = { - "mode0", - mode0_methods, - 0 + "mode0", + mode0_methods, + 0 }; STATIC devclass_t mode0_devclass; @@ -541,31 +541,31 @@ DRIVER_MODULE(mode0, pci, mode0_driver, mode0_devclass, 0, 0); #else STATIC u_long asr_pcicount = 0; STATIC struct pci_device asr_pcidev = { - "asr", - asr_probe, - asr_attach, - &asr_pcicount, - NULL + "asr", + asr_probe, + asr_attach, + &asr_pcicount, + NULL }; DATA_SET (asr_pciset, asr_pcidev); STATIC u_long domino_pcicount = 0; STATIC struct pci_device domino_pcidev = { - "domino", - domino_probe, - domino_attach, - &domino_pcicount, - NULL + "domino", + domino_probe, + domino_attach, + &domino_pcicount, + NULL }; DATA_SET (domino_pciset, domino_pcidev); STATIC u_long mode0_pcicount = 0; STATIC struct pci_device mode0_pcidev = { - "mode0", - mode0_probe, - mode0_attach, - &mode0_pcicount, - NULL + "mode0", + mode0_probe, + mode0_attach, + &mode0_pcicount, + NULL }; DATA_SET (mode0_pciset, mode0_pcidev); #endif @@ -575,26 +575,26 @@ DATA_SET (mode0_pciset, mode0_pcidev); * * only ioctl is used. the sd driver provides all other access. */ -#define CDEV_MAJOR 154 /* preferred default character major */ +#define CDEV_MAJOR 154 /* preferred default character major */ STATIC struct cdevsw asr_cdevsw = { - asr_open, /* open */ - asr_close, /* close */ - noread, /* read */ - nowrite, /* write */ - asr_ioctl, /* ioctl */ - nopoll, /* poll */ - nommap, /* mmap */ - nostrategy, /* strategy */ - "asr", /* name */ - CDEV_MAJOR, /* maj */ - nodump, /* dump */ - nopsize, /* psize */ - 0, /* flags */ + asr_open, /* open */ + asr_close, /* close */ + noread, /* read */ + nowrite, /* write */ + asr_ioctl, /* ioctl */ + nopoll, /* poll */ + nommap, /* mmap */ + nostrategy, /* strategy */ + "asr", /* name */ + CDEV_MAJOR, /* maj */ + nodump, /* dump */ + nopsize, /* psize */ + 0, /* flags */ }; #ifdef ASR_MEASURE_PERFORMANCE -STATIC u_int32_t asr_time_delta(IN struct timeval start, - IN struct timeval end); +STATIC u_int32_t asr_time_delta(IN struct timeval start, + IN struct timeval end); #endif #ifdef ASR_VERY_BROKEN @@ -603,36 +603,36 @@ STATIC u_int32_t asr_time_delta(IN struct timeval start, */ STATIC void asr_drvinit ( - void * unused) + void * unused) { - static int asr_devsw_installed = 0; - - if (asr_devsw_installed) { - return; - } - asr_devsw_installed++; - /* - * Find a free spot (the report during driver load used by - * osd layer in engine to generate the controlling nodes). - */ - while ((asr_cdevsw.d_maj < NUMCDEVSW) - && (devsw(makedev(asr_cdevsw.d_maj,0)) != (struct cdevsw *)NULL)) { - ++asr_cdevsw.d_maj; - } - if (asr_cdevsw.d_maj >= NUMCDEVSW) for ( - asr_cdevsw.d_maj = 0; - (asr_cdevsw.d_maj < CDEV_MAJOR) - && (devsw(makedev(asr_cdevsw.d_maj,0)) != (struct cdevsw *)NULL); - ++asr_cdevsw.d_maj); - /* - * Come to papa - */ - cdevsw_add(&asr_cdevsw); - /* - * delete any nodes that would attach to the primary adapter, - * let the adapter scans add them. - */ - destroy_dev(makedev(asr_cdevsw.d_maj,0)); + static int asr_devsw_installed = 0; + + if (asr_devsw_installed) { + return; + } + asr_devsw_installed++; + /* + * Find a free spot (the report during driver load used by + * osd layer in engine to generate the controlling nodes). + */ + while ((asr_cdevsw.d_maj < NUMCDEVSW) + && (devsw(makedev(asr_cdevsw.d_maj,0)) != (struct cdevsw *)NULL)) { + ++asr_cdevsw.d_maj; + } + if (asr_cdevsw.d_maj >= NUMCDEVSW) for ( + asr_cdevsw.d_maj = 0; + (asr_cdevsw.d_maj < CDEV_MAJOR) + && (devsw(makedev(asr_cdevsw.d_maj,0)) != (struct cdevsw *)NULL); + ++asr_cdevsw.d_maj); + /* + * Come to papa + */ + cdevsw_add(&asr_cdevsw); + /* + * delete any nodes that would attach to the primary adapter, + * let the adapter scans add them. + */ + destroy_dev(makedev(asr_cdevsw.d_maj,0)); } /* asr_drvinit */ /* Must initialize before CAM layer picks up our HBA driver */ @@ -640,185 +640,185 @@ SYSINIT(asrdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,asr_drvinit,NULL) #endif /* I2O support routines */ -#define defAlignLong(STRUCT,NAME) char NAME[sizeof(STRUCT)] -#define getAlignLong(STRUCT,NAME) ((STRUCT *)(NAME)) +#define defAlignLong(STRUCT,NAME) char NAME[sizeof(STRUCT)] +#define getAlignLong(STRUCT,NAME) ((STRUCT *)(NAME)) /* - * Fill message with default. + * Fill message with default. */ STATIC PI2O_MESSAGE_FRAME ASR_fillMessage ( - IN char * Message, - IN u_int16_t size) + IN char * Message, + IN u_int16_t size) { - OUT PI2O_MESSAGE_FRAME Message_Ptr; - - Message_Ptr = getAlignLong(I2O_MESSAGE_FRAME, Message); - bzero ((void *)Message_Ptr, size); - I2O_MESSAGE_FRAME_setVersionOffset(Message_Ptr, I2O_VERSION_11); - I2O_MESSAGE_FRAME_setMessageSize(Message_Ptr, - (size + sizeof(U32) - 1) >> 2); - I2O_MESSAGE_FRAME_setInitiatorAddress (Message_Ptr, 1); - return (Message_Ptr); + OUT PI2O_MESSAGE_FRAME Message_Ptr; + + Message_Ptr = getAlignLong(I2O_MESSAGE_FRAME, Message); + bzero ((void *)Message_Ptr, size); + I2O_MESSAGE_FRAME_setVersionOffset(Message_Ptr, I2O_VERSION_11); + I2O_MESSAGE_FRAME_setMessageSize(Message_Ptr, + (size + sizeof(U32) - 1) >> 2); + I2O_MESSAGE_FRAME_setInitiatorAddress (Message_Ptr, 1); + return (Message_Ptr); } /* ASR_fillMessage */ -#define EMPTY_QUEUE ((U32)-1L) +#define EMPTY_QUEUE ((U32)-1L) STATIC INLINE U32 ASR_getMessage( - IN i2oRegs_t * virt) + IN i2oRegs_t * virt) { - OUT U32 MessageOffset; + OUT U32 MessageOffset; - if ((MessageOffset = virt->ToFIFO) == EMPTY_QUEUE) { - MessageOffset = virt->ToFIFO; - } - return (MessageOffset); + if ((MessageOffset = virt->ToFIFO) == EMPTY_QUEUE) { + MessageOffset = virt->ToFIFO; + } + return (MessageOffset); } /* ASR_getMessage */ /* Issue a polled command */ STATIC U32 ASR_initiateCp ( - INOUT i2oRegs_t * virt, - INOUT U8 * fvirt, - IN PI2O_MESSAGE_FRAME Message) + INOUT i2oRegs_t * virt, + INOUT U8 * fvirt, + IN PI2O_MESSAGE_FRAME Message) { - OUT U32 Mask = -1L; - U32 MessageOffset; - u_int Delay = 1500; - - /* - * ASR_initiateCp is only used for synchronous commands and will - * be made more resiliant to adapter delays since commands like - * resetIOP can cause the adapter to be deaf for a little time. - */ - while (((MessageOffset = ASR_getMessage(virt)) == EMPTY_QUEUE) - && (--Delay != 0)) { - DELAY (10000); - } - if (MessageOffset != EMPTY_QUEUE) { - bcopy (Message, fvirt + MessageOffset, - I2O_MESSAGE_FRAME_getMessageSize(Message) << 2); - /* - * Disable the Interrupts - */ - virt->Mask = (Mask = virt->Mask) | Mask_InterruptsDisabled; - virt->ToFIFO = MessageOffset; - } - return (Mask); + OUT U32 Mask = -1L; + U32 MessageOffset; + u_int Delay = 1500; + + /* + * ASR_initiateCp is only used for synchronous commands and will + * be made more resiliant to adapter delays since commands like + * resetIOP can cause the adapter to be deaf for a little time. + */ + while (((MessageOffset = ASR_getMessage(virt)) == EMPTY_QUEUE) + && (--Delay != 0)) { + DELAY (10000); + } + if (MessageOffset != EMPTY_QUEUE) { + bcopy (Message, fvirt + MessageOffset, + I2O_MESSAGE_FRAME_getMessageSize(Message) << 2); + /* + * Disable the Interrupts + */ + virt->Mask = (Mask = virt->Mask) | Mask_InterruptsDisabled; + virt->ToFIFO = MessageOffset; + } + return (Mask); } /* ASR_initiateCp */ /* - * Reset the adapter. + * Reset the adapter. */ STATIC U32 ASR_resetIOP ( - INOUT i2oRegs_t * virt, - INOUT U8 * fvirt) + INOUT i2oRegs_t * virt, + INOUT U8 * fvirt) { - struct resetMessage { - I2O_EXEC_IOP_RESET_MESSAGE M; - U32 R; - }; - defAlignLong(struct resetMessage,Message); - PI2O_EXEC_IOP_RESET_MESSAGE Message_Ptr; - OUT U32 * volatile Reply_Ptr; - U32 Old; - - /* - * Build up our copy of the Message. - */ - Message_Ptr = (PI2O_EXEC_IOP_RESET_MESSAGE)ASR_fillMessage(Message, - sizeof(I2O_EXEC_IOP_RESET_MESSAGE)); - I2O_EXEC_IOP_RESET_MESSAGE_setFunction(Message_Ptr, I2O_EXEC_IOP_RESET); - /* - * Reset the Reply Status - */ - *(Reply_Ptr = (U32 *)((char *)Message_Ptr - + sizeof(I2O_EXEC_IOP_RESET_MESSAGE))) = 0; - I2O_EXEC_IOP_RESET_MESSAGE_setStatusWordLowAddress(Message_Ptr, - KVTOPHYS((void *)Reply_Ptr)); - /* - * Send the Message out - */ - if ((Old = ASR_initiateCp (virt, fvirt, (PI2O_MESSAGE_FRAME)Message_Ptr)) != (U32)-1L) { - /* - * Wait for a response (Poll), timeouts are dangerous if - * the card is truly responsive. We assume response in 2s. - */ - u_int8_t Delay = 200; - - while ((*Reply_Ptr == 0) && (--Delay != 0)) { - DELAY (10000); - } - /* - * Re-enable the interrupts. - */ - virt->Mask = Old; - ASSERT (*Reply_Ptr); - return (*Reply_Ptr); - } - ASSERT (Old != (U32)-1L); - return (0); + struct resetMessage { + I2O_EXEC_IOP_RESET_MESSAGE M; + U32 R; + }; + defAlignLong(struct resetMessage,Message); + PI2O_EXEC_IOP_RESET_MESSAGE Message_Ptr; + OUT U32 * volatile Reply_Ptr; + U32 Old; + + /* + * Build up our copy of the Message. + */ + Message_Ptr = (PI2O_EXEC_IOP_RESET_MESSAGE)ASR_fillMessage(Message, + sizeof(I2O_EXEC_IOP_RESET_MESSAGE)); + I2O_EXEC_IOP_RESET_MESSAGE_setFunction(Message_Ptr, I2O_EXEC_IOP_RESET); + /* + * Reset the Reply Status + */ + *(Reply_Ptr = (U32 *)((char *)Message_Ptr + + sizeof(I2O_EXEC_IOP_RESET_MESSAGE))) = 0; + I2O_EXEC_IOP_RESET_MESSAGE_setStatusWordLowAddress(Message_Ptr, + KVTOPHYS((void *)Reply_Ptr)); + /* + * Send the Message out + */ + if ((Old = ASR_initiateCp (virt, fvirt, (PI2O_MESSAGE_FRAME)Message_Ptr)) != (U32)-1L) { + /* + * Wait for a response (Poll), timeouts are dangerous if + * the card is truly responsive. We assume response in 2s. + */ + u_int8_t Delay = 200; + + while ((*Reply_Ptr == 0) && (--Delay != 0)) { + DELAY (10000); + } + /* + * Re-enable the interrupts. + */ + virt->Mask = Old; + ASSERT (*Reply_Ptr); + return (*Reply_Ptr); + } + ASSERT (Old != (U32)-1L); + return (0); } /* ASR_resetIOP */ /* - * Get the curent state of the adapter + * Get the curent state of the adapter */ STATIC INLINE PI2O_EXEC_STATUS_GET_REPLY ASR_getStatus ( - INOUT i2oRegs_t * virt, - INOUT U8 * fvirt, - OUT PI2O_EXEC_STATUS_GET_REPLY buffer) + INOUT i2oRegs_t * virt, + INOUT U8 * fvirt, + OUT PI2O_EXEC_STATUS_GET_REPLY buffer) { - defAlignLong(I2O_EXEC_STATUS_GET_MESSAGE,Message); - PI2O_EXEC_STATUS_GET_MESSAGE Message_Ptr; - U32 Old; - - /* - * Build up our copy of the Message. - */ - Message_Ptr = (PI2O_EXEC_STATUS_GET_MESSAGE)ASR_fillMessage(Message, - sizeof(I2O_EXEC_STATUS_GET_MESSAGE)); - I2O_EXEC_STATUS_GET_MESSAGE_setFunction(Message_Ptr, - I2O_EXEC_STATUS_GET); - I2O_EXEC_STATUS_GET_MESSAGE_setReplyBufferAddressLow(Message_Ptr, - KVTOPHYS((void *)buffer)); - /* This one is a Byte Count */ - I2O_EXEC_STATUS_GET_MESSAGE_setReplyBufferLength(Message_Ptr, - sizeof(I2O_EXEC_STATUS_GET_REPLY)); - /* - * Reset the Reply Status - */ - bzero ((void *)buffer, sizeof(I2O_EXEC_STATUS_GET_REPLY)); - /* - * Send the Message out - */ - if ((Old = ASR_initiateCp (virt, fvirt, (PI2O_MESSAGE_FRAME)Message_Ptr)) != (U32)-1L) { - /* - * Wait for a response (Poll), timeouts are dangerous if - * the card is truly responsive. We assume response in 50ms. - */ - u_int8_t Delay = 255; - - while (*((U8 * volatile)&(buffer->SyncByte)) == 0) { - if (--Delay == 0) { - buffer = (PI2O_EXEC_STATUS_GET_REPLY)NULL; - break; - } - DELAY (1000); - } - /* - * Re-enable the interrupts. - */ - virt->Mask = Old; - return (buffer); - } - return ((PI2O_EXEC_STATUS_GET_REPLY)NULL); + defAlignLong(I2O_EXEC_STATUS_GET_MESSAGE,Message); + PI2O_EXEC_STATUS_GET_MESSAGE Message_Ptr; + U32 Old; + + /* + * Build up our copy of the Message. + */ + Message_Ptr = (PI2O_EXEC_STATUS_GET_MESSAGE)ASR_fillMessage(Message, + sizeof(I2O_EXEC_STATUS_GET_MESSAGE)); + I2O_EXEC_STATUS_GET_MESSAGE_setFunction(Message_Ptr, + I2O_EXEC_STATUS_GET); + I2O_EXEC_STATUS_GET_MESSAGE_setReplyBufferAddressLow(Message_Ptr, + KVTOPHYS((void *)buffer)); + /* This one is a Byte Count */ + I2O_EXEC_STATUS_GET_MESSAGE_setReplyBufferLength(Message_Ptr, + sizeof(I2O_EXEC_STATUS_GET_REPLY)); + /* + * Reset the Reply Status + */ + bzero ((void *)buffer, sizeof(I2O_EXEC_STATUS_GET_REPLY)); + /* + * Send the Message out + */ + if ((Old = ASR_initiateCp (virt, fvirt, (PI2O_MESSAGE_FRAME)Message_Ptr)) != (U32)-1L) { + /* + * Wait for a response (Poll), timeouts are dangerous if + * the card is truly responsive. We assume response in 50ms. + */ + u_int8_t Delay = 255; + + while (*((U8 * volatile)&(buffer->SyncByte)) == 0) { + if (--Delay == 0) { + buffer = (PI2O_EXEC_STATUS_GET_REPLY)NULL; + break; + } + DELAY (1000); + } + /* + * Re-enable the interrupts. + */ + virt->Mask = Old; + return (buffer); + } + return ((PI2O_EXEC_STATUS_GET_REPLY)NULL); } /* ASR_getStatus */ /* - * Check if the device is a SCSI I2O HBA, and add it to the list. + * Check if the device is a SCSI I2O HBA, and add it to the list. */ /* @@ -828,11 +828,11 @@ ASR_getStatus ( STATIC PROBE_RET asr_probe(PROBE_ARGS) { - PROBE_SET(); - if ((id == 0xA5011044) || (id == 0xA5111044)) { - PROBE_RETURN ("Adaptec Caching SCSI RAID"); - } - PROBE_RETURN (NULL); + PROBE_SET(); + if ((id == 0xA5011044) || (id == 0xA5111044)) { + PROBE_RETURN ("Adaptec Caching SCSI RAID"); + } + PROBE_RETURN (NULL); } /* asr_probe */ /* @@ -841,17 +841,17 @@ asr_probe(PROBE_ARGS) STATIC PROBE_RET domino_probe(PROBE_ARGS) { - PROBE_SET(); - if (id == 0x10121044) { - PROBE_RETURN ("Adaptec Caching Memory Controller"); - } - PROBE_RETURN (NULL); + PROBE_SET(); + if (id == 0x10121044) { + PROBE_RETURN ("Adaptec Caching Memory Controller"); + } + PROBE_RETURN (NULL); } /* domino_probe */ STATIC ATTACH_RET domino_attach (ATTACH_ARGS) { - ATTACH_RETURN (0); + ATTACH_RETURN (0); } /* domino_attach */ /* @@ -860,782 +860,782 @@ domino_attach (ATTACH_ARGS) STATIC PROBE_RET mode0_probe(PROBE_ARGS) { - PROBE_SET(); - - /* - * If/When we can get a business case to commit to a - * Mode0 driver here, we can make all these tests more - * specific and robust. Mode0 adapters have their processors - * turned off, this the chips are in a raw state. - */ - - /* This is a PLX9054 */ - if (id == 0x905410B5) { - PROBE_RETURN ("Adaptec Mode0 PM3757"); - } - /* This is a PLX9080 */ - if (id == 0x908010B5) { - PROBE_RETURN ("Adaptec Mode0 PM3754/PM3755"); - } - /* This is a ZION 80303 */ - if (id == 0x53098086) { - PROBE_RETURN ("Adaptec Mode0 3010S"); - } - /* This is an i960RS */ - if (id == 0x39628086) { - PROBE_RETURN ("Adaptec Mode0 2100S"); - } - /* This is an i960RN */ - if (id == 0x19648086) { - PROBE_RETURN ("Adaptec Mode0 PM2865/2400A/3200S/3400S"); - } -#if 0 /* this would match any generic i960 -- mjs */ - /* This is an i960RP (typically also on Motherboards) */ - if (id == 0x19608086) { - PROBE_RETURN ("Adaptec Mode0 PM2554/PM1554/PM2654"); - } + PROBE_SET(); + + /* + * If/When we can get a business case to commit to a + * Mode0 driver here, we can make all these tests more + * specific and robust. Mode0 adapters have their processors + * turned off, this the chips are in a raw state. + */ + + /* This is a PLX9054 */ + if (id == 0x905410B5) { + PROBE_RETURN ("Adaptec Mode0 PM3757"); + } + /* This is a PLX9080 */ + if (id == 0x908010B5) { + PROBE_RETURN ("Adaptec Mode0 PM3754/PM3755"); + } + /* This is a ZION 80303 */ + if (id == 0x53098086) { + PROBE_RETURN ("Adaptec Mode0 3010S"); + } + /* This is an i960RS */ + if (id == 0x39628086) { + PROBE_RETURN ("Adaptec Mode0 2100S"); + } + /* This is an i960RN */ + if (id == 0x19648086) { + PROBE_RETURN ("Adaptec Mode0 PM2865/2400A/3200S/3400S"); + } +#if 0 /* this would match any generic i960 -- mjs */ + /* This is an i960RP (typically also on Motherboards) */ + if (id == 0x19608086) { + PROBE_RETURN ("Adaptec Mode0 PM2554/PM1554/PM2654"); + } #endif - PROBE_RETURN (NULL); + PROBE_RETURN (NULL); } /* mode0_probe */ STATIC ATTACH_RET mode0_attach (ATTACH_ARGS) { - ATTACH_RETURN (0); + ATTACH_RETURN (0); } /* mode0_attach */ STATIC INLINE union asr_ccb * asr_alloc_ccb ( - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { - OUT union asr_ccb * new_ccb; - - if ((new_ccb = (union asr_ccb *)malloc(sizeof(*new_ccb), - M_DEVBUF, M_WAITOK | M_ZERO)) != (union asr_ccb *)NULL) { - new_ccb->ccb_h.pinfo.priority = 1; - new_ccb->ccb_h.pinfo.index = CAM_UNQUEUED_INDEX; - new_ccb->ccb_h.spriv_ptr0 = sc; - } - return (new_ccb); + OUT union asr_ccb * new_ccb; + + if ((new_ccb = (union asr_ccb *)malloc(sizeof(*new_ccb), + M_DEVBUF, M_WAITOK | M_ZERO)) != (union asr_ccb *)NULL) { + new_ccb->ccb_h.pinfo.priority = 1; + new_ccb->ccb_h.pinfo.index = CAM_UNQUEUED_INDEX; + new_ccb->ccb_h.spriv_ptr0 = sc; + } + return (new_ccb); } /* asr_alloc_ccb */ STATIC INLINE void asr_free_ccb ( - IN union asr_ccb * free_ccb) + IN union asr_ccb * free_ccb) { - free(free_ccb, M_DEVBUF); + free(free_ccb, M_DEVBUF); } /* asr_free_ccb */ /* - * Print inquiry data `carefully' + * Print inquiry data `carefully' */ STATIC void ASR_prstring ( - u_int8_t * s, - int len) + u_int8_t * s, + int len) { - while ((--len >= 0) && (*s) && (*s != ' ') && (*s != '-')) { - printf ("%c", *(s++)); - } + while ((--len >= 0) && (*s) && (*s != ' ') && (*s != '-')) { + printf ("%c", *(s++)); + } } /* ASR_prstring */ /* * Prototypes */ STATIC INLINE int ASR_queue( - IN Asr_softc_t * sc, - IN PI2O_MESSAGE_FRAME Message); + IN Asr_softc_t * sc, + IN PI2O_MESSAGE_FRAME Message); /* - * Send a message synchronously and without Interrupt to a ccb. + * Send a message synchronously and without Interrupt to a ccb. */ STATIC int ASR_queue_s ( - INOUT union asr_ccb * ccb, - IN PI2O_MESSAGE_FRAME Message) + INOUT union asr_ccb * ccb, + IN PI2O_MESSAGE_FRAME Message) { - int s; - U32 Mask; - Asr_softc_t * sc = (Asr_softc_t *)(ccb->ccb_h.spriv_ptr0); - - /* - * We do not need any (optional byteswapping) method access to - * the Initiator context field. - */ - I2O_MESSAGE_FRAME_setInitiatorContext64(Message, (long)ccb); - - /* Prevent interrupt service */ - s = splcam (); - sc->ha_Virt->Mask = (Mask = sc->ha_Virt->Mask) - | Mask_InterruptsDisabled; - - if (ASR_queue (sc, Message) == EMPTY_QUEUE) { - ccb->ccb_h.status &= ~CAM_STATUS_MASK; - ccb->ccb_h.status |= CAM_REQUEUE_REQ; - } - - /* - * Wait for this board to report a finished instruction. - */ - while ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INPROG) { - (void)asr_intr (sc); - } - - /* Re-enable Interrupts */ - sc->ha_Virt->Mask = Mask; - splx(s); - - return (ccb->ccb_h.status); + int s; + U32 Mask; + Asr_softc_t * sc = (Asr_softc_t *)(ccb->ccb_h.spriv_ptr0); + + /* + * We do not need any (optional byteswapping) method access to + * the Initiator context field. + */ + I2O_MESSAGE_FRAME_setInitiatorContext64(Message, (long)ccb); + + /* Prevent interrupt service */ + s = splcam (); + sc->ha_Virt->Mask = (Mask = sc->ha_Virt->Mask) + | Mask_InterruptsDisabled; + + if (ASR_queue (sc, Message) == EMPTY_QUEUE) { + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + ccb->ccb_h.status |= CAM_REQUEUE_REQ; + } + + /* + * Wait for this board to report a finished instruction. + */ + while ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INPROG) { + (void)asr_intr (sc); + } + + /* Re-enable Interrupts */ + sc->ha_Virt->Mask = Mask; + splx(s); + + return (ccb->ccb_h.status); } /* ASR_queue_s */ /* - * Send a message synchronously to a Asr_softc_t + * Send a message synchronously to a Asr_softc_t */ STATIC int ASR_queue_c ( - IN Asr_softc_t * sc, - IN PI2O_MESSAGE_FRAME Message) + IN Asr_softc_t * sc, + IN PI2O_MESSAGE_FRAME Message) { - union asr_ccb * ccb; - OUT int status; + union asr_ccb * ccb; + OUT int status; - if ((ccb = asr_alloc_ccb (sc)) == (union asr_ccb *)NULL) { - return (CAM_REQUEUE_REQ); - } + if ((ccb = asr_alloc_ccb (sc)) == (union asr_ccb *)NULL) { + return (CAM_REQUEUE_REQ); + } - status = ASR_queue_s (ccb, Message); + status = ASR_queue_s (ccb, Message); - asr_free_ccb(ccb); + asr_free_ccb(ccb); - return (status); + return (status); } /* ASR_queue_c */ /* - * Add the specified ccb to the active queue + * Add the specified ccb to the active queue */ STATIC INLINE void ASR_ccbAdd ( - IN Asr_softc_t * sc, - INOUT union asr_ccb * ccb) + IN Asr_softc_t * sc, + INOUT union asr_ccb * ccb) { - int s; - - s = splcam(); - LIST_INSERT_HEAD(&(sc->ha_ccb), &(ccb->ccb_h), sim_links.le); - if (ccb->ccb_h.timeout != CAM_TIME_INFINITY) { - if (ccb->ccb_h.timeout == CAM_TIME_DEFAULT) { - /* - * RAID systems can take considerable time to - * complete some commands given the large cache - * flashes switching from write back to write thru. - */ - ccb->ccb_h.timeout = 6 * 60 * 1000; - } - ccb->ccb_h.timeout_ch = timeout(asr_timeout, (caddr_t)ccb, - (ccb->ccb_h.timeout * hz) / 1000); - } - splx(s); + int s; + + s = splcam(); + LIST_INSERT_HEAD(&(sc->ha_ccb), &(ccb->ccb_h), sim_links.le); + if (ccb->ccb_h.timeout != CAM_TIME_INFINITY) { + if (ccb->ccb_h.timeout == CAM_TIME_DEFAULT) { + /* + * RAID systems can take considerable time to + * complete some commands given the large cache + * flashes switching from write back to write thru. + */ + ccb->ccb_h.timeout = 6 * 60 * 1000; + } + ccb->ccb_h.timeout_ch = timeout(asr_timeout, (caddr_t)ccb, + (ccb->ccb_h.timeout * hz) / 1000); + } + splx(s); } /* ASR_ccbAdd */ /* - * Remove the specified ccb from the active queue. + * Remove the specified ccb from the active queue. */ STATIC INLINE void ASR_ccbRemove ( - IN Asr_softc_t * sc, - INOUT union asr_ccb * ccb) + IN Asr_softc_t * sc, + INOUT union asr_ccb * ccb) { - int s; + int s; - s = splcam(); - untimeout(asr_timeout, (caddr_t)ccb, ccb->ccb_h.timeout_ch); - LIST_REMOVE(&(ccb->ccb_h), sim_links.le); - splx(s); + s = splcam(); + untimeout(asr_timeout, (caddr_t)ccb, ccb->ccb_h.timeout_ch); + LIST_REMOVE(&(ccb->ccb_h), sim_links.le); + splx(s); } /* ASR_ccbRemove */ /* - * Fail all the active commands, so they get re-issued by the operating - * system. + * Fail all the active commands, so they get re-issued by the operating + * system. */ STATIC INLINE void ASR_failActiveCommands ( - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { - struct ccb_hdr * ccb; - int s; + struct ccb_hdr * ccb; + int s; #if 0 /* Currently handled by callers, unnecessary paranoia currently */ /* Left in for historical perspective. */ - defAlignLong(I2O_EXEC_LCT_NOTIFY_MESSAGE,Message); - PI2O_EXEC_LCT_NOTIFY_MESSAGE Message_Ptr; - - /* Send a blind LCT command to wait for the enableSys to complete */ - Message_Ptr = (PI2O_EXEC_LCT_NOTIFY_MESSAGE)ASR_fillMessage(Message, - sizeof(I2O_EXEC_LCT_NOTIFY_MESSAGE) - sizeof(I2O_SG_ELEMENT)); - I2O_MESSAGE_FRAME_setFunction(&(Message_Ptr->StdMessageFrame), - I2O_EXEC_LCT_NOTIFY); - I2O_EXEC_LCT_NOTIFY_MESSAGE_setClassIdentifier(Message_Ptr, - I2O_CLASS_MATCH_ANYCLASS); - (void)ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); + defAlignLong(I2O_EXEC_LCT_NOTIFY_MESSAGE,Message); + PI2O_EXEC_LCT_NOTIFY_MESSAGE Message_Ptr; + + /* Send a blind LCT command to wait for the enableSys to complete */ + Message_Ptr = (PI2O_EXEC_LCT_NOTIFY_MESSAGE)ASR_fillMessage(Message, + sizeof(I2O_EXEC_LCT_NOTIFY_MESSAGE) - sizeof(I2O_SG_ELEMENT)); + I2O_MESSAGE_FRAME_setFunction(&(Message_Ptr->StdMessageFrame), + I2O_EXEC_LCT_NOTIFY); + I2O_EXEC_LCT_NOTIFY_MESSAGE_setClassIdentifier(Message_Ptr, + I2O_CLASS_MATCH_ANYCLASS); + (void)ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); #endif - s = splcam(); - /* - * We do not need to inform the CAM layer that we had a bus - * reset since we manage it on our own, this also prevents the - * SCSI_DELAY settling that would be required on other systems. - * The `SCSI_DELAY' has already been handled by the card via the - * acquisition of the LCT table while we are at CAM priority level. - * for (int bus = 0; bus <= sc->ha_MaxBus; ++bus) { - * xpt_async (AC_BUS_RESET, sc->ha_path[bus], NULL); - * } - */ - while ((ccb = LIST_FIRST(&(sc->ha_ccb))) != (struct ccb_hdr *)NULL) { - ASR_ccbRemove (sc, (union asr_ccb *)ccb); - - ccb->status &= ~CAM_STATUS_MASK; - ccb->status |= CAM_REQUEUE_REQ; - /* Nothing Transfered */ - ((struct ccb_scsiio *)ccb)->resid - = ((struct ccb_scsiio *)ccb)->dxfer_len; - - if (ccb->path) { - xpt_done ((union ccb *)ccb); - } else { - wakeup ((caddr_t)ccb); - } - } - splx(s); + s = splcam(); + /* + * We do not need to inform the CAM layer that we had a bus + * reset since we manage it on our own, this also prevents the + * SCSI_DELAY settling that would be required on other systems. + * The `SCSI_DELAY' has already been handled by the card via the + * acquisition of the LCT table while we are at CAM priority level. + * for (int bus = 0; bus <= sc->ha_MaxBus; ++bus) { + * xpt_async (AC_BUS_RESET, sc->ha_path[bus], NULL); + * } + */ + while ((ccb = LIST_FIRST(&(sc->ha_ccb))) != (struct ccb_hdr *)NULL) { + ASR_ccbRemove (sc, (union asr_ccb *)ccb); + + ccb->status &= ~CAM_STATUS_MASK; + ccb->status |= CAM_REQUEUE_REQ; + /* Nothing Transfered */ + ((struct ccb_scsiio *)ccb)->resid + = ((struct ccb_scsiio *)ccb)->dxfer_len; + + if (ccb->path) { + xpt_done ((union ccb *)ccb); + } else { + wakeup ((caddr_t)ccb); + } + } + splx(s); } /* ASR_failActiveCommands */ /* - * The following command causes the HBA to reset the specific bus + * The following command causes the HBA to reset the specific bus */ STATIC INLINE void ASR_resetBus( - IN Asr_softc_t * sc, - IN int bus) + IN Asr_softc_t * sc, + IN int bus) { - defAlignLong(I2O_HBA_BUS_RESET_MESSAGE,Message); - I2O_HBA_BUS_RESET_MESSAGE * Message_Ptr; - PI2O_LCT_ENTRY Device; - - Message_Ptr = (I2O_HBA_BUS_RESET_MESSAGE *)ASR_fillMessage(Message, - sizeof(I2O_HBA_BUS_RESET_MESSAGE)); - I2O_MESSAGE_FRAME_setFunction(&Message_Ptr->StdMessageFrame, - I2O_HBA_BUS_RESET); - for (Device = sc->ha_LCT->LCTEntry; Device < (PI2O_LCT_ENTRY) - (((U32 *)sc->ha_LCT)+I2O_LCT_getTableSize(sc->ha_LCT)); - ++Device) { - if (((Device->le_type & I2O_PORT) != 0) - && (Device->le_bus == bus)) { - I2O_MESSAGE_FRAME_setTargetAddress( - &Message_Ptr->StdMessageFrame, - I2O_LCT_ENTRY_getLocalTID(Device)); - /* Asynchronous command, with no expectations */ - (void)ASR_queue(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); - break; - } - } + defAlignLong(I2O_HBA_BUS_RESET_MESSAGE,Message); + I2O_HBA_BUS_RESET_MESSAGE * Message_Ptr; + PI2O_LCT_ENTRY Device; + + Message_Ptr = (I2O_HBA_BUS_RESET_MESSAGE *)ASR_fillMessage(Message, + sizeof(I2O_HBA_BUS_RESET_MESSAGE)); + I2O_MESSAGE_FRAME_setFunction(&Message_Ptr->StdMessageFrame, + I2O_HBA_BUS_RESET); + for (Device = sc->ha_LCT->LCTEntry; Device < (PI2O_LCT_ENTRY) + (((U32 *)sc->ha_LCT)+I2O_LCT_getTableSize(sc->ha_LCT)); + ++Device) { + if (((Device->le_type & I2O_PORT) != 0) + && (Device->le_bus == bus)) { + I2O_MESSAGE_FRAME_setTargetAddress( + &Message_Ptr->StdMessageFrame, + I2O_LCT_ENTRY_getLocalTID(Device)); + /* Asynchronous command, with no expectations */ + (void)ASR_queue(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); + break; + } + } } /* ASR_resetBus */ STATIC INLINE int ASR_getBlinkLedCode ( - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { - if ((sc != (Asr_softc_t *)NULL) - && (sc->ha_blinkLED != (u_int8_t *)NULL) - && (sc->ha_blinkLED[1] == 0xBC)) { - return (sc->ha_blinkLED[0]); - } - return (0); + if ((sc != (Asr_softc_t *)NULL) + && (sc->ha_blinkLED != (u_int8_t *)NULL) + && (sc->ha_blinkLED[1] == 0xBC)) { + return (sc->ha_blinkLED[0]); + } + return (0); } /* ASR_getBlinkCode */ /* - * Determine the address of an TID lookup. Must be done at high priority - * since the address can be changed by other threads of execution. + * Determine the address of an TID lookup. Must be done at high priority + * since the address can be changed by other threads of execution. * - * Returns NULL pointer if not indexible (but will attempt to generate - * an index if `new_entry' flag is set to TRUE). + * Returns NULL pointer if not indexible (but will attempt to generate + * an index if `new_entry' flag is set to TRUE). * - * All addressible entries are to be guaranteed zero if never initialized. + * All addressible entries are to be guaranteed zero if never initialized. */ STATIC INLINE tid_t * ASR_getTidAddress( - INOUT Asr_softc_t * sc, - IN int bus, - IN int target, - IN int lun, - IN int new_entry) + INOUT Asr_softc_t * sc, + IN int bus, + IN int target, + IN int lun, + IN int new_entry) { - target2lun_t * bus_ptr; - lun2tid_t * target_ptr; - unsigned new_size; - - /* - * Validity checking of incoming parameters. More of a bound - * expansion limit than an issue with the code dealing with the - * values. - * - * sc must be valid before it gets here, so that check could be - * dropped if speed a critical issue. - */ - if ((sc == (Asr_softc_t *)NULL) - || (bus > MAX_CHANNEL) - || (target > sc->ha_MaxId) - || (lun > sc->ha_MaxLun)) { - debug_asr_printf("(%lx,%d,%d,%d) target out of range\n", - (u_long)sc, bus, target, lun); - return ((tid_t *)NULL); - } - /* - * See if there is an associated bus list. - * - * for performance, allocate in size of BUS_CHUNK chunks. - * BUS_CHUNK must be a power of two. This is to reduce - * fragmentation effects on the allocations. - */ -# define BUS_CHUNK 8 - new_size = ((target + BUS_CHUNK - 1) & ~(BUS_CHUNK - 1)); - if ((bus_ptr = sc->ha_targets[bus]) == (target2lun_t *)NULL) { - /* - * Allocate a new structure? - * Since one element in structure, the +1 - * needed for size has been abstracted. - */ - if ((new_entry == FALSE) - || ((sc->ha_targets[bus] = bus_ptr = (target2lun_t *)malloc ( - sizeof(*bus_ptr) + (sizeof(bus_ptr->LUN) * new_size), - M_TEMP, M_WAITOK | M_ZERO)) - == (target2lun_t *)NULL)) { - debug_asr_printf("failed to allocate bus list\n"); - return ((tid_t *)NULL); - } - bus_ptr->size = new_size + 1; - } else if (bus_ptr->size <= new_size) { - target2lun_t * new_bus_ptr; - - /* - * Reallocate a new structure? - * Since one element in structure, the +1 - * needed for size has been abstracted. - */ - if ((new_entry == FALSE) - || ((new_bus_ptr = (target2lun_t *)malloc ( - sizeof(*bus_ptr) + (sizeof(bus_ptr->LUN) * new_size), - M_TEMP, M_WAITOK | M_ZERO)) - == (target2lun_t *)NULL)) { - debug_asr_printf("failed to reallocate bus list\n"); - return ((tid_t *)NULL); - } - /* - * Copy the whole thing, safer, simpler coding - * and not really performance critical at this point. - */ - bcopy (bus_ptr, new_bus_ptr, sizeof(*bus_ptr) - + (sizeof(bus_ptr->LUN) * (bus_ptr->size - 1))); - sc->ha_targets[bus] = new_bus_ptr; - free (bus_ptr, M_TEMP); - bus_ptr = new_bus_ptr; - bus_ptr->size = new_size + 1; - } - /* - * We now have the bus list, lets get to the target list. - * Since most systems have only *one* lun, we do not allocate - * in chunks as above, here we allow one, then in chunk sizes. - * TARGET_CHUNK must be a power of two. This is to reduce - * fragmentation effects on the allocations. - */ -# define TARGET_CHUNK 8 - if ((new_size = lun) != 0) { - new_size = ((lun + TARGET_CHUNK - 1) & ~(TARGET_CHUNK - 1)); - } - if ((target_ptr = bus_ptr->LUN[target]) == (lun2tid_t *)NULL) { - /* - * Allocate a new structure? - * Since one element in structure, the +1 - * needed for size has been abstracted. - */ - if ((new_entry == FALSE) - || ((bus_ptr->LUN[target] = target_ptr = (lun2tid_t *)malloc ( - sizeof(*target_ptr) + (sizeof(target_ptr->TID) * new_size), - M_TEMP, M_WAITOK | M_ZERO)) - == (lun2tid_t *)NULL)) { - debug_asr_printf("failed to allocate target list\n"); - return ((tid_t *)NULL); - } - target_ptr->size = new_size + 1; - } else if (target_ptr->size <= new_size) { - lun2tid_t * new_target_ptr; - - /* - * Reallocate a new structure? - * Since one element in structure, the +1 - * needed for size has been abstracted. - */ - if ((new_entry == FALSE) - || ((new_target_ptr = (lun2tid_t *)malloc ( - sizeof(*target_ptr) + (sizeof(target_ptr->TID) * new_size), - M_TEMP, M_WAITOK | M_ZERO)) - == (lun2tid_t *)NULL)) { - debug_asr_printf("failed to reallocate target list\n"); - return ((tid_t *)NULL); - } - /* - * Copy the whole thing, safer, simpler coding - * and not really performance critical at this point. - */ - bcopy (target_ptr, new_target_ptr, - sizeof(*target_ptr) - + (sizeof(target_ptr->TID) * (target_ptr->size - 1))); - bus_ptr->LUN[target] = new_target_ptr; - free (target_ptr, M_TEMP); - target_ptr = new_target_ptr; - target_ptr->size = new_size + 1; - } - /* - * Now, acquire the TID address from the LUN indexed list. - */ - return (&(target_ptr->TID[lun])); + target2lun_t * bus_ptr; + lun2tid_t * target_ptr; + unsigned new_size; + + /* + * Validity checking of incoming parameters. More of a bound + * expansion limit than an issue with the code dealing with the + * values. + * + * sc must be valid before it gets here, so that check could be + * dropped if speed a critical issue. + */ + if ((sc == (Asr_softc_t *)NULL) + || (bus > MAX_CHANNEL) + || (target > sc->ha_MaxId) + || (lun > sc->ha_MaxLun)) { + debug_asr_printf("(%lx,%d,%d,%d) target out of range\n", + (u_long)sc, bus, target, lun); + return ((tid_t *)NULL); + } + /* + * See if there is an associated bus list. + * + * for performance, allocate in size of BUS_CHUNK chunks. + * BUS_CHUNK must be a power of two. This is to reduce + * fragmentation effects on the allocations. + */ +# define BUS_CHUNK 8 + new_size = ((target + BUS_CHUNK - 1) & ~(BUS_CHUNK - 1)); + if ((bus_ptr = sc->ha_targets[bus]) == (target2lun_t *)NULL) { + /* + * Allocate a new structure? + * Since one element in structure, the +1 + * needed for size has been abstracted. + */ + if ((new_entry == FALSE) + || ((sc->ha_targets[bus] = bus_ptr = (target2lun_t *)malloc ( + sizeof(*bus_ptr) + (sizeof(bus_ptr->LUN) * new_size), + M_TEMP, M_WAITOK | M_ZERO)) + == (target2lun_t *)NULL)) { + debug_asr_printf("failed to allocate bus list\n"); + return ((tid_t *)NULL); + } + bus_ptr->size = new_size + 1; + } else if (bus_ptr->size <= new_size) { + target2lun_t * new_bus_ptr; + + /* + * Reallocate a new structure? + * Since one element in structure, the +1 + * needed for size has been abstracted. + */ + if ((new_entry == FALSE) + || ((new_bus_ptr = (target2lun_t *)malloc ( + sizeof(*bus_ptr) + (sizeof(bus_ptr->LUN) * new_size), + M_TEMP, M_WAITOK | M_ZERO)) + == (target2lun_t *)NULL)) { + debug_asr_printf("failed to reallocate bus list\n"); + return ((tid_t *)NULL); + } + /* + * Copy the whole thing, safer, simpler coding + * and not really performance critical at this point. + */ + bcopy (bus_ptr, new_bus_ptr, sizeof(*bus_ptr) + + (sizeof(bus_ptr->LUN) * (bus_ptr->size - 1))); + sc->ha_targets[bus] = new_bus_ptr; + free (bus_ptr, M_TEMP); + bus_ptr = new_bus_ptr; + bus_ptr->size = new_size + 1; + } + /* + * We now have the bus list, lets get to the target list. + * Since most systems have only *one* lun, we do not allocate + * in chunks as above, here we allow one, then in chunk sizes. + * TARGET_CHUNK must be a power of two. This is to reduce + * fragmentation effects on the allocations. + */ +# define TARGET_CHUNK 8 + if ((new_size = lun) != 0) { + new_size = ((lun + TARGET_CHUNK - 1) & ~(TARGET_CHUNK - 1)); + } + if ((target_ptr = bus_ptr->LUN[target]) == (lun2tid_t *)NULL) { + /* + * Allocate a new structure? + * Since one element in structure, the +1 + * needed for size has been abstracted. + */ + if ((new_entry == FALSE) + || ((bus_ptr->LUN[target] = target_ptr = (lun2tid_t *)malloc ( + sizeof(*target_ptr) + (sizeof(target_ptr->TID) * new_size), + M_TEMP, M_WAITOK | M_ZERO)) + == (lun2tid_t *)NULL)) { + debug_asr_printf("failed to allocate target list\n"); + return ((tid_t *)NULL); + } + target_ptr->size = new_size + 1; + } else if (target_ptr->size <= new_size) { + lun2tid_t * new_target_ptr; + + /* + * Reallocate a new structure? + * Since one element in structure, the +1 + * needed for size has been abstracted. + */ + if ((new_entry == FALSE) + || ((new_target_ptr = (lun2tid_t *)malloc ( + sizeof(*target_ptr) + (sizeof(target_ptr->TID) * new_size), + M_TEMP, M_WAITOK | M_ZERO)) + == (lun2tid_t *)NULL)) { + debug_asr_printf("failed to reallocate target list\n"); + return ((tid_t *)NULL); + } + /* + * Copy the whole thing, safer, simpler coding + * and not really performance critical at this point. + */ + bcopy (target_ptr, new_target_ptr, + sizeof(*target_ptr) + + (sizeof(target_ptr->TID) * (target_ptr->size - 1))); + bus_ptr->LUN[target] = new_target_ptr; + free (target_ptr, M_TEMP); + target_ptr = new_target_ptr; + target_ptr->size = new_size + 1; + } + /* + * Now, acquire the TID address from the LUN indexed list. + */ + return (&(target_ptr->TID[lun])); } /* ASR_getTidAddress */ /* - * Get a pre-existing TID relationship. + * Get a pre-existing TID relationship. * - * If the TID was never set, return (tid_t)-1. + * If the TID was never set, return (tid_t)-1. * - * should use mutex rather than spl. + * should use mutex rather than spl. */ STATIC INLINE tid_t ASR_getTid ( - IN Asr_softc_t * sc, - IN int bus, - IN int target, - IN int lun) + IN Asr_softc_t * sc, + IN int bus, + IN int target, + IN int lun) { - tid_t * tid_ptr; - int s; - OUT tid_t retval; - - s = splcam(); - if (((tid_ptr = ASR_getTidAddress (sc, bus, target, lun, FALSE)) - == (tid_t *)NULL) - /* (tid_t)0 or (tid_t)-1 indicate no TID */ - || (*tid_ptr == (tid_t)0)) { - splx(s); - return ((tid_t)-1); - } - retval = *tid_ptr; - splx(s); - return (retval); + tid_t * tid_ptr; + int s; + OUT tid_t retval; + + s = splcam(); + if (((tid_ptr = ASR_getTidAddress (sc, bus, target, lun, FALSE)) + == (tid_t *)NULL) + /* (tid_t)0 or (tid_t)-1 indicate no TID */ + || (*tid_ptr == (tid_t)0)) { + splx(s); + return ((tid_t)-1); + } + retval = *tid_ptr; + splx(s); + return (retval); } /* ASR_getTid */ /* - * Set a TID relationship. + * Set a TID relationship. * - * If the TID was not set, return (tid_t)-1. + * If the TID was not set, return (tid_t)-1. * - * should use mutex rather than spl. + * should use mutex rather than spl. */ STATIC INLINE tid_t ASR_setTid ( - INOUT Asr_softc_t * sc, - IN int bus, - IN int target, - IN int lun, - INOUT tid_t TID) + INOUT Asr_softc_t * sc, + IN int bus, + IN int target, + IN int lun, + INOUT tid_t TID) { - tid_t * tid_ptr; - int s; - - if (TID != (tid_t)-1) { - if (TID == 0) { - return ((tid_t)-1); - } - s = splcam(); - if ((tid_ptr = ASR_getTidAddress (sc, bus, target, lun, TRUE)) - == (tid_t *)NULL) { - splx(s); - return ((tid_t)-1); - } - *tid_ptr = TID; - splx(s); - } - return (TID); + tid_t * tid_ptr; + int s; + + if (TID != (tid_t)-1) { + if (TID == 0) { + return ((tid_t)-1); + } + s = splcam(); + if ((tid_ptr = ASR_getTidAddress (sc, bus, target, lun, TRUE)) + == (tid_t *)NULL) { + splx(s); + return ((tid_t)-1); + } + *tid_ptr = TID; + splx(s); + } + return (TID); } /* ASR_setTid */ /*-------------------------------------------------------------------------*/ -/* Function ASR_rescan */ +/* Function ASR_rescan */ /*-------------------------------------------------------------------------*/ -/* The Parameters Passed To This Function Are : */ -/* Asr_softc_t * : HBA miniport driver's adapter data storage. */ -/* */ -/* This Function Will rescan the adapter and resynchronize any data */ -/* */ -/* Return : 0 For OK, Error Code Otherwise */ +/* The Parameters Passed To This Function Are : */ +/* Asr_softc_t * : HBA miniport driver's adapter data storage. */ +/* */ +/* This Function Will rescan the adapter and resynchronize any data */ +/* */ +/* Return : 0 For OK, Error Code Otherwise */ /*-------------------------------------------------------------------------*/ STATIC INLINE int ASR_rescan( - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { - int bus; - OUT int error; - - /* - * Re-acquire the LCT table and synchronize us to the adapter. - */ - if ((error = ASR_acquireLct(sc)) == 0) { - error = ASR_acquireHrt(sc); - } - - if (error != 0) { - return error; - } - - bus = sc->ha_MaxBus; - /* Reset all existing cached TID lookups */ - do { - int target, event = 0; - - /* - * Scan for all targets on this bus to see if they - * got affected by the rescan. - */ - for (target = 0; target <= sc->ha_MaxId; ++target) { - int lun; - - /* Stay away from the controller ID */ - if (target == sc->ha_adapter_target[bus]) { - continue; - } - for (lun = 0; lun <= sc->ha_MaxLun; ++lun) { - PI2O_LCT_ENTRY Device; - tid_t TID = (tid_t)-1; - tid_t LastTID; - - /* - * See if the cached TID changed. Search for - * the device in our new LCT. - */ - for (Device = sc->ha_LCT->LCTEntry; - Device < (PI2O_LCT_ENTRY)(((U32 *)sc->ha_LCT) - + I2O_LCT_getTableSize(sc->ha_LCT)); - ++Device) { - if ((Device->le_type != I2O_UNKNOWN) - && (Device->le_bus == bus) - && (Device->le_target == target) - && (Device->le_lun == lun) - && (I2O_LCT_ENTRY_getUserTID(Device) - == 0xFFF)) { - TID = I2O_LCT_ENTRY_getLocalTID( - Device); - break; - } - } - /* - * Indicate to the OS that the label needs - * to be recalculated, or that the specific - * open device is no longer valid (Merde) - * because the cached TID changed. - */ - LastTID = ASR_getTid (sc, bus, target, lun); - if (LastTID != TID) { - struct cam_path * path; - - if (xpt_create_path(&path, - /*periph*/NULL, - cam_sim_path(sc->ha_sim[bus]), - target, lun) != CAM_REQ_CMP) { - if (TID == (tid_t)-1) { - event |= AC_LOST_DEVICE; - } else { - event |= AC_INQ_CHANGED - | AC_GETDEV_CHANGED; - } - } else { - if (TID == (tid_t)-1) { - xpt_async( - AC_LOST_DEVICE, - path, NULL); - } else if (LastTID == (tid_t)-1) { - struct ccb_getdev ccb; - - xpt_setup_ccb( - &(ccb.ccb_h), - path, /*priority*/5); - xpt_async( - AC_FOUND_DEVICE, - path, - &ccb); - } else { - xpt_async( - AC_INQ_CHANGED, - path, NULL); - xpt_async( - AC_GETDEV_CHANGED, - path, NULL); - } - } - } - /* - * We have the option of clearing the - * cached TID for it to be rescanned, or to - * set it now even if the device never got - * accessed. We chose the later since we - * currently do not use the condition that - * the TID ever got cached. - */ - ASR_setTid (sc, bus, target, lun, TID); - } - } - /* - * The xpt layer can not handle multiple events at the - * same call. - */ - if (event & AC_LOST_DEVICE) { - xpt_async(AC_LOST_DEVICE, sc->ha_path[bus], NULL); - } - if (event & AC_INQ_CHANGED) { - xpt_async(AC_INQ_CHANGED, sc->ha_path[bus], NULL); - } - if (event & AC_GETDEV_CHANGED) { - xpt_async(AC_GETDEV_CHANGED, sc->ha_path[bus], NULL); - } - } while (--bus >= 0); - return (error); + int bus; + OUT int error; + + /* + * Re-acquire the LCT table and synchronize us to the adapter. + */ + if ((error = ASR_acquireLct(sc)) == 0) { + error = ASR_acquireHrt(sc); + } + + if (error != 0) { + return error; + } + + bus = sc->ha_MaxBus; + /* Reset all existing cached TID lookups */ + do { + int target, event = 0; + + /* + * Scan for all targets on this bus to see if they + * got affected by the rescan. + */ + for (target = 0; target <= sc->ha_MaxId; ++target) { + int lun; + + /* Stay away from the controller ID */ + if (target == sc->ha_adapter_target[bus]) { + continue; + } + for (lun = 0; lun <= sc->ha_MaxLun; ++lun) { + PI2O_LCT_ENTRY Device; + tid_t TID = (tid_t)-1; + tid_t LastTID; + + /* + * See if the cached TID changed. Search for + * the device in our new LCT. + */ + for (Device = sc->ha_LCT->LCTEntry; + Device < (PI2O_LCT_ENTRY)(((U32 *)sc->ha_LCT) + + I2O_LCT_getTableSize(sc->ha_LCT)); + ++Device) { + if ((Device->le_type != I2O_UNKNOWN) + && (Device->le_bus == bus) + && (Device->le_target == target) + && (Device->le_lun == lun) + && (I2O_LCT_ENTRY_getUserTID(Device) + == 0xFFF)) { + TID = I2O_LCT_ENTRY_getLocalTID( + Device); + break; + } + } + /* + * Indicate to the OS that the label needs + * to be recalculated, or that the specific + * open device is no longer valid (Merde) + * because the cached TID changed. + */ + LastTID = ASR_getTid (sc, bus, target, lun); + if (LastTID != TID) { + struct cam_path * path; + + if (xpt_create_path(&path, + /*periph*/NULL, + cam_sim_path(sc->ha_sim[bus]), + target, lun) != CAM_REQ_CMP) { + if (TID == (tid_t)-1) { + event |= AC_LOST_DEVICE; + } else { + event |= AC_INQ_CHANGED + | AC_GETDEV_CHANGED; + } + } else { + if (TID == (tid_t)-1) { + xpt_async( + AC_LOST_DEVICE, + path, NULL); + } else if (LastTID == (tid_t)-1) { + struct ccb_getdev ccb; + + xpt_setup_ccb( + &(ccb.ccb_h), + path, /*priority*/5); + xpt_async( + AC_FOUND_DEVICE, + path, + &ccb); + } else { + xpt_async( + AC_INQ_CHANGED, + path, NULL); + xpt_async( + AC_GETDEV_CHANGED, + path, NULL); + } + } + } + /* + * We have the option of clearing the + * cached TID for it to be rescanned, or to + * set it now even if the device never got + * accessed. We chose the later since we + * currently do not use the condition that + * the TID ever got cached. + */ + ASR_setTid (sc, bus, target, lun, TID); + } + } + /* + * The xpt layer can not handle multiple events at the + * same call. + */ + if (event & AC_LOST_DEVICE) { + xpt_async(AC_LOST_DEVICE, sc->ha_path[bus], NULL); + } + if (event & AC_INQ_CHANGED) { + xpt_async(AC_INQ_CHANGED, sc->ha_path[bus], NULL); + } + if (event & AC_GETDEV_CHANGED) { + xpt_async(AC_GETDEV_CHANGED, sc->ha_path[bus], NULL); + } + } while (--bus >= 0); + return (error); } /* ASR_rescan */ /*-------------------------------------------------------------------------*/ -/* Function ASR_reset */ +/* Function ASR_reset */ /*-------------------------------------------------------------------------*/ -/* The Parameters Passed To This Function Are : */ -/* Asr_softc_t * : HBA miniport driver's adapter data storage. */ -/* */ -/* This Function Will reset the adapter and resynchronize any data */ -/* */ -/* Return : None */ +/* The Parameters Passed To This Function Are : */ +/* Asr_softc_t * : HBA miniport driver's adapter data storage. */ +/* */ +/* This Function Will reset the adapter and resynchronize any data */ +/* */ +/* Return : None */ /*-------------------------------------------------------------------------*/ STATIC INLINE int ASR_reset( - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { - int s, retVal; - - s = splcam(); - if ((sc->ha_in_reset == HA_IN_RESET) - || (sc->ha_in_reset == HA_OFF_LINE_RECOVERY)) { - splx (s); - return (EBUSY); - } - /* - * Promotes HA_OPERATIONAL to HA_IN_RESET, - * or HA_OFF_LINE to HA_OFF_LINE_RECOVERY. - */ - ++(sc->ha_in_reset); - if (ASR_resetIOP (sc->ha_Virt, sc->ha_Fvirt) == 0) { - debug_asr_printf ("ASR_resetIOP failed\n"); - /* - * We really need to take this card off-line, easier said - * than make sense. Better to keep retrying for now since if a - * UART cable is connected the blinkLEDs the adapter is now in - * a hard state requiring action from the monitor commands to - * the HBA to continue. For debugging waiting forever is a - * good thing. In a production system, however, one may wish - * to instead take the card off-line ... - */ -# if 0 && (defined(HA_OFF_LINE)) - /* - * Take adapter off-line. - */ - printf ("asr%d: Taking adapter off-line\n", - sc->ha_path[0] - ? cam_sim_unit(xpt_path_sim(sc->ha_path[0])) - : 0); - sc->ha_in_reset = HA_OFF_LINE; - splx (s); - return (ENXIO); -# else - /* Wait Forever */ - while (ASR_resetIOP (sc->ha_Virt, sc->ha_Fvirt) == 0); -# endif - } - retVal = ASR_init (sc); - splx (s); - if (retVal != 0) { - debug_asr_printf ("ASR_init failed\n"); - sc->ha_in_reset = HA_OFF_LINE; - return (ENXIO); - } - if (ASR_rescan (sc) != 0) { - debug_asr_printf ("ASR_rescan failed\n"); - } - ASR_failActiveCommands (sc); - if (sc->ha_in_reset == HA_OFF_LINE_RECOVERY) { - printf ("asr%d: Brining adapter back on-line\n", - sc->ha_path[0] - ? cam_sim_unit(xpt_path_sim(sc->ha_path[0])) - : 0); - } - sc->ha_in_reset = HA_OPERATIONAL; - return (0); + int s, retVal; + + s = splcam(); + if ((sc->ha_in_reset == HA_IN_RESET) + || (sc->ha_in_reset == HA_OFF_LINE_RECOVERY)) { + splx (s); + return (EBUSY); + } + /* + * Promotes HA_OPERATIONAL to HA_IN_RESET, + * or HA_OFF_LINE to HA_OFF_LINE_RECOVERY. + */ + ++(sc->ha_in_reset); + if (ASR_resetIOP (sc->ha_Virt, sc->ha_Fvirt) == 0) { + debug_asr_printf ("ASR_resetIOP failed\n"); + /* + * We really need to take this card off-line, easier said + * than make sense. Better to keep retrying for now since if a + * UART cable is connected the blinkLEDs the adapter is now in + * a hard state requiring action from the monitor commands to + * the HBA to continue. For debugging waiting forever is a + * good thing. In a production system, however, one may wish + * to instead take the card off-line ... + */ +# if 0 && (defined(HA_OFF_LINE)) + /* + * Take adapter off-line. + */ + printf ("asr%d: Taking adapter off-line\n", + sc->ha_path[0] + ? cam_sim_unit(xpt_path_sim(sc->ha_path[0])) + : 0); + sc->ha_in_reset = HA_OFF_LINE; + splx (s); + return (ENXIO); +# else + /* Wait Forever */ + while (ASR_resetIOP (sc->ha_Virt, sc->ha_Fvirt) == 0); +# endif + } + retVal = ASR_init (sc); + splx (s); + if (retVal != 0) { + debug_asr_printf ("ASR_init failed\n"); + sc->ha_in_reset = HA_OFF_LINE; + return (ENXIO); + } + if (ASR_rescan (sc) != 0) { + debug_asr_printf ("ASR_rescan failed\n"); + } + ASR_failActiveCommands (sc); + if (sc->ha_in_reset == HA_OFF_LINE_RECOVERY) { + printf ("asr%d: Brining adapter back on-line\n", + sc->ha_path[0] + ? cam_sim_unit(xpt_path_sim(sc->ha_path[0])) + : 0); + } + sc->ha_in_reset = HA_OPERATIONAL; + return (0); } /* ASR_reset */ /* - * Device timeout handler. + * Device timeout handler. */ STATIC void asr_timeout( - INOUT void * arg) + INOUT void * arg) { - union asr_ccb * ccb = (union asr_ccb *)arg; - Asr_softc_t * sc = (Asr_softc_t *)(ccb->ccb_h.spriv_ptr0); - int s; - - debug_asr_print_path(ccb); - debug_asr_printf("timed out"); - - /* - * Check if the adapter has locked up? - */ - if ((s = ASR_getBlinkLedCode(sc)) != 0) { - /* Reset Adapter */ - printf ("asr%d: Blink LED 0x%x resetting adapter\n", - cam_sim_unit(xpt_path_sim(ccb->ccb_h.path)), s); - if (ASR_reset (sc) == ENXIO) { - /* Try again later */ - ccb->ccb_h.timeout_ch = timeout(asr_timeout, - (caddr_t)ccb, - (ccb->ccb_h.timeout * hz) / 1000); - } - return; - } - /* - * Abort does not function on the ASR card!!! Walking away from - * the SCSI command is also *very* dangerous. A SCSI BUS reset is - * our best bet, followed by a complete adapter reset if that fails. - */ - s = splcam(); - /* Check if we already timed out once to raise the issue */ - if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_CMD_TIMEOUT) { - debug_asr_printf (" AGAIN\nreinitializing adapter\n"); - if (ASR_reset (sc) == ENXIO) { - ccb->ccb_h.timeout_ch = timeout(asr_timeout, - (caddr_t)ccb, - (ccb->ccb_h.timeout * hz) / 1000); - } - splx(s); - return; - } - debug_asr_printf ("\nresetting bus\n"); - /* If the BUS reset does not take, then an adapter reset is next! */ - ccb->ccb_h.status &= ~CAM_STATUS_MASK; - ccb->ccb_h.status |= CAM_CMD_TIMEOUT; - ccb->ccb_h.timeout_ch = timeout(asr_timeout, (caddr_t)ccb, - (ccb->ccb_h.timeout * hz) / 1000); - ASR_resetBus (sc, cam_sim_bus(xpt_path_sim(ccb->ccb_h.path))); - xpt_async (AC_BUS_RESET, ccb->ccb_h.path, NULL); - splx(s); + union asr_ccb * ccb = (union asr_ccb *)arg; + Asr_softc_t * sc = (Asr_softc_t *)(ccb->ccb_h.spriv_ptr0); + int s; + + debug_asr_print_path(ccb); + debug_asr_printf("timed out"); + + /* + * Check if the adapter has locked up? + */ + if ((s = ASR_getBlinkLedCode(sc)) != 0) { + /* Reset Adapter */ + printf ("asr%d: Blink LED 0x%x resetting adapter\n", + cam_sim_unit(xpt_path_sim(ccb->ccb_h.path)), s); + if (ASR_reset (sc) == ENXIO) { + /* Try again later */ + ccb->ccb_h.timeout_ch = timeout(asr_timeout, + (caddr_t)ccb, + (ccb->ccb_h.timeout * hz) / 1000); + } + return; + } + /* + * Abort does not function on the ASR card!!! Walking away from + * the SCSI command is also *very* dangerous. A SCSI BUS reset is + * our best bet, followed by a complete adapter reset if that fails. + */ + s = splcam(); + /* Check if we already timed out once to raise the issue */ + if ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_CMD_TIMEOUT) { + debug_asr_printf (" AGAIN\nreinitializing adapter\n"); + if (ASR_reset (sc) == ENXIO) { + ccb->ccb_h.timeout_ch = timeout(asr_timeout, + (caddr_t)ccb, + (ccb->ccb_h.timeout * hz) / 1000); + } + splx(s); + return; + } + debug_asr_printf ("\nresetting bus\n"); + /* If the BUS reset does not take, then an adapter reset is next! */ + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + ccb->ccb_h.status |= CAM_CMD_TIMEOUT; + ccb->ccb_h.timeout_ch = timeout(asr_timeout, (caddr_t)ccb, + (ccb->ccb_h.timeout * hz) / 1000); + ASR_resetBus (sc, cam_sim_bus(xpt_path_sim(ccb->ccb_h.path))); + xpt_async (AC_BUS_RESET, ccb->ccb_h.path, NULL); + splx(s); } /* asr_timeout */ /* @@ -1643,404 +1643,404 @@ asr_timeout( */ STATIC INLINE int ASR_queue( - IN Asr_softc_t * sc, - IN PI2O_MESSAGE_FRAME Message) + IN Asr_softc_t * sc, + IN PI2O_MESSAGE_FRAME Message) { - OUT U32 MessageOffset; - union asr_ccb * ccb; + OUT U32 MessageOffset; + union asr_ccb * ccb; - debug_asr_printf ("Host Command Dump:\n"); - debug_asr_dump_message (Message); + debug_asr_printf ("Host Command Dump:\n"); + debug_asr_dump_message (Message); - ccb = (union asr_ccb *)(long) - I2O_MESSAGE_FRAME_getInitiatorContext64(Message); + ccb = (union asr_ccb *)(long) + I2O_MESSAGE_FRAME_getInitiatorContext64(Message); - if ((MessageOffset = ASR_getMessage(sc->ha_Virt)) != EMPTY_QUEUE) { + if ((MessageOffset = ASR_getMessage(sc->ha_Virt)) != EMPTY_QUEUE) { #ifdef ASR_MEASURE_PERFORMANCE - int startTimeIndex; - - if (ccb) { - ++sc->ha_performance.command_count[ - (int) ccb->csio.cdb_io.cdb_bytes[0]]; - DEQ_TIMEQ_FREE_LIST(startTimeIndex, - sc->ha_timeQFreeList, - sc->ha_timeQFreeHead, - sc->ha_timeQFreeTail); - if (-1 != startTimeIndex) { - microtime(&(sc->ha_timeQ[startTimeIndex])); - } - /* Time stamp the command before we send it out */ - ((PRIVATE_SCSI_SCB_EXECUTE_MESSAGE *) Message)-> - PrivateMessageFrame.TransactionContext - = (I2O_TRANSACTION_CONTEXT) startTimeIndex; - - ++sc->ha_submitted_ccbs_count; - if (sc->ha_performance.max_submit_count - < sc->ha_submitted_ccbs_count) { - sc->ha_performance.max_submit_count - = sc->ha_submitted_ccbs_count; - } - } + int startTimeIndex; + + if (ccb) { + ++sc->ha_performance.command_count[ + (int) ccb->csio.cdb_io.cdb_bytes[0]]; + DEQ_TIMEQ_FREE_LIST(startTimeIndex, + sc->ha_timeQFreeList, + sc->ha_timeQFreeHead, + sc->ha_timeQFreeTail); + if (-1 != startTimeIndex) { + microtime(&(sc->ha_timeQ[startTimeIndex])); + } + /* Time stamp the command before we send it out */ + ((PRIVATE_SCSI_SCB_EXECUTE_MESSAGE *) Message)-> + PrivateMessageFrame.TransactionContext + = (I2O_TRANSACTION_CONTEXT) startTimeIndex; + + ++sc->ha_submitted_ccbs_count; + if (sc->ha_performance.max_submit_count + < sc->ha_submitted_ccbs_count) { + sc->ha_performance.max_submit_count + = sc->ha_submitted_ccbs_count; + } + } #endif - bcopy (Message, sc->ha_Fvirt + MessageOffset, - I2O_MESSAGE_FRAME_getMessageSize(Message) << 2); - if (ccb) { - ASR_ccbAdd (sc, ccb); - } - /* Post the command */ - sc->ha_Virt->ToFIFO = MessageOffset; - } else { - if (ASR_getBlinkLedCode(sc)) { - /* - * Unlikely we can do anything if we can't grab a - * message frame :-(, but lets give it a try. - */ - (void)ASR_reset (sc); - } - } - return (MessageOffset); + bcopy (Message, sc->ha_Fvirt + MessageOffset, + I2O_MESSAGE_FRAME_getMessageSize(Message) << 2); + if (ccb) { + ASR_ccbAdd (sc, ccb); + } + /* Post the command */ + sc->ha_Virt->ToFIFO = MessageOffset; + } else { + if (ASR_getBlinkLedCode(sc)) { + /* + * Unlikely we can do anything if we can't grab a + * message frame :-(, but lets give it a try. + */ + (void)ASR_reset (sc); + } + } + return (MessageOffset); } /* ASR_queue */ /* Simple Scatter Gather elements */ -#define SG(SGL,Index,Flags,Buffer,Size) \ - I2O_FLAGS_COUNT_setCount( \ - &(((PI2O_SG_ELEMENT)(SGL))->u.Simple[Index].FlagsCount), \ - Size); \ - I2O_FLAGS_COUNT_setFlags( \ - &(((PI2O_SG_ELEMENT)(SGL))->u.Simple[Index].FlagsCount), \ - I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT | (Flags)); \ - I2O_SGE_SIMPLE_ELEMENT_setPhysicalAddress( \ - &(((PI2O_SG_ELEMENT)(SGL))->u.Simple[Index]), \ - (Buffer == NULL) ? NULL : KVTOPHYS(Buffer)) +#define SG(SGL,Index,Flags,Buffer,Size) \ + I2O_FLAGS_COUNT_setCount( \ + &(((PI2O_SG_ELEMENT)(SGL))->u.Simple[Index].FlagsCount), \ + Size); \ + I2O_FLAGS_COUNT_setFlags( \ + &(((PI2O_SG_ELEMENT)(SGL))->u.Simple[Index].FlagsCount), \ + I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT | (Flags)); \ + I2O_SGE_SIMPLE_ELEMENT_setPhysicalAddress( \ + &(((PI2O_SG_ELEMENT)(SGL))->u.Simple[Index]), \ + (Buffer == NULL) ? NULL : KVTOPHYS(Buffer)) /* - * Retrieve Parameter Group. - * Buffer must be allocated using defAlignLong macro. + * Retrieve Parameter Group. + * Buffer must be allocated using defAlignLong macro. */ STATIC void * ASR_getParams( - IN Asr_softc_t * sc, - IN tid_t TID, - IN int Group, - OUT void * Buffer, - IN unsigned BufferSize) + IN Asr_softc_t * sc, + IN tid_t TID, + IN int Group, + OUT void * Buffer, + IN unsigned BufferSize) { - struct paramGetMessage { - I2O_UTIL_PARAMS_GET_MESSAGE M; - char F[ - sizeof(I2O_SGE_SIMPLE_ELEMENT)*2 - sizeof(I2O_SG_ELEMENT)]; - struct Operations { - I2O_PARAM_OPERATIONS_LIST_HEADER Header; - I2O_PARAM_OPERATION_ALL_TEMPLATE Template[1]; - } O; - }; - defAlignLong(struct paramGetMessage, Message); - struct Operations * Operations_Ptr; - I2O_UTIL_PARAMS_GET_MESSAGE * Message_Ptr; - struct ParamBuffer { - I2O_PARAM_RESULTS_LIST_HEADER Header; - I2O_PARAM_READ_OPERATION_RESULT Read; - char Info[1]; - } * Buffer_Ptr; - - Message_Ptr = (I2O_UTIL_PARAMS_GET_MESSAGE *)ASR_fillMessage(Message, - sizeof(I2O_UTIL_PARAMS_GET_MESSAGE) - + sizeof(I2O_SGE_SIMPLE_ELEMENT)*2 - sizeof(I2O_SG_ELEMENT)); - Operations_Ptr = (struct Operations *)((char *)Message_Ptr - + sizeof(I2O_UTIL_PARAMS_GET_MESSAGE) - + sizeof(I2O_SGE_SIMPLE_ELEMENT)*2 - sizeof(I2O_SG_ELEMENT)); - bzero ((void *)Operations_Ptr, sizeof(struct Operations)); - I2O_PARAM_OPERATIONS_LIST_HEADER_setOperationCount( - &(Operations_Ptr->Header), 1); - I2O_PARAM_OPERATION_ALL_TEMPLATE_setOperation( - &(Operations_Ptr->Template[0]), I2O_PARAMS_OPERATION_FIELD_GET); - I2O_PARAM_OPERATION_ALL_TEMPLATE_setFieldCount( - &(Operations_Ptr->Template[0]), 0xFFFF); - I2O_PARAM_OPERATION_ALL_TEMPLATE_setGroupNumber( - &(Operations_Ptr->Template[0]), Group); - bzero ((void *)(Buffer_Ptr = getAlignLong(struct ParamBuffer, Buffer)), - BufferSize); - - I2O_MESSAGE_FRAME_setVersionOffset(&(Message_Ptr->StdMessageFrame), - I2O_VERSION_11 - + (((sizeof(I2O_UTIL_PARAMS_GET_MESSAGE) - sizeof(I2O_SG_ELEMENT)) - / sizeof(U32)) << 4)); - I2O_MESSAGE_FRAME_setTargetAddress (&(Message_Ptr->StdMessageFrame), - TID); - I2O_MESSAGE_FRAME_setFunction (&(Message_Ptr->StdMessageFrame), - I2O_UTIL_PARAMS_GET); - /* - * Set up the buffers as scatter gather elements. - */ - SG(&(Message_Ptr->SGL), 0, - I2O_SGL_FLAGS_DIR | I2O_SGL_FLAGS_END_OF_BUFFER, - Operations_Ptr, sizeof(struct Operations)); - SG(&(Message_Ptr->SGL), 1, - I2O_SGL_FLAGS_LAST_ELEMENT | I2O_SGL_FLAGS_END_OF_BUFFER, - Buffer_Ptr, BufferSize); - - if ((ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr) == CAM_REQ_CMP) - && (Buffer_Ptr->Header.ResultCount)) { - return ((void *)(Buffer_Ptr->Info)); - } - return ((void *)NULL); + struct paramGetMessage { + I2O_UTIL_PARAMS_GET_MESSAGE M; + char F[ + sizeof(I2O_SGE_SIMPLE_ELEMENT)*2 - sizeof(I2O_SG_ELEMENT)]; + struct Operations { + I2O_PARAM_OPERATIONS_LIST_HEADER Header; + I2O_PARAM_OPERATION_ALL_TEMPLATE Template[1]; + } O; + }; + defAlignLong(struct paramGetMessage, Message); + struct Operations * Operations_Ptr; + I2O_UTIL_PARAMS_GET_MESSAGE * Message_Ptr; + struct ParamBuffer { + I2O_PARAM_RESULTS_LIST_HEADER Header; + I2O_PARAM_READ_OPERATION_RESULT Read; + char Info[1]; + } * Buffer_Ptr; + + Message_Ptr = (I2O_UTIL_PARAMS_GET_MESSAGE *)ASR_fillMessage(Message, + sizeof(I2O_UTIL_PARAMS_GET_MESSAGE) + + sizeof(I2O_SGE_SIMPLE_ELEMENT)*2 - sizeof(I2O_SG_ELEMENT)); + Operations_Ptr = (struct Operations *)((char *)Message_Ptr + + sizeof(I2O_UTIL_PARAMS_GET_MESSAGE) + + sizeof(I2O_SGE_SIMPLE_ELEMENT)*2 - sizeof(I2O_SG_ELEMENT)); + bzero ((void *)Operations_Ptr, sizeof(struct Operations)); + I2O_PARAM_OPERATIONS_LIST_HEADER_setOperationCount( + &(Operations_Ptr->Header), 1); + I2O_PARAM_OPERATION_ALL_TEMPLATE_setOperation( + &(Operations_Ptr->Template[0]), I2O_PARAMS_OPERATION_FIELD_GET); + I2O_PARAM_OPERATION_ALL_TEMPLATE_setFieldCount( + &(Operations_Ptr->Template[0]), 0xFFFF); + I2O_PARAM_OPERATION_ALL_TEMPLATE_setGroupNumber( + &(Operations_Ptr->Template[0]), Group); + bzero ((void *)(Buffer_Ptr = getAlignLong(struct ParamBuffer, Buffer)), + BufferSize); + + I2O_MESSAGE_FRAME_setVersionOffset(&(Message_Ptr->StdMessageFrame), + I2O_VERSION_11 + + (((sizeof(I2O_UTIL_PARAMS_GET_MESSAGE) - sizeof(I2O_SG_ELEMENT)) + / sizeof(U32)) << 4)); + I2O_MESSAGE_FRAME_setTargetAddress (&(Message_Ptr->StdMessageFrame), + TID); + I2O_MESSAGE_FRAME_setFunction (&(Message_Ptr->StdMessageFrame), + I2O_UTIL_PARAMS_GET); + /* + * Set up the buffers as scatter gather elements. + */ + SG(&(Message_Ptr->SGL), 0, + I2O_SGL_FLAGS_DIR | I2O_SGL_FLAGS_END_OF_BUFFER, + Operations_Ptr, sizeof(struct Operations)); + SG(&(Message_Ptr->SGL), 1, + I2O_SGL_FLAGS_LAST_ELEMENT | I2O_SGL_FLAGS_END_OF_BUFFER, + Buffer_Ptr, BufferSize); + + if ((ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr) == CAM_REQ_CMP) + && (Buffer_Ptr->Header.ResultCount)) { + return ((void *)(Buffer_Ptr->Info)); + } + return ((void *)NULL); } /* ASR_getParams */ /* - * Acquire the LCT information. + * Acquire the LCT information. */ STATIC INLINE int ASR_acquireLct ( - INOUT Asr_softc_t * sc) + INOUT Asr_softc_t * sc) { - PI2O_EXEC_LCT_NOTIFY_MESSAGE Message_Ptr; - PI2O_SGE_SIMPLE_ELEMENT sg; - int MessageSizeInBytes; - caddr_t v; - int len; - I2O_LCT Table; - PI2O_LCT_ENTRY Entry; - - /* - * sc value assumed valid - */ - MessageSizeInBytes = sizeof(I2O_EXEC_LCT_NOTIFY_MESSAGE) - - sizeof(I2O_SG_ELEMENT) + sizeof(I2O_SGE_SIMPLE_ELEMENT); - if ((Message_Ptr = (PI2O_EXEC_LCT_NOTIFY_MESSAGE)malloc ( - MessageSizeInBytes, M_TEMP, M_WAITOK)) - == (PI2O_EXEC_LCT_NOTIFY_MESSAGE)NULL) { - return (ENOMEM); - } - (void)ASR_fillMessage((char *)Message_Ptr, MessageSizeInBytes); - I2O_MESSAGE_FRAME_setVersionOffset(&(Message_Ptr->StdMessageFrame), - (I2O_VERSION_11 + - (((sizeof(I2O_EXEC_LCT_NOTIFY_MESSAGE) - sizeof(I2O_SG_ELEMENT)) - / sizeof(U32)) << 4))); - I2O_MESSAGE_FRAME_setFunction(&(Message_Ptr->StdMessageFrame), - I2O_EXEC_LCT_NOTIFY); - I2O_EXEC_LCT_NOTIFY_MESSAGE_setClassIdentifier(Message_Ptr, - I2O_CLASS_MATCH_ANYCLASS); - /* - * Call the LCT table to determine the number of device entries - * to reserve space for. - */ - SG(&(Message_Ptr->SGL), 0, - I2O_SGL_FLAGS_LAST_ELEMENT | I2O_SGL_FLAGS_END_OF_BUFFER, &Table, - sizeof(I2O_LCT)); - /* - * since this code is reused in several systems, code efficiency - * is greater by using a shift operation rather than a divide by - * sizeof(u_int32_t). - */ - I2O_LCT_setTableSize(&Table, - (sizeof(I2O_LCT) - sizeof(I2O_LCT_ENTRY)) >> 2); - (void)ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); - /* - * Determine the size of the LCT table. - */ - if (sc->ha_LCT) { - free (sc->ha_LCT, M_TEMP); - } - /* - * malloc only generates contiguous memory when less than a - * page is expected. We must break the request up into an SG list ... - */ - if (((len = (I2O_LCT_getTableSize(&Table) << 2)) <= - (sizeof(I2O_LCT) - sizeof(I2O_LCT_ENTRY))) - || (len > (128 * 1024))) { /* Arbitrary */ - free (Message_Ptr, M_TEMP); - return (EINVAL); - } - if ((sc->ha_LCT = (PI2O_LCT)malloc (len, M_TEMP, M_WAITOK)) - == (PI2O_LCT)NULL) { - free (Message_Ptr, M_TEMP); - return (ENOMEM); - } - /* - * since this code is reused in several systems, code efficiency - * is greater by using a shift operation rather than a divide by - * sizeof(u_int32_t). - */ - I2O_LCT_setTableSize(sc->ha_LCT, - (sizeof(I2O_LCT) - sizeof(I2O_LCT_ENTRY)) >> 2); - /* - * Convert the access to the LCT table into a SG list. - */ - sg = Message_Ptr->SGL.u.Simple; - v = (caddr_t)(sc->ha_LCT); - for (;;) { - int next, base, span; - - span = 0; - next = base = KVTOPHYS(v); - I2O_SGE_SIMPLE_ELEMENT_setPhysicalAddress(sg, base); - - /* How far can we go contiguously */ - while ((len > 0) && (base == next)) { - int size; - - next = trunc_page(base) + PAGE_SIZE; - size = next - base; - if (size > len) { - size = len; - } - span += size; - v += size; - len -= size; - base = KVTOPHYS(v); - } - - /* Construct the Flags */ - I2O_FLAGS_COUNT_setCount(&(sg->FlagsCount), span); - { - int rw = I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT; - if (len <= 0) { - rw = (I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT - | I2O_SGL_FLAGS_LAST_ELEMENT - | I2O_SGL_FLAGS_END_OF_BUFFER); - } - I2O_FLAGS_COUNT_setFlags(&(sg->FlagsCount), rw); - } - - if (len <= 0) { - break; - } - - /* - * Incrementing requires resizing of the packet. - */ - ++sg; - MessageSizeInBytes += sizeof(*sg); - I2O_MESSAGE_FRAME_setMessageSize( - &(Message_Ptr->StdMessageFrame), - I2O_MESSAGE_FRAME_getMessageSize( - &(Message_Ptr->StdMessageFrame)) - + (sizeof(*sg) / sizeof(U32))); - { - PI2O_EXEC_LCT_NOTIFY_MESSAGE NewMessage_Ptr; - - if ((NewMessage_Ptr = (PI2O_EXEC_LCT_NOTIFY_MESSAGE) - malloc (MessageSizeInBytes, M_TEMP, M_WAITOK)) - == (PI2O_EXEC_LCT_NOTIFY_MESSAGE)NULL) { - free (sc->ha_LCT, M_TEMP); - sc->ha_LCT = (PI2O_LCT)NULL; - free (Message_Ptr, M_TEMP); - return (ENOMEM); - } - span = ((caddr_t)sg) - (caddr_t)Message_Ptr; - bcopy ((caddr_t)Message_Ptr, - (caddr_t)NewMessage_Ptr, span); - free (Message_Ptr, M_TEMP); - sg = (PI2O_SGE_SIMPLE_ELEMENT) - (((caddr_t)NewMessage_Ptr) + span); - Message_Ptr = NewMessage_Ptr; - } - } - { int retval; - - retval = ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); - free (Message_Ptr, M_TEMP); - if (retval != CAM_REQ_CMP) { - return (ENODEV); - } - } - /* If the LCT table grew, lets truncate accesses */ - if (I2O_LCT_getTableSize(&Table) < I2O_LCT_getTableSize(sc->ha_LCT)) { - I2O_LCT_setTableSize(sc->ha_LCT, I2O_LCT_getTableSize(&Table)); - } - for (Entry = sc->ha_LCT->LCTEntry; Entry < (PI2O_LCT_ENTRY) - (((U32 *)sc->ha_LCT)+I2O_LCT_getTableSize(sc->ha_LCT)); - ++Entry) { - Entry->le_type = I2O_UNKNOWN; - switch (I2O_CLASS_ID_getClass(&(Entry->ClassID))) { - - case I2O_CLASS_RANDOM_BLOCK_STORAGE: - Entry->le_type = I2O_BSA; - break; - - case I2O_CLASS_SCSI_PERIPHERAL: - Entry->le_type = I2O_SCSI; - break; - - case I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL: - Entry->le_type = I2O_FCA; - break; - - case I2O_CLASS_BUS_ADAPTER_PORT: - Entry->le_type = I2O_PORT | I2O_SCSI; - /* FALLTHRU */ - case I2O_CLASS_FIBRE_CHANNEL_PORT: - if (I2O_CLASS_ID_getClass(&(Entry->ClassID)) == - I2O_CLASS_FIBRE_CHANNEL_PORT) { - Entry->le_type = I2O_PORT | I2O_FCA; - } - { struct ControllerInfo { - I2O_PARAM_RESULTS_LIST_HEADER Header; - I2O_PARAM_READ_OPERATION_RESULT Read; - I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR Info; - }; - defAlignLong(struct ControllerInfo, Buffer); - PI2O_HBA_SCSI_CONTROLLER_INFO_SCALAR Info; - - Entry->le_bus = 0xff; - Entry->le_target = 0xff; - Entry->le_lun = 0xff; - - if ((Info = (PI2O_HBA_SCSI_CONTROLLER_INFO_SCALAR) - ASR_getParams(sc, - I2O_LCT_ENTRY_getLocalTID(Entry), - I2O_HBA_SCSI_CONTROLLER_INFO_GROUP_NO, - Buffer, sizeof(struct ControllerInfo))) - == (PI2O_HBA_SCSI_CONTROLLER_INFO_SCALAR)NULL) { - continue; - } - Entry->le_target - = I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_getInitiatorID( - Info); - Entry->le_lun = 0; - } /* FALLTHRU */ - default: - continue; - } - { struct DeviceInfo { - I2O_PARAM_RESULTS_LIST_HEADER Header; - I2O_PARAM_READ_OPERATION_RESULT Read; - I2O_DPT_DEVICE_INFO_SCALAR Info; - }; - defAlignLong (struct DeviceInfo, Buffer); - PI2O_DPT_DEVICE_INFO_SCALAR Info; - - Entry->le_bus = 0xff; - Entry->le_target = 0xff; - Entry->le_lun = 0xff; - - if ((Info = (PI2O_DPT_DEVICE_INFO_SCALAR) - ASR_getParams(sc, - I2O_LCT_ENTRY_getLocalTID(Entry), - I2O_DPT_DEVICE_INFO_GROUP_NO, - Buffer, sizeof(struct DeviceInfo))) - == (PI2O_DPT_DEVICE_INFO_SCALAR)NULL) { - continue; - } - Entry->le_type - |= I2O_DPT_DEVICE_INFO_SCALAR_getDeviceType(Info); - Entry->le_bus - = I2O_DPT_DEVICE_INFO_SCALAR_getBus(Info); - if ((Entry->le_bus > sc->ha_MaxBus) - && (Entry->le_bus <= MAX_CHANNEL)) { - sc->ha_MaxBus = Entry->le_bus; - } - Entry->le_target - = I2O_DPT_DEVICE_INFO_SCALAR_getIdentifier(Info); - Entry->le_lun - = I2O_DPT_DEVICE_INFO_SCALAR_getLunInfo(Info); - } - } - /* - * A zero return value indicates success. - */ - return (0); + PI2O_EXEC_LCT_NOTIFY_MESSAGE Message_Ptr; + PI2O_SGE_SIMPLE_ELEMENT sg; + int MessageSizeInBytes; + caddr_t v; + int len; + I2O_LCT Table; + PI2O_LCT_ENTRY Entry; + + /* + * sc value assumed valid + */ + MessageSizeInBytes = sizeof(I2O_EXEC_LCT_NOTIFY_MESSAGE) + - sizeof(I2O_SG_ELEMENT) + sizeof(I2O_SGE_SIMPLE_ELEMENT); + if ((Message_Ptr = (PI2O_EXEC_LCT_NOTIFY_MESSAGE)malloc ( + MessageSizeInBytes, M_TEMP, M_WAITOK)) + == (PI2O_EXEC_LCT_NOTIFY_MESSAGE)NULL) { + return (ENOMEM); + } + (void)ASR_fillMessage((char *)Message_Ptr, MessageSizeInBytes); + I2O_MESSAGE_FRAME_setVersionOffset(&(Message_Ptr->StdMessageFrame), + (I2O_VERSION_11 + + (((sizeof(I2O_EXEC_LCT_NOTIFY_MESSAGE) - sizeof(I2O_SG_ELEMENT)) + / sizeof(U32)) << 4))); + I2O_MESSAGE_FRAME_setFunction(&(Message_Ptr->StdMessageFrame), + I2O_EXEC_LCT_NOTIFY); + I2O_EXEC_LCT_NOTIFY_MESSAGE_setClassIdentifier(Message_Ptr, + I2O_CLASS_MATCH_ANYCLASS); + /* + * Call the LCT table to determine the number of device entries + * to reserve space for. + */ + SG(&(Message_Ptr->SGL), 0, + I2O_SGL_FLAGS_LAST_ELEMENT | I2O_SGL_FLAGS_END_OF_BUFFER, &Table, + sizeof(I2O_LCT)); + /* + * since this code is reused in several systems, code efficiency + * is greater by using a shift operation rather than a divide by + * sizeof(u_int32_t). + */ + I2O_LCT_setTableSize(&Table, + (sizeof(I2O_LCT) - sizeof(I2O_LCT_ENTRY)) >> 2); + (void)ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); + /* + * Determine the size of the LCT table. + */ + if (sc->ha_LCT) { + free (sc->ha_LCT, M_TEMP); + } + /* + * malloc only generates contiguous memory when less than a + * page is expected. We must break the request up into an SG list ... + */ + if (((len = (I2O_LCT_getTableSize(&Table) << 2)) <= + (sizeof(I2O_LCT) - sizeof(I2O_LCT_ENTRY))) + || (len > (128 * 1024))) { /* Arbitrary */ + free (Message_Ptr, M_TEMP); + return (EINVAL); + } + if ((sc->ha_LCT = (PI2O_LCT)malloc (len, M_TEMP, M_WAITOK)) + == (PI2O_LCT)NULL) { + free (Message_Ptr, M_TEMP); + return (ENOMEM); + } + /* + * since this code is reused in several systems, code efficiency + * is greater by using a shift operation rather than a divide by + * sizeof(u_int32_t). + */ + I2O_LCT_setTableSize(sc->ha_LCT, + (sizeof(I2O_LCT) - sizeof(I2O_LCT_ENTRY)) >> 2); + /* + * Convert the access to the LCT table into a SG list. + */ + sg = Message_Ptr->SGL.u.Simple; + v = (caddr_t)(sc->ha_LCT); + for (;;) { + int next, base, span; + + span = 0; + next = base = KVTOPHYS(v); + I2O_SGE_SIMPLE_ELEMENT_setPhysicalAddress(sg, base); + + /* How far can we go contiguously */ + while ((len > 0) && (base == next)) { + int size; + + next = trunc_page(base) + PAGE_SIZE; + size = next - base; + if (size > len) { + size = len; + } + span += size; + v += size; + len -= size; + base = KVTOPHYS(v); + } + + /* Construct the Flags */ + I2O_FLAGS_COUNT_setCount(&(sg->FlagsCount), span); + { + int rw = I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT; + if (len <= 0) { + rw = (I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT + | I2O_SGL_FLAGS_LAST_ELEMENT + | I2O_SGL_FLAGS_END_OF_BUFFER); + } + I2O_FLAGS_COUNT_setFlags(&(sg->FlagsCount), rw); + } + + if (len <= 0) { + break; + } + + /* + * Incrementing requires resizing of the packet. + */ + ++sg; + MessageSizeInBytes += sizeof(*sg); + I2O_MESSAGE_FRAME_setMessageSize( + &(Message_Ptr->StdMessageFrame), + I2O_MESSAGE_FRAME_getMessageSize( + &(Message_Ptr->StdMessageFrame)) + + (sizeof(*sg) / sizeof(U32))); + { + PI2O_EXEC_LCT_NOTIFY_MESSAGE NewMessage_Ptr; + + if ((NewMessage_Ptr = (PI2O_EXEC_LCT_NOTIFY_MESSAGE) + malloc (MessageSizeInBytes, M_TEMP, M_WAITOK)) + == (PI2O_EXEC_LCT_NOTIFY_MESSAGE)NULL) { + free (sc->ha_LCT, M_TEMP); + sc->ha_LCT = (PI2O_LCT)NULL; + free (Message_Ptr, M_TEMP); + return (ENOMEM); + } + span = ((caddr_t)sg) - (caddr_t)Message_Ptr; + bcopy ((caddr_t)Message_Ptr, + (caddr_t)NewMessage_Ptr, span); + free (Message_Ptr, M_TEMP); + sg = (PI2O_SGE_SIMPLE_ELEMENT) + (((caddr_t)NewMessage_Ptr) + span); + Message_Ptr = NewMessage_Ptr; + } + } + { int retval; + + retval = ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); + free (Message_Ptr, M_TEMP); + if (retval != CAM_REQ_CMP) { + return (ENODEV); + } + } + /* If the LCT table grew, lets truncate accesses */ + if (I2O_LCT_getTableSize(&Table) < I2O_LCT_getTableSize(sc->ha_LCT)) { + I2O_LCT_setTableSize(sc->ha_LCT, I2O_LCT_getTableSize(&Table)); + } + for (Entry = sc->ha_LCT->LCTEntry; Entry < (PI2O_LCT_ENTRY) + (((U32 *)sc->ha_LCT)+I2O_LCT_getTableSize(sc->ha_LCT)); + ++Entry) { + Entry->le_type = I2O_UNKNOWN; + switch (I2O_CLASS_ID_getClass(&(Entry->ClassID))) { + + case I2O_CLASS_RANDOM_BLOCK_STORAGE: + Entry->le_type = I2O_BSA; + break; + + case I2O_CLASS_SCSI_PERIPHERAL: + Entry->le_type = I2O_SCSI; + break; + + case I2O_CLASS_FIBRE_CHANNEL_PERIPHERAL: + Entry->le_type = I2O_FCA; + break; + + case I2O_CLASS_BUS_ADAPTER_PORT: + Entry->le_type = I2O_PORT | I2O_SCSI; + /* FALLTHRU */ + case I2O_CLASS_FIBRE_CHANNEL_PORT: + if (I2O_CLASS_ID_getClass(&(Entry->ClassID)) == + I2O_CLASS_FIBRE_CHANNEL_PORT) { + Entry->le_type = I2O_PORT | I2O_FCA; + } + { struct ControllerInfo { + I2O_PARAM_RESULTS_LIST_HEADER Header; + I2O_PARAM_READ_OPERATION_RESULT Read; + I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR Info; + }; + defAlignLong(struct ControllerInfo, Buffer); + PI2O_HBA_SCSI_CONTROLLER_INFO_SCALAR Info; + + Entry->le_bus = 0xff; + Entry->le_target = 0xff; + Entry->le_lun = 0xff; + + if ((Info = (PI2O_HBA_SCSI_CONTROLLER_INFO_SCALAR) + ASR_getParams(sc, + I2O_LCT_ENTRY_getLocalTID(Entry), + I2O_HBA_SCSI_CONTROLLER_INFO_GROUP_NO, + Buffer, sizeof(struct ControllerInfo))) + == (PI2O_HBA_SCSI_CONTROLLER_INFO_SCALAR)NULL) { + continue; + } + Entry->le_target + = I2O_HBA_SCSI_CONTROLLER_INFO_SCALAR_getInitiatorID( + Info); + Entry->le_lun = 0; + } /* FALLTHRU */ + default: + continue; + } + { struct DeviceInfo { + I2O_PARAM_RESULTS_LIST_HEADER Header; + I2O_PARAM_READ_OPERATION_RESULT Read; + I2O_DPT_DEVICE_INFO_SCALAR Info; + }; + defAlignLong (struct DeviceInfo, Buffer); + PI2O_DPT_DEVICE_INFO_SCALAR Info; + + Entry->le_bus = 0xff; + Entry->le_target = 0xff; + Entry->le_lun = 0xff; + + if ((Info = (PI2O_DPT_DEVICE_INFO_SCALAR) + ASR_getParams(sc, + I2O_LCT_ENTRY_getLocalTID(Entry), + I2O_DPT_DEVICE_INFO_GROUP_NO, + Buffer, sizeof(struct DeviceInfo))) + == (PI2O_DPT_DEVICE_INFO_SCALAR)NULL) { + continue; + } + Entry->le_type + |= I2O_DPT_DEVICE_INFO_SCALAR_getDeviceType(Info); + Entry->le_bus + = I2O_DPT_DEVICE_INFO_SCALAR_getBus(Info); + if ((Entry->le_bus > sc->ha_MaxBus) + && (Entry->le_bus <= MAX_CHANNEL)) { + sc->ha_MaxBus = Entry->le_bus; + } + Entry->le_target + = I2O_DPT_DEVICE_INFO_SCALAR_getIdentifier(Info); + Entry->le_lun + = I2O_DPT_DEVICE_INFO_SCALAR_getLunInfo(Info); + } + } + /* + * A zero return value indicates success. + */ + return (0); } /* ASR_acquireLct */ /* @@ -2050,1405 +2050,1405 @@ ASR_acquireLct ( */ STATIC INLINE PI2O_MESSAGE_FRAME ASR_init_message( - IN union asr_ccb * ccb, - OUT PI2O_MESSAGE_FRAME Message) + IN union asr_ccb * ccb, + OUT PI2O_MESSAGE_FRAME Message) { - int next, span, base, rw; - OUT PI2O_MESSAGE_FRAME Message_Ptr; - Asr_softc_t * sc = (Asr_softc_t *)(ccb->ccb_h.spriv_ptr0); - PI2O_SGE_SIMPLE_ELEMENT sg; - caddr_t v; - vm_size_t size, len; - U32 MessageSize; - - /* We only need to zero out the PRIVATE_SCSI_SCB_EXECUTE_MESSAGE */ - bzero (Message_Ptr = getAlignLong(I2O_MESSAGE_FRAME, Message), - (sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - sizeof(I2O_SG_ELEMENT))); - - { - int target = ccb->ccb_h.target_id; - int lun = ccb->ccb_h.target_lun; - int bus = cam_sim_bus(xpt_path_sim(ccb->ccb_h.path)); - tid_t TID; - - if ((TID = ASR_getTid (sc, bus, target, lun)) == (tid_t)-1) { - PI2O_LCT_ENTRY Device; - - TID = (tid_t)0; - for (Device = sc->ha_LCT->LCTEntry; Device < (PI2O_LCT_ENTRY) - (((U32 *)sc->ha_LCT)+I2O_LCT_getTableSize(sc->ha_LCT)); - ++Device) { - if ((Device->le_type != I2O_UNKNOWN) - && (Device->le_bus == bus) - && (Device->le_target == target) - && (Device->le_lun == lun) - && (I2O_LCT_ENTRY_getUserTID(Device) == 0xFFF)) { - TID = I2O_LCT_ENTRY_getLocalTID(Device); - ASR_setTid (sc, Device->le_bus, - Device->le_target, Device->le_lun, - TID); - break; - } - } - } - if (TID == (tid_t)0) { - return ((PI2O_MESSAGE_FRAME)NULL); - } - I2O_MESSAGE_FRAME_setTargetAddress(Message_Ptr, TID); - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setTID( - (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr, TID); - } - I2O_MESSAGE_FRAME_setVersionOffset(Message_Ptr, I2O_VERSION_11 | - (((sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - sizeof(I2O_SG_ELEMENT)) - / sizeof(U32)) << 4)); - I2O_MESSAGE_FRAME_setMessageSize(Message_Ptr, - (sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - - sizeof(I2O_SG_ELEMENT)) / sizeof(U32)); - I2O_MESSAGE_FRAME_setInitiatorAddress (Message_Ptr, 1); - I2O_MESSAGE_FRAME_setFunction(Message_Ptr, I2O_PRIVATE_MESSAGE); - I2O_PRIVATE_MESSAGE_FRAME_setXFunctionCode ( - (PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr, I2O_SCSI_SCB_EXEC); - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags ( - (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr, - I2O_SCB_FLAG_ENABLE_DISCONNECT - | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG - | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER); - /* - * We do not need any (optional byteswapping) method access to - * the Initiator & Transaction context field. - */ - I2O_MESSAGE_FRAME_setInitiatorContext64(Message, (long)ccb); - - I2O_PRIVATE_MESSAGE_FRAME_setOrganizationID( - (PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr, DPT_ORGANIZATION_ID); - /* - * copy the cdb over - */ - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setCDBLength( - (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr, ccb->csio.cdb_len); - bcopy (&(ccb->csio.cdb_io), - ((PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr)->CDB, ccb->csio.cdb_len); - - /* - * Given a buffer describing a transfer, set up a scatter/gather map - * in a ccb to map that SCSI transfer. - */ - - rw = (ccb->ccb_h.flags & CAM_DIR_IN) ? 0 : I2O_SGL_FLAGS_DIR; - - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags ( - (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr, - (ccb->csio.dxfer_len) - ? ((rw) ? (I2O_SCB_FLAG_XFER_TO_DEVICE - | I2O_SCB_FLAG_ENABLE_DISCONNECT - | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG - | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER) - : (I2O_SCB_FLAG_XFER_FROM_DEVICE - | I2O_SCB_FLAG_ENABLE_DISCONNECT - | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG - | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER)) - : (I2O_SCB_FLAG_ENABLE_DISCONNECT - | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG - | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER)); - - /* - * Given a transfer described by a `data', fill in the SG list. - */ - sg = &((PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr)->SGL.u.Simple[0]; - - len = ccb->csio.dxfer_len; - v = ccb->csio.data_ptr; - ASSERT (ccb->csio.dxfer_len >= 0); - MessageSize = I2O_MESSAGE_FRAME_getMessageSize(Message_Ptr); - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setByteCount( - (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr, len); - while ((len > 0) && (sg < &((PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - Message_Ptr)->SGL.u.Simple[SG_SIZE])) { - span = 0; - next = base = KVTOPHYS(v); - I2O_SGE_SIMPLE_ELEMENT_setPhysicalAddress(sg, base); - - /* How far can we go contiguously */ - while ((len > 0) && (base == next)) { - next = trunc_page(base) + PAGE_SIZE; - size = next - base; - if (size > len) { - size = len; - } - span += size; - v += size; - len -= size; - base = KVTOPHYS(v); - } - - I2O_FLAGS_COUNT_setCount(&(sg->FlagsCount), span); - if (len == 0) { - rw |= I2O_SGL_FLAGS_LAST_ELEMENT; - } - I2O_FLAGS_COUNT_setFlags(&(sg->FlagsCount), - I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT | rw); - ++sg; - MessageSize += sizeof(*sg) / sizeof(U32); - } - /* We always do the request sense ... */ - if ((span = ccb->csio.sense_len) == 0) { - span = sizeof(ccb->csio.sense_data); - } - SG(sg, 0, I2O_SGL_FLAGS_LAST_ELEMENT | I2O_SGL_FLAGS_END_OF_BUFFER, - &(ccb->csio.sense_data), span); - I2O_MESSAGE_FRAME_setMessageSize(Message_Ptr, - MessageSize + (sizeof(*sg) / sizeof(U32))); - return (Message_Ptr); + int next, span, base, rw; + OUT PI2O_MESSAGE_FRAME Message_Ptr; + Asr_softc_t * sc = (Asr_softc_t *)(ccb->ccb_h.spriv_ptr0); + PI2O_SGE_SIMPLE_ELEMENT sg; + caddr_t v; + vm_size_t size, len; + U32 MessageSize; + + /* We only need to zero out the PRIVATE_SCSI_SCB_EXECUTE_MESSAGE */ + bzero (Message_Ptr = getAlignLong(I2O_MESSAGE_FRAME, Message), + (sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - sizeof(I2O_SG_ELEMENT))); + + { + int target = ccb->ccb_h.target_id; + int lun = ccb->ccb_h.target_lun; + int bus = cam_sim_bus(xpt_path_sim(ccb->ccb_h.path)); + tid_t TID; + + if ((TID = ASR_getTid (sc, bus, target, lun)) == (tid_t)-1) { + PI2O_LCT_ENTRY Device; + + TID = (tid_t)0; + for (Device = sc->ha_LCT->LCTEntry; Device < (PI2O_LCT_ENTRY) + (((U32 *)sc->ha_LCT)+I2O_LCT_getTableSize(sc->ha_LCT)); + ++Device) { + if ((Device->le_type != I2O_UNKNOWN) + && (Device->le_bus == bus) + && (Device->le_target == target) + && (Device->le_lun == lun) + && (I2O_LCT_ENTRY_getUserTID(Device) == 0xFFF)) { + TID = I2O_LCT_ENTRY_getLocalTID(Device); + ASR_setTid (sc, Device->le_bus, + Device->le_target, Device->le_lun, + TID); + break; + } + } + } + if (TID == (tid_t)0) { + return ((PI2O_MESSAGE_FRAME)NULL); + } + I2O_MESSAGE_FRAME_setTargetAddress(Message_Ptr, TID); + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setTID( + (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr, TID); + } + I2O_MESSAGE_FRAME_setVersionOffset(Message_Ptr, I2O_VERSION_11 | + (((sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - sizeof(I2O_SG_ELEMENT)) + / sizeof(U32)) << 4)); + I2O_MESSAGE_FRAME_setMessageSize(Message_Ptr, + (sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) + - sizeof(I2O_SG_ELEMENT)) / sizeof(U32)); + I2O_MESSAGE_FRAME_setInitiatorAddress (Message_Ptr, 1); + I2O_MESSAGE_FRAME_setFunction(Message_Ptr, I2O_PRIVATE_MESSAGE); + I2O_PRIVATE_MESSAGE_FRAME_setXFunctionCode ( + (PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr, I2O_SCSI_SCB_EXEC); + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags ( + (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr, + I2O_SCB_FLAG_ENABLE_DISCONNECT + | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG + | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER); + /* + * We do not need any (optional byteswapping) method access to + * the Initiator & Transaction context field. + */ + I2O_MESSAGE_FRAME_setInitiatorContext64(Message, (long)ccb); + + I2O_PRIVATE_MESSAGE_FRAME_setOrganizationID( + (PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr, DPT_ORGANIZATION_ID); + /* + * copy the cdb over + */ + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setCDBLength( + (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr, ccb->csio.cdb_len); + bcopy (&(ccb->csio.cdb_io), + ((PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr)->CDB, ccb->csio.cdb_len); + + /* + * Given a buffer describing a transfer, set up a scatter/gather map + * in a ccb to map that SCSI transfer. + */ + + rw = (ccb->ccb_h.flags & CAM_DIR_IN) ? 0 : I2O_SGL_FLAGS_DIR; + + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags ( + (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr, + (ccb->csio.dxfer_len) + ? ((rw) ? (I2O_SCB_FLAG_XFER_TO_DEVICE + | I2O_SCB_FLAG_ENABLE_DISCONNECT + | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG + | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER) + : (I2O_SCB_FLAG_XFER_FROM_DEVICE + | I2O_SCB_FLAG_ENABLE_DISCONNECT + | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG + | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER)) + : (I2O_SCB_FLAG_ENABLE_DISCONNECT + | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG + | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER)); + + /* + * Given a transfer described by a `data', fill in the SG list. + */ + sg = &((PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr)->SGL.u.Simple[0]; + + len = ccb->csio.dxfer_len; + v = ccb->csio.data_ptr; + ASSERT (ccb->csio.dxfer_len >= 0); + MessageSize = I2O_MESSAGE_FRAME_getMessageSize(Message_Ptr); + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setByteCount( + (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr, len); + while ((len > 0) && (sg < &((PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE) + Message_Ptr)->SGL.u.Simple[SG_SIZE])) { + span = 0; + next = base = KVTOPHYS(v); + I2O_SGE_SIMPLE_ELEMENT_setPhysicalAddress(sg, base); + + /* How far can we go contiguously */ + while ((len > 0) && (base == next)) { + next = trunc_page(base) + PAGE_SIZE; + size = next - base; + if (size > len) { + size = len; + } + span += size; + v += size; + len -= size; + base = KVTOPHYS(v); + } + + I2O_FLAGS_COUNT_setCount(&(sg->FlagsCount), span); + if (len == 0) { + rw |= I2O_SGL_FLAGS_LAST_ELEMENT; + } + I2O_FLAGS_COUNT_setFlags(&(sg->FlagsCount), + I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT | rw); + ++sg; + MessageSize += sizeof(*sg) / sizeof(U32); + } + /* We always do the request sense ... */ + if ((span = ccb->csio.sense_len) == 0) { + span = sizeof(ccb->csio.sense_data); + } + SG(sg, 0, I2O_SGL_FLAGS_LAST_ELEMENT | I2O_SGL_FLAGS_END_OF_BUFFER, + &(ccb->csio.sense_data), span); + I2O_MESSAGE_FRAME_setMessageSize(Message_Ptr, + MessageSize + (sizeof(*sg) / sizeof(U32))); + return (Message_Ptr); } /* ASR_init_message */ /* - * Reset the adapter. + * Reset the adapter. */ STATIC INLINE U32 ASR_initOutBound ( - INOUT Asr_softc_t * sc) + INOUT Asr_softc_t * sc) { - struct initOutBoundMessage { - I2O_EXEC_OUTBOUND_INIT_MESSAGE M; - U32 R; - }; - defAlignLong(struct initOutBoundMessage,Message); - PI2O_EXEC_OUTBOUND_INIT_MESSAGE Message_Ptr; - OUT U32 * volatile Reply_Ptr; - U32 Old; - - /* - * Build up our copy of the Message. - */ - Message_Ptr = (PI2O_EXEC_OUTBOUND_INIT_MESSAGE)ASR_fillMessage(Message, - sizeof(I2O_EXEC_OUTBOUND_INIT_MESSAGE)); - I2O_MESSAGE_FRAME_setFunction(&(Message_Ptr->StdMessageFrame), - I2O_EXEC_OUTBOUND_INIT); - I2O_EXEC_OUTBOUND_INIT_MESSAGE_setHostPageFrameSize(Message_Ptr, PAGE_SIZE); - I2O_EXEC_OUTBOUND_INIT_MESSAGE_setOutboundMFrameSize(Message_Ptr, - sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)); - /* - * Reset the Reply Status - */ - *(Reply_Ptr = (U32 *)((char *)Message_Ptr - + sizeof(I2O_EXEC_OUTBOUND_INIT_MESSAGE))) = 0; - SG (&(Message_Ptr->SGL), 0, I2O_SGL_FLAGS_LAST_ELEMENT, Reply_Ptr, - sizeof(U32)); - /* - * Send the Message out - */ - if ((Old = ASR_initiateCp (sc->ha_Virt, sc->ha_Fvirt, (PI2O_MESSAGE_FRAME)Message_Ptr)) != (U32)-1L) { - u_long size, addr; - - /* - * Wait for a response (Poll). - */ - while (*Reply_Ptr < I2O_EXEC_OUTBOUND_INIT_REJECTED); - /* - * Re-enable the interrupts. - */ - sc->ha_Virt->Mask = Old; - /* - * Populate the outbound table. - */ - if (sc->ha_Msgs == (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)NULL) { - - /* Allocate the reply frames */ - size = sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME) - * sc->ha_Msgs_Count; - - /* - * contigmalloc only works reliably at - * initialization time. - */ - if ((sc->ha_Msgs = (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME) - contigmalloc (size, M_DEVBUF, M_WAITOK, 0ul, - 0xFFFFFFFFul, (u_long)sizeof(U32), 0ul)) - != (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)NULL) { - (void)bzero ((char *)sc->ha_Msgs, size); - sc->ha_Msgs_Phys = KVTOPHYS(sc->ha_Msgs); - } - } - - /* Initialize the outbound FIFO */ - if (sc->ha_Msgs != (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)NULL) - for (size = sc->ha_Msgs_Count, addr = sc->ha_Msgs_Phys; - size; --size) { - sc->ha_Virt->FromFIFO = addr; - addr += sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME); - } - return (*Reply_Ptr); - } - return (0); + struct initOutBoundMessage { + I2O_EXEC_OUTBOUND_INIT_MESSAGE M; + U32 R; + }; + defAlignLong(struct initOutBoundMessage,Message); + PI2O_EXEC_OUTBOUND_INIT_MESSAGE Message_Ptr; + OUT U32 * volatile Reply_Ptr; + U32 Old; + + /* + * Build up our copy of the Message. + */ + Message_Ptr = (PI2O_EXEC_OUTBOUND_INIT_MESSAGE)ASR_fillMessage(Message, + sizeof(I2O_EXEC_OUTBOUND_INIT_MESSAGE)); + I2O_MESSAGE_FRAME_setFunction(&(Message_Ptr->StdMessageFrame), + I2O_EXEC_OUTBOUND_INIT); + I2O_EXEC_OUTBOUND_INIT_MESSAGE_setHostPageFrameSize(Message_Ptr, PAGE_SIZE); + I2O_EXEC_OUTBOUND_INIT_MESSAGE_setOutboundMFrameSize(Message_Ptr, + sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)); + /* + * Reset the Reply Status + */ + *(Reply_Ptr = (U32 *)((char *)Message_Ptr + + sizeof(I2O_EXEC_OUTBOUND_INIT_MESSAGE))) = 0; + SG (&(Message_Ptr->SGL), 0, I2O_SGL_FLAGS_LAST_ELEMENT, Reply_Ptr, + sizeof(U32)); + /* + * Send the Message out + */ + if ((Old = ASR_initiateCp (sc->ha_Virt, sc->ha_Fvirt, (PI2O_MESSAGE_FRAME)Message_Ptr)) != (U32)-1L) { + u_long size, addr; + + /* + * Wait for a response (Poll). + */ + while (*Reply_Ptr < I2O_EXEC_OUTBOUND_INIT_REJECTED); + /* + * Re-enable the interrupts. + */ + sc->ha_Virt->Mask = Old; + /* + * Populate the outbound table. + */ + if (sc->ha_Msgs == (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)NULL) { + + /* Allocate the reply frames */ + size = sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME) + * sc->ha_Msgs_Count; + + /* + * contigmalloc only works reliably at + * initialization time. + */ + if ((sc->ha_Msgs = (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME) + contigmalloc (size, M_DEVBUF, M_WAITOK, 0ul, + 0xFFFFFFFFul, (u_long)sizeof(U32), 0ul)) + != (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)NULL) { + (void)bzero ((char *)sc->ha_Msgs, size); + sc->ha_Msgs_Phys = KVTOPHYS(sc->ha_Msgs); + } + } + + /* Initialize the outbound FIFO */ + if (sc->ha_Msgs != (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)NULL) + for (size = sc->ha_Msgs_Count, addr = sc->ha_Msgs_Phys; + size; --size) { + sc->ha_Virt->FromFIFO = addr; + addr += sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME); + } + return (*Reply_Ptr); + } + return (0); } /* ASR_initOutBound */ /* - * Set the system table + * Set the system table */ STATIC INLINE int ASR_setSysTab( - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { - PI2O_EXEC_SYS_TAB_SET_MESSAGE Message_Ptr; - PI2O_SET_SYSTAB_HEADER SystemTable; - Asr_softc_t * ha; - PI2O_SGE_SIMPLE_ELEMENT sg; - int retVal; - - if ((SystemTable = (PI2O_SET_SYSTAB_HEADER)malloc ( - sizeof(I2O_SET_SYSTAB_HEADER), M_TEMP, M_WAITOK | M_ZERO)) - == (PI2O_SET_SYSTAB_HEADER)NULL) { - return (ENOMEM); - } - for (ha = Asr_softc; ha; ha = ha->ha_next) { - ++SystemTable->NumberEntries; - } - if ((Message_Ptr = (PI2O_EXEC_SYS_TAB_SET_MESSAGE)malloc ( - sizeof(I2O_EXEC_SYS_TAB_SET_MESSAGE) - sizeof(I2O_SG_ELEMENT) - + ((3+SystemTable->NumberEntries) * sizeof(I2O_SGE_SIMPLE_ELEMENT)), - M_TEMP, M_WAITOK)) == (PI2O_EXEC_SYS_TAB_SET_MESSAGE)NULL) { - free (SystemTable, M_TEMP); - return (ENOMEM); - } - (void)ASR_fillMessage((char *)Message_Ptr, - sizeof(I2O_EXEC_SYS_TAB_SET_MESSAGE) - sizeof(I2O_SG_ELEMENT) - + ((3+SystemTable->NumberEntries) * sizeof(I2O_SGE_SIMPLE_ELEMENT))); - I2O_MESSAGE_FRAME_setVersionOffset(&(Message_Ptr->StdMessageFrame), - (I2O_VERSION_11 + - (((sizeof(I2O_EXEC_SYS_TAB_SET_MESSAGE) - sizeof(I2O_SG_ELEMENT)) - / sizeof(U32)) << 4))); - I2O_MESSAGE_FRAME_setFunction(&(Message_Ptr->StdMessageFrame), - I2O_EXEC_SYS_TAB_SET); - /* - * Call the LCT table to determine the number of device entries - * to reserve space for. - * since this code is reused in several systems, code efficiency - * is greater by using a shift operation rather than a divide by - * sizeof(u_int32_t). - */ - sg = (PI2O_SGE_SIMPLE_ELEMENT)((char *)Message_Ptr - + ((I2O_MESSAGE_FRAME_getVersionOffset( - &(Message_Ptr->StdMessageFrame)) & 0xF0) >> 2)); - SG(sg, 0, I2O_SGL_FLAGS_DIR, SystemTable, sizeof(I2O_SET_SYSTAB_HEADER)); - ++sg; - for (ha = Asr_softc; ha; ha = ha->ha_next) { - SG(sg, 0, - ((ha->ha_next) - ? (I2O_SGL_FLAGS_DIR) - : (I2O_SGL_FLAGS_DIR | I2O_SGL_FLAGS_END_OF_BUFFER)), - &(ha->ha_SystemTable), sizeof(ha->ha_SystemTable)); - ++sg; - } - SG(sg, 0, I2O_SGL_FLAGS_DIR | I2O_SGL_FLAGS_END_OF_BUFFER, NULL, 0); - SG(sg, 1, I2O_SGL_FLAGS_DIR | I2O_SGL_FLAGS_LAST_ELEMENT - | I2O_SGL_FLAGS_END_OF_BUFFER, NULL, 0); - retVal = ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); - free (Message_Ptr, M_TEMP); - free (SystemTable, M_TEMP); - return (retVal); + PI2O_EXEC_SYS_TAB_SET_MESSAGE Message_Ptr; + PI2O_SET_SYSTAB_HEADER SystemTable; + Asr_softc_t * ha; + PI2O_SGE_SIMPLE_ELEMENT sg; + int retVal; + + if ((SystemTable = (PI2O_SET_SYSTAB_HEADER)malloc ( + sizeof(I2O_SET_SYSTAB_HEADER), M_TEMP, M_WAITOK | M_ZERO)) + == (PI2O_SET_SYSTAB_HEADER)NULL) { + return (ENOMEM); + } + for (ha = Asr_softc; ha; ha = ha->ha_next) { + ++SystemTable->NumberEntries; + } + if ((Message_Ptr = (PI2O_EXEC_SYS_TAB_SET_MESSAGE)malloc ( + sizeof(I2O_EXEC_SYS_TAB_SET_MESSAGE) - sizeof(I2O_SG_ELEMENT) + + ((3+SystemTable->NumberEntries) * sizeof(I2O_SGE_SIMPLE_ELEMENT)), + M_TEMP, M_WAITOK)) == (PI2O_EXEC_SYS_TAB_SET_MESSAGE)NULL) { + free (SystemTable, M_TEMP); + return (ENOMEM); + } + (void)ASR_fillMessage((char *)Message_Ptr, + sizeof(I2O_EXEC_SYS_TAB_SET_MESSAGE) - sizeof(I2O_SG_ELEMENT) + + ((3+SystemTable->NumberEntries) * sizeof(I2O_SGE_SIMPLE_ELEMENT))); + I2O_MESSAGE_FRAME_setVersionOffset(&(Message_Ptr->StdMessageFrame), + (I2O_VERSION_11 + + (((sizeof(I2O_EXEC_SYS_TAB_SET_MESSAGE) - sizeof(I2O_SG_ELEMENT)) + / sizeof(U32)) << 4))); + I2O_MESSAGE_FRAME_setFunction(&(Message_Ptr->StdMessageFrame), + I2O_EXEC_SYS_TAB_SET); + /* + * Call the LCT table to determine the number of device entries + * to reserve space for. + * since this code is reused in several systems, code efficiency + * is greater by using a shift operation rather than a divide by + * sizeof(u_int32_t). + */ + sg = (PI2O_SGE_SIMPLE_ELEMENT)((char *)Message_Ptr + + ((I2O_MESSAGE_FRAME_getVersionOffset( + &(Message_Ptr->StdMessageFrame)) & 0xF0) >> 2)); + SG(sg, 0, I2O_SGL_FLAGS_DIR, SystemTable, sizeof(I2O_SET_SYSTAB_HEADER)); + ++sg; + for (ha = Asr_softc; ha; ha = ha->ha_next) { + SG(sg, 0, + ((ha->ha_next) + ? (I2O_SGL_FLAGS_DIR) + : (I2O_SGL_FLAGS_DIR | I2O_SGL_FLAGS_END_OF_BUFFER)), + &(ha->ha_SystemTable), sizeof(ha->ha_SystemTable)); + ++sg; + } + SG(sg, 0, I2O_SGL_FLAGS_DIR | I2O_SGL_FLAGS_END_OF_BUFFER, NULL, 0); + SG(sg, 1, I2O_SGL_FLAGS_DIR | I2O_SGL_FLAGS_LAST_ELEMENT + | I2O_SGL_FLAGS_END_OF_BUFFER, NULL, 0); + retVal = ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); + free (Message_Ptr, M_TEMP); + free (SystemTable, M_TEMP); + return (retVal); } /* ASR_setSysTab */ STATIC INLINE int ASR_acquireHrt ( - INOUT Asr_softc_t * sc) + INOUT Asr_softc_t * sc) { - defAlignLong(I2O_EXEC_HRT_GET_MESSAGE,Message); - I2O_EXEC_HRT_GET_MESSAGE * Message_Ptr; - struct { - I2O_HRT Header; - I2O_HRT_ENTRY Entry[MAX_CHANNEL]; - } Hrt; - u_int8_t NumberOfEntries; - PI2O_HRT_ENTRY Entry; - - bzero ((void *)&Hrt, sizeof (Hrt)); - Message_Ptr = (I2O_EXEC_HRT_GET_MESSAGE *)ASR_fillMessage(Message, - sizeof(I2O_EXEC_HRT_GET_MESSAGE) - sizeof(I2O_SG_ELEMENT) - + sizeof(I2O_SGE_SIMPLE_ELEMENT)); - I2O_MESSAGE_FRAME_setVersionOffset(&(Message_Ptr->StdMessageFrame), - (I2O_VERSION_11 - + (((sizeof(I2O_EXEC_HRT_GET_MESSAGE) - sizeof(I2O_SG_ELEMENT)) - / sizeof(U32)) << 4))); - I2O_MESSAGE_FRAME_setFunction (&(Message_Ptr->StdMessageFrame), - I2O_EXEC_HRT_GET); - - /* - * Set up the buffers as scatter gather elements. - */ - SG(&(Message_Ptr->SGL), 0, - I2O_SGL_FLAGS_LAST_ELEMENT | I2O_SGL_FLAGS_END_OF_BUFFER, - &Hrt, sizeof(Hrt)); - if (ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr) != CAM_REQ_CMP) { - return (ENODEV); - } - if ((NumberOfEntries = I2O_HRT_getNumberEntries(&Hrt.Header)) - > (MAX_CHANNEL + 1)) { - NumberOfEntries = MAX_CHANNEL + 1; - } - for (Entry = Hrt.Header.HRTEntry; - NumberOfEntries != 0; - ++Entry, --NumberOfEntries) { - PI2O_LCT_ENTRY Device; - - for (Device = sc->ha_LCT->LCTEntry; Device < (PI2O_LCT_ENTRY) - (((U32 *)sc->ha_LCT)+I2O_LCT_getTableSize(sc->ha_LCT)); - ++Device) { - if (I2O_LCT_ENTRY_getLocalTID(Device) - == (I2O_HRT_ENTRY_getAdapterID(Entry) & 0xFFF)) { - Device->le_bus = I2O_HRT_ENTRY_getAdapterID( - Entry) >> 16; - if ((Device->le_bus > sc->ha_MaxBus) - && (Device->le_bus <= MAX_CHANNEL)) { - sc->ha_MaxBus = Device->le_bus; - } - } - } - } - return (0); + defAlignLong(I2O_EXEC_HRT_GET_MESSAGE,Message); + I2O_EXEC_HRT_GET_MESSAGE * Message_Ptr; + struct { + I2O_HRT Header; + I2O_HRT_ENTRY Entry[MAX_CHANNEL]; + } Hrt; + u_int8_t NumberOfEntries; + PI2O_HRT_ENTRY Entry; + + bzero ((void *)&Hrt, sizeof (Hrt)); + Message_Ptr = (I2O_EXEC_HRT_GET_MESSAGE *)ASR_fillMessage(Message, + sizeof(I2O_EXEC_HRT_GET_MESSAGE) - sizeof(I2O_SG_ELEMENT) + + sizeof(I2O_SGE_SIMPLE_ELEMENT)); + I2O_MESSAGE_FRAME_setVersionOffset(&(Message_Ptr->StdMessageFrame), + (I2O_VERSION_11 + + (((sizeof(I2O_EXEC_HRT_GET_MESSAGE) - sizeof(I2O_SG_ELEMENT)) + / sizeof(U32)) << 4))); + I2O_MESSAGE_FRAME_setFunction (&(Message_Ptr->StdMessageFrame), + I2O_EXEC_HRT_GET); + + /* + * Set up the buffers as scatter gather elements. + */ + SG(&(Message_Ptr->SGL), 0, + I2O_SGL_FLAGS_LAST_ELEMENT | I2O_SGL_FLAGS_END_OF_BUFFER, + &Hrt, sizeof(Hrt)); + if (ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr) != CAM_REQ_CMP) { + return (ENODEV); + } + if ((NumberOfEntries = I2O_HRT_getNumberEntries(&Hrt.Header)) + > (MAX_CHANNEL + 1)) { + NumberOfEntries = MAX_CHANNEL + 1; + } + for (Entry = Hrt.Header.HRTEntry; + NumberOfEntries != 0; + ++Entry, --NumberOfEntries) { + PI2O_LCT_ENTRY Device; + + for (Device = sc->ha_LCT->LCTEntry; Device < (PI2O_LCT_ENTRY) + (((U32 *)sc->ha_LCT)+I2O_LCT_getTableSize(sc->ha_LCT)); + ++Device) { + if (I2O_LCT_ENTRY_getLocalTID(Device) + == (I2O_HRT_ENTRY_getAdapterID(Entry) & 0xFFF)) { + Device->le_bus = I2O_HRT_ENTRY_getAdapterID( + Entry) >> 16; + if ((Device->le_bus > sc->ha_MaxBus) + && (Device->le_bus <= MAX_CHANNEL)) { + sc->ha_MaxBus = Device->le_bus; + } + } + } + } + return (0); } /* ASR_acquireHrt */ /* - * Enable the adapter. + * Enable the adapter. */ STATIC INLINE int ASR_enableSys ( - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { - defAlignLong(I2O_EXEC_SYS_ENABLE_MESSAGE,Message); - PI2O_EXEC_SYS_ENABLE_MESSAGE Message_Ptr; - - Message_Ptr = (PI2O_EXEC_SYS_ENABLE_MESSAGE)ASR_fillMessage(Message, - sizeof(I2O_EXEC_SYS_ENABLE_MESSAGE)); - I2O_MESSAGE_FRAME_setFunction(&(Message_Ptr->StdMessageFrame), - I2O_EXEC_SYS_ENABLE); - return (ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr) != 0); + defAlignLong(I2O_EXEC_SYS_ENABLE_MESSAGE,Message); + PI2O_EXEC_SYS_ENABLE_MESSAGE Message_Ptr; + + Message_Ptr = (PI2O_EXEC_SYS_ENABLE_MESSAGE)ASR_fillMessage(Message, + sizeof(I2O_EXEC_SYS_ENABLE_MESSAGE)); + I2O_MESSAGE_FRAME_setFunction(&(Message_Ptr->StdMessageFrame), + I2O_EXEC_SYS_ENABLE); + return (ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr) != 0); } /* ASR_enableSys */ /* - * Perform the stages necessary to initialize the adapter + * Perform the stages necessary to initialize the adapter */ STATIC int ASR_init( - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { - return ((ASR_initOutBound(sc) == 0) - || (ASR_setSysTab(sc) != CAM_REQ_CMP) - || (ASR_enableSys(sc) != CAM_REQ_CMP)); + return ((ASR_initOutBound(sc) == 0) + || (ASR_setSysTab(sc) != CAM_REQ_CMP) + || (ASR_enableSys(sc) != CAM_REQ_CMP)); } /* ASR_init */ /* - * Send a Synchronize Cache command to the target device. + * Send a Synchronize Cache command to the target device. */ STATIC INLINE void ASR_sync ( - IN Asr_softc_t * sc, - IN int bus, - IN int target, - IN int lun) + IN Asr_softc_t * sc, + IN int bus, + IN int target, + IN int lun) { - tid_t TID; - - /* - * We will not synchronize the device when there are outstanding - * commands issued by the OS (this is due to a locked up device, - * as the OS normally would flush all outstanding commands before - * issuing a shutdown or an adapter reset). - */ - if ((sc != (Asr_softc_t *)NULL) - && (LIST_FIRST(&(sc->ha_ccb)) != (struct ccb_hdr *)NULL) - && ((TID = ASR_getTid (sc, bus, target, lun)) != (tid_t)-1) - && (TID != (tid_t)0)) { - defAlignLong(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE,Message); - PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE Message_Ptr; - - bzero (Message_Ptr - = getAlignLong(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE, Message), - sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - - sizeof(I2O_SG_ELEMENT) + sizeof(I2O_SGE_SIMPLE_ELEMENT)); - - I2O_MESSAGE_FRAME_setVersionOffset( - (PI2O_MESSAGE_FRAME)Message_Ptr, - I2O_VERSION_11 - | (((sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - - sizeof(I2O_SG_ELEMENT)) - / sizeof(U32)) << 4)); - I2O_MESSAGE_FRAME_setMessageSize( - (PI2O_MESSAGE_FRAME)Message_Ptr, - (sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - - sizeof(I2O_SG_ELEMENT)) - / sizeof(U32)); - I2O_MESSAGE_FRAME_setInitiatorAddress ( - (PI2O_MESSAGE_FRAME)Message_Ptr, 1); - I2O_MESSAGE_FRAME_setFunction( - (PI2O_MESSAGE_FRAME)Message_Ptr, I2O_PRIVATE_MESSAGE); - I2O_MESSAGE_FRAME_setTargetAddress( - (PI2O_MESSAGE_FRAME)Message_Ptr, TID); - I2O_PRIVATE_MESSAGE_FRAME_setXFunctionCode ( - (PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr, - I2O_SCSI_SCB_EXEC); - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setTID(Message_Ptr, TID); - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags (Message_Ptr, - I2O_SCB_FLAG_ENABLE_DISCONNECT - | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG - | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER); - I2O_PRIVATE_MESSAGE_FRAME_setOrganizationID( - (PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr, - DPT_ORGANIZATION_ID); - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setCDBLength(Message_Ptr, 6); - Message_Ptr->CDB[0] = SYNCHRONIZE_CACHE; - Message_Ptr->CDB[1] = (lun << 5); - - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags (Message_Ptr, - (I2O_SCB_FLAG_XFER_FROM_DEVICE - | I2O_SCB_FLAG_ENABLE_DISCONNECT - | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG - | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER)); - - (void)ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); - - } + tid_t TID; + + /* + * We will not synchronize the device when there are outstanding + * commands issued by the OS (this is due to a locked up device, + * as the OS normally would flush all outstanding commands before + * issuing a shutdown or an adapter reset). + */ + if ((sc != (Asr_softc_t *)NULL) + && (LIST_FIRST(&(sc->ha_ccb)) != (struct ccb_hdr *)NULL) + && ((TID = ASR_getTid (sc, bus, target, lun)) != (tid_t)-1) + && (TID != (tid_t)0)) { + defAlignLong(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE,Message); + PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE Message_Ptr; + + bzero (Message_Ptr + = getAlignLong(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE, Message), + sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) + - sizeof(I2O_SG_ELEMENT) + sizeof(I2O_SGE_SIMPLE_ELEMENT)); + + I2O_MESSAGE_FRAME_setVersionOffset( + (PI2O_MESSAGE_FRAME)Message_Ptr, + I2O_VERSION_11 + | (((sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) + - sizeof(I2O_SG_ELEMENT)) + / sizeof(U32)) << 4)); + I2O_MESSAGE_FRAME_setMessageSize( + (PI2O_MESSAGE_FRAME)Message_Ptr, + (sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) + - sizeof(I2O_SG_ELEMENT)) + / sizeof(U32)); + I2O_MESSAGE_FRAME_setInitiatorAddress ( + (PI2O_MESSAGE_FRAME)Message_Ptr, 1); + I2O_MESSAGE_FRAME_setFunction( + (PI2O_MESSAGE_FRAME)Message_Ptr, I2O_PRIVATE_MESSAGE); + I2O_MESSAGE_FRAME_setTargetAddress( + (PI2O_MESSAGE_FRAME)Message_Ptr, TID); + I2O_PRIVATE_MESSAGE_FRAME_setXFunctionCode ( + (PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr, + I2O_SCSI_SCB_EXEC); + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setTID(Message_Ptr, TID); + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags (Message_Ptr, + I2O_SCB_FLAG_ENABLE_DISCONNECT + | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG + | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER); + I2O_PRIVATE_MESSAGE_FRAME_setOrganizationID( + (PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr, + DPT_ORGANIZATION_ID); + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setCDBLength(Message_Ptr, 6); + Message_Ptr->CDB[0] = SYNCHRONIZE_CACHE; + Message_Ptr->CDB[1] = (lun << 5); + + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags (Message_Ptr, + (I2O_SCB_FLAG_XFER_FROM_DEVICE + | I2O_SCB_FLAG_ENABLE_DISCONNECT + | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG + | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER)); + + (void)ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); + + } } STATIC INLINE void ASR_synchronize ( - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { - int bus, target, lun; - - for (bus = 0; bus <= sc->ha_MaxBus; ++bus) { - for (target = 0; target <= sc->ha_MaxId; ++target) { - for (lun = 0; lun <= sc->ha_MaxLun; ++lun) { - ASR_sync(sc,bus,target,lun); - } - } - } + int bus, target, lun; + + for (bus = 0; bus <= sc->ha_MaxBus; ++bus) { + for (target = 0; target <= sc->ha_MaxId; ++target) { + for (lun = 0; lun <= sc->ha_MaxLun; ++lun) { + ASR_sync(sc,bus,target,lun); + } + } + } } /* - * Reset the HBA, targets and BUS. - * Currently this resets *all* the SCSI busses. + * Reset the HBA, targets and BUS. + * Currently this resets *all* the SCSI busses. */ STATIC INLINE void asr_hbareset( - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { - ASR_synchronize (sc); - (void)ASR_reset (sc); + ASR_synchronize (sc); + (void)ASR_reset (sc); } /* asr_hbareset */ /* - * A reduced copy of the real pci_map_mem, incorporating the MAX_MAP + * A reduced copy of the real pci_map_mem, incorporating the MAX_MAP * limit and a reduction in error checking (in the pre 4.0 case). */ STATIC int asr_pci_map_mem ( #if __FreeBSD_version >= 400000 - IN device_t tag, + IN device_t tag, #else - IN pcici_t tag, + IN pcici_t tag, #endif - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { - int rid; - u_int32_t p, l, s; + int rid; + u_int32_t p, l, s; #if __FreeBSD_version >= 400000 - /* - * I2O specification says we must find first *memory* mapped BAR - */ - for (rid = PCIR_MAPS; - rid < (PCIR_MAPS + 4 * sizeof(u_int32_t)); - rid += sizeof(u_int32_t)) { - p = pci_read_config(tag, rid, sizeof(p)); - if ((p & 1) == 0) { - break; - } - } - /* - * Give up? - */ - if (rid >= (PCIR_MAPS + 4 * sizeof(u_int32_t))) { - rid = PCIR_MAPS; - } - p = pci_read_config(tag, rid, sizeof(p)); - pci_write_config(tag, rid, -1, sizeof(p)); - l = 0 - (pci_read_config(tag, rid, sizeof(l)) & ~15); - pci_write_config(tag, rid, p, sizeof(p)); - if (l > MAX_MAP) { - l = MAX_MAP; - } - /* - * The 2005S Zero Channel RAID solution is not a perfect PCI - * citizen. It asks for 4MB on BAR0, and 0MB on BAR1, once - * enabled it rewrites the size of BAR0 to 2MB, sets BAR1 to - * BAR0+2MB and sets it's size to 2MB. The IOP registers are - * accessible via BAR0, the messaging registers are accessible - * via BAR1. If the subdevice code is 50 to 59 decimal. - */ - s = pci_read_config(tag, PCIR_DEVVENDOR, sizeof(s)); - if (s != 0xA5111044) { - s = pci_read_config(tag, PCIR_SUBVEND_0, sizeof(s)); - if ((((ADPTDOMINATOR_SUB_ID_START ^ s) & 0xF000FFFF) == 0) - && (ADPTDOMINATOR_SUB_ID_START <= s) - && (s <= ADPTDOMINATOR_SUB_ID_END)) { - l = MAX_MAP; /* Conjoined BAR Raptor Daptor */ - } - } - p &= ~15; - sc->ha_mem_res = bus_alloc_resource(tag, SYS_RES_MEMORY, &rid, - p, p + l, l, RF_ACTIVE); - if (sc->ha_mem_res == (struct resource *)NULL) { - return (0); - } - sc->ha_Base = (void *)rman_get_start(sc->ha_mem_res); - if (sc->ha_Base == (void *)NULL) { - return (0); - } - sc->ha_Virt = (i2oRegs_t *) rman_get_virtual(sc->ha_mem_res); - if (s == 0xA5111044) { /* Split BAR Raptor Daptor */ - if ((rid += sizeof(u_int32_t)) - >= (PCIR_MAPS + 4 * sizeof(u_int32_t))) { - return (0); - } - p = pci_read_config(tag, rid, sizeof(p)); - pci_write_config(tag, rid, -1, sizeof(p)); - l = 0 - (pci_read_config(tag, rid, sizeof(l)) & ~15); - pci_write_config(tag, rid, p, sizeof(p)); - if (l > MAX_MAP) { - l = MAX_MAP; - } - p &= ~15; - sc->ha_mes_res = bus_alloc_resource(tag, SYS_RES_MEMORY, &rid, - p, p + l, l, RF_ACTIVE); - if (sc->ha_mes_res == (struct resource *)NULL) { - return (0); - } - if ((void *)rman_get_start(sc->ha_mes_res) == (void *)NULL) { - return (0); - } - sc->ha_Fvirt = (U8 *) rman_get_virtual(sc->ha_mes_res); - } else { - sc->ha_Fvirt = (U8 *)(sc->ha_Virt); - } + /* + * I2O specification says we must find first *memory* mapped BAR + */ + for (rid = PCIR_MAPS; + rid < (PCIR_MAPS + 4 * sizeof(u_int32_t)); + rid += sizeof(u_int32_t)) { + p = pci_read_config(tag, rid, sizeof(p)); + if ((p & 1) == 0) { + break; + } + } + /* + * Give up? + */ + if (rid >= (PCIR_MAPS + 4 * sizeof(u_int32_t))) { + rid = PCIR_MAPS; + } + p = pci_read_config(tag, rid, sizeof(p)); + pci_write_config(tag, rid, -1, sizeof(p)); + l = 0 - (pci_read_config(tag, rid, sizeof(l)) & ~15); + pci_write_config(tag, rid, p, sizeof(p)); + if (l > MAX_MAP) { + l = MAX_MAP; + } + /* + * The 2005S Zero Channel RAID solution is not a perfect PCI + * citizen. It asks for 4MB on BAR0, and 0MB on BAR1, once + * enabled it rewrites the size of BAR0 to 2MB, sets BAR1 to + * BAR0+2MB and sets it's size to 2MB. The IOP registers are + * accessible via BAR0, the messaging registers are accessible + * via BAR1. If the subdevice code is 50 to 59 decimal. + */ + s = pci_read_config(tag, PCIR_DEVVENDOR, sizeof(s)); + if (s != 0xA5111044) { + s = pci_read_config(tag, PCIR_SUBVEND_0, sizeof(s)); + if ((((ADPTDOMINATOR_SUB_ID_START ^ s) & 0xF000FFFF) == 0) + && (ADPTDOMINATOR_SUB_ID_START <= s) + && (s <= ADPTDOMINATOR_SUB_ID_END)) { + l = MAX_MAP; /* Conjoined BAR Raptor Daptor */ + } + } + p &= ~15; + sc->ha_mem_res = bus_alloc_resource(tag, SYS_RES_MEMORY, &rid, + p, p + l, l, RF_ACTIVE); + if (sc->ha_mem_res == (struct resource *)NULL) { + return (0); + } + sc->ha_Base = (void *)rman_get_start(sc->ha_mem_res); + if (sc->ha_Base == (void *)NULL) { + return (0); + } + sc->ha_Virt = (i2oRegs_t *) rman_get_virtual(sc->ha_mem_res); + if (s == 0xA5111044) { /* Split BAR Raptor Daptor */ + if ((rid += sizeof(u_int32_t)) + >= (PCIR_MAPS + 4 * sizeof(u_int32_t))) { + return (0); + } + p = pci_read_config(tag, rid, sizeof(p)); + pci_write_config(tag, rid, -1, sizeof(p)); + l = 0 - (pci_read_config(tag, rid, sizeof(l)) & ~15); + pci_write_config(tag, rid, p, sizeof(p)); + if (l > MAX_MAP) { + l = MAX_MAP; + } + p &= ~15; + sc->ha_mes_res = bus_alloc_resource(tag, SYS_RES_MEMORY, &rid, + p, p + l, l, RF_ACTIVE); + if (sc->ha_mes_res == (struct resource *)NULL) { + return (0); + } + if ((void *)rman_get_start(sc->ha_mes_res) == (void *)NULL) { + return (0); + } + sc->ha_Fvirt = (U8 *) rman_get_virtual(sc->ha_mes_res); + } else { + sc->ha_Fvirt = (U8 *)(sc->ha_Virt); + } #else - vm_size_t psize, poffs; - - /* - * I2O specification says we must find first *memory* mapped BAR - */ - for (rid = PCI_MAP_REG_START; - rid < (PCI_MAP_REG_START + 4 * sizeof(u_int32_t)); - rid += sizeof(u_int32_t)) { - p = pci_conf_read (tag, rid); - if ((p & 1) == 0) { - break; - } - } - if (rid >= (PCI_MAP_REG_START + 4 * sizeof(u_int32_t))) { - rid = PCI_MAP_REG_START; - } - /* - ** save old mapping, get size and type of memory - ** - ** type is in the lowest four bits. - ** If device requires 2^n bytes, the next - ** n-4 bits are read as 0. - */ - - sc->ha_Base = (void *)((p = pci_conf_read (tag, rid)) - & PCI_MAP_MEMORY_ADDRESS_MASK); - pci_conf_write (tag, rid, 0xfffffffful); - l = pci_conf_read (tag, rid); - pci_conf_write (tag, rid, p); - - /* - ** check the type - */ - - if (!((l & PCI_MAP_MEMORY_TYPE_MASK) == PCI_MAP_MEMORY_TYPE_32BIT_1M - && ((u_long)sc->ha_Base & ~0xfffff) == 0) - && ((l & PCI_MAP_MEMORY_TYPE_MASK) != PCI_MAP_MEMORY_TYPE_32BIT)) { - debug_asr_printf ( - "asr_pci_map_mem failed: bad memory type=0x%x\n", - (unsigned) l); - return (0); - }; - - /* - ** get the size. - */ - - psize = -(l & PCI_MAP_MEMORY_ADDRESS_MASK); - if (psize > MAX_MAP) { - psize = MAX_MAP; - } - /* - * The 2005S Zero Channel RAID solution is not a perfect PCI - * citizen. It asks for 4MB on BAR0, and 0MB on BAR1, once - * enabled it rewrites the size of BAR0 to 2MB, sets BAR1 to - * BAR0+2MB and sets it's size to 2MB. The IOP registers are - * accessible via BAR0, the messaging registers are accessible - * via BAR1. If the subdevice code is 50 to 59 decimal. - */ - s = pci_read_config(tag, PCIR_DEVVENDOR, sizeof(s)); - if (s != 0xA5111044) { - s = pci_conf_read (tag, PCIR_SUBVEND_0) - if ((((ADPTDOMINATOR_SUB_ID_START ^ s) & 0xF000FFFF) == 0) - && (ADPTDOMINATOR_SUB_ID_START <= s) - && (s <= ADPTDOMINATOR_SUB_ID_END)) { - psize = MAX_MAP; - } - } - - if ((sc->ha_Base == (void *)NULL) - || (sc->ha_Base == (void *)PCI_MAP_MEMORY_ADDRESS_MASK)) { - debug_asr_printf ("asr_pci_map_mem: not configured by bios.\n"); - return (0); - }; - - /* - ** Truncate sc->ha_Base to page boundary. - ** (Or does pmap_mapdev the job?) - */ - - poffs = (u_long)sc->ha_Base - trunc_page ((u_long)sc->ha_Base); - sc->ha_Virt = (i2oRegs_t *)pmap_mapdev ((u_long)sc->ha_Base - poffs, - psize + poffs); - - if (sc->ha_Virt == (i2oRegs_t *)NULL) { - return (0); - } - - sc->ha_Virt = (i2oRegs_t *)((u_long)sc->ha_Virt + poffs); - if (s == 0xA5111044) { - if ((rid += sizeof(u_int32_t)) - >= (PCI_MAP_REG_START + 4 * sizeof(u_int32_t))) { - return (0); - } - - /* - ** save old mapping, get size and type of memory - ** - ** type is in the lowest four bits. - ** If device requires 2^n bytes, the next - ** n-4 bits are read as 0. - */ - - if ((((p = pci_conf_read (tag, rid)) - & PCI_MAP_MEMORY_ADDRESS_MASK) == 0L) - || ((p & PCI_MAP_MEMORY_ADDRESS_MASK) - == PCI_MAP_MEMORY_ADDRESS_MASK)) { - debug_asr_printf ("asr_pci_map_mem: not configured by bios.\n"); - } - pci_conf_write (tag, rid, 0xfffffffful); - l = pci_conf_read (tag, rid); - pci_conf_write (tag, rid, p); - p &= PCI_MAP_MEMORY_TYPE_MASK; - - /* - ** check the type - */ - - if (!((l & PCI_MAP_MEMORY_TYPE_MASK) - == PCI_MAP_MEMORY_TYPE_32BIT_1M - && (p & ~0xfffff) == 0) - && ((l & PCI_MAP_MEMORY_TYPE_MASK) - != PCI_MAP_MEMORY_TYPE_32BIT)) { - debug_asr_printf ( - "asr_pci_map_mem failed: bad memory type=0x%x\n", - (unsigned) l); - return (0); - }; - - /* - ** get the size. - */ - - psize = -(l & PCI_MAP_MEMORY_ADDRESS_MASK); - if (psize > MAX_MAP) { - psize = MAX_MAP; - } - - /* - ** Truncate p to page boundary. - ** (Or does pmap_mapdev the job?) - */ - - poffs = p - trunc_page (p); - sc->ha_Fvirt = (U8 *)pmap_mapdev (p - poffs, psize + poffs); - - if (sc->ha_Fvirt == (U8 *)NULL) { - return (0); - } - - sc->ha_Fvirt = (U8 *)((u_long)sc->ha_Fvirt + poffs); - } else { - sc->ha_Fvirt = (U8 *)(sc->ha_Virt); - } + vm_size_t psize, poffs; + + /* + * I2O specification says we must find first *memory* mapped BAR + */ + for (rid = PCI_MAP_REG_START; + rid < (PCI_MAP_REG_START + 4 * sizeof(u_int32_t)); + rid += sizeof(u_int32_t)) { + p = pci_conf_read (tag, rid); + if ((p & 1) == 0) { + break; + } + } + if (rid >= (PCI_MAP_REG_START + 4 * sizeof(u_int32_t))) { + rid = PCI_MAP_REG_START; + } + /* + ** save old mapping, get size and type of memory + ** + ** type is in the lowest four bits. + ** If device requires 2^n bytes, the next + ** n-4 bits are read as 0. + */ + + sc->ha_Base = (void *)((p = pci_conf_read (tag, rid)) + & PCI_MAP_MEMORY_ADDRESS_MASK); + pci_conf_write (tag, rid, 0xfffffffful); + l = pci_conf_read (tag, rid); + pci_conf_write (tag, rid, p); + + /* + ** check the type + */ + + if (!((l & PCI_MAP_MEMORY_TYPE_MASK) == PCI_MAP_MEMORY_TYPE_32BIT_1M + && ((u_long)sc->ha_Base & ~0xfffff) == 0) + && ((l & PCI_MAP_MEMORY_TYPE_MASK) != PCI_MAP_MEMORY_TYPE_32BIT)) { + debug_asr_printf ( + "asr_pci_map_mem failed: bad memory type=0x%x\n", + (unsigned) l); + return (0); + }; + + /* + ** get the size. + */ + + psize = -(l & PCI_MAP_MEMORY_ADDRESS_MASK); + if (psize > MAX_MAP) { + psize = MAX_MAP; + } + /* + * The 2005S Zero Channel RAID solution is not a perfect PCI + * citizen. It asks for 4MB on BAR0, and 0MB on BAR1, once + * enabled it rewrites the size of BAR0 to 2MB, sets BAR1 to + * BAR0+2MB and sets it's size to 2MB. The IOP registers are + * accessible via BAR0, the messaging registers are accessible + * via BAR1. If the subdevice code is 50 to 59 decimal. + */ + s = pci_read_config(tag, PCIR_DEVVENDOR, sizeof(s)); + if (s != 0xA5111044) { + s = pci_conf_read (tag, PCIR_SUBVEND_0) + if ((((ADPTDOMINATOR_SUB_ID_START ^ s) & 0xF000FFFF) == 0) + && (ADPTDOMINATOR_SUB_ID_START <= s) + && (s <= ADPTDOMINATOR_SUB_ID_END)) { + psize = MAX_MAP; + } + } + + if ((sc->ha_Base == (void *)NULL) + || (sc->ha_Base == (void *)PCI_MAP_MEMORY_ADDRESS_MASK)) { + debug_asr_printf ("asr_pci_map_mem: not configured by bios.\n"); + return (0); + }; + + /* + ** Truncate sc->ha_Base to page boundary. + ** (Or does pmap_mapdev the job?) + */ + + poffs = (u_long)sc->ha_Base - trunc_page ((u_long)sc->ha_Base); + sc->ha_Virt = (i2oRegs_t *)pmap_mapdev ((u_long)sc->ha_Base - poffs, + psize + poffs); + + if (sc->ha_Virt == (i2oRegs_t *)NULL) { + return (0); + } + + sc->ha_Virt = (i2oRegs_t *)((u_long)sc->ha_Virt + poffs); + if (s == 0xA5111044) { + if ((rid += sizeof(u_int32_t)) + >= (PCI_MAP_REG_START + 4 * sizeof(u_int32_t))) { + return (0); + } + + /* + ** save old mapping, get size and type of memory + ** + ** type is in the lowest four bits. + ** If device requires 2^n bytes, the next + ** n-4 bits are read as 0. + */ + + if ((((p = pci_conf_read (tag, rid)) + & PCI_MAP_MEMORY_ADDRESS_MASK) == 0L) + || ((p & PCI_MAP_MEMORY_ADDRESS_MASK) + == PCI_MAP_MEMORY_ADDRESS_MASK)) { + debug_asr_printf ("asr_pci_map_mem: not configured by bios.\n"); + } + pci_conf_write (tag, rid, 0xfffffffful); + l = pci_conf_read (tag, rid); + pci_conf_write (tag, rid, p); + p &= PCI_MAP_MEMORY_TYPE_MASK; + + /* + ** check the type + */ + + if (!((l & PCI_MAP_MEMORY_TYPE_MASK) + == PCI_MAP_MEMORY_TYPE_32BIT_1M + && (p & ~0xfffff) == 0) + && ((l & PCI_MAP_MEMORY_TYPE_MASK) + != PCI_MAP_MEMORY_TYPE_32BIT)) { + debug_asr_printf ( + "asr_pci_map_mem failed: bad memory type=0x%x\n", + (unsigned) l); + return (0); + }; + + /* + ** get the size. + */ + + psize = -(l & PCI_MAP_MEMORY_ADDRESS_MASK); + if (psize > MAX_MAP) { + psize = MAX_MAP; + } + + /* + ** Truncate p to page boundary. + ** (Or does pmap_mapdev the job?) + */ + + poffs = p - trunc_page (p); + sc->ha_Fvirt = (U8 *)pmap_mapdev (p - poffs, psize + poffs); + + if (sc->ha_Fvirt == (U8 *)NULL) { + return (0); + } + + sc->ha_Fvirt = (U8 *)((u_long)sc->ha_Fvirt + poffs); + } else { + sc->ha_Fvirt = (U8 *)(sc->ha_Virt); + } #endif - return (1); + return (1); } /* asr_pci_map_mem */ /* - * A simplified copy of the real pci_map_int with additional + * A simplified copy of the real pci_map_int with additional * registration requirements. */ STATIC int asr_pci_map_int ( #if __FreeBSD_version >= 400000 - IN device_t tag, + IN device_t tag, #else - IN pcici_t tag, + IN pcici_t tag, #endif - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { #if __FreeBSD_version >= 400000 - int rid = 0; - - sc->ha_irq_res = bus_alloc_resource(tag, SYS_RES_IRQ, &rid, - 0, ~0, 1, RF_ACTIVE | RF_SHAREABLE); - if (sc->ha_irq_res == (struct resource *)NULL) { - return (0); - } - if (bus_setup_intr(tag, sc->ha_irq_res, INTR_TYPE_CAM | INTR_ENTROPY, - (driver_intr_t *)asr_intr, (void *)sc, &(sc->ha_intr))) { - return (0); - } - sc->ha_irq = pci_read_config(tag, PCIR_INTLINE, sizeof(char)); + int rid = 0; + + sc->ha_irq_res = bus_alloc_resource(tag, SYS_RES_IRQ, &rid, + 0, ~0, 1, RF_ACTIVE | RF_SHAREABLE); + if (sc->ha_irq_res == (struct resource *)NULL) { + return (0); + } + if (bus_setup_intr(tag, sc->ha_irq_res, INTR_TYPE_CAM | INTR_ENTROPY, + (driver_intr_t *)asr_intr, (void *)sc, &(sc->ha_intr))) { + return (0); + } + sc->ha_irq = pci_read_config(tag, PCIR_INTLINE, sizeof(char)); #else - if (!pci_map_int(tag, (pci_inthand_t *)asr_intr, - (void *)sc, &cam_imask)) { - return (0); - } - sc->ha_irq = pci_conf_read(tag, PCIR_INTLINE); + if (!pci_map_int(tag, (pci_inthand_t *)asr_intr, + (void *)sc, &cam_imask)) { + return (0); + } + sc->ha_irq = pci_conf_read(tag, PCIR_INTLINE); #endif - return (1); + return (1); } /* asr_pci_map_int */ /* - * Attach the devices, and virtual devices to the driver list. + * Attach the devices, and virtual devices to the driver list. */ STATIC ATTACH_RET asr_attach (ATTACH_ARGS) { - Asr_softc_t * sc; - struct scsi_inquiry_data * iq; - ATTACH_SET(); + Asr_softc_t * sc; + struct scsi_inquiry_data * iq; + ATTACH_SET(); - if ((sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT | M_ZERO)) == + if ((sc = malloc(sizeof(*sc), M_DEVBUF, M_NOWAIT | M_ZERO)) == (Asr_softc_t *)NULL) - { - ATTACH_RETURN(ENOMEM); - } - if (Asr_softc == (Asr_softc_t *)NULL) { - /* - * Fixup the OS revision as saved in the dptsig for the - * engine (dptioctl.h) to pick up. - */ - bcopy (osrelease, &ASR_sig.dsDescription[16], 5); - printf ("asr%d: major=%d\n", unit, asr_cdevsw.d_maj); - } - /* - * Initialize the software structure - */ - LIST_INIT(&(sc->ha_ccb)); -# ifdef ASR_MEASURE_PERFORMANCE - { - u_int32_t i; - - /* initialize free list for timeQ */ - sc->ha_timeQFreeHead = 0; - sc->ha_timeQFreeTail = MAX_TIMEQ_SIZE - 1; - for (i = 0; i < MAX_TIMEQ_SIZE; i++) { - sc->ha_timeQFreeList[i] = i; - } - } -# endif - /* Link us into the HA list */ - { - Asr_softc_t **ha; - - for (ha = &Asr_softc; *ha; ha = &((*ha)->ha_next)); - *(ha) = sc; - } - { - PI2O_EXEC_STATUS_GET_REPLY status; - int size; - - /* - * This is the real McCoy! - */ - if (!asr_pci_map_mem(tag, sc)) { - printf ("asr%d: could not map memory\n", unit); - ATTACH_RETURN(ENXIO); - } - /* Enable if not formerly enabled */ + { + ATTACH_RETURN(ENOMEM); + } + if (Asr_softc == (Asr_softc_t *)NULL) { + /* + * Fixup the OS revision as saved in the dptsig for the + * engine (dptioctl.h) to pick up. + */ + bcopy (osrelease, &ASR_sig.dsDescription[16], 5); + printf ("asr%d: major=%d\n", unit, asr_cdevsw.d_maj); + } + /* + * Initialize the software structure + */ + LIST_INIT(&(sc->ha_ccb)); +# ifdef ASR_MEASURE_PERFORMANCE + { + u_int32_t i; + + /* initialize free list for timeQ */ + sc->ha_timeQFreeHead = 0; + sc->ha_timeQFreeTail = MAX_TIMEQ_SIZE - 1; + for (i = 0; i < MAX_TIMEQ_SIZE; i++) { + sc->ha_timeQFreeList[i] = i; + } + } +# endif + /* Link us into the HA list */ + { + Asr_softc_t **ha; + + for (ha = &Asr_softc; *ha; ha = &((*ha)->ha_next)); + *(ha) = sc; + } + { + PI2O_EXEC_STATUS_GET_REPLY status; + int size; + + /* + * This is the real McCoy! + */ + if (!asr_pci_map_mem(tag, sc)) { + printf ("asr%d: could not map memory\n", unit); + ATTACH_RETURN(ENXIO); + } + /* Enable if not formerly enabled */ #if __FreeBSD_version >= 400000 - pci_write_config (tag, PCIR_COMMAND, - pci_read_config (tag, PCIR_COMMAND, sizeof(char)) - | PCIM_CMD_MEMEN | PCIM_CMD_BUSMASTEREN, sizeof(char)); - /* Knowledge is power, responsibility is direct */ - { - struct pci_devinfo { - STAILQ_ENTRY(pci_devinfo) pci_links; - struct resource_list resources; - pcicfgregs cfg; - } * dinfo = device_get_ivars(tag); - sc->ha_pciBusNum = dinfo->cfg.bus; - sc->ha_pciDeviceNum = (dinfo->cfg.slot << 3) - | dinfo->cfg.func; - } + pci_write_config (tag, PCIR_COMMAND, + pci_read_config (tag, PCIR_COMMAND, sizeof(char)) + | PCIM_CMD_MEMEN | PCIM_CMD_BUSMASTEREN, sizeof(char)); + /* Knowledge is power, responsibility is direct */ + { + struct pci_devinfo { + STAILQ_ENTRY(pci_devinfo) pci_links; + struct resource_list resources; + pcicfgregs cfg; + } * dinfo = device_get_ivars(tag); + sc->ha_pciBusNum = dinfo->cfg.bus; + sc->ha_pciDeviceNum = (dinfo->cfg.slot << 3) + | dinfo->cfg.func; + } #else - pci_conf_write (tag, PCIR_COMMAND, - pci_conf_read (tag, PCIR_COMMAND) - | PCIM_CMD_MEMEN | PCIM_CMD_BUSMASTEREN); - /* Knowledge is power, responsibility is direct */ - switch (pci_mechanism) { - - case 1: - sc->ha_pciBusNum = tag.cfg1 >> 16; - sc->ha_pciDeviceNum = tag.cfg1 >> 8; - - case 2: - sc->ha_pciBusNum = tag.cfg2.forward; - sc->ha_pciDeviceNum = ((tag.cfg2.enable >> 1) & 7) - | (tag.cfg2.port >> 5); - } + pci_conf_write (tag, PCIR_COMMAND, + pci_conf_read (tag, PCIR_COMMAND) + | PCIM_CMD_MEMEN | PCIM_CMD_BUSMASTEREN); + /* Knowledge is power, responsibility is direct */ + switch (pci_mechanism) { + + case 1: + sc->ha_pciBusNum = tag.cfg1 >> 16; + sc->ha_pciDeviceNum = tag.cfg1 >> 8; + + case 2: + sc->ha_pciBusNum = tag.cfg2.forward; + sc->ha_pciDeviceNum = ((tag.cfg2.enable >> 1) & 7) + | (tag.cfg2.port >> 5); + } #endif - /* Check if the device is there? */ - if ((ASR_resetIOP(sc->ha_Virt, sc->ha_Fvirt) == 0) - || ((status = (PI2O_EXEC_STATUS_GET_REPLY)malloc ( - sizeof(I2O_EXEC_STATUS_GET_REPLY), M_TEMP, M_WAITOK)) - == (PI2O_EXEC_STATUS_GET_REPLY)NULL) - || (ASR_getStatus(sc->ha_Virt, sc->ha_Fvirt, status) == NULL)) { - printf ("asr%d: could not initialize hardware\n", unit); - ATTACH_RETURN(ENODEV); /* Get next, maybe better luck */ - } - sc->ha_SystemTable.OrganizationID = status->OrganizationID; - sc->ha_SystemTable.IOP_ID = status->IOP_ID; - sc->ha_SystemTable.I2oVersion = status->I2oVersion; - sc->ha_SystemTable.IopState = status->IopState; - sc->ha_SystemTable.MessengerType = status->MessengerType; - sc->ha_SystemTable.InboundMessageFrameSize - = status->InboundMFrameSize; - sc->ha_SystemTable.MessengerInfo.InboundMessagePortAddressLow - = (U32)(sc->ha_Base) + (U32)(&(((i2oRegs_t *)NULL)->ToFIFO)); - - if (!asr_pci_map_int(tag, (void *)sc)) { - printf ("asr%d: could not map interrupt\n", unit); - ATTACH_RETURN(ENXIO); - } - - /* Adjust the maximim inbound count */ - if (((sc->ha_QueueSize - = I2O_EXEC_STATUS_GET_REPLY_getMaxInboundMFrames(status)) - > MAX_INBOUND) - || (sc->ha_QueueSize == 0)) { - sc->ha_QueueSize = MAX_INBOUND; - } - - /* Adjust the maximum outbound count */ - if (((sc->ha_Msgs_Count - = I2O_EXEC_STATUS_GET_REPLY_getMaxOutboundMFrames(status)) - > MAX_OUTBOUND) - || (sc->ha_Msgs_Count == 0)) { - sc->ha_Msgs_Count = MAX_OUTBOUND; - } - if (sc->ha_Msgs_Count > sc->ha_QueueSize) { - sc->ha_Msgs_Count = sc->ha_QueueSize; - } - - /* Adjust the maximum SG size to adapter */ - if ((size = (I2O_EXEC_STATUS_GET_REPLY_getInboundMFrameSize( - status) << 2)) > MAX_INBOUND_SIZE) { - size = MAX_INBOUND_SIZE; - } - free (status, M_TEMP); - sc->ha_SgSize = (size - sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - + sizeof(I2O_SG_ELEMENT)) / sizeof(I2O_SGE_SIMPLE_ELEMENT); - } - - /* - * Only do a bus/HBA reset on the first time through. On this - * first time through, we do not send a flush to the devices. - */ - if (ASR_init(sc) == 0) { - struct BufferInfo { - I2O_PARAM_RESULTS_LIST_HEADER Header; - I2O_PARAM_READ_OPERATION_RESULT Read; - I2O_DPT_EXEC_IOP_BUFFERS_SCALAR Info; - }; - defAlignLong (struct BufferInfo, Buffer); - PI2O_DPT_EXEC_IOP_BUFFERS_SCALAR Info; -# define FW_DEBUG_BLED_OFFSET 8 - - if ((Info = (PI2O_DPT_EXEC_IOP_BUFFERS_SCALAR) - ASR_getParams(sc, 0, - I2O_DPT_EXEC_IOP_BUFFERS_GROUP_NO, - Buffer, sizeof(struct BufferInfo))) - != (PI2O_DPT_EXEC_IOP_BUFFERS_SCALAR)NULL) { - sc->ha_blinkLED = sc->ha_Fvirt - + I2O_DPT_EXEC_IOP_BUFFERS_SCALAR_getSerialOutputOffset(Info) - + FW_DEBUG_BLED_OFFSET; - } - if (ASR_acquireLct(sc) == 0) { - (void)ASR_acquireHrt(sc); - } - } else { - printf ("asr%d: failed to initialize\n", unit); - ATTACH_RETURN(ENXIO); - } - /* - * Add in additional probe responses for more channels. We - * are reusing the variable `target' for a channel loop counter. - * Done here because of we need both the acquireLct and - * acquireHrt data. - */ - { PI2O_LCT_ENTRY Device; - - for (Device = sc->ha_LCT->LCTEntry; Device < (PI2O_LCT_ENTRY) - (((U32 *)sc->ha_LCT)+I2O_LCT_getTableSize(sc->ha_LCT)); - ++Device) { - if (Device->le_type == I2O_UNKNOWN) { - continue; - } - if (I2O_LCT_ENTRY_getUserTID(Device) == 0xFFF) { - if (Device->le_target > sc->ha_MaxId) { - sc->ha_MaxId = Device->le_target; - } - if (Device->le_lun > sc->ha_MaxLun) { - sc->ha_MaxLun = Device->le_lun; - } - } - if (((Device->le_type & I2O_PORT) != 0) - && (Device->le_bus <= MAX_CHANNEL)) { - /* Do not increase MaxId for efficiency */ - sc->ha_adapter_target[Device->le_bus] - = Device->le_target; - } - } - } - - - /* - * Print the HBA model number as inquired from the card. - */ - - printf ("asr%d:", unit); - - if ((iq = (struct scsi_inquiry_data *)malloc ( - sizeof(struct scsi_inquiry_data), M_TEMP, M_WAITOK | M_ZERO)) - != (struct scsi_inquiry_data *)NULL) { - defAlignLong(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE,Message); - PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE Message_Ptr; - int posted = 0; - - bzero (Message_Ptr - = getAlignLong(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE, Message), - sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - - sizeof(I2O_SG_ELEMENT) + sizeof(I2O_SGE_SIMPLE_ELEMENT)); - - I2O_MESSAGE_FRAME_setVersionOffset( - (PI2O_MESSAGE_FRAME)Message_Ptr, - I2O_VERSION_11 - | (((sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - - sizeof(I2O_SG_ELEMENT)) - / sizeof(U32)) << 4)); - I2O_MESSAGE_FRAME_setMessageSize( - (PI2O_MESSAGE_FRAME)Message_Ptr, - (sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) - - sizeof(I2O_SG_ELEMENT) + sizeof(I2O_SGE_SIMPLE_ELEMENT)) - / sizeof(U32)); - I2O_MESSAGE_FRAME_setInitiatorAddress ( - (PI2O_MESSAGE_FRAME)Message_Ptr, 1); - I2O_MESSAGE_FRAME_setFunction( - (PI2O_MESSAGE_FRAME)Message_Ptr, I2O_PRIVATE_MESSAGE); - I2O_PRIVATE_MESSAGE_FRAME_setXFunctionCode ( - (PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr, - I2O_SCSI_SCB_EXEC); - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags (Message_Ptr, - I2O_SCB_FLAG_ENABLE_DISCONNECT - | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG - | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER); - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setInterpret(Message_Ptr, 1); - I2O_PRIVATE_MESSAGE_FRAME_setOrganizationID( - (PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr, - DPT_ORGANIZATION_ID); - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setCDBLength(Message_Ptr, 6); - Message_Ptr->CDB[0] = INQUIRY; - Message_Ptr->CDB[4] = (unsigned char)sizeof(struct scsi_inquiry_data); - if (Message_Ptr->CDB[4] == 0) { - Message_Ptr->CDB[4] = 255; - } - - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags (Message_Ptr, - (I2O_SCB_FLAG_XFER_FROM_DEVICE - | I2O_SCB_FLAG_ENABLE_DISCONNECT - | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG - | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER)); - - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setByteCount( - (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr, - sizeof(struct scsi_inquiry_data)); - SG(&(Message_Ptr->SGL), 0, - I2O_SGL_FLAGS_LAST_ELEMENT | I2O_SGL_FLAGS_END_OF_BUFFER, - iq, sizeof(struct scsi_inquiry_data)); - (void)ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); - - if (iq->vendor[0] && (iq->vendor[0] != ' ')) { - printf (" "); - ASR_prstring (iq->vendor, 8); - ++posted; - } - if (iq->product[0] && (iq->product[0] != ' ')) { - printf (" "); - ASR_prstring (iq->product, 16); - ++posted; - } - if (iq->revision[0] && (iq->revision[0] != ' ')) { - printf (" FW Rev. "); - ASR_prstring (iq->revision, 4); - ++posted; - } - free ((caddr_t)iq, M_TEMP); - if (posted) { - printf (","); - } - } - printf (" %d channel, %d CCBs, Protocol I2O\n", sc->ha_MaxBus + 1, - (sc->ha_QueueSize > MAX_INBOUND) ? MAX_INBOUND : sc->ha_QueueSize); - - /* - * fill in the prototype cam_path. - */ - { - int bus; - union asr_ccb * ccb; - - if ((ccb = asr_alloc_ccb (sc)) == (union asr_ccb *)NULL) { - printf ("asr%d: CAM could not be notified of asynchronous callback parameters\n", unit); - ATTACH_RETURN(ENOMEM); - } - for (bus = 0; bus <= sc->ha_MaxBus; ++bus) { - struct cam_devq * devq; - int QueueSize = sc->ha_QueueSize; - - if (QueueSize > MAX_INBOUND) { - QueueSize = MAX_INBOUND; - } - - /* - * Create the device queue for our SIM(s). - */ - if ((devq = cam_simq_alloc(QueueSize)) == NULL) { - continue; - } - - /* - * Construct our first channel SIM entry - */ - sc->ha_sim[bus] = cam_sim_alloc( - asr_action, asr_poll, "asr", sc, - unit, 1, QueueSize, devq); - if (sc->ha_sim[bus] == NULL) { - continue; - } - - if (xpt_bus_register(sc->ha_sim[bus], bus) - != CAM_SUCCESS) { - cam_sim_free(sc->ha_sim[bus], - /*free_devq*/TRUE); - sc->ha_sim[bus] = NULL; - continue; - } - - if (xpt_create_path(&(sc->ha_path[bus]), /*periph*/NULL, - cam_sim_path(sc->ha_sim[bus]), CAM_TARGET_WILDCARD, - CAM_LUN_WILDCARD) != CAM_REQ_CMP) { - xpt_bus_deregister( - cam_sim_path(sc->ha_sim[bus])); - cam_sim_free(sc->ha_sim[bus], - /*free_devq*/TRUE); - sc->ha_sim[bus] = NULL; - continue; - } - } - asr_free_ccb (ccb); - } - /* - * Generate the device node information - */ - (void)make_dev(&asr_cdevsw, unit, 0, 0, S_IRWXU, "rasr%d", unit); - ATTACH_RETURN(0); + /* Check if the device is there? */ + if ((ASR_resetIOP(sc->ha_Virt, sc->ha_Fvirt) == 0) + || ((status = (PI2O_EXEC_STATUS_GET_REPLY)malloc ( + sizeof(I2O_EXEC_STATUS_GET_REPLY), M_TEMP, M_WAITOK)) + == (PI2O_EXEC_STATUS_GET_REPLY)NULL) + || (ASR_getStatus(sc->ha_Virt, sc->ha_Fvirt, status) == NULL)) { + printf ("asr%d: could not initialize hardware\n", unit); + ATTACH_RETURN(ENODEV); /* Get next, maybe better luck */ + } + sc->ha_SystemTable.OrganizationID = status->OrganizationID; + sc->ha_SystemTable.IOP_ID = status->IOP_ID; + sc->ha_SystemTable.I2oVersion = status->I2oVersion; + sc->ha_SystemTable.IopState = status->IopState; + sc->ha_SystemTable.MessengerType = status->MessengerType; + sc->ha_SystemTable.InboundMessageFrameSize + = status->InboundMFrameSize; + sc->ha_SystemTable.MessengerInfo.InboundMessagePortAddressLow + = (U32)(sc->ha_Base) + (U32)(&(((i2oRegs_t *)NULL)->ToFIFO)); + + if (!asr_pci_map_int(tag, (void *)sc)) { + printf ("asr%d: could not map interrupt\n", unit); + ATTACH_RETURN(ENXIO); + } + + /* Adjust the maximim inbound count */ + if (((sc->ha_QueueSize + = I2O_EXEC_STATUS_GET_REPLY_getMaxInboundMFrames(status)) + > MAX_INBOUND) + || (sc->ha_QueueSize == 0)) { + sc->ha_QueueSize = MAX_INBOUND; + } + + /* Adjust the maximum outbound count */ + if (((sc->ha_Msgs_Count + = I2O_EXEC_STATUS_GET_REPLY_getMaxOutboundMFrames(status)) + > MAX_OUTBOUND) + || (sc->ha_Msgs_Count == 0)) { + sc->ha_Msgs_Count = MAX_OUTBOUND; + } + if (sc->ha_Msgs_Count > sc->ha_QueueSize) { + sc->ha_Msgs_Count = sc->ha_QueueSize; + } + + /* Adjust the maximum SG size to adapter */ + if ((size = (I2O_EXEC_STATUS_GET_REPLY_getInboundMFrameSize( + status) << 2)) > MAX_INBOUND_SIZE) { + size = MAX_INBOUND_SIZE; + } + free (status, M_TEMP); + sc->ha_SgSize = (size - sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) + + sizeof(I2O_SG_ELEMENT)) / sizeof(I2O_SGE_SIMPLE_ELEMENT); + } + + /* + * Only do a bus/HBA reset on the first time through. On this + * first time through, we do not send a flush to the devices. + */ + if (ASR_init(sc) == 0) { + struct BufferInfo { + I2O_PARAM_RESULTS_LIST_HEADER Header; + I2O_PARAM_READ_OPERATION_RESULT Read; + I2O_DPT_EXEC_IOP_BUFFERS_SCALAR Info; + }; + defAlignLong (struct BufferInfo, Buffer); + PI2O_DPT_EXEC_IOP_BUFFERS_SCALAR Info; +# define FW_DEBUG_BLED_OFFSET 8 + + if ((Info = (PI2O_DPT_EXEC_IOP_BUFFERS_SCALAR) + ASR_getParams(sc, 0, + I2O_DPT_EXEC_IOP_BUFFERS_GROUP_NO, + Buffer, sizeof(struct BufferInfo))) + != (PI2O_DPT_EXEC_IOP_BUFFERS_SCALAR)NULL) { + sc->ha_blinkLED = sc->ha_Fvirt + + I2O_DPT_EXEC_IOP_BUFFERS_SCALAR_getSerialOutputOffset(Info) + + FW_DEBUG_BLED_OFFSET; + } + if (ASR_acquireLct(sc) == 0) { + (void)ASR_acquireHrt(sc); + } + } else { + printf ("asr%d: failed to initialize\n", unit); + ATTACH_RETURN(ENXIO); + } + /* + * Add in additional probe responses for more channels. We + * are reusing the variable `target' for a channel loop counter. + * Done here because of we need both the acquireLct and + * acquireHrt data. + */ + { PI2O_LCT_ENTRY Device; + + for (Device = sc->ha_LCT->LCTEntry; Device < (PI2O_LCT_ENTRY) + (((U32 *)sc->ha_LCT)+I2O_LCT_getTableSize(sc->ha_LCT)); + ++Device) { + if (Device->le_type == I2O_UNKNOWN) { + continue; + } + if (I2O_LCT_ENTRY_getUserTID(Device) == 0xFFF) { + if (Device->le_target > sc->ha_MaxId) { + sc->ha_MaxId = Device->le_target; + } + if (Device->le_lun > sc->ha_MaxLun) { + sc->ha_MaxLun = Device->le_lun; + } + } + if (((Device->le_type & I2O_PORT) != 0) + && (Device->le_bus <= MAX_CHANNEL)) { + /* Do not increase MaxId for efficiency */ + sc->ha_adapter_target[Device->le_bus] + = Device->le_target; + } + } + } + + + /* + * Print the HBA model number as inquired from the card. + */ + + printf ("asr%d:", unit); + + if ((iq = (struct scsi_inquiry_data *)malloc ( + sizeof(struct scsi_inquiry_data), M_TEMP, M_WAITOK | M_ZERO)) + != (struct scsi_inquiry_data *)NULL) { + defAlignLong(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE,Message); + PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE Message_Ptr; + int posted = 0; + + bzero (Message_Ptr + = getAlignLong(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE, Message), + sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) + - sizeof(I2O_SG_ELEMENT) + sizeof(I2O_SGE_SIMPLE_ELEMENT)); + + I2O_MESSAGE_FRAME_setVersionOffset( + (PI2O_MESSAGE_FRAME)Message_Ptr, + I2O_VERSION_11 + | (((sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) + - sizeof(I2O_SG_ELEMENT)) + / sizeof(U32)) << 4)); + I2O_MESSAGE_FRAME_setMessageSize( + (PI2O_MESSAGE_FRAME)Message_Ptr, + (sizeof(PRIVATE_SCSI_SCB_EXECUTE_MESSAGE) + - sizeof(I2O_SG_ELEMENT) + sizeof(I2O_SGE_SIMPLE_ELEMENT)) + / sizeof(U32)); + I2O_MESSAGE_FRAME_setInitiatorAddress ( + (PI2O_MESSAGE_FRAME)Message_Ptr, 1); + I2O_MESSAGE_FRAME_setFunction( + (PI2O_MESSAGE_FRAME)Message_Ptr, I2O_PRIVATE_MESSAGE); + I2O_PRIVATE_MESSAGE_FRAME_setXFunctionCode ( + (PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr, + I2O_SCSI_SCB_EXEC); + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags (Message_Ptr, + I2O_SCB_FLAG_ENABLE_DISCONNECT + | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG + | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER); + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setInterpret(Message_Ptr, 1); + I2O_PRIVATE_MESSAGE_FRAME_setOrganizationID( + (PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr, + DPT_ORGANIZATION_ID); + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setCDBLength(Message_Ptr, 6); + Message_Ptr->CDB[0] = INQUIRY; + Message_Ptr->CDB[4] = (unsigned char)sizeof(struct scsi_inquiry_data); + if (Message_Ptr->CDB[4] == 0) { + Message_Ptr->CDB[4] = 255; + } + + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setSCBFlags (Message_Ptr, + (I2O_SCB_FLAG_XFER_FROM_DEVICE + | I2O_SCB_FLAG_ENABLE_DISCONNECT + | I2O_SCB_FLAG_SIMPLE_QUEUE_TAG + | I2O_SCB_FLAG_SENSE_DATA_IN_BUFFER)); + + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_setByteCount( + (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr, + sizeof(struct scsi_inquiry_data)); + SG(&(Message_Ptr->SGL), 0, + I2O_SGL_FLAGS_LAST_ELEMENT | I2O_SGL_FLAGS_END_OF_BUFFER, + iq, sizeof(struct scsi_inquiry_data)); + (void)ASR_queue_c(sc, (PI2O_MESSAGE_FRAME)Message_Ptr); + + if (iq->vendor[0] && (iq->vendor[0] != ' ')) { + printf (" "); + ASR_prstring (iq->vendor, 8); + ++posted; + } + if (iq->product[0] && (iq->product[0] != ' ')) { + printf (" "); + ASR_prstring (iq->product, 16); + ++posted; + } + if (iq->revision[0] && (iq->revision[0] != ' ')) { + printf (" FW Rev. "); + ASR_prstring (iq->revision, 4); + ++posted; + } + free ((caddr_t)iq, M_TEMP); + if (posted) { + printf (","); + } + } + printf (" %d channel, %d CCBs, Protocol I2O\n", sc->ha_MaxBus + 1, + (sc->ha_QueueSize > MAX_INBOUND) ? MAX_INBOUND : sc->ha_QueueSize); + + /* + * fill in the prototype cam_path. + */ + { + int bus; + union asr_ccb * ccb; + + if ((ccb = asr_alloc_ccb (sc)) == (union asr_ccb *)NULL) { + printf ("asr%d: CAM could not be notified of asynchronous callback parameters\n", unit); + ATTACH_RETURN(ENOMEM); + } + for (bus = 0; bus <= sc->ha_MaxBus; ++bus) { + struct cam_devq * devq; + int QueueSize = sc->ha_QueueSize; + + if (QueueSize > MAX_INBOUND) { + QueueSize = MAX_INBOUND; + } + + /* + * Create the device queue for our SIM(s). + */ + if ((devq = cam_simq_alloc(QueueSize)) == NULL) { + continue; + } + + /* + * Construct our first channel SIM entry + */ + sc->ha_sim[bus] = cam_sim_alloc( + asr_action, asr_poll, "asr", sc, + unit, 1, QueueSize, devq); + if (sc->ha_sim[bus] == NULL) { + continue; + } + + if (xpt_bus_register(sc->ha_sim[bus], bus) + != CAM_SUCCESS) { + cam_sim_free(sc->ha_sim[bus], + /*free_devq*/TRUE); + sc->ha_sim[bus] = NULL; + continue; + } + + if (xpt_create_path(&(sc->ha_path[bus]), /*periph*/NULL, + cam_sim_path(sc->ha_sim[bus]), CAM_TARGET_WILDCARD, + CAM_LUN_WILDCARD) != CAM_REQ_CMP) { + xpt_bus_deregister( + cam_sim_path(sc->ha_sim[bus])); + cam_sim_free(sc->ha_sim[bus], + /*free_devq*/TRUE); + sc->ha_sim[bus] = NULL; + continue; + } + } + asr_free_ccb (ccb); + } + /* + * Generate the device node information + */ + (void)make_dev(&asr_cdevsw, unit, 0, 0, S_IRWXU, "rasr%d", unit); + ATTACH_RETURN(0); } /* asr_attach */ STATIC void asr_poll( - IN struct cam_sim *sim) + IN struct cam_sim *sim) { - asr_intr(cam_sim_softc(sim)); + asr_intr(cam_sim_softc(sim)); } /* asr_poll */ STATIC void asr_action( - IN struct cam_sim * sim, - IN union ccb * ccb) + IN struct cam_sim * sim, + IN union ccb * ccb) { - struct Asr_softc * sc; - - debug_asr_printf ("asr_action(%lx,%lx{%x})\n", - (u_long)sim, (u_long)ccb, ccb->ccb_h.func_code); - - CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, ("asr_action\n")); - - ccb->ccb_h.spriv_ptr0 = sc = (struct Asr_softc *)cam_sim_softc(sim); - - switch (ccb->ccb_h.func_code) { - - /* Common cases first */ - case XPT_SCSI_IO: /* Execute the requested I/O operation */ - { - struct Message { - char M[MAX_INBOUND_SIZE]; - }; - defAlignLong(struct Message,Message); - PI2O_MESSAGE_FRAME Message_Ptr; - - /* Reject incoming commands while we are resetting the card */ - if (sc->ha_in_reset != HA_OPERATIONAL) { - ccb->ccb_h.status &= ~CAM_STATUS_MASK; - if (sc->ha_in_reset >= HA_OFF_LINE) { - /* HBA is now off-line */ - ccb->ccb_h.status |= CAM_UNREC_HBA_ERROR; - } else { - /* HBA currently resetting, try again later. */ - ccb->ccb_h.status |= CAM_REQUEUE_REQ; - } - debug_asr_cmd_printf (" e\n"); - xpt_done(ccb); - debug_asr_cmd_printf (" q\n"); - break; - } - if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_INPROG) { - printf( - "asr%d WARNING: scsi_cmd(%x) already done on b%dt%du%d\n", - cam_sim_unit(xpt_path_sim(ccb->ccb_h.path)), - ccb->csio.cdb_io.cdb_bytes[0], - cam_sim_bus(sim), - ccb->ccb_h.target_id, - ccb->ccb_h.target_lun); - } - debug_asr_cmd_printf ("(%d,%d,%d,%d)", - cam_sim_unit(sim), - cam_sim_bus(sim), - ccb->ccb_h.target_id, - ccb->ccb_h.target_lun); - debug_asr_cmd_dump_ccb(ccb); - - if ((Message_Ptr = ASR_init_message ((union asr_ccb *)ccb, - (PI2O_MESSAGE_FRAME)Message)) != (PI2O_MESSAGE_FRAME)NULL) { - debug_asr_cmd2_printf ("TID=%x:\n", - PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_getTID( - (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr)); - debug_asr_cmd2_dump_message(Message_Ptr); - debug_asr_cmd1_printf (" q"); - - if (ASR_queue (sc, Message_Ptr) == EMPTY_QUEUE) { + struct Asr_softc * sc; + + debug_asr_printf ("asr_action(%lx,%lx{%x})\n", + (u_long)sim, (u_long)ccb, ccb->ccb_h.func_code); + + CAM_DEBUG(ccb->ccb_h.path, CAM_DEBUG_TRACE, ("asr_action\n")); + + ccb->ccb_h.spriv_ptr0 = sc = (struct Asr_softc *)cam_sim_softc(sim); + + switch (ccb->ccb_h.func_code) { + + /* Common cases first */ + case XPT_SCSI_IO: /* Execute the requested I/O operation */ + { + struct Message { + char M[MAX_INBOUND_SIZE]; + }; + defAlignLong(struct Message,Message); + PI2O_MESSAGE_FRAME Message_Ptr; + + /* Reject incoming commands while we are resetting the card */ + if (sc->ha_in_reset != HA_OPERATIONAL) { + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + if (sc->ha_in_reset >= HA_OFF_LINE) { + /* HBA is now off-line */ + ccb->ccb_h.status |= CAM_UNREC_HBA_ERROR; + } else { + /* HBA currently resetting, try again later. */ + ccb->ccb_h.status |= CAM_REQUEUE_REQ; + } + debug_asr_cmd_printf (" e\n"); + xpt_done(ccb); + debug_asr_cmd_printf (" q\n"); + break; + } + if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_INPROG) { + printf( + "asr%d WARNING: scsi_cmd(%x) already done on b%dt%du%d\n", + cam_sim_unit(xpt_path_sim(ccb->ccb_h.path)), + ccb->csio.cdb_io.cdb_bytes[0], + cam_sim_bus(sim), + ccb->ccb_h.target_id, + ccb->ccb_h.target_lun); + } + debug_asr_cmd_printf ("(%d,%d,%d,%d)", + cam_sim_unit(sim), + cam_sim_bus(sim), + ccb->ccb_h.target_id, + ccb->ccb_h.target_lun); + debug_asr_cmd_dump_ccb(ccb); + + if ((Message_Ptr = ASR_init_message ((union asr_ccb *)ccb, + (PI2O_MESSAGE_FRAME)Message)) != (PI2O_MESSAGE_FRAME)NULL) { + debug_asr_cmd2_printf ("TID=%x:\n", + PRIVATE_SCSI_SCB_EXECUTE_MESSAGE_getTID( + (PPRIVATE_SCSI_SCB_EXECUTE_MESSAGE)Message_Ptr)); + debug_asr_cmd2_dump_message(Message_Ptr); + debug_asr_cmd1_printf (" q"); + + if (ASR_queue (sc, Message_Ptr) == EMPTY_QUEUE) { #ifdef ASR_MEASURE_PERFORMANCE - ++sc->ha_performance.command_too_busy; + ++sc->ha_performance.command_too_busy; #endif - ccb->ccb_h.status &= ~CAM_STATUS_MASK; - ccb->ccb_h.status |= CAM_REQUEUE_REQ; - debug_asr_cmd_printf (" E\n"); - xpt_done(ccb); - } - debug_asr_cmd_printf (" Q\n"); - break; - } - /* - * We will get here if there is no valid TID for the device - * referenced in the scsi command packet. - */ - ccb->ccb_h.status &= ~CAM_STATUS_MASK; - ccb->ccb_h.status |= CAM_SEL_TIMEOUT; - debug_asr_cmd_printf (" B\n"); - xpt_done(ccb); - break; - } - - case XPT_RESET_DEV: /* Bus Device Reset the specified SCSI device */ - /* Rese HBA device ... */ - asr_hbareset (sc); - ccb->ccb_h.status = CAM_REQ_CMP; - xpt_done(ccb); - break; - -# if (defined(REPORT_LUNS)) - case REPORT_LUNS: -# endif - case XPT_ABORT: /* Abort the specified CCB */ - /* XXX Implement */ - ccb->ccb_h.status = CAM_REQ_INVALID; - xpt_done(ccb); - break; - - case XPT_SET_TRAN_SETTINGS: - /* XXX Implement */ - ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; - xpt_done(ccb); - break; - - case XPT_GET_TRAN_SETTINGS: - /* Get default/user set transfer settings for the target */ - { - struct ccb_trans_settings *cts; - u_int target_mask; - - cts = &(ccb->cts); - target_mask = 0x01 << ccb->ccb_h.target_id; - if ((cts->flags & CCB_TRANS_USER_SETTINGS) != 0) { - cts->flags = CCB_TRANS_DISC_ENB|CCB_TRANS_TAG_ENB; - cts->bus_width = MSG_EXT_WDTR_BUS_16_BIT; - cts->sync_period = 6; /* 40MHz */ - cts->sync_offset = 15; - - cts->valid = CCB_TRANS_SYNC_RATE_VALID - | CCB_TRANS_SYNC_OFFSET_VALID - | CCB_TRANS_BUS_WIDTH_VALID - | CCB_TRANS_DISC_VALID - | CCB_TRANS_TQ_VALID; - ccb->ccb_h.status = CAM_REQ_CMP; - } else { - ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; - } - xpt_done(ccb); - break; - } - - case XPT_CALC_GEOMETRY: - { - struct ccb_calc_geometry *ccg; - u_int32_t size_mb; - u_int32_t secs_per_cylinder; - - ccg = &(ccb->ccg); - size_mb = ccg->volume_size - / ((1024L * 1024L) / ccg->block_size); - - if (size_mb > 4096) { - ccg->heads = 255; - ccg->secs_per_track = 63; - } else if (size_mb > 2048) { - ccg->heads = 128; - ccg->secs_per_track = 63; - } else if (size_mb > 1024) { - ccg->heads = 65; - ccg->secs_per_track = 63; - } else { - ccg->heads = 64; - ccg->secs_per_track = 32; - } - secs_per_cylinder = ccg->heads * ccg->secs_per_track; - ccg->cylinders = ccg->volume_size / secs_per_cylinder; - ccb->ccb_h.status = CAM_REQ_CMP; - xpt_done(ccb); - break; - } - - case XPT_RESET_BUS: /* Reset the specified SCSI bus */ - ASR_resetBus (sc, cam_sim_bus(sim)); - ccb->ccb_h.status = CAM_REQ_CMP; - xpt_done(ccb); - break; - - case XPT_TERM_IO: /* Terminate the I/O process */ - /* XXX Implement */ - ccb->ccb_h.status = CAM_REQ_INVALID; - xpt_done(ccb); - break; - - case XPT_PATH_INQ: /* Path routing inquiry */ - { - struct ccb_pathinq *cpi = &(ccb->cpi); - - cpi->version_num = 1; /* XXX??? */ - cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE|PI_WIDE_16; - cpi->target_sprt = 0; - /* Not necessary to reset bus, done by HDM initialization */ - cpi->hba_misc = PIM_NOBUSRESET; - cpi->hba_eng_cnt = 0; - cpi->max_target = sc->ha_MaxId; - cpi->max_lun = sc->ha_MaxLun; - cpi->initiator_id = sc->ha_adapter_target[cam_sim_bus(sim)]; - cpi->bus_id = cam_sim_bus(sim); - cpi->base_transfer_speed = 3300; - strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); - strncpy(cpi->hba_vid, "Adaptec", HBA_IDLEN); - strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN); - cpi->unit_number = cam_sim_unit(sim); - cpi->ccb_h.status = CAM_REQ_CMP; - xpt_done(ccb); - break; - } - default: - ccb->ccb_h.status = CAM_REQ_INVALID; - xpt_done(ccb); - break; - } + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + ccb->ccb_h.status |= CAM_REQUEUE_REQ; + debug_asr_cmd_printf (" E\n"); + xpt_done(ccb); + } + debug_asr_cmd_printf (" Q\n"); + break; + } + /* + * We will get here if there is no valid TID for the device + * referenced in the scsi command packet. + */ + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + ccb->ccb_h.status |= CAM_SEL_TIMEOUT; + debug_asr_cmd_printf (" B\n"); + xpt_done(ccb); + break; + } + + case XPT_RESET_DEV: /* Bus Device Reset the specified SCSI device */ + /* Rese HBA device ... */ + asr_hbareset (sc); + ccb->ccb_h.status = CAM_REQ_CMP; + xpt_done(ccb); + break; + +# if (defined(REPORT_LUNS)) + case REPORT_LUNS: +# endif + case XPT_ABORT: /* Abort the specified CCB */ + /* XXX Implement */ + ccb->ccb_h.status = CAM_REQ_INVALID; + xpt_done(ccb); + break; + + case XPT_SET_TRAN_SETTINGS: + /* XXX Implement */ + ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; + xpt_done(ccb); + break; + + case XPT_GET_TRAN_SETTINGS: + /* Get default/user set transfer settings for the target */ + { + struct ccb_trans_settings *cts; + u_int target_mask; + + cts = &(ccb->cts); + target_mask = 0x01 << ccb->ccb_h.target_id; + if ((cts->flags & CCB_TRANS_USER_SETTINGS) != 0) { + cts->flags = CCB_TRANS_DISC_ENB|CCB_TRANS_TAG_ENB; + cts->bus_width = MSG_EXT_WDTR_BUS_16_BIT; + cts->sync_period = 6; /* 40MHz */ + cts->sync_offset = 15; + + cts->valid = CCB_TRANS_SYNC_RATE_VALID + | CCB_TRANS_SYNC_OFFSET_VALID + | CCB_TRANS_BUS_WIDTH_VALID + | CCB_TRANS_DISC_VALID + | CCB_TRANS_TQ_VALID; + ccb->ccb_h.status = CAM_REQ_CMP; + } else { + ccb->ccb_h.status = CAM_FUNC_NOTAVAIL; + } + xpt_done(ccb); + break; + } + + case XPT_CALC_GEOMETRY: + { + struct ccb_calc_geometry *ccg; + u_int32_t size_mb; + u_int32_t secs_per_cylinder; + + ccg = &(ccb->ccg); + size_mb = ccg->volume_size + / ((1024L * 1024L) / ccg->block_size); + + if (size_mb > 4096) { + ccg->heads = 255; + ccg->secs_per_track = 63; + } else if (size_mb > 2048) { + ccg->heads = 128; + ccg->secs_per_track = 63; + } else if (size_mb > 1024) { + ccg->heads = 65; + ccg->secs_per_track = 63; + } else { + ccg->heads = 64; + ccg->secs_per_track = 32; + } + secs_per_cylinder = ccg->heads * ccg->secs_per_track; + ccg->cylinders = ccg->volume_size / secs_per_cylinder; + ccb->ccb_h.status = CAM_REQ_CMP; + xpt_done(ccb); + break; + } + + case XPT_RESET_BUS: /* Reset the specified SCSI bus */ + ASR_resetBus (sc, cam_sim_bus(sim)); + ccb->ccb_h.status = CAM_REQ_CMP; + xpt_done(ccb); + break; + + case XPT_TERM_IO: /* Terminate the I/O process */ + /* XXX Implement */ + ccb->ccb_h.status = CAM_REQ_INVALID; + xpt_done(ccb); + break; + + case XPT_PATH_INQ: /* Path routing inquiry */ + { + struct ccb_pathinq *cpi = &(ccb->cpi); + + cpi->version_num = 1; /* XXX??? */ + cpi->hba_inquiry = PI_SDTR_ABLE|PI_TAG_ABLE|PI_WIDE_16; + cpi->target_sprt = 0; + /* Not necessary to reset bus, done by HDM initialization */ + cpi->hba_misc = PIM_NOBUSRESET; + cpi->hba_eng_cnt = 0; + cpi->max_target = sc->ha_MaxId; + cpi->max_lun = sc->ha_MaxLun; + cpi->initiator_id = sc->ha_adapter_target[cam_sim_bus(sim)]; + cpi->bus_id = cam_sim_bus(sim); + cpi->base_transfer_speed = 3300; + strncpy(cpi->sim_vid, "FreeBSD", SIM_IDLEN); + strncpy(cpi->hba_vid, "Adaptec", HBA_IDLEN); + strncpy(cpi->dev_name, cam_sim_name(sim), DEV_IDLEN); + cpi->unit_number = cam_sim_unit(sim); + cpi->ccb_h.status = CAM_REQ_CMP; + xpt_done(ccb); + break; + } + default: + ccb->ccb_h.status = CAM_REQ_INVALID; + xpt_done(ccb); + break; + } } /* asr_action */ #ifdef ASR_MEASURE_PERFORMANCE -#define WRITE_OP 1 -#define READ_OP 2 -#define min_submitR sc->ha_performance.read_by_size_min_time[index] -#define max_submitR sc->ha_performance.read_by_size_max_time[index] -#define min_submitW sc->ha_performance.write_by_size_min_time[index] -#define max_submitW sc->ha_performance.write_by_size_max_time[index] +#define WRITE_OP 1 +#define READ_OP 2 +#define min_submitR sc->ha_performance.read_by_size_min_time[index] +#define max_submitR sc->ha_performance.read_by_size_max_time[index] +#define min_submitW sc->ha_performance.write_by_size_min_time[index] +#define max_submitW sc->ha_performance.write_by_size_max_time[index] STATIC INLINE void asr_IObySize( - IN Asr_softc_t * sc, - IN u_int32_t submitted_time, - IN int op, - IN int index) + IN Asr_softc_t * sc, + IN u_int32_t submitted_time, + IN int op, + IN int index) { - struct timeval submitted_timeval; - - submitted_timeval.tv_sec = 0; - submitted_timeval.tv_usec = submitted_time; - - if ( op == READ_OP ) { - ++sc->ha_performance.read_by_size_count[index]; - - if ( submitted_time != 0xffffffff ) { - timevaladd( - &(sc->ha_performance.read_by_size_total_time[index]), - &submitted_timeval); - if ( (min_submitR == 0) - || (submitted_time < min_submitR) ) { - min_submitR = submitted_time; - } - - if ( submitted_time > max_submitR ) { - max_submitR = submitted_time; - } - } - } else { - ++sc->ha_performance.write_by_size_count[index]; - if ( submitted_time != 0xffffffff ) { - timevaladd( - &(sc->ha_performance.write_by_size_total_time[index]), - &submitted_timeval); - if ( (submitted_time < min_submitW) - || (min_submitW == 0) ) { - min_submitW = submitted_time; - } - - if ( submitted_time > max_submitW ) { - max_submitW = submitted_time; - } - } - } + struct timeval submitted_timeval; + + submitted_timeval.tv_sec = 0; + submitted_timeval.tv_usec = submitted_time; + + if ( op == READ_OP ) { + ++sc->ha_performance.read_by_size_count[index]; + + if ( submitted_time != 0xffffffff ) { + timevaladd( + &(sc->ha_performance.read_by_size_total_time[index]), + &submitted_timeval); + if ( (min_submitR == 0) + || (submitted_time < min_submitR) ) { + min_submitR = submitted_time; + } + + if ( submitted_time > max_submitR ) { + max_submitR = submitted_time; + } + } + } else { + ++sc->ha_performance.write_by_size_count[index]; + if ( submitted_time != 0xffffffff ) { + timevaladd( + &(sc->ha_performance.write_by_size_total_time[index]), + &submitted_timeval); + if ( (submitted_time < min_submitW) + || (min_submitW == 0) ) { + min_submitW = submitted_time; + } + + if ( submitted_time > max_submitW ) { + max_submitW = submitted_time; + } + } + } } /* asr_IObySize */ #endif @@ -3457,403 +3457,403 @@ asr_IObySize( */ STATIC int asr_intr ( - IN Asr_softc_t * sc) + IN Asr_softc_t * sc) { - OUT int processed; + OUT int processed; #ifdef ASR_MEASURE_PERFORMANCE - struct timeval junk; + struct timeval junk; - microtime(&junk); - sc->ha_performance.intr_started = junk; + microtime(&junk); + sc->ha_performance.intr_started = junk; #endif - for (processed = 0; - sc->ha_Virt->Status & Mask_InterruptsDisabled; - processed = 1) { - union asr_ccb * ccb; - U32 ReplyOffset; - PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME Reply; - - if (((ReplyOffset = sc->ha_Virt->FromFIFO) == EMPTY_QUEUE) - && ((ReplyOffset = sc->ha_Virt->FromFIFO) == EMPTY_QUEUE)) { - break; - } - Reply = (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)(ReplyOffset - - sc->ha_Msgs_Phys + (char *)(sc->ha_Msgs)); - /* - * We do not need any (optional byteswapping) method access to - * the Initiator context field. - */ - ccb = (union asr_ccb *)(long) - I2O_MESSAGE_FRAME_getInitiatorContext64( - &(Reply->StdReplyFrame.StdMessageFrame)); - if (I2O_MESSAGE_FRAME_getMsgFlags( - &(Reply->StdReplyFrame.StdMessageFrame)) - & I2O_MESSAGE_FLAGS_FAIL) { - defAlignLong(I2O_UTIL_NOP_MESSAGE,Message); - PI2O_UTIL_NOP_MESSAGE Message_Ptr; - U32 MessageOffset; - - MessageOffset = (u_long) - I2O_FAILURE_REPLY_MESSAGE_FRAME_getPreservedMFA( - (PI2O_FAILURE_REPLY_MESSAGE_FRAME)Reply); - /* - * Get the Original Message Frame's address, and get - * it's Transaction Context into our space. (Currently - * unused at original authorship, but better to be - * safe than sorry). Straight copy means that we - * need not concern ourselves with the (optional - * byteswapping) method access. - */ - Reply->StdReplyFrame.TransactionContext - = ((PI2O_SINGLE_REPLY_MESSAGE_FRAME) - (sc->ha_Fvirt + MessageOffset))->TransactionContext; - /* - * For 64 bit machines, we need to reconstruct the - * 64 bit context. - */ - ccb = (union asr_ccb *)(long) - I2O_MESSAGE_FRAME_getInitiatorContext64( - &(Reply->StdReplyFrame.StdMessageFrame)); - /* - * Unique error code for command failure. - */ - I2O_SINGLE_REPLY_MESSAGE_FRAME_setDetailedStatusCode( - &(Reply->StdReplyFrame), (u_int16_t)-2); - /* - * Modify the message frame to contain a NOP and - * re-issue it to the controller. - */ - Message_Ptr = (PI2O_UTIL_NOP_MESSAGE)ASR_fillMessage( - Message, sizeof(I2O_UTIL_NOP_MESSAGE)); -# if (I2O_UTIL_NOP != 0) - I2O_MESSAGE_FRAME_setFunction ( - &(Message_Ptr->StdMessageFrame), - I2O_UTIL_NOP); -# endif - /* - * Copy the packet out to the Original Message - */ - bcopy ((caddr_t)Message_Ptr, - sc->ha_Fvirt + MessageOffset, - sizeof(I2O_UTIL_NOP_MESSAGE)); - /* - * Issue the NOP - */ - sc->ha_Virt->ToFIFO = MessageOffset; - } - - /* - * Asynchronous command with no return requirements, - * and a generic handler for immunity against odd error - * returns from the adapter. - */ - if (ccb == (union asr_ccb *)NULL) { - /* - * Return Reply so that it can be used for the - * next command - */ - sc->ha_Virt->FromFIFO = ReplyOffset; - continue; - } - - /* Welease Wadjah! (and stop timeouts) */ - ASR_ccbRemove (sc, ccb); - - switch ( - I2O_SINGLE_REPLY_MESSAGE_FRAME_getDetailedStatusCode( - &(Reply->StdReplyFrame))) { - - case I2O_SCSI_DSC_SUCCESS: - ccb->ccb_h.status &= ~CAM_STATUS_MASK; - ccb->ccb_h.status |= CAM_REQ_CMP; - break; - - case I2O_SCSI_DSC_CHECK_CONDITION: - ccb->ccb_h.status &= ~CAM_STATUS_MASK; - ccb->ccb_h.status |= CAM_REQ_CMP|CAM_AUTOSNS_VALID; - break; - - case I2O_SCSI_DSC_BUSY: - /* FALLTHRU */ - case I2O_SCSI_HBA_DSC_ADAPTER_BUSY: - /* FALLTHRU */ - case I2O_SCSI_HBA_DSC_SCSI_BUS_RESET: - /* FALLTHRU */ - case I2O_SCSI_HBA_DSC_BUS_BUSY: - ccb->ccb_h.status &= ~CAM_STATUS_MASK; - ccb->ccb_h.status |= CAM_SCSI_BUSY; - break; - - case I2O_SCSI_HBA_DSC_SELECTION_TIMEOUT: - ccb->ccb_h.status &= ~CAM_STATUS_MASK; - ccb->ccb_h.status |= CAM_SEL_TIMEOUT; - break; - - case I2O_SCSI_HBA_DSC_COMMAND_TIMEOUT: - /* FALLTHRU */ - case I2O_SCSI_HBA_DSC_DEVICE_NOT_PRESENT: - /* FALLTHRU */ - case I2O_SCSI_HBA_DSC_LUN_INVALID: - /* FALLTHRU */ - case I2O_SCSI_HBA_DSC_SCSI_TID_INVALID: - ccb->ccb_h.status &= ~CAM_STATUS_MASK; - ccb->ccb_h.status |= CAM_CMD_TIMEOUT; - break; - - case I2O_SCSI_HBA_DSC_DATA_OVERRUN: - /* FALLTHRU */ - case I2O_SCSI_HBA_DSC_REQUEST_LENGTH_ERROR: - ccb->ccb_h.status &= ~CAM_STATUS_MASK; - ccb->ccb_h.status |= CAM_DATA_RUN_ERR; - break; - - default: - ccb->ccb_h.status &= ~CAM_STATUS_MASK; - ccb->ccb_h.status |= CAM_REQUEUE_REQ; - break; - } - if ((ccb->csio.resid = ccb->csio.dxfer_len) != 0) { - ccb->csio.resid -= - I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_getTransferCount( - Reply); - } + for (processed = 0; + sc->ha_Virt->Status & Mask_InterruptsDisabled; + processed = 1) { + union asr_ccb * ccb; + U32 ReplyOffset; + PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME Reply; + + if (((ReplyOffset = sc->ha_Virt->FromFIFO) == EMPTY_QUEUE) + && ((ReplyOffset = sc->ha_Virt->FromFIFO) == EMPTY_QUEUE)) { + break; + } + Reply = (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)(ReplyOffset + - sc->ha_Msgs_Phys + (char *)(sc->ha_Msgs)); + /* + * We do not need any (optional byteswapping) method access to + * the Initiator context field. + */ + ccb = (union asr_ccb *)(long) + I2O_MESSAGE_FRAME_getInitiatorContext64( + &(Reply->StdReplyFrame.StdMessageFrame)); + if (I2O_MESSAGE_FRAME_getMsgFlags( + &(Reply->StdReplyFrame.StdMessageFrame)) + & I2O_MESSAGE_FLAGS_FAIL) { + defAlignLong(I2O_UTIL_NOP_MESSAGE,Message); + PI2O_UTIL_NOP_MESSAGE Message_Ptr; + U32 MessageOffset; + + MessageOffset = (u_long) + I2O_FAILURE_REPLY_MESSAGE_FRAME_getPreservedMFA( + (PI2O_FAILURE_REPLY_MESSAGE_FRAME)Reply); + /* + * Get the Original Message Frame's address, and get + * it's Transaction Context into our space. (Currently + * unused at original authorship, but better to be + * safe than sorry). Straight copy means that we + * need not concern ourselves with the (optional + * byteswapping) method access. + */ + Reply->StdReplyFrame.TransactionContext + = ((PI2O_SINGLE_REPLY_MESSAGE_FRAME) + (sc->ha_Fvirt + MessageOffset))->TransactionContext; + /* + * For 64 bit machines, we need to reconstruct the + * 64 bit context. + */ + ccb = (union asr_ccb *)(long) + I2O_MESSAGE_FRAME_getInitiatorContext64( + &(Reply->StdReplyFrame.StdMessageFrame)); + /* + * Unique error code for command failure. + */ + I2O_SINGLE_REPLY_MESSAGE_FRAME_setDetailedStatusCode( + &(Reply->StdReplyFrame), (u_int16_t)-2); + /* + * Modify the message frame to contain a NOP and + * re-issue it to the controller. + */ + Message_Ptr = (PI2O_UTIL_NOP_MESSAGE)ASR_fillMessage( + Message, sizeof(I2O_UTIL_NOP_MESSAGE)); +# if (I2O_UTIL_NOP != 0) + I2O_MESSAGE_FRAME_setFunction ( + &(Message_Ptr->StdMessageFrame), + I2O_UTIL_NOP); +# endif + /* + * Copy the packet out to the Original Message + */ + bcopy ((caddr_t)Message_Ptr, + sc->ha_Fvirt + MessageOffset, + sizeof(I2O_UTIL_NOP_MESSAGE)); + /* + * Issue the NOP + */ + sc->ha_Virt->ToFIFO = MessageOffset; + } + + /* + * Asynchronous command with no return requirements, + * and a generic handler for immunity against odd error + * returns from the adapter. + */ + if (ccb == (union asr_ccb *)NULL) { + /* + * Return Reply so that it can be used for the + * next command + */ + sc->ha_Virt->FromFIFO = ReplyOffset; + continue; + } + + /* Welease Wadjah! (and stop timeouts) */ + ASR_ccbRemove (sc, ccb); + + switch ( + I2O_SINGLE_REPLY_MESSAGE_FRAME_getDetailedStatusCode( + &(Reply->StdReplyFrame))) { + + case I2O_SCSI_DSC_SUCCESS: + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + ccb->ccb_h.status |= CAM_REQ_CMP; + break; + + case I2O_SCSI_DSC_CHECK_CONDITION: + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + ccb->ccb_h.status |= CAM_REQ_CMP|CAM_AUTOSNS_VALID; + break; + + case I2O_SCSI_DSC_BUSY: + /* FALLTHRU */ + case I2O_SCSI_HBA_DSC_ADAPTER_BUSY: + /* FALLTHRU */ + case I2O_SCSI_HBA_DSC_SCSI_BUS_RESET: + /* FALLTHRU */ + case I2O_SCSI_HBA_DSC_BUS_BUSY: + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + ccb->ccb_h.status |= CAM_SCSI_BUSY; + break; + + case I2O_SCSI_HBA_DSC_SELECTION_TIMEOUT: + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + ccb->ccb_h.status |= CAM_SEL_TIMEOUT; + break; + + case I2O_SCSI_HBA_DSC_COMMAND_TIMEOUT: + /* FALLTHRU */ + case I2O_SCSI_HBA_DSC_DEVICE_NOT_PRESENT: + /* FALLTHRU */ + case I2O_SCSI_HBA_DSC_LUN_INVALID: + /* FALLTHRU */ + case I2O_SCSI_HBA_DSC_SCSI_TID_INVALID: + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + ccb->ccb_h.status |= CAM_CMD_TIMEOUT; + break; + + case I2O_SCSI_HBA_DSC_DATA_OVERRUN: + /* FALLTHRU */ + case I2O_SCSI_HBA_DSC_REQUEST_LENGTH_ERROR: + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + ccb->ccb_h.status |= CAM_DATA_RUN_ERR; + break; + + default: + ccb->ccb_h.status &= ~CAM_STATUS_MASK; + ccb->ccb_h.status |= CAM_REQUEUE_REQ; + break; + } + if ((ccb->csio.resid = ccb->csio.dxfer_len) != 0) { + ccb->csio.resid -= + I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_getTransferCount( + Reply); + } #ifdef ASR_MEASURE_PERFORMANCE - { - struct timeval endTime; - u_int32_t submitted_time; - u_int32_t size; - int op_type; - int startTimeIndex; - - --sc->ha_submitted_ccbs_count; - startTimeIndex - = (int)Reply->StdReplyFrame.TransactionContext; - if (-1 != startTimeIndex) { - /* Compute the time spent in device/adapter */ - microtime(&endTime); - submitted_time = asr_time_delta(sc->ha_timeQ[ - startTimeIndex], endTime); - /* put the startTimeIndex back on free list */ - ENQ_TIMEQ_FREE_LIST(startTimeIndex, - sc->ha_timeQFreeList, - sc->ha_timeQFreeHead, - sc->ha_timeQFreeTail); - } else { - submitted_time = 0xffffffff; - } - -#define maxctime sc->ha_performance.max_command_time[ccb->csio.cdb_io.cdb_bytes[0]] -#define minctime sc->ha_performance.min_command_time[ccb->csio.cdb_io.cdb_bytes[0]] - if (submitted_time != 0xffffffff) { - if ( maxctime < submitted_time ) { - maxctime = submitted_time; - } - if ( (minctime == 0) - || (minctime > submitted_time) ) { - minctime = submitted_time; - } - - if ( sc->ha_performance.max_submit_time - < submitted_time ) { - sc->ha_performance.max_submit_time - = submitted_time; - } - if ( sc->ha_performance.min_submit_time == 0 - || sc->ha_performance.min_submit_time - > submitted_time) { - sc->ha_performance.min_submit_time - = submitted_time; - } - - switch ( ccb->csio.cdb_io.cdb_bytes[0] ) { - - case 0xa8: /* 12-byte READ */ - /* FALLTHRU */ - case 0x08: /* 6-byte READ */ - /* FALLTHRU */ - case 0x28: /* 10-byte READ */ - op_type = READ_OP; - break; - - case 0x0a: /* 6-byte WRITE */ - /* FALLTHRU */ - case 0xaa: /* 12-byte WRITE */ - /* FALLTHRU */ - case 0x2a: /* 10-byte WRITE */ - op_type = WRITE_OP; - break; - - default: - op_type = 0; - break; - } - - if ( op_type != 0 ) { - struct scsi_rw_big * cmd; - - cmd = (struct scsi_rw_big *) - &(ccb->csio.cdb_io); - - size = (((u_int32_t) cmd->length2 << 8) - | ((u_int32_t) cmd->length1)) << 9; - - switch ( size ) { - - case 512: - asr_IObySize(sc, - submitted_time, op_type, - SIZE_512); - break; - - case 1024: - asr_IObySize(sc, - submitted_time, op_type, - SIZE_1K); - break; - - case 2048: - asr_IObySize(sc, - submitted_time, op_type, - SIZE_2K); - break; - - case 4096: - asr_IObySize(sc, - submitted_time, op_type, - SIZE_4K); - break; - - case 8192: - asr_IObySize(sc, - submitted_time, op_type, - SIZE_8K); - break; - - case 16384: - asr_IObySize(sc, - submitted_time, op_type, - SIZE_16K); - break; - - case 32768: - asr_IObySize(sc, - submitted_time, op_type, - SIZE_32K); - break; - - case 65536: - asr_IObySize(sc, - submitted_time, op_type, - SIZE_64K); - break; - - default: - if ( size > (1 << 16) ) { - asr_IObySize(sc, - submitted_time, - op_type, - SIZE_BIGGER); - } else { - asr_IObySize(sc, - submitted_time, - op_type, - SIZE_OTHER); - } - break; - } - } - } - } + { + struct timeval endTime; + u_int32_t submitted_time; + u_int32_t size; + int op_type; + int startTimeIndex; + + --sc->ha_submitted_ccbs_count; + startTimeIndex + = (int)Reply->StdReplyFrame.TransactionContext; + if (-1 != startTimeIndex) { + /* Compute the time spent in device/adapter */ + microtime(&endTime); + submitted_time = asr_time_delta(sc->ha_timeQ[ + startTimeIndex], endTime); + /* put the startTimeIndex back on free list */ + ENQ_TIMEQ_FREE_LIST(startTimeIndex, + sc->ha_timeQFreeList, + sc->ha_timeQFreeHead, + sc->ha_timeQFreeTail); + } else { + submitted_time = 0xffffffff; + } + +#define maxctime sc->ha_performance.max_command_time[ccb->csio.cdb_io.cdb_bytes[0]] +#define minctime sc->ha_performance.min_command_time[ccb->csio.cdb_io.cdb_bytes[0]] + if (submitted_time != 0xffffffff) { + if ( maxctime < submitted_time ) { + maxctime = submitted_time; + } + if ( (minctime == 0) + || (minctime > submitted_time) ) { + minctime = submitted_time; + } + + if ( sc->ha_performance.max_submit_time + < submitted_time ) { + sc->ha_performance.max_submit_time + = submitted_time; + } + if ( sc->ha_performance.min_submit_time == 0 + || sc->ha_performance.min_submit_time + > submitted_time) { + sc->ha_performance.min_submit_time + = submitted_time; + } + + switch ( ccb->csio.cdb_io.cdb_bytes[0] ) { + + case 0xa8: /* 12-byte READ */ + /* FALLTHRU */ + case 0x08: /* 6-byte READ */ + /* FALLTHRU */ + case 0x28: /* 10-byte READ */ + op_type = READ_OP; + break; + + case 0x0a: /* 6-byte WRITE */ + /* FALLTHRU */ + case 0xaa: /* 12-byte WRITE */ + /* FALLTHRU */ + case 0x2a: /* 10-byte WRITE */ + op_type = WRITE_OP; + break; + + default: + op_type = 0; + break; + } + + if ( op_type != 0 ) { + struct scsi_rw_big * cmd; + + cmd = (struct scsi_rw_big *) + &(ccb->csio.cdb_io); + + size = (((u_int32_t) cmd->length2 << 8) + | ((u_int32_t) cmd->length1)) << 9; + + switch ( size ) { + + case 512: + asr_IObySize(sc, + submitted_time, op_type, + SIZE_512); + break; + + case 1024: + asr_IObySize(sc, + submitted_time, op_type, + SIZE_1K); + break; + + case 2048: + asr_IObySize(sc, + submitted_time, op_type, + SIZE_2K); + break; + + case 4096: + asr_IObySize(sc, + submitted_time, op_type, + SIZE_4K); + break; + + case 8192: + asr_IObySize(sc, + submitted_time, op_type, + SIZE_8K); + break; + + case 16384: + asr_IObySize(sc, + submitted_time, op_type, + SIZE_16K); + break; + + case 32768: + asr_IObySize(sc, + submitted_time, op_type, + SIZE_32K); + break; + + case 65536: + asr_IObySize(sc, + submitted_time, op_type, + SIZE_64K); + break; + + default: + if ( size > (1 << 16) ) { + asr_IObySize(sc, + submitted_time, + op_type, + SIZE_BIGGER); + } else { + asr_IObySize(sc, + submitted_time, + op_type, + SIZE_OTHER); + } + break; + } + } + } + } #endif - /* Sense data in reply packet */ - if (ccb->ccb_h.status & CAM_AUTOSNS_VALID) { - u_int16_t size = I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_getAutoSenseTransferCount(Reply); - - if (size) { - if (size > sizeof(ccb->csio.sense_data)) { - size = sizeof(ccb->csio.sense_data); - } - if (size > I2O_SCSI_SENSE_DATA_SZ) { - size = I2O_SCSI_SENSE_DATA_SZ; - } - if ((ccb->csio.sense_len) - && (size > ccb->csio.sense_len)) { - size = ccb->csio.sense_len; - } - bcopy ((caddr_t)Reply->SenseData, - (caddr_t)&(ccb->csio.sense_data), size); - } - } - - /* - * Return Reply so that it can be used for the next command - * since we have no more need for it now - */ - sc->ha_Virt->FromFIFO = ReplyOffset; - - if (ccb->ccb_h.path) { - xpt_done ((union ccb *)ccb); - } else { - wakeup ((caddr_t)ccb); - } - } + /* Sense data in reply packet */ + if (ccb->ccb_h.status & CAM_AUTOSNS_VALID) { + u_int16_t size = I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_getAutoSenseTransferCount(Reply); + + if (size) { + if (size > sizeof(ccb->csio.sense_data)) { + size = sizeof(ccb->csio.sense_data); + } + if (size > I2O_SCSI_SENSE_DATA_SZ) { + size = I2O_SCSI_SENSE_DATA_SZ; + } + if ((ccb->csio.sense_len) + && (size > ccb->csio.sense_len)) { + size = ccb->csio.sense_len; + } + bcopy ((caddr_t)Reply->SenseData, + (caddr_t)&(ccb->csio.sense_data), size); + } + } + + /* + * Return Reply so that it can be used for the next command + * since we have no more need for it now + */ + sc->ha_Virt->FromFIFO = ReplyOffset; + + if (ccb->ccb_h.path) { + xpt_done ((union ccb *)ccb); + } else { + wakeup ((caddr_t)ccb); + } + } #ifdef ASR_MEASURE_PERFORMANCE - { - u_int32_t result; - - microtime(&junk); - result = asr_time_delta(sc->ha_performance.intr_started, junk); - - if (result != 0xffffffff) { - if ( sc->ha_performance.max_intr_time < result ) { - sc->ha_performance.max_intr_time = result; - } - - if ( (sc->ha_performance.min_intr_time == 0) - || (sc->ha_performance.min_intr_time > result) ) { - sc->ha_performance.min_intr_time = result; - } - } - } + { + u_int32_t result; + + microtime(&junk); + result = asr_time_delta(sc->ha_performance.intr_started, junk); + + if (result != 0xffffffff) { + if ( sc->ha_performance.max_intr_time < result ) { + sc->ha_performance.max_intr_time = result; + } + + if ( (sc->ha_performance.min_intr_time == 0) + || (sc->ha_performance.min_intr_time > result) ) { + sc->ha_performance.min_intr_time = result; + } + } + } #endif - return (processed); + return (processed); } /* asr_intr */ -#undef QueueSize /* Grrrr */ -#undef SG_Size /* Grrrr */ +#undef QueueSize /* Grrrr */ +#undef SG_Size /* Grrrr */ /* - * Meant to be included at the bottom of asr.c !!! + * Meant to be included at the bottom of asr.c !!! */ /* - * Included here as hard coded. Done because other necessary include - * files utilize C++ comment structures which make them a nuisance to - * included here just to pick up these three typedefs. + * Included here as hard coded. Done because other necessary include + * files utilize C++ comment structures which make them a nuisance to + * included here just to pick up these three typedefs. */ typedef U32 DPT_TAG_T; typedef U32 DPT_MSG_T; typedef U32 DPT_RTN_T; -#undef SCSI_RESET /* Conflicts with "scsi/scsiconf.h" defintion */ -#include "dev/asr/osd_unix.h" +#undef SCSI_RESET /* Conflicts with "scsi/scsiconf.h" defintion */ +#include "dev/asr/osd_unix.h" -#define asr_unit(dev) minor(dev) +#define asr_unit(dev) minor(dev) STATIC INLINE Asr_softc_t * ASR_get_sc ( - IN dev_t dev) + IN dev_t dev) { - int unit = asr_unit(dev); - OUT Asr_softc_t * sc = Asr_softc; + int unit = asr_unit(dev); + OUT Asr_softc_t * sc = Asr_softc; - while (sc && sc->ha_sim[0] && (cam_sim_unit(sc->ha_sim[0]) != unit)) { - sc = sc->ha_next; - } - return (sc); + while (sc && sc->ha_sim[0] && (cam_sim_unit(sc->ha_sim[0]) != unit)) { + sc = sc->ha_next; + } + return (sc); } /* ASR_get_sc */ STATIC u_int8_t ASR_ctlr_held; @@ -3863,800 +3863,800 @@ STATIC u_int8_t ASR_ctlr_held; STATIC int asr_open( - IN dev_t dev, - int32_t flags, - int32_t ifmt, - IN struct thread * td) + IN dev_t dev, + int32_t flags, + int32_t ifmt, + IN struct thread * td) { - int s; - OUT int error; - UNREFERENCED_PARAMETER(flags); - UNREFERENCED_PARAMETER(ifmt); - - if (ASR_get_sc (dev) == (Asr_softc_t *)NULL) { - return (ENODEV); - } - s = splcam (); - if (ASR_ctlr_held) { - error = EBUSY; - } else if ((error = suser(td)) == 0) { - ++ASR_ctlr_held; - } - splx(s); - return (error); + int s; + OUT int error; + UNREFERENCED_PARAMETER(flags); + UNREFERENCED_PARAMETER(ifmt); + + if (ASR_get_sc (dev) == (Asr_softc_t *)NULL) { + return (ENODEV); + } + s = splcam (); + if (ASR_ctlr_held) { + error = EBUSY; + } else if ((error = suser(td)) == 0) { + ++ASR_ctlr_held; + } + splx(s); + return (error); } /* asr_open */ STATIC int asr_close( - dev_t dev, - int flags, - int ifmt, - struct thread * td) + dev_t dev, + int flags, + int ifmt, + struct thread * td) { - UNREFERENCED_PARAMETER(dev); - UNREFERENCED_PARAMETER(flags); - UNREFERENCED_PARAMETER(ifmt); - UNREFERENCED_PARAMETER(td); + UNREFERENCED_PARAMETER(dev); + UNREFERENCED_PARAMETER(flags); + UNREFERENCED_PARAMETER(ifmt); + UNREFERENCED_PARAMETER(td); - ASR_ctlr_held = 0; - return (0); + ASR_ctlr_held = 0; + return (0); } /* asr_close */ /*-------------------------------------------------------------------------*/ -/* Function ASR_queue_i */ +/* Function ASR_queue_i */ /*-------------------------------------------------------------------------*/ -/* The Parameters Passed To This Function Are : */ -/* Asr_softc_t * : HBA miniport driver's adapter data storage. */ -/* PI2O_MESSAGE_FRAME : Msg Structure Pointer For This Command */ -/* I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME following the Msg Structure */ -/* */ -/* This Function Will Take The User Request Packet And Convert It To An */ -/* I2O MSG And Send It Off To The Adapter. */ -/* */ -/* Return : 0 For OK, Error Code Otherwise */ +/* The Parameters Passed To This Function Are : */ +/* Asr_softc_t * : HBA miniport driver's adapter data storage. */ +/* PI2O_MESSAGE_FRAME : Msg Structure Pointer For This Command */ +/* I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME following the Msg Structure */ +/* */ +/* This Function Will Take The User Request Packet And Convert It To An */ +/* I2O MSG And Send It Off To The Adapter. */ +/* */ +/* Return : 0 For OK, Error Code Otherwise */ /*-------------------------------------------------------------------------*/ STATIC INLINE int ASR_queue_i( - IN Asr_softc_t * sc, - INOUT PI2O_MESSAGE_FRAME Packet) + IN Asr_softc_t * sc, + INOUT PI2O_MESSAGE_FRAME Packet) { - union asr_ccb * ccb; - PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME Reply; - PI2O_MESSAGE_FRAME Message_Ptr; - PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME Reply_Ptr; - int MessageSizeInBytes; - int ReplySizeInBytes; - int error; - int s; - /* Scatter Gather buffer list */ - struct ioctlSgList_S { - SLIST_ENTRY(ioctlSgList_S) link; - caddr_t UserSpace; - I2O_FLAGS_COUNT FlagsCount; - char KernelSpace[sizeof(long)]; - } * elm; - /* Generates a `first' entry */ - SLIST_HEAD(ioctlSgListHead_S, ioctlSgList_S) sgList; - - if (ASR_getBlinkLedCode(sc)) { - debug_usr_cmd_printf ("Adapter currently in BlinkLed %x\n", - ASR_getBlinkLedCode(sc)); - return (EIO); - } - /* Copy in the message into a local allocation */ - if ((Message_Ptr = (PI2O_MESSAGE_FRAME)malloc ( - sizeof(I2O_MESSAGE_FRAME), M_TEMP, M_WAITOK)) - == (PI2O_MESSAGE_FRAME)NULL) { - debug_usr_cmd_printf ( - "Failed to acquire I2O_MESSAGE_FRAME memory\n"); - return (ENOMEM); - } - if ((error = copyin ((caddr_t)Packet, (caddr_t)Message_Ptr, - sizeof(I2O_MESSAGE_FRAME))) != 0) { - free (Message_Ptr, M_TEMP); - debug_usr_cmd_printf ("Can't copy in packet errno=%d\n", error); - return (error); - } - /* Acquire information to determine type of packet */ - MessageSizeInBytes = (I2O_MESSAGE_FRAME_getMessageSize(Message_Ptr)<<2); - /* The offset of the reply information within the user packet */ - Reply = (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)((char *)Packet - + MessageSizeInBytes); - - /* Check if the message is a synchronous initialization command */ - s = I2O_MESSAGE_FRAME_getFunction(Message_Ptr); - free (Message_Ptr, M_TEMP); - switch (s) { - - case I2O_EXEC_IOP_RESET: - { U32 status; - - status = ASR_resetIOP(sc->ha_Virt, sc->ha_Fvirt); - ReplySizeInBytes = sizeof(status); - debug_usr_cmd_printf ("resetIOP done\n"); - return (copyout ((caddr_t)&status, (caddr_t)Reply, - ReplySizeInBytes)); - } - - case I2O_EXEC_STATUS_GET: - { I2O_EXEC_STATUS_GET_REPLY status; - - if (ASR_getStatus (sc->ha_Virt, sc->ha_Fvirt, &status) - == (PI2O_EXEC_STATUS_GET_REPLY)NULL) { - debug_usr_cmd_printf ("getStatus failed\n"); - return (ENXIO); - } - ReplySizeInBytes = sizeof(status); - debug_usr_cmd_printf ("getStatus done\n"); - return (copyout ((caddr_t)&status, (caddr_t)Reply, - ReplySizeInBytes)); - } - - case I2O_EXEC_OUTBOUND_INIT: - { U32 status; - - status = ASR_initOutBound(sc); - ReplySizeInBytes = sizeof(status); - debug_usr_cmd_printf ("intOutBound done\n"); - return (copyout ((caddr_t)&status, (caddr_t)Reply, - ReplySizeInBytes)); - } - } - - /* Determine if the message size is valid */ - if ((MessageSizeInBytes < sizeof(I2O_MESSAGE_FRAME)) - || (MAX_INBOUND_SIZE < MessageSizeInBytes)) { - debug_usr_cmd_printf ("Packet size %d incorrect\n", - MessageSizeInBytes); - return (EINVAL); - } - - if ((Message_Ptr = (PI2O_MESSAGE_FRAME)malloc (MessageSizeInBytes, - M_TEMP, M_WAITOK)) == (PI2O_MESSAGE_FRAME)NULL) { - debug_usr_cmd_printf ("Failed to acquire frame[%d] memory\n", - MessageSizeInBytes); - return (ENOMEM); - } - if ((error = copyin ((caddr_t)Packet, (caddr_t)Message_Ptr, - MessageSizeInBytes)) != 0) { - free (Message_Ptr, M_TEMP); - debug_usr_cmd_printf ("Can't copy in packet[%d] errno=%d\n", - MessageSizeInBytes, error); - return (error); - } - - /* Check the size of the reply frame, and start constructing */ - - if ((Reply_Ptr = (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)malloc ( - sizeof(I2O_MESSAGE_FRAME), M_TEMP, M_WAITOK)) - == (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)NULL) { - free (Message_Ptr, M_TEMP); - debug_usr_cmd_printf ( - "Failed to acquire I2O_MESSAGE_FRAME memory\n"); - return (ENOMEM); - } - if ((error = copyin ((caddr_t)Reply, (caddr_t)Reply_Ptr, - sizeof(I2O_MESSAGE_FRAME))) != 0) { - free (Reply_Ptr, M_TEMP); - free (Message_Ptr, M_TEMP); - debug_usr_cmd_printf ( - "Failed to copy in reply frame, errno=%d\n", - error); - return (error); - } - ReplySizeInBytes = (I2O_MESSAGE_FRAME_getMessageSize( - &(Reply_Ptr->StdReplyFrame.StdMessageFrame)) << 2); - free (Reply_Ptr, M_TEMP); - if (ReplySizeInBytes < sizeof(I2O_SINGLE_REPLY_MESSAGE_FRAME)) { - free (Message_Ptr, M_TEMP); - debug_usr_cmd_printf ( - "Failed to copy in reply frame[%d], errno=%d\n", - ReplySizeInBytes, error); - return (EINVAL); - } - - if ((Reply_Ptr = (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)malloc ( - ((ReplySizeInBytes > sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)) - ? ReplySizeInBytes - : sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)), - M_TEMP, M_WAITOK)) == (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)NULL) { - free (Message_Ptr, M_TEMP); - debug_usr_cmd_printf ("Failed to acquire frame[%d] memory\n", - ReplySizeInBytes); - return (ENOMEM); - } - (void)ASR_fillMessage ((char *)Reply_Ptr, ReplySizeInBytes); - Reply_Ptr->StdReplyFrame.StdMessageFrame.InitiatorContext - = Message_Ptr->InitiatorContext; - Reply_Ptr->StdReplyFrame.TransactionContext - = ((PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr)->TransactionContext; - I2O_MESSAGE_FRAME_setMsgFlags( - &(Reply_Ptr->StdReplyFrame.StdMessageFrame), - I2O_MESSAGE_FRAME_getMsgFlags( - &(Reply_Ptr->StdReplyFrame.StdMessageFrame)) - | I2O_MESSAGE_FLAGS_REPLY); - - /* Check if the message is a special case command */ - switch (I2O_MESSAGE_FRAME_getFunction(Message_Ptr)) { - case I2O_EXEC_SYS_TAB_SET: /* Special Case of empty Scatter Gather */ - if (MessageSizeInBytes == ((I2O_MESSAGE_FRAME_getVersionOffset( - Message_Ptr) & 0xF0) >> 2)) { - free (Message_Ptr, M_TEMP); - I2O_SINGLE_REPLY_MESSAGE_FRAME_setDetailedStatusCode( - &(Reply_Ptr->StdReplyFrame), - (ASR_setSysTab(sc) != CAM_REQ_CMP)); - I2O_MESSAGE_FRAME_setMessageSize( - &(Reply_Ptr->StdReplyFrame.StdMessageFrame), - sizeof(I2O_SINGLE_REPLY_MESSAGE_FRAME)); - error = copyout ((caddr_t)Reply_Ptr, (caddr_t)Reply, - ReplySizeInBytes); - free (Reply_Ptr, M_TEMP); - return (error); - } - } - - /* Deal in the general case */ - /* First allocate and optionally copy in each scatter gather element */ - SLIST_INIT(&sgList); - if ((I2O_MESSAGE_FRAME_getVersionOffset(Message_Ptr) & 0xF0) != 0) { - PI2O_SGE_SIMPLE_ELEMENT sg; - - /* - * since this code is reused in several systems, code - * efficiency is greater by using a shift operation rather - * than a divide by sizeof(u_int32_t). - */ - sg = (PI2O_SGE_SIMPLE_ELEMENT)((char *)Message_Ptr - + ((I2O_MESSAGE_FRAME_getVersionOffset(Message_Ptr) & 0xF0) - >> 2)); - while (sg < (PI2O_SGE_SIMPLE_ELEMENT)(((caddr_t)Message_Ptr) - + MessageSizeInBytes)) { - caddr_t v; - int len; - - if ((I2O_FLAGS_COUNT_getFlags(&(sg->FlagsCount)) - & I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT) == 0) { - error = EINVAL; - break; - } - len = I2O_FLAGS_COUNT_getCount(&(sg->FlagsCount)); - debug_usr_cmd_printf ("SG[%d] = %x[%d]\n", - sg - (PI2O_SGE_SIMPLE_ELEMENT)((char *)Message_Ptr - + ((I2O_MESSAGE_FRAME_getVersionOffset( - Message_Ptr) & 0xF0) >> 2)), - I2O_SGE_SIMPLE_ELEMENT_getPhysicalAddress(sg), len); - - if ((elm = (struct ioctlSgList_S *)malloc ( - sizeof(*elm) - sizeof(elm->KernelSpace) + len, - M_TEMP, M_WAITOK)) - == (struct ioctlSgList_S *)NULL) { - debug_usr_cmd_printf ( - "Failed to allocate SG[%d]\n", len); - error = ENOMEM; - break; - } - SLIST_INSERT_HEAD(&sgList, elm, link); - elm->FlagsCount = sg->FlagsCount; - elm->UserSpace = (caddr_t) - (I2O_SGE_SIMPLE_ELEMENT_getPhysicalAddress(sg)); - v = elm->KernelSpace; - /* Copy in outgoing data (DIR bit could be invalid) */ - if ((error = copyin (elm->UserSpace, (caddr_t)v, len)) - != 0) { - break; - } - /* - * If the buffer is not contiguous, lets - * break up the scatter/gather entries. - */ - while ((len > 0) - && (sg < (PI2O_SGE_SIMPLE_ELEMENT) - (((caddr_t)Message_Ptr) + MAX_INBOUND_SIZE))) { - int next, base, span; - - span = 0; - next = base = KVTOPHYS(v); - I2O_SGE_SIMPLE_ELEMENT_setPhysicalAddress(sg, - base); - - /* How far can we go physically contiguously */ - while ((len > 0) && (base == next)) { - int size; - - next = trunc_page(base) + PAGE_SIZE; - size = next - base; - if (size > len) { - size = len; - } - span += size; - v += size; - len -= size; - base = KVTOPHYS(v); - } - - /* Construct the Flags */ - I2O_FLAGS_COUNT_setCount(&(sg->FlagsCount), - span); - { - int flags = I2O_FLAGS_COUNT_getFlags( - &(elm->FlagsCount)); - /* Any remaining length? */ - if (len > 0) { - flags &= - ~(I2O_SGL_FLAGS_END_OF_BUFFER - | I2O_SGL_FLAGS_LAST_ELEMENT); - } - I2O_FLAGS_COUNT_setFlags( - &(sg->FlagsCount), flags); - } - - debug_usr_cmd_printf ("sg[%d] = %x[%d]\n", - sg - (PI2O_SGE_SIMPLE_ELEMENT) - ((char *)Message_Ptr - + ((I2O_MESSAGE_FRAME_getVersionOffset( - Message_Ptr) & 0xF0) >> 2)), - I2O_SGE_SIMPLE_ELEMENT_getPhysicalAddress(sg), - span); - if (len <= 0) { - break; - } - - /* - * Incrementing requires resizing of the - * packet, and moving up the existing SG - * elements. - */ - ++sg; - MessageSizeInBytes += sizeof(*sg); - I2O_MESSAGE_FRAME_setMessageSize(Message_Ptr, - I2O_MESSAGE_FRAME_getMessageSize(Message_Ptr) - + (sizeof(*sg) / sizeof(U32))); - { - PI2O_MESSAGE_FRAME NewMessage_Ptr; - - if ((NewMessage_Ptr - = (PI2O_MESSAGE_FRAME) - malloc (MessageSizeInBytes, - M_TEMP, M_WAITOK)) - == (PI2O_MESSAGE_FRAME)NULL) { - debug_usr_cmd_printf ( - "Failed to acquire frame[%d] memory\n", - MessageSizeInBytes); - error = ENOMEM; - break; - } - span = ((caddr_t)sg) - - (caddr_t)Message_Ptr; - bcopy ((caddr_t)Message_Ptr, - (caddr_t)NewMessage_Ptr, span); - bcopy ((caddr_t)(sg-1), - ((caddr_t)NewMessage_Ptr) + span, - MessageSizeInBytes - span); - free (Message_Ptr, M_TEMP); - sg = (PI2O_SGE_SIMPLE_ELEMENT) - (((caddr_t)NewMessage_Ptr) + span); - Message_Ptr = NewMessage_Ptr; - } - } - if ((error) - || ((I2O_FLAGS_COUNT_getFlags(&(sg->FlagsCount)) - & I2O_SGL_FLAGS_LAST_ELEMENT) != 0)) { - break; - } - ++sg; - } - if (error) { - while ((elm = SLIST_FIRST(&sgList)) - != (struct ioctlSgList_S *)NULL) { - SLIST_REMOVE_HEAD(&sgList, link); - free (elm, M_TEMP); - } - free (Reply_Ptr, M_TEMP); - free (Message_Ptr, M_TEMP); - return (error); - } - } - - debug_usr_cmd_printf ("Inbound: "); - debug_usr_cmd_dump_message(Message_Ptr); - - /* Send the command */ - if ((ccb = asr_alloc_ccb (sc)) == (union asr_ccb *)NULL) { - /* Free up in-kernel buffers */ - while ((elm = SLIST_FIRST(&sgList)) - != (struct ioctlSgList_S *)NULL) { - SLIST_REMOVE_HEAD(&sgList, link); - free (elm, M_TEMP); - } - free (Reply_Ptr, M_TEMP); - free (Message_Ptr, M_TEMP); - return (ENOMEM); - } - - /* - * We do not need any (optional byteswapping) method access to - * the Initiator context field. - */ - I2O_MESSAGE_FRAME_setInitiatorContext64( - (PI2O_MESSAGE_FRAME)Message_Ptr, (long)ccb); - - (void)ASR_queue (sc, (PI2O_MESSAGE_FRAME)Message_Ptr); - - free (Message_Ptr, M_TEMP); - - /* - * Wait for the board to report a finished instruction. - */ - s = splcam(); - while ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INPROG) { - if (ASR_getBlinkLedCode(sc)) { - /* Reset Adapter */ - printf ("asr%d: Blink LED 0x%x resetting adapter\n", - cam_sim_unit(xpt_path_sim(ccb->ccb_h.path)), - ASR_getBlinkLedCode(sc)); - if (ASR_reset (sc) == ENXIO) { - /* Command Cleanup */ - ASR_ccbRemove(sc, ccb); - } - splx(s); - /* Free up in-kernel buffers */ - while ((elm = SLIST_FIRST(&sgList)) - != (struct ioctlSgList_S *)NULL) { - SLIST_REMOVE_HEAD(&sgList, link); - free (elm, M_TEMP); - } - free (Reply_Ptr, M_TEMP); - asr_free_ccb(ccb); - return (EIO); - } - /* Check every second for BlinkLed */ - /* There is no PRICAM, but outwardly PRIBIO is functional */ - tsleep((caddr_t)ccb, PRIBIO, "asr", hz); - } - splx(s); - - debug_usr_cmd_printf ("Outbound: "); - debug_usr_cmd_dump_message(Reply_Ptr); - - I2O_SINGLE_REPLY_MESSAGE_FRAME_setDetailedStatusCode( - &(Reply_Ptr->StdReplyFrame), - (ccb->ccb_h.status != CAM_REQ_CMP)); - - if (ReplySizeInBytes >= (sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME) - - I2O_SCSI_SENSE_DATA_SZ - sizeof(U32))) { - I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_setTransferCount(Reply_Ptr, - ccb->csio.dxfer_len - ccb->csio.resid); - } - if ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) && (ReplySizeInBytes - > (sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME) - - I2O_SCSI_SENSE_DATA_SZ))) { - int size = ReplySizeInBytes - - sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME) - - I2O_SCSI_SENSE_DATA_SZ; - - if (size > sizeof(ccb->csio.sense_data)) { - size = sizeof(ccb->csio.sense_data); - } - bcopy ((caddr_t)&(ccb->csio.sense_data), (caddr_t)Reply_Ptr->SenseData, - size); - I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_setAutoSenseTransferCount( - Reply_Ptr, size); - } - - /* Free up in-kernel buffers */ - while ((elm = SLIST_FIRST(&sgList)) != (struct ioctlSgList_S *)NULL) { - /* Copy out as necessary */ - if ((error == 0) - /* DIR bit considered `valid', error due to ignorance works */ - && ((I2O_FLAGS_COUNT_getFlags(&(elm->FlagsCount)) - & I2O_SGL_FLAGS_DIR) == 0)) { - error = copyout ((caddr_t)(elm->KernelSpace), - elm->UserSpace, - I2O_FLAGS_COUNT_getCount(&(elm->FlagsCount))); - } - SLIST_REMOVE_HEAD(&sgList, link); - free (elm, M_TEMP); - } - if (error == 0) { - /* Copy reply frame to user space */ - error = copyout ((caddr_t)Reply_Ptr, (caddr_t)Reply, - ReplySizeInBytes); - } - free (Reply_Ptr, M_TEMP); - asr_free_ccb(ccb); - - return (error); + union asr_ccb * ccb; + PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME Reply; + PI2O_MESSAGE_FRAME Message_Ptr; + PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME Reply_Ptr; + int MessageSizeInBytes; + int ReplySizeInBytes; + int error; + int s; + /* Scatter Gather buffer list */ + struct ioctlSgList_S { + SLIST_ENTRY(ioctlSgList_S) link; + caddr_t UserSpace; + I2O_FLAGS_COUNT FlagsCount; + char KernelSpace[sizeof(long)]; + } * elm; + /* Generates a `first' entry */ + SLIST_HEAD(ioctlSgListHead_S, ioctlSgList_S) sgList; + + if (ASR_getBlinkLedCode(sc)) { + debug_usr_cmd_printf ("Adapter currently in BlinkLed %x\n", + ASR_getBlinkLedCode(sc)); + return (EIO); + } + /* Copy in the message into a local allocation */ + if ((Message_Ptr = (PI2O_MESSAGE_FRAME)malloc ( + sizeof(I2O_MESSAGE_FRAME), M_TEMP, M_WAITOK)) + == (PI2O_MESSAGE_FRAME)NULL) { + debug_usr_cmd_printf ( + "Failed to acquire I2O_MESSAGE_FRAME memory\n"); + return (ENOMEM); + } + if ((error = copyin ((caddr_t)Packet, (caddr_t)Message_Ptr, + sizeof(I2O_MESSAGE_FRAME))) != 0) { + free (Message_Ptr, M_TEMP); + debug_usr_cmd_printf ("Can't copy in packet errno=%d\n", error); + return (error); + } + /* Acquire information to determine type of packet */ + MessageSizeInBytes = (I2O_MESSAGE_FRAME_getMessageSize(Message_Ptr)<<2); + /* The offset of the reply information within the user packet */ + Reply = (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)((char *)Packet + + MessageSizeInBytes); + + /* Check if the message is a synchronous initialization command */ + s = I2O_MESSAGE_FRAME_getFunction(Message_Ptr); + free (Message_Ptr, M_TEMP); + switch (s) { + + case I2O_EXEC_IOP_RESET: + { U32 status; + + status = ASR_resetIOP(sc->ha_Virt, sc->ha_Fvirt); + ReplySizeInBytes = sizeof(status); + debug_usr_cmd_printf ("resetIOP done\n"); + return (copyout ((caddr_t)&status, (caddr_t)Reply, + ReplySizeInBytes)); + } + + case I2O_EXEC_STATUS_GET: + { I2O_EXEC_STATUS_GET_REPLY status; + + if (ASR_getStatus (sc->ha_Virt, sc->ha_Fvirt, &status) + == (PI2O_EXEC_STATUS_GET_REPLY)NULL) { + debug_usr_cmd_printf ("getStatus failed\n"); + return (ENXIO); + } + ReplySizeInBytes = sizeof(status); + debug_usr_cmd_printf ("getStatus done\n"); + return (copyout ((caddr_t)&status, (caddr_t)Reply, + ReplySizeInBytes)); + } + + case I2O_EXEC_OUTBOUND_INIT: + { U32 status; + + status = ASR_initOutBound(sc); + ReplySizeInBytes = sizeof(status); + debug_usr_cmd_printf ("intOutBound done\n"); + return (copyout ((caddr_t)&status, (caddr_t)Reply, + ReplySizeInBytes)); + } + } + + /* Determine if the message size is valid */ + if ((MessageSizeInBytes < sizeof(I2O_MESSAGE_FRAME)) + || (MAX_INBOUND_SIZE < MessageSizeInBytes)) { + debug_usr_cmd_printf ("Packet size %d incorrect\n", + MessageSizeInBytes); + return (EINVAL); + } + + if ((Message_Ptr = (PI2O_MESSAGE_FRAME)malloc (MessageSizeInBytes, + M_TEMP, M_WAITOK)) == (PI2O_MESSAGE_FRAME)NULL) { + debug_usr_cmd_printf ("Failed to acquire frame[%d] memory\n", + MessageSizeInBytes); + return (ENOMEM); + } + if ((error = copyin ((caddr_t)Packet, (caddr_t)Message_Ptr, + MessageSizeInBytes)) != 0) { + free (Message_Ptr, M_TEMP); + debug_usr_cmd_printf ("Can't copy in packet[%d] errno=%d\n", + MessageSizeInBytes, error); + return (error); + } + + /* Check the size of the reply frame, and start constructing */ + + if ((Reply_Ptr = (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)malloc ( + sizeof(I2O_MESSAGE_FRAME), M_TEMP, M_WAITOK)) + == (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)NULL) { + free (Message_Ptr, M_TEMP); + debug_usr_cmd_printf ( + "Failed to acquire I2O_MESSAGE_FRAME memory\n"); + return (ENOMEM); + } + if ((error = copyin ((caddr_t)Reply, (caddr_t)Reply_Ptr, + sizeof(I2O_MESSAGE_FRAME))) != 0) { + free (Reply_Ptr, M_TEMP); + free (Message_Ptr, M_TEMP); + debug_usr_cmd_printf ( + "Failed to copy in reply frame, errno=%d\n", + error); + return (error); + } + ReplySizeInBytes = (I2O_MESSAGE_FRAME_getMessageSize( + &(Reply_Ptr->StdReplyFrame.StdMessageFrame)) << 2); + free (Reply_Ptr, M_TEMP); + if (ReplySizeInBytes < sizeof(I2O_SINGLE_REPLY_MESSAGE_FRAME)) { + free (Message_Ptr, M_TEMP); + debug_usr_cmd_printf ( + "Failed to copy in reply frame[%d], errno=%d\n", + ReplySizeInBytes, error); + return (EINVAL); + } + + if ((Reply_Ptr = (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)malloc ( + ((ReplySizeInBytes > sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)) + ? ReplySizeInBytes + : sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)), + M_TEMP, M_WAITOK)) == (PI2O_SCSI_ERROR_REPLY_MESSAGE_FRAME)NULL) { + free (Message_Ptr, M_TEMP); + debug_usr_cmd_printf ("Failed to acquire frame[%d] memory\n", + ReplySizeInBytes); + return (ENOMEM); + } + (void)ASR_fillMessage ((char *)Reply_Ptr, ReplySizeInBytes); + Reply_Ptr->StdReplyFrame.StdMessageFrame.InitiatorContext + = Message_Ptr->InitiatorContext; + Reply_Ptr->StdReplyFrame.TransactionContext + = ((PI2O_PRIVATE_MESSAGE_FRAME)Message_Ptr)->TransactionContext; + I2O_MESSAGE_FRAME_setMsgFlags( + &(Reply_Ptr->StdReplyFrame.StdMessageFrame), + I2O_MESSAGE_FRAME_getMsgFlags( + &(Reply_Ptr->StdReplyFrame.StdMessageFrame)) + | I2O_MESSAGE_FLAGS_REPLY); + + /* Check if the message is a special case command */ + switch (I2O_MESSAGE_FRAME_getFunction(Message_Ptr)) { + case I2O_EXEC_SYS_TAB_SET: /* Special Case of empty Scatter Gather */ + if (MessageSizeInBytes == ((I2O_MESSAGE_FRAME_getVersionOffset( + Message_Ptr) & 0xF0) >> 2)) { + free (Message_Ptr, M_TEMP); + I2O_SINGLE_REPLY_MESSAGE_FRAME_setDetailedStatusCode( + &(Reply_Ptr->StdReplyFrame), + (ASR_setSysTab(sc) != CAM_REQ_CMP)); + I2O_MESSAGE_FRAME_setMessageSize( + &(Reply_Ptr->StdReplyFrame.StdMessageFrame), + sizeof(I2O_SINGLE_REPLY_MESSAGE_FRAME)); + error = copyout ((caddr_t)Reply_Ptr, (caddr_t)Reply, + ReplySizeInBytes); + free (Reply_Ptr, M_TEMP); + return (error); + } + } + + /* Deal in the general case */ + /* First allocate and optionally copy in each scatter gather element */ + SLIST_INIT(&sgList); + if ((I2O_MESSAGE_FRAME_getVersionOffset(Message_Ptr) & 0xF0) != 0) { + PI2O_SGE_SIMPLE_ELEMENT sg; + + /* + * since this code is reused in several systems, code + * efficiency is greater by using a shift operation rather + * than a divide by sizeof(u_int32_t). + */ + sg = (PI2O_SGE_SIMPLE_ELEMENT)((char *)Message_Ptr + + ((I2O_MESSAGE_FRAME_getVersionOffset(Message_Ptr) & 0xF0) + >> 2)); + while (sg < (PI2O_SGE_SIMPLE_ELEMENT)(((caddr_t)Message_Ptr) + + MessageSizeInBytes)) { + caddr_t v; + int len; + + if ((I2O_FLAGS_COUNT_getFlags(&(sg->FlagsCount)) + & I2O_SGL_FLAGS_SIMPLE_ADDRESS_ELEMENT) == 0) { + error = EINVAL; + break; + } + len = I2O_FLAGS_COUNT_getCount(&(sg->FlagsCount)); + debug_usr_cmd_printf ("SG[%d] = %x[%d]\n", + sg - (PI2O_SGE_SIMPLE_ELEMENT)((char *)Message_Ptr + + ((I2O_MESSAGE_FRAME_getVersionOffset( + Message_Ptr) & 0xF0) >> 2)), + I2O_SGE_SIMPLE_ELEMENT_getPhysicalAddress(sg), len); + + if ((elm = (struct ioctlSgList_S *)malloc ( + sizeof(*elm) - sizeof(elm->KernelSpace) + len, + M_TEMP, M_WAITOK)) + == (struct ioctlSgList_S *)NULL) { + debug_usr_cmd_printf ( + "Failed to allocate SG[%d]\n", len); + error = ENOMEM; + break; + } + SLIST_INSERT_HEAD(&sgList, elm, link); + elm->FlagsCount = sg->FlagsCount; + elm->UserSpace = (caddr_t) + (I2O_SGE_SIMPLE_ELEMENT_getPhysicalAddress(sg)); + v = elm->KernelSpace; + /* Copy in outgoing data (DIR bit could be invalid) */ + if ((error = copyin (elm->UserSpace, (caddr_t)v, len)) + != 0) { + break; + } + /* + * If the buffer is not contiguous, lets + * break up the scatter/gather entries. + */ + while ((len > 0) + && (sg < (PI2O_SGE_SIMPLE_ELEMENT) + (((caddr_t)Message_Ptr) + MAX_INBOUND_SIZE))) { + int next, base, span; + + span = 0; + next = base = KVTOPHYS(v); + I2O_SGE_SIMPLE_ELEMENT_setPhysicalAddress(sg, + base); + + /* How far can we go physically contiguously */ + while ((len > 0) && (base == next)) { + int size; + + next = trunc_page(base) + PAGE_SIZE; + size = next - base; + if (size > len) { + size = len; + } + span += size; + v += size; + len -= size; + base = KVTOPHYS(v); + } + + /* Construct the Flags */ + I2O_FLAGS_COUNT_setCount(&(sg->FlagsCount), + span); + { + int flags = I2O_FLAGS_COUNT_getFlags( + &(elm->FlagsCount)); + /* Any remaining length? */ + if (len > 0) { + flags &= + ~(I2O_SGL_FLAGS_END_OF_BUFFER + | I2O_SGL_FLAGS_LAST_ELEMENT); + } + I2O_FLAGS_COUNT_setFlags( + &(sg->FlagsCount), flags); + } + + debug_usr_cmd_printf ("sg[%d] = %x[%d]\n", + sg - (PI2O_SGE_SIMPLE_ELEMENT) + ((char *)Message_Ptr + + ((I2O_MESSAGE_FRAME_getVersionOffset( + Message_Ptr) & 0xF0) >> 2)), + I2O_SGE_SIMPLE_ELEMENT_getPhysicalAddress(sg), + span); + if (len <= 0) { + break; + } + + /* + * Incrementing requires resizing of the + * packet, and moving up the existing SG + * elements. + */ + ++sg; + MessageSizeInBytes += sizeof(*sg); + I2O_MESSAGE_FRAME_setMessageSize(Message_Ptr, + I2O_MESSAGE_FRAME_getMessageSize(Message_Ptr) + + (sizeof(*sg) / sizeof(U32))); + { + PI2O_MESSAGE_FRAME NewMessage_Ptr; + + if ((NewMessage_Ptr + = (PI2O_MESSAGE_FRAME) + malloc (MessageSizeInBytes, + M_TEMP, M_WAITOK)) + == (PI2O_MESSAGE_FRAME)NULL) { + debug_usr_cmd_printf ( + "Failed to acquire frame[%d] memory\n", + MessageSizeInBytes); + error = ENOMEM; + break; + } + span = ((caddr_t)sg) + - (caddr_t)Message_Ptr; + bcopy ((caddr_t)Message_Ptr, + (caddr_t)NewMessage_Ptr, span); + bcopy ((caddr_t)(sg-1), + ((caddr_t)NewMessage_Ptr) + span, + MessageSizeInBytes - span); + free (Message_Ptr, M_TEMP); + sg = (PI2O_SGE_SIMPLE_ELEMENT) + (((caddr_t)NewMessage_Ptr) + span); + Message_Ptr = NewMessage_Ptr; + } + } + if ((error) + || ((I2O_FLAGS_COUNT_getFlags(&(sg->FlagsCount)) + & I2O_SGL_FLAGS_LAST_ELEMENT) != 0)) { + break; + } + ++sg; + } + if (error) { + while ((elm = SLIST_FIRST(&sgList)) + != (struct ioctlSgList_S *)NULL) { + SLIST_REMOVE_HEAD(&sgList, link); + free (elm, M_TEMP); + } + free (Reply_Ptr, M_TEMP); + free (Message_Ptr, M_TEMP); + return (error); + } + } + + debug_usr_cmd_printf ("Inbound: "); + debug_usr_cmd_dump_message(Message_Ptr); + + /* Send the command */ + if ((ccb = asr_alloc_ccb (sc)) == (union asr_ccb *)NULL) { + /* Free up in-kernel buffers */ + while ((elm = SLIST_FIRST(&sgList)) + != (struct ioctlSgList_S *)NULL) { + SLIST_REMOVE_HEAD(&sgList, link); + free (elm, M_TEMP); + } + free (Reply_Ptr, M_TEMP); + free (Message_Ptr, M_TEMP); + return (ENOMEM); + } + + /* + * We do not need any (optional byteswapping) method access to + * the Initiator context field. + */ + I2O_MESSAGE_FRAME_setInitiatorContext64( + (PI2O_MESSAGE_FRAME)Message_Ptr, (long)ccb); + + (void)ASR_queue (sc, (PI2O_MESSAGE_FRAME)Message_Ptr); + + free (Message_Ptr, M_TEMP); + + /* + * Wait for the board to report a finished instruction. + */ + s = splcam(); + while ((ccb->ccb_h.status & CAM_STATUS_MASK) == CAM_REQ_INPROG) { + if (ASR_getBlinkLedCode(sc)) { + /* Reset Adapter */ + printf ("asr%d: Blink LED 0x%x resetting adapter\n", + cam_sim_unit(xpt_path_sim(ccb->ccb_h.path)), + ASR_getBlinkLedCode(sc)); + if (ASR_reset (sc) == ENXIO) { + /* Command Cleanup */ + ASR_ccbRemove(sc, ccb); + } + splx(s); + /* Free up in-kernel buffers */ + while ((elm = SLIST_FIRST(&sgList)) + != (struct ioctlSgList_S *)NULL) { + SLIST_REMOVE_HEAD(&sgList, link); + free (elm, M_TEMP); + } + free (Reply_Ptr, M_TEMP); + asr_free_ccb(ccb); + return (EIO); + } + /* Check every second for BlinkLed */ + /* There is no PRICAM, but outwardly PRIBIO is functional */ + tsleep((caddr_t)ccb, PRIBIO, "asr", hz); + } + splx(s); + + debug_usr_cmd_printf ("Outbound: "); + debug_usr_cmd_dump_message(Reply_Ptr); + + I2O_SINGLE_REPLY_MESSAGE_FRAME_setDetailedStatusCode( + &(Reply_Ptr->StdReplyFrame), + (ccb->ccb_h.status != CAM_REQ_CMP)); + + if (ReplySizeInBytes >= (sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME) + - I2O_SCSI_SENSE_DATA_SZ - sizeof(U32))) { + I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_setTransferCount(Reply_Ptr, + ccb->csio.dxfer_len - ccb->csio.resid); + } + if ((ccb->ccb_h.status & CAM_AUTOSNS_VALID) && (ReplySizeInBytes + > (sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME) + - I2O_SCSI_SENSE_DATA_SZ))) { + int size = ReplySizeInBytes + - sizeof(I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME) + - I2O_SCSI_SENSE_DATA_SZ; + + if (size > sizeof(ccb->csio.sense_data)) { + size = sizeof(ccb->csio.sense_data); + } + bcopy ((caddr_t)&(ccb->csio.sense_data), (caddr_t)Reply_Ptr->SenseData, + size); + I2O_SCSI_ERROR_REPLY_MESSAGE_FRAME_setAutoSenseTransferCount( + Reply_Ptr, size); + } + + /* Free up in-kernel buffers */ + while ((elm = SLIST_FIRST(&sgList)) != (struct ioctlSgList_S *)NULL) { + /* Copy out as necessary */ + if ((error == 0) + /* DIR bit considered `valid', error due to ignorance works */ + && ((I2O_FLAGS_COUNT_getFlags(&(elm->FlagsCount)) + & I2O_SGL_FLAGS_DIR) == 0)) { + error = copyout ((caddr_t)(elm->KernelSpace), + elm->UserSpace, + I2O_FLAGS_COUNT_getCount(&(elm->FlagsCount))); + } + SLIST_REMOVE_HEAD(&sgList, link); + free (elm, M_TEMP); + } + if (error == 0) { + /* Copy reply frame to user space */ + error = copyout ((caddr_t)Reply_Ptr, (caddr_t)Reply, + ReplySizeInBytes); + } + free (Reply_Ptr, M_TEMP); + asr_free_ccb(ccb); + + return (error); } /* ASR_queue_i */ /*----------------------------------------------------------------------*/ -/* Function asr_ioctl */ +/* Function asr_ioctl */ /*----------------------------------------------------------------------*/ -/* The parameters passed to this function are : */ -/* dev : Device number. */ -/* cmd : Ioctl Command */ -/* data : User Argument Passed In. */ -/* flag : Mode Parameter */ -/* proc : Process Parameter */ -/* */ -/* This function is the user interface into this adapter driver */ -/* */ -/* Return : zero if OK, error code if not */ +/* The parameters passed to this function are : */ +/* dev : Device number. */ +/* cmd : Ioctl Command */ +/* data : User Argument Passed In. */ +/* flag : Mode Parameter */ +/* proc : Process Parameter */ +/* */ +/* This function is the user interface into this adapter driver */ +/* */ +/* Return : zero if OK, error code if not */ /*----------------------------------------------------------------------*/ STATIC int asr_ioctl( - IN dev_t dev, - IN u_long cmd, - INOUT caddr_t data, - int flag, - struct thread * td) + IN dev_t dev, + IN u_long cmd, + INOUT caddr_t data, + int flag, + struct thread * td) { - int i, j; - OUT int error = 0; - Asr_softc_t * sc = ASR_get_sc (dev); - UNREFERENCED_PARAMETER(flag); - UNREFERENCED_PARAMETER(td); - - if (sc != (Asr_softc_t *)NULL) - switch(cmd) { - - case DPT_SIGNATURE: -# if (dsDescription_size != 50) - case DPT_SIGNATURE + ((50 - dsDescription_size) << 16): -# endif - if (cmd & 0xFFFF0000) { - (void)bcopy ((caddr_t)(&ASR_sig), data, - sizeof(dpt_sig_S)); - return (0); - } - /* Traditional version of the ioctl interface */ - case DPT_SIGNATURE & 0x0000FFFF: - return (copyout ((caddr_t)(&ASR_sig), *((caddr_t *)data), - sizeof(dpt_sig_S))); - - /* Traditional version of the ioctl interface */ - case DPT_CTRLINFO & 0x0000FFFF: - case DPT_CTRLINFO: { - struct { - u_int16_t length; - u_int16_t drvrHBAnum; - u_int32_t baseAddr; - u_int16_t blinkState; - u_int8_t pciBusNum; - u_int8_t pciDeviceNum; - u_int16_t hbaFlags; - u_int16_t Interrupt; - u_int32_t reserved1; - u_int32_t reserved2; - u_int32_t reserved3; - } CtlrInfo; - - bzero (&CtlrInfo, sizeof(CtlrInfo)); - CtlrInfo.length = sizeof(CtlrInfo) - sizeof(u_int16_t); - CtlrInfo.drvrHBAnum = asr_unit(dev); - CtlrInfo.baseAddr = (u_long)sc->ha_Base; - i = ASR_getBlinkLedCode (sc); - if (i == -1) { - i = 0; - } - CtlrInfo.blinkState = i; - CtlrInfo.pciBusNum = sc->ha_pciBusNum; - CtlrInfo.pciDeviceNum = sc->ha_pciDeviceNum; -#define FLG_OSD_PCI_VALID 0x0001 -#define FLG_OSD_DMA 0x0002 -#define FLG_OSD_I2O 0x0004 - CtlrInfo.hbaFlags = FLG_OSD_PCI_VALID | FLG_OSD_DMA | FLG_OSD_I2O; - CtlrInfo.Interrupt = sc->ha_irq; - if (cmd & 0xFFFF0000) { - bcopy (&CtlrInfo, data, sizeof(CtlrInfo)); - } else { - error = copyout (&CtlrInfo, *(caddr_t *)data, sizeof(CtlrInfo)); - } - } return (error); - - /* Traditional version of the ioctl interface */ - case DPT_SYSINFO & 0x0000FFFF: - case DPT_SYSINFO: { - sysInfo_S Info; - char * cp; - /* Kernel Specific ptok `hack' */ -# define ptok(a) ((char *)(a) + KERNBASE) - - bzero (&Info, sizeof(Info)); - - /* Appears I am the only person in the Kernel doing this */ - outb (0x70, 0x12); - i = inb(0x71); - j = i >> 4; - if (i == 0x0f) { - outb (0x70, 0x19); - j = inb (0x71); - } - Info.drive0CMOS = j; - - j = i & 0x0f; - if (i == 0x0f) { - outb (0x70, 0x1a); - j = inb (0x71); - } - Info.drive1CMOS = j; - - Info.numDrives = *((char *)ptok(0x475)); - - Info.processorFamily = ASR_sig.dsProcessorFamily; + int i, j; + OUT int error = 0; + Asr_softc_t * sc = ASR_get_sc (dev); + UNREFERENCED_PARAMETER(flag); + UNREFERENCED_PARAMETER(td); + + if (sc != (Asr_softc_t *)NULL) + switch(cmd) { + + case DPT_SIGNATURE: +# if (dsDescription_size != 50) + case DPT_SIGNATURE + ((50 - dsDescription_size) << 16): +# endif + if (cmd & 0xFFFF0000) { + (void)bcopy ((caddr_t)(&ASR_sig), data, + sizeof(dpt_sig_S)); + return (0); + } + /* Traditional version of the ioctl interface */ + case DPT_SIGNATURE & 0x0000FFFF: + return (copyout ((caddr_t)(&ASR_sig), *((caddr_t *)data), + sizeof(dpt_sig_S))); + + /* Traditional version of the ioctl interface */ + case DPT_CTRLINFO & 0x0000FFFF: + case DPT_CTRLINFO: { + struct { + u_int16_t length; + u_int16_t drvrHBAnum; + u_int32_t baseAddr; + u_int16_t blinkState; + u_int8_t pciBusNum; + u_int8_t pciDeviceNum; + u_int16_t hbaFlags; + u_int16_t Interrupt; + u_int32_t reserved1; + u_int32_t reserved2; + u_int32_t reserved3; + } CtlrInfo; + + bzero (&CtlrInfo, sizeof(CtlrInfo)); + CtlrInfo.length = sizeof(CtlrInfo) - sizeof(u_int16_t); + CtlrInfo.drvrHBAnum = asr_unit(dev); + CtlrInfo.baseAddr = (u_long)sc->ha_Base; + i = ASR_getBlinkLedCode (sc); + if (i == -1) { + i = 0; + } + CtlrInfo.blinkState = i; + CtlrInfo.pciBusNum = sc->ha_pciBusNum; + CtlrInfo.pciDeviceNum = sc->ha_pciDeviceNum; +#define FLG_OSD_PCI_VALID 0x0001 +#define FLG_OSD_DMA 0x0002 +#define FLG_OSD_I2O 0x0004 + CtlrInfo.hbaFlags = FLG_OSD_PCI_VALID | FLG_OSD_DMA | FLG_OSD_I2O; + CtlrInfo.Interrupt = sc->ha_irq; + if (cmd & 0xFFFF0000) { + bcopy (&CtlrInfo, data, sizeof(CtlrInfo)); + } else { + error = copyout (&CtlrInfo, *(caddr_t *)data, sizeof(CtlrInfo)); + } + } return (error); + + /* Traditional version of the ioctl interface */ + case DPT_SYSINFO & 0x0000FFFF: + case DPT_SYSINFO: { + sysInfo_S Info; + char * cp; + /* Kernel Specific ptok `hack' */ +# define ptok(a) ((char *)(a) + KERNBASE) + + bzero (&Info, sizeof(Info)); + + /* Appears I am the only person in the Kernel doing this */ + outb (0x70, 0x12); + i = inb(0x71); + j = i >> 4; + if (i == 0x0f) { + outb (0x70, 0x19); + j = inb (0x71); + } + Info.drive0CMOS = j; + + j = i & 0x0f; + if (i == 0x0f) { + outb (0x70, 0x1a); + j = inb (0x71); + } + Info.drive1CMOS = j; + + Info.numDrives = *((char *)ptok(0x475)); + + Info.processorFamily = ASR_sig.dsProcessorFamily; #if defined (__i386__) - switch (cpu) { - case CPU_386SX: case CPU_386: - Info.processorType = PROC_386; break; - case CPU_486SX: case CPU_486: - Info.processorType = PROC_486; break; - case CPU_586: - Info.processorType = PROC_PENTIUM; break; - case CPU_686: - Info.processorType = PROC_SEXIUM; break; - } + switch (cpu) { + case CPU_386SX: case CPU_386: + Info.processorType = PROC_386; break; + case CPU_486SX: case CPU_486: + Info.processorType = PROC_486; break; + case CPU_586: + Info.processorType = PROC_PENTIUM; break; + case CPU_686: + Info.processorType = PROC_SEXIUM; break; + } #elif defined (__alpha__) Info.processorType = PROC_ALPHA; #endif - Info.osType = OS_BSDI_UNIX; - Info.osMajorVersion = osrelease[0] - '0'; - Info.osMinorVersion = osrelease[2] - '0'; - /* Info.osRevision = 0; */ - /* Info.osSubRevision = 0; */ - Info.busType = SI_PCI_BUS; - Info.flags = SI_CMOS_Valid | SI_NumDrivesValid - | SI_OSversionValid | SI_BusTypeValid | SI_NO_SmartROM; - - /* Go Out And Look For I2O SmartROM */ - for(j = 0xC8000; j < 0xE0000; j += 2048) { - int k; - - cp = ptok(j); - if (*((unsigned short *)cp) != 0xAA55) { - continue; - } - j += (cp[2] * 512) - 2048; - if ((*((u_long *)(cp + 6)) - != ('S' + (' ' * 256) + (' ' * 65536L))) - || (*((u_long *)(cp + 10)) - != ('I' + ('2' * 256) + ('0' * 65536L)))) { - continue; - } - cp += 0x24; - for (k = 0; k < 64; ++k) { - if (*((unsigned short *)cp) - == (' ' + ('v' * 256))) { - break; - } - } - if (k < 64) { - Info.smartROMMajorVersion - = *((unsigned char *)(cp += 4)) - '0'; - Info.smartROMMinorVersion - = *((unsigned char *)(cp += 2)); - Info.smartROMRevision - = *((unsigned char *)(++cp)); - Info.flags |= SI_SmartROMverValid; - Info.flags &= ~SI_NO_SmartROM; - break; - } - } - /* Get The Conventional Memory Size From CMOS */ - outb (0x70, 0x16); - j = inb (0x71); - j <<= 8; - outb (0x70, 0x15); - j |= inb(0x71); - Info.conventionalMemSize = j; - - /* Get The Extended Memory Found At Power On From CMOS */ - outb (0x70, 0x31); - j = inb (0x71); - j <<= 8; - outb (0x70, 0x30); - j |= inb(0x71); - Info.extendedMemSize = j; - Info.flags |= SI_MemorySizeValid; - -# if (defined(THIS_IS_BROKEN)) - /* If There Is 1 or 2 Drives Found, Set Up Drive Parameters */ - if (Info.numDrives > 0) { - /* - * Get The Pointer From Int 41 For The First - * Drive Parameters - */ - j = ((unsigned)(*((unsigned short *)ptok(0x104+2))) << 4) - + (unsigned)(*((unsigned short *)ptok(0x104+0))); - /* - * It appears that SmartROM's Int41/Int46 pointers - * use memory that gets stepped on by the kernel - * loading. We no longer have access to this - * geometry information but try anyways (!?) - */ - Info.drives[0].cylinders = *((unsigned char *)ptok(j)); - ++j; - Info.drives[0].cylinders += ((int)*((unsigned char *) - ptok(j))) << 8; - ++j; - Info.drives[0].heads = *((unsigned char *)ptok(j)); - j += 12; - Info.drives[0].sectors = *((unsigned char *)ptok(j)); - Info.flags |= SI_DriveParamsValid; - if ((Info.drives[0].cylinders == 0) - || (Info.drives[0].heads == 0) - || (Info.drives[0].sectors == 0)) { - Info.flags &= ~SI_DriveParamsValid; - } - if (Info.numDrives > 1) { - /* - * Get The Pointer From Int 46 For The - * Second Drive Parameters - */ - j = ((unsigned)(*((unsigned short *)ptok(0x118+2))) << 4) - + (unsigned)(*((unsigned short *)ptok(0x118+0))); - Info.drives[1].cylinders = *((unsigned char *) - ptok(j)); - ++j; - Info.drives[1].cylinders += ((int) - *((unsigned char *)ptok(j))) << 8; - ++j; - Info.drives[1].heads = *((unsigned char *) - ptok(j)); - j += 12; - Info.drives[1].sectors = *((unsigned char *) - ptok(j)); - if ((Info.drives[1].cylinders == 0) - || (Info.drives[1].heads == 0) - || (Info.drives[1].sectors == 0)) { - Info.flags &= ~SI_DriveParamsValid; - } - } - } -# endif - /* Copy Out The Info Structure To The User */ - if (cmd & 0xFFFF0000) { - bcopy (&Info, data, sizeof(Info)); - } else { - error = copyout (&Info, *(caddr_t *)data, sizeof(Info)); - } - return (error); } - - /* Get The BlinkLED State */ - case DPT_BLINKLED: - i = ASR_getBlinkLedCode (sc); - if (i == -1) { - i = 0; - } - if (cmd & 0xFFFF0000) { - bcopy ((caddr_t)(&i), data, sizeof(i)); - } else { - error = copyout (&i, *(caddr_t *)data, sizeof(i)); - } - break; - - /* Get performance metrics */ + Info.osType = OS_BSDI_UNIX; + Info.osMajorVersion = osrelease[0] - '0'; + Info.osMinorVersion = osrelease[2] - '0'; + /* Info.osRevision = 0; */ + /* Info.osSubRevision = 0; */ + Info.busType = SI_PCI_BUS; + Info.flags = SI_CMOS_Valid | SI_NumDrivesValid + | SI_OSversionValid | SI_BusTypeValid | SI_NO_SmartROM; + + /* Go Out And Look For I2O SmartROM */ + for(j = 0xC8000; j < 0xE0000; j += 2048) { + int k; + + cp = ptok(j); + if (*((unsigned short *)cp) != 0xAA55) { + continue; + } + j += (cp[2] * 512) - 2048; + if ((*((u_long *)(cp + 6)) + != ('S' + (' ' * 256) + (' ' * 65536L))) + || (*((u_long *)(cp + 10)) + != ('I' + ('2' * 256) + ('0' * 65536L)))) { + continue; + } + cp += 0x24; + for (k = 0; k < 64; ++k) { + if (*((unsigned short *)cp) + == (' ' + ('v' * 256))) { + break; + } + } + if (k < 64) { + Info.smartROMMajorVersion + = *((unsigned char *)(cp += 4)) - '0'; + Info.smartROMMinorVersion + = *((unsigned char *)(cp += 2)); + Info.smartROMRevision + = *((unsigned char *)(++cp)); + Info.flags |= SI_SmartROMverValid; + Info.flags &= ~SI_NO_SmartROM; + break; + } + } + /* Get The Conventional Memory Size From CMOS */ + outb (0x70, 0x16); + j = inb (0x71); + j <<= 8; + outb (0x70, 0x15); + j |= inb(0x71); + Info.conventionalMemSize = j; + + /* Get The Extended Memory Found At Power On From CMOS */ + outb (0x70, 0x31); + j = inb (0x71); + j <<= 8; + outb (0x70, 0x30); + j |= inb(0x71); + Info.extendedMemSize = j; + Info.flags |= SI_MemorySizeValid; + +# if (defined(THIS_IS_BROKEN)) + /* If There Is 1 or 2 Drives Found, Set Up Drive Parameters */ + if (Info.numDrives > 0) { + /* + * Get The Pointer From Int 41 For The First + * Drive Parameters + */ + j = ((unsigned)(*((unsigned short *)ptok(0x104+2))) << 4) + + (unsigned)(*((unsigned short *)ptok(0x104+0))); + /* + * It appears that SmartROM's Int41/Int46 pointers + * use memory that gets stepped on by the kernel + * loading. We no longer have access to this + * geometry information but try anyways (!?) + */ + Info.drives[0].cylinders = *((unsigned char *)ptok(j)); + ++j; + Info.drives[0].cylinders += ((int)*((unsigned char *) + ptok(j))) << 8; + ++j; + Info.drives[0].heads = *((unsigned char *)ptok(j)); + j += 12; + Info.drives[0].sectors = *((unsigned char *)ptok(j)); + Info.flags |= SI_DriveParamsValid; + if ((Info.drives[0].cylinders == 0) + || (Info.drives[0].heads == 0) + || (Info.drives[0].sectors == 0)) { + Info.flags &= ~SI_DriveParamsValid; + } + if (Info.numDrives > 1) { + /* + * Get The Pointer From Int 46 For The + * Second Drive Parameters + */ + j = ((unsigned)(*((unsigned short *)ptok(0x118+2))) << 4) + + (unsigned)(*((unsigned short *)ptok(0x118+0))); + Info.drives[1].cylinders = *((unsigned char *) + ptok(j)); + ++j; + Info.drives[1].cylinders += ((int) + *((unsigned char *)ptok(j))) << 8; + ++j; + Info.drives[1].heads = *((unsigned char *) + ptok(j)); + j += 12; + Info.drives[1].sectors = *((unsigned char *) + ptok(j)); + if ((Info.drives[1].cylinders == 0) + || (Info.drives[1].heads == 0) + || (Info.drives[1].sectors == 0)) { + Info.flags &= ~SI_DriveParamsValid; + } + } + } +# endif + /* Copy Out The Info Structure To The User */ + if (cmd & 0xFFFF0000) { + bcopy (&Info, data, sizeof(Info)); + } else { + error = copyout (&Info, *(caddr_t *)data, sizeof(Info)); + } + return (error); } + + /* Get The BlinkLED State */ + case DPT_BLINKLED: + i = ASR_getBlinkLedCode (sc); + if (i == -1) { + i = 0; + } + if (cmd & 0xFFFF0000) { + bcopy ((caddr_t)(&i), data, sizeof(i)); + } else { + error = copyout (&i, *(caddr_t *)data, sizeof(i)); + } + break; + + /* Get performance metrics */ #ifdef ASR_MEASURE_PERFORMANCE - case DPT_PERF_INFO: - bcopy((caddr_t) &(sc->ha_performance), data, - sizeof(sc->ha_performance)); - return (0); + case DPT_PERF_INFO: + bcopy((caddr_t) &(sc->ha_performance), data, + sizeof(sc->ha_performance)); + return (0); #endif - /* Send an I2O command */ - case I2OUSRCMD: - return (ASR_queue_i (sc, *((PI2O_MESSAGE_FRAME *)data))); + /* Send an I2O command */ + case I2OUSRCMD: + return (ASR_queue_i (sc, *((PI2O_MESSAGE_FRAME *)data))); - /* Reset and re-initialize the adapter */ - case I2ORESETCMD: - return (ASR_reset (sc)); + /* Reset and re-initialize the adapter */ + case I2ORESETCMD: + return (ASR_reset (sc)); - /* Rescan the LCT table and resynchronize the information */ - case I2ORESCANCMD: - return (ASR_rescan (sc)); - } - return (EINVAL); + /* Rescan the LCT table and resynchronize the information */ + case I2ORESCANCMD: + return (ASR_rescan (sc)); + } + return (EINVAL); } /* asr_ioctl */ #ifdef ASR_MEASURE_PERFORMANCE @@ -4669,26 +4669,26 @@ asr_ioctl( STATIC u_int32_t asr_time_delta( - IN struct timeval start, - IN struct timeval end) + IN struct timeval start, + IN struct timeval end) { - OUT u_int32_t result; - - if (start.tv_sec > end.tv_sec) { - result = 0xffffffff; - } - else { - if (start.tv_sec == end.tv_sec) { - if (start.tv_usec > end.tv_usec) { - result = 0xffffffff; - } else { - return (end.tv_usec - start.tv_usec); - } - } else { - return (end.tv_sec - start.tv_sec) * 1000000 + - end.tv_usec + (1000000 - start.tv_usec); - } - } - return(result); + OUT u_int32_t result; + + if (start.tv_sec > end.tv_sec) { + result = 0xffffffff; + } + else { + if (start.tv_sec == end.tv_sec) { + if (start.tv_usec > end.tv_usec) { + result = 0xffffffff; + } else { + return (end.tv_usec - start.tv_usec); + } + } else { + return (end.tv_sec - start.tv_sec) * 1000000 + + end.tv_usec + (1000000 - start.tv_usec); + } + } + return(result); } /* asr_time_delta */ #endif |
